MTUP

MTUP, the Message Text Update Program, was the tool and source language that ICL’s VME mainframe operating system used to build message text modules (MTMs). An MTUP source file is a list of numbered texts. Each text mixes fixed wording with run-time parameters, layout directives and CASE selections. Compiling the file produces an ordinary VME object module. An S3 or SCL program calls that module with a text number and a list of parameters and gets the finished message back. MTUP is not a general-purpose language: it formats text and returns a result, and it does nothing else. It is a small example of something most systems now handle with resource files and printf-style format strings, namely keeping a program’s wording out of its code.

What survives

MTUP is poorly documented. No ICL manual for it has been found online, and the name returns almost nothing in a web search. This page is therefore built from two primary sources. Read it with that limit in mind.

• The SWURCC VME Kermit distribution (1986). It is held in the Columbia University Kermit archive as iclvme2900. It contains two complete MTUP source files, the S3 code that calls them, the SCL build procedure and an October 1986 user guide. The guide describes the program as built “from the S3 and MTUP language sources”. The Kermit Project’s list of the languages Kermit has been written in includes “MTUP — ICL Message Text Update Program” next to “S3 — Implementation language for ICL 2900 VME”.
• 99 Bottles of Beer entry 1197 (2006). John Tiller’s note there says that MTUP “is a compiler used on Fujitsu’s VME mainframes to produce a Message Text Module (MTM). The MTM is used to merge fixed blocks of text held within the module with parameter data supplied at run-time.”

The Wikipedia article on ICL VME adds that the SCL command NEW_MESSAGE_TEXT_MODULE “creates a module containing parameterized error messages suitable for localization”. That is the command the Kermit build script uses to compile its MTUP files.

What none of these sources covers: when MTUP first appeared, who designed it, how it changed between VME releases, whether ICL used it for VME’s own system messages, and whether it is still shipped with today’s OpenVME. The encyclopedia lists it as a 1980s language. The surviving evidence shows only that MTUP was in use by February 1986. Since VME itself dates from the mid-1970s, MTUP could be older.

History and context

VME, the Virtual Machine Environment, was developed in the 1970s as VME/B for ICL’s New Range, launched in October 1974 as the 2900 Series. Its system software was written in S3, an ICL implementation language derived from Algol 68. Users drove it through SCL, the System Control Language, a typed, block-structured command language with a similar Algol-style surface. Every compiler on VME, including the MTUP processor, produced the same Object Module Format (OMF). The Collector could then link MTUP output and S3 output into a single loadable module.

Message text modules fit that design. A program did not embed its error and help wording in code. It called an MTM with a text number and the values to insert, so the wording could be revised or translated by editing and recompiling a text file, leaving the program untouched. Wikipedia’s phrase “suitable for localization” points the same way, but no source describes a translated MTM in practice.

The best-documented MTUP user is VME Kermit. Richard Andrews and David Lord wrote it at the South West Universities Regional Computer Centre (SWURCC) at Claverton Down, Bath, and dated version 1.00 to February 1986. Columbia’s Kermit Project announced it on 16 April 1986, describing it as Kermit for “ICL 2900 systems running the VME Operating System (also known as VME2900 and VME/B - all identical)”. Version 1.01 followed on 16 October 1986, with fixes by Dave Allum and David Lord. In that release the message module formerly called KMT_SP_MTUP_MODULE was renamed KMT_SP_MTM, and the old name survives in the comment on the file’s final *END line.

Language structure

An MTUP file opens with directive lines that begin with *. The Kermit help module starts like this:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

*@ KERMIT HELP SYSTEM MESSAGE TEXT MODULE @
*@ ====== ==== ====== ======= ==== ====== @

*CREATE(KMTHELPMTM)
*PROC(KMTHELPMTM)
*VERSION(101)
*PARAMS(EXP&ICL)
*LINESPLIT(SPACE)

*@ N.B. NIL IS ASSUMED TO HAVE A VALUE OF -1 @

*CREATE names the module, *PROC names the procedure it exports, and *VERSION(101) matches Kermit’s file generation number. The other directives seen in the surviving sources are *PARAMS(...), *LINESPLIT(SPACE), *SPACEFILL(NO) and *ESCAPE(<>). Their names suggest parameter conventions, how long text is broken across lines, padding, and the choice of bracket characters. No document has been found that defines their exact meaning, so this page does not try to.

Each text then begins with * followed by its number: *1, *250, *89044. The 99 Bottles example uses *ADD(1) to start text 1. Comments use the @ ... @ brackets found throughout VME source, both in S3 and in SCL. A file ends with *END.

Inside a text

The body of a text is literal wording, with constructs in angle brackets. These are the ones the surviving sources use:

The “apparent role” column is inferred from how each construct is used in working code, not taken from a specification.

CASE appears in three forms:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

@ compare a parameter with literals (99 Bottles of Beer, 2006) @
CASE P1 EQUALS
<0>   THEN
      <No more>
DEFAULT
      P1
ESAC,

@ pick the n-th alternative by a parameter's value (VME Kermit, 1986) @
<HALT -1>TYPE     = <CASE P6
                     THEN <INVALID TYPE>,
                          <B (BREAK)>,
                          <D (DATA)>,
                          ...
                     DEFAULT <INVALID TYPE>
                     ESAC>

@ prefix-compare a parameter with keywords (VME Kermit, 1986) @
<CASE P1 STARTS
         <SERVER>     THEN HALT  0,
         <RECEIVE>    THEN HALT  1,
         <SEND>       THEN HALT  2,
         ...
      DEFAULT              HALT  8 @ invalid command @
 ESAC
>

The CASE ... ESAC bracketing is the same as in S3 and SCL, the other VME languages around MTUP.

Calling a module from S3

In VME Kermit, the S3 side declares the compiled module as an external procedure that takes a text number and a parameter area and returns an integer:

1
2
3
4
5

EXT
PROC
   (INT,                                         @ TEXT_NUMBER                 @
    REF () KMT_MTM_VALUES                        @ AREA                        @
   ) INT                               KMT_SP_MTM;

The first four entries of the area are fixed: a message buffer, a place for the returned length, a “recall data” reference, and the number of parameters. The message parameters follow. The caller then loops. It logs each piece of returned text and passes the reply back as the next text number, until the module signals that it has finished. In the code, -2 means no message was found and -3 means the text is in the recall data. Messages that run over several lines are assembled this way.

Two uses of one mechanism

VME Kermit shows that an MTM can do more than hold wording. Its two modules serve two different purposes:

1. Messages and help. KMT_HELP_MTM holds 74 numbered texts behind Kermit’s HELP command, including a menu laid out with <TAB 35>. KMT_SP_MTM holds 119 texts covering version banners, packet traces and error messages. The error handler uses a Kermit result code directly as the text number. Text 89050, for example, expands to “Maximum retries exceeded.”
2. Keyword recognition. Texts 5000 to 5150 print nothing. Each one applies CASE ... STARTS to a parameter, the word the user typed, and ends in HALT n, so the call returns an integer. The S3 user-interface module calls KMT_SP_MTM(5010, ...) and treats the result as the command code: 0 for SERVER, 1 for RECEIVE, through to 8 for an invalid command.

So the module handled both what the program said and which words it understood. The program’s English vocabulary sat in one text file, outside the S3 code.

The 99 Bottles example

John Tiller’s 2006 example is the only MTUP program written to show the language off. One text produces a whole verse. The first line uses CASE P1 EQUALS on the bottle count to choose between “No more” and the number, and between “bottle” and “bottles”. The second line tests P2 for the special value -1 that triggers “Go to the store and buy some more, 99”. Because “the MTM doesn’t have the ability to log anything to the screen”, Tiller pairs it with an SCL procedure that declares the module as an external procedure, loops FOR BOTTLES FROM 99 TO 0 BY -1, calls it with PARAM_1 = BOTTLES and PARAM_2 = BOTTLES - 1, and prints each result with SEND_MESSAGE. His note also points readers to Steve Hammond’s separate SCL entry on the same site.

Current status

The encyclopedia lists MTUP as historical. That holds for its public visibility. VME itself lives on as OpenVME. Fujitsu announced superNova, which runs VME as a hosted subsystem on x86-64 servers, in 2007, and in 2020, according to Wikipedia, it moved 13 HM Revenue and Customs applications onto its managed VME hosting platform. No public source says whether the MTUP processor or NEW_MESSAGE_TEXT_MODULE survives in current OpenVME releases, and the encyclopedia’s “1990s” end date for MTUP is likewise unverified. There is no emulator or public implementation, so MTUP code cannot be run today.

Why it matters

MTUP shows how far VME’s designers took the idea that a mainframe system is assembled from separately compiled modules in a common object format. Message wording was not left as strings scattered through the code. It had its own source language and compiler and went through the same Collector as everything else. VME Kermit shows the payoff: a Kermit port by a small university computing centre kept every user-facing string, and its whole command vocabulary, in two text files that someone without the S3 compiler could have read and edited.

Today a programmer would use gettext catalogues, Java resource bundles or ICU MessageFormat, whose plural and select rules do the job MTUP’s CASE P1 EQUALS <1> did for “bottle” against “bottles”. No source links MTUP to any of these later systems, so the comparison is offered as an analogy, not as a line of descent.