Try MTS

Site Update, August 2023

Fri, 25 Aug 2023 16:40:19 +0000

archive.michigan-terminal-system.org is currently down, so I’ve replaced links on this site with links to archive.org. Here is a recent snapshot of the site and here is a copy of the MTS distribution that can be easily downloaded.

Please leave a comment or email me if anything is still broken.

PL360 - Introduction and a hypotenuse program

Sun, 01 Mar 2020 10:18:30 +0000

In this single part post, we’ll take a quick look at PL360, a low level programming language targeted at the System/360.

PL360

PL360 was initially designed by Niklaus Wirth at Stanford in the late 1960s. He was working on a successor to ALGOL and was unsatisfied with the choices of implementation languages: assembler or FORTRAN. Quoting from his original paper, he wanted a tool which would:

(1) allow full use of the facilities provided by the 360 hardware, (2) provide convenience in writing and correcting programs, and (3) encourage the user to write in a clear and comprehensible style.

As a result, he and his team came up with PL360. As the name suggests, the language is tied to the architecture of the System/360, providing direct access to opcodes like STC and the need to specify which registers to use. It also contains high level features like IF ... THEN conditionals and WHILE ... DO loops, plus syntax to make common tasks easier, eg R1 := R1 + R2 + R3.

PL360 on MTS

PL360 on MTS seems to date back to at least distribution 1.0. The version was have on the latest distribution 6.0 has the following note in the drive file listing under component 108:

This version of PL360 is based on one received from Stanford in late 1977 and installed at UM in January, 1978. The latest versions are distributed by UBC as part of the SPIRES distribution.

PL360 is installed on MTS as *PL360. The compiler takes input from SCARDS and writes an object file to SPUNCH. For example:

$RUN *PL360 SCARDS=input SPUNCH=object

At run time, to use the standard I/O library you need to add *PL360LIB to the $RUN command, ie:

$RUN object+*PL360LIB

Note that documentation linked below mentions that some procedures in the standard library are not available on MTS, such as VALTOBCD which converts a number to an EBCDIC representation.

Prerequisites

No special installation instructions to get this language running - just do the standard D6.0 setup as described in this guide and then sign on as a regular user such as ST01.

Hypotenuse program

Our sample program will calculate the hypotenuse of a right angled triangle: this is taken from the PL360 textbook linked below. The original version used VALTOBCD etc which is not available, so we’ll supply the input values in the main program and use the MTS debugger to view the results.

The program uses Newton’s methods to take square roots R'' = ((X/R') + R')/2:

where R’ is an approximation for the root of X, and R’’ is the next approximation. When the difference between R’ and R’’ becomes very small, R’’ is the assumed root of X. The first approximation of R’ is taken to be X with its exponent cut in half. Thus, the first approximation for the root of 128 would be 8. Likewise, 1/8 would be the approximation for 1/128. (128 = #80)

The procedure to calculate square roots looks like below. The format is mostly unchanged; I’ve added line numbers in the first two columns which would not be present in the actual program text.

 1   PROCEDURE SQRT (R14);  IF F01 > 0L THEN
 2   |-- THIS PROCEDURE TAKES THE SQUARE ROOT OF THE VALUE IN F01 --|
 3   BEGIN  LONG REAL TEMPCELL;  |-- TEMPORARY STORAGE --|
 4          LONG REAL REGISTER DIFF SYN F67,  |-- TEMPORARY --|
 5          APROX1 SYN F23, APROX2 SYN F45;   |-- REGISTERS --|
 6      TEMPCELL := F01;  R1 := R1-R1;
 7   |-- COMPUTE HALF THE ORIGINAL EXPONENT, EXCESS 64 NOTATION --|
 8      IC(R1,TEMPCELL);  R1 := R1 - #40S SHRA 1 + #40S;
 9      STC(R1,TEMPCELL);  APROX2 := TEMPCELL;  DIFF := 2L;
10      WHILE DIFF > 10'_6L DO  |-- FIND SQRT OF F01 --|
11      BEGIN  APROX1 := APROX2;  |-- NEW APPROXIMATION FROM OLD --|
12         APROX2 := F01/APROX1 + APROX1 / 2L;
13         DIFF := APROX2 - APROX1;  DIFF := ABS DIFF;
14      END;  F01 := APROX2;  |-- REPLACE F01 BY SQRT OF F01 --|
15   END;

The procedure implicitly takes its input and returns output to floating point register 0. R14 is used to denote the register containing the address to jump to on return.

The IF statement will guard against negative input values, skipping the whole procedure unless the input is positive.

The body of the iF starts on line 3 with BEGIN. It creates temporary storage TEMPCELL and provides synonyms for floating point registers to make the code clearer.

Cutting the exponent is done by taking the byte containing the exponent (the ‘characteristic’ in IBM’s language) out of the floating point value (with IC), shifting it right one bit (which divides it by two) and then storing it back into the floating point value. Why is #40S subtracted before the shift and then added back again? I had to look at the ‘Principles of Operation’ for this: turns out characteristic is biased by +64, ie hex 40.

We then use a WHILE ... DO statement to loop the approximation calculation until the difference is less then 10^-6. Note that precedence is strictly left to right, so we can write the approximation calculation on line 12 in that way.

To calculate the hypotenuse, we need to sum the squares of the two sides and call SQRT. This can be easily done:

BEGIN
   F01 := 3.0 * 3.0;
   F23 := 4.0 * 4.0;
   F01 := F01 + F23;
   SQRT;
END.

Note the END is terminated with a period to denote this is the main program.

Compiling and running the program

We compile the program as follows:

$run *PL360 SCARDS=hyp.pl3 SPUNCH=hyp.l

The output shows a listing and a cross-reference table, and ends with NO ERRORS DETECTED so we are good.

To test, we run this under the debugger and print out the floating point registers at the end with DUMP FRS:

$debug hyp.l
Ready
run
User program return.
Ready
dump frs

 Floating Point Registers

                 Hex              Decimal

   FR0 :  41500000 00000000    5.
   FR2 :  41500000 02C4F885    5.00000001031688268
   FR4 :  41500000 00000000    5.
   FR6 :  3A2C4F88 50000000    .103168826814936665E-07
stop

FR0 contains 5, so it looks like it worked!

Final thoughts

PL360 occupies a unique slot in the set of languages on the System/360: tied closely to the architecture but operating at a higher level then assembler. Apart from Wirth’s work, it did enjoy some use for other applications, eg the SPIRES database system, but was not widely adopted on MTS or other systems.

Further information

The original paper Wirth wrote on PL360, PL360, a Programming Language for the 360 Computers gives background on why it was developed and an overview of the language.

MTS CCMEMO 75 has an overview of the language and its implementation on MTS.

Copies of the “PL360 Reference Manual” formerly distributed by Stanford can be found on the Internet, eg here. A textbook based on this manual can be found here.

Full source code for this program can be found on github.

PLUS - Grep

Sun, 26 Jan 2020 09:45:32 +0000

For the final post in this series, let’s write a real program in PLUS. Rather than working on a Rosetta Code problem, I’ll use this opportunity to implement a useful program, a version of Unix grep for MTS.

Grep

Grep is a program from Unix to find text in files. The first version was written in around 1974 in PDP-11 assembly language, and is available on pretty much every Unix derived system today. I don’t believe there is an equivalent for MTS - the MTS File Editor does have a rich pattern matching language but is a bit unwieldy to use from the command line.

The requirements for the program are:

input a pattern to search for, which should support some kind of regular expression to match arbitrary text
input a file or list of files to search in
compare the pattern to the contents of the files and print any lines that match.
follow MTS conventions for calling the program.

Pattern matching

The first problem is how can we match patterns? There is no regular expression library like regex in Unix. Looking through Volume 3, on page 366.3 there is a set of routines that look promising:

Three system subroutines, PATBUILD, PATMATCH, and PATFREE, are available for implementing $FILESTATUS-like pattern-matching capabili- ties from user programs.

PATBUILD will build a pattern from an input string. The input string may be of any length and may specify a file name or a generic string. For example:

File names: “2CYB:data?”, “?.doc”, “2ABC:?”

Generic strings: “Bill R?”, “in the state of ?”

PATMATCH will compare an input string against the pattern built by PATBUILD. The input string may be of any length.

PATFREE will free the storage used to build the pattern.

Although this is more suited for file wildcard expansion than general text search, we’ll use this as a quick way to get the program running.

The PLUS Source Library Definition does not mention these routines, but looking through the actual contents of *PLUS.SOURCELIB there are definitions available. For example for patbuild:

%Include(Numeric_Types);
type Patbuild_Procedure_Type is
     procedure
     reference parameters Patstring is value unknown,
        Strlen is value Integer,
        Patworkaddr is pointer to unknown,
     optional reference parameters Flags is value bit(32),
        Ccid is value character(4),
        Chars is value character(2),
     end;

/* Values used in Flags word */
constant Patbuild_Filename is '00000000',
  Patbuild_Nonfilename is '00000001',
  Patbuild_Ignore_Case is '00000000',
  Patbuild_Dont_Ignore_Case is '00000004';

Driving the pattern matcher

Let’s define a data structure to be used by our grep program.

global Grep
   /* The pat subroutines need a working area. */
   type Pattern_Work_Area_Storage_Type is bit(32);
   type Pattern_Work_Area_Type is pointer to Pattern_Work_Area_Storage_Type;
   constant Pattern_Work_Area_Size is Byte_Size(Pattern_Work_Area_Storage_Type);

   constant Wildcard_Character is "?";

   type Pattern_Struct is
      record
         Work_Area is Pattern_Work_Area_Type,
         Error_Message is Varying_String,
         Match_Count is Integer
      end record;
end global Grep;

And also some procedures, using pass-by-reference for structs and strings to avoid copying.

procedure Grep_Initialize is
   procedure
   reference parameters
      Pattern is Pattern_Struct,
      Pattern_Expression is Varying_String
   result
      Grep_Initialize_Result is Boolean
   end;

procedure Grep_Match is
   procedure
   reference parameters
      Pattern is Pattern_Struct,
      Query_Text is Varying_String
   result
      Match_Result is Boolean
   end;

procedure Grep_Terminate is
   procedure
   reference parameter
      Pattern is Pattern_Struct
   end;

Grep_Initialize will take our data structure and a pattern expression input by the user. It will fill out the data structure and return a Boolean to show if it worked or not. If it failed, the Error_Message field in the struct will be set to an appropriate message.

Grep_Match will apply the pattern to a line of query text and return a Boolean stating whether there was a match or not. It will update the Match_Count member in the structure so we can keep track of how many results we get.

Finally, Grep_Terminate will free up the memory used by the system.

`Grep_Initialize` in detail

Let’s look at the implementation of Grep_Initialize.

definition Grep_Initialize;
   Pattern.Match_Count := 0;
   Pattern.Error_Message := "";
   Pattern.Work_Area := Getspace(0, Pattern_Work_Area_Size);

   if Length(Pattern_Expression) = 0
   then
      Pattern.Error_Message := "Missing pattern in PAR field";
      return with False;
   end if;

   /* Add leading and trailing wildcards to match anywhere
      on a line. */
   variable Match_In_Line is Varying_String;
   Match_In_Line := Wildcard_Character || Pattern_Expression ||
                    Wildcard_Character;

   variable Len is Integer;
   variable Text_Ptr is pointer to Fixed_String;
   Get_String_Text_And_Length(Match_In_Line, Text_Ptr, Len);

   variable Return_Code is Return_Code_Type;
   Patbuild(Text_Ptr@, Len, Pattern.Work_Area, Pattern_Flags,
            return code Return_Code);

   /* Any error code greater than this is unrecoveable. */
   constant Patbuild_Error_Code_Threshold is 8;
   if Return_Code > Patbuild_Error_Code_Threshold
   then
      Pattern.Error_Message := "Error constructing pattern";
      return with False;
   end if;

   return with True;
end Grep_Initialize;

It first starts by initializing the Pattern structure we passed in. The work area is a piece of memory needed by the system pattern routines so this is allocated. It then checks the pattern expression provided to see if it is not empty. If OK, it adds the wildcard ? to the start and end of the expression, so we can match text anywhere on a line.

We are nearly ready to call Patbuild to initialize the pattern. However, our pattern expression is a Varying_String and Patbuild requires a location in memory for the underlying string and a length. To get this, we define a macro Get_String_Text_And_Length that does some type casting to get access to the members of Varying_String:

macro Get_String_Text_And_Length

   /* Given a Varying_String, get the address of the underlying
      Fixed_String and copy the length to an Integer variable.
      This is needed for the calls to system subrountines
      like Patbuild below. */

   parameters are V_String, Text_Ptr, Len;
   equate V_String_Struct to V_String as Varying_String_Structure_Type;
   equate Text to V_String_Struct.Varying_String_Text as Fixed_String;
   Text_Ptr := Address(Text);
   Len := Length(V_String);
end macro;

The macro encapsulates the details of accessing these members and allows us to use this in other parts of the program, but avoids the cost of a procedure call as the code will be inlined to the current function.

We can now call Patbuild using the return code Return_Code parameter to get the system routine result code. Volume 3 states this can fail under some cases, so we check this code and return an appropriate Boolean.

`Grep_Match` and `Grep_Terminate`

The procedure to do the actual matching is then simple:

definition Grep_Match;
   variable Len is Integer;
   variable Text_Ptr is pointer to Fixed_String;
   Get_String_Text_And_Length(Query_Text, Text_Ptr, Len);

   variable Return_Code is Return_Code_Type;
   Patmatch(Text_Ptr@, Len, Pattern.Work_Area, return code Return_Code);

   if Return_Code = 0
   then
      Pattern.Match_Count +:= 1;
      return with True;
   end if;
   return with False;
end Grep_Match;

Grep_Terminate just calls Patfree.

Calling the `Grep` routines

The Main procedure can now be constructed by

reading the PAR parameter from the command line to get the pattern expression
calling Grep_Initialize
loop, reading lines from SCARDS, matching and printing results
print a final count of matches

definition Main;
   variable Msg is pointer to Stream_Type;
   variable Pattern is Pattern_Struct;
   variable Pattern_Expression is Varying_String;
   variable Line is Varying_String;
   variable Return_Code is Return_Code_Type;

   Msg := Message_Initialize();

   Pattern_Expression := Trim(Par);
   if not Grep_Initialize(Pattern, Pattern_Expression)
   then
      Message(Msg, "<v></>", Pattern.Error_Message);
   else
      /* Read lines from SCARDS and print any that match. */
      cycle
         Scards_Varying(Line, Return_Code);
         if Return_Code > 0
         then
            exit;
         end if;
         if Grep_Match(Pattern, Line)
         then
            Sprint_Varying(Line);
         end if ;
      end cycle;
      Message(Msg, "<i> match(es) found</>", Pattern.Match_Count);
   end if;

   Grep_Terminate(Pattern);
   Message_Terminate(Msg);
end Main;

Compiling and running the program

The program can be compiled with $run *PLUS SCARDS=grep.plus SPUNCH=grep

Here are some examples of running the program.

Matching a wildcard expression:

 # $run grep scards=hello.plus par=hello?world
 # Execution begins   16:37:36
   %Title := "Hello World Program";
      Sprint_String("Hello, world!");
   2 match(es) found
 # Execution terminated   16:37:37  T=0.001

Matching against a large file (around 372kB)

# $run grep scards=*PLUS.SOURCELIB par=patmatch
# Execution begins   16:45:30
  PATMATCH    30300
  PATMATCH_PROCEDURE_TYPE         30400
  /begin Patmatch
  %Include(Patmatch_Procedure_Type);
  procedure Patmatch is system Patmatch_Procedure_Type
  /begin Patmatch_Procedure_Type
  type Patmatch_Procedure_Type is
  7 match(es) found
# Execution terminated   16:45:31  T=0.232

Matching across several files:

# $run grep scards=hello.plus+grep.plus par=title
# Execution begins   16:47:19
  %Title := "Hello World Program";
  %Title := "Find text in files";
  2 match(es) found
# Execution terminated   16:47:19  T=0.006

Areas for improvement

By using the pattern routines provided by the MTS system, we have produced a basic grep program in 166 lines of code. There are, however, several ways we could improve it.

The program only supports case-insensitive matching. This is a by-product of the way the PAR command line is passed to the program in upper case. It would be nice to search multiple files, such as all files in a catalog, without having to use concatenation. It would also be good to show which file and line was matched.

One way to support this would be to use the PAR command line to pass a file specification, eg PLUS:?, and use SCARDS to pass in the text to be searched. The file specification could be expanded to a list of files, and by reading from SCARDS we could supply a mixed case pattern expression.

Another area to improve would be the pattern matching. As you can see from the run of grep on a large file, it’s not that fast. We also don’t provide as rich a pattern matching language as POSIX regexes. Looking at the source code for the pattern matching routines, they do a simple scan of the text - which is reasonable for the purpose they were designed for, to match filenames - but for a more complete implementation we’d want to look at writing our own regex library using something like the Boyer-Moore algorithm to improve the search time.

One last crazy idea. MTS has a PLUS compiler that produced PDP-11 object code, *PLUS11. What if we compiled grep.plus to run on the PDP_11, bringing grep back home? Unfortunately the pattern system routines like patbuild aren’t available on the PDP-11, but it’s only a matter of implementation…

Update 28 June 2020: according to the comment from Jeff Ogden, it is possible to get access to the contents of the parameter field without case conversion by using the PARSTR subroutine documented on page 366.1 of Volume 3.

Any other suggestions for improvements? Please post in the comments.

Final thoughts on PLUS

I really enjoyed using PLUS. The language feels like C with a more Pascal-ly syntax, balancing power with expressiveness. The integration with MTS is extensive, and if you want to extend MTS further it would be an ideal choice.

Further information

Full source code for these programs can be found on github.

There’s an interesting post on a FreeBSD mailing list by the original author of GNU grep on why it is so fast.

The MTS File Editor pattern matching language is described from page 159 onwards in Volume 18 of the MTS documentation set.

PLUS - Language Features

Sun, 12 Jan 2020 09:28:53 +0000

Let’s look in more detail at some of the features of the PLUS language.

Format

PLUS is free format and case-insensitive, so the variable count is the same as COUNT. Comments are the same as PL/I and C, ie /* ... /*. Statements are separated by semicolons. Input files to the compiler contain procedures and global definitions so they can be compiled separately.

Variables and types

Variables must be defined before use and given a type. They can then be assigned to with :=. Numeric types must be given a range, for example:

variable Count is (1 to 5);
variable Temperature is (-100 to 100);
Count := 1;
Temperature := -100;

Type definitions can be names with type and multiple definitions can be done on the same line:

type Temperature_Type is (-100 to 100);
variable Current_Temp is Temperature_Type;
variables High_Temp, Low_Temp are Temperature_Type;

The third line above is an example of multiple definitions on the same line; the variables and are keywords are just syntactical sugar for the singular forms.

Fixed string types include the length of the string, variable strings contain a min/max length. So in the below, My_Name is varying. Strings can be concatenated with ||.

variable My_Name is character(50);
variables First_Name, Last_Name are character(1 to 25);
First_Name := "Jane";
Last_Name := "Doe";
My_Name := First_Name || Last_Name;

Bit types allow precise control over the amount of memory used:

variable Full_Word is bit(32);
variable Byte is bit(8);

There are type attributes such as aligned or packed for further fine-grained control.

Identifiers are like C enums:

variable Device is (Reader, Punch, Printer);

There are also real and set types defined in the language but not fully implemented - so you can create a real and assign to it but not do arithmetic.

Arrays have an index (which can be non-numeric) and a value

variable Lookup is array character(1) of character(8);
variable Matrix is array (1 to 10) of array (1 to 10) of Temperature_Type;

The size of the array must be determined at compile time. Elements can be accessed via round brackets.

Pointers work similarly to C pointers but use the suffix @ for de-referencing and the built-in procured Address for assignment.

variable Ptr is pointer to Count_Type;
type Count_Type is (1 to 10);
variable x is Count_Type;

x := 5;
Ptr := Address(x);
Ptr@ +:= 1;

Note that the type of what the pointer is accessing (here Count_Type) can be defined after it is introduced. Note also the +:= form to increment a value; here the underlying variable x pointed to by Ptr is updated to be 6.

Record types define structures.

type My_Record is
   record
      a is (1 to 1),
      b is character(50)
   end;

There are also variant records which allow something similar to C’s unions.

equate allows aliasing of variables or variable expressions.

Procedures

Procedures need to be declared before they are defined. They can also be treated as types.

/* Pull in definition of Integer */
%Include(Numeric_Types);

type Arithmetic_Procedure is
   procedure
   parameters
      x is Integer,
      y is Integer
   result
      answer is Integer
   end;

/* Declaration */
procedure Plus is Arithmetic_Procedure;

/* Definition */
definition Plus;
  answer := x + y;
end Plus;

/* ... */
variable x is Integer;
x := Plus(2, 3);

Parameters are passed by value by default; you can define them as reference parameter to pass a reference in instead, and the compiler will behind the scenes pass a pointer and de-reference it in the procedure.

Expressions and control structures

The usual range of arithmetic and logical expressions are supported. There is no separate Boolean type but anything non zero is counted as true.

For conditionals, there is if ... then ... elseif ... else... end if and select ... case ... end select.

The cycle statement starts a infinite loop that can be broken out of using exit or restarted with repeat, which can be used to write loops. An example from the tutorial:

variables Count, Return_Code are Integer,
String is Varying_String;
Count := 0;
/* Loop reading and writing records, counting number copied. */
cycle
   Scards_Varying(String, Return_Code);
   if Return_Code ¬= 0
   then
      /* Terminate loop when no more input */
      exit
   end if;
   Spunch_Varying(String);
   Count := Count + 1
end cycle;

A more restrictive do statement allows single variable incrementing or decrementing, like we saw in the Hello World program in part 1.

begin ... end can be used to start a new block with its own scoped variables, and supports exit and break like cycle.

Constants, macros and compiler directives

Compile time constants can be defined as follows

constant Zero_Temp is 0;

and can be used in type definitions as well as variable initialisation.

Macros provide a procedure like interface and copy the text of the macro into the current scope.

Compiler directives start with %. We’ve seen %Title in part 1 and $Include above; other directives control things like compiler listing output and extra code checks.

Input/output and the standard library

There are only a few built in procedures in PLUS; most functionality is provided by the standard source library *PLUS.SOURCELIB. This include I/O routines like Sprint_String or Scards_Varying which respectively send a fixed string to the output device and read a varying string from the input device.

A more complex, printf style procedure called Message can be used for string printing.

Message(Msg, "<hi> items found at <v></>", count, location);

This will print the halfword integer and varying strings included in the parameter list. The </> prints a new line. (I think the resemblance to HTML-like tags is coincidental, as PLUS predates even SGML of which HTML was a subset).

The standard source library also includes many routines to call MTS system procedures so you can control devices, file attributes directly from PLUS.

Further information

As mentioned in part 1, the main language tutorial and reference is at Bitsavers along with the source library reference.

PLUS - Introduction

Sun, 05 Jan 2020 09:45:05 +0000

The PLUS language holds a special place in the history of MTS - let’s look at it in more detail.

PLUS

PLUS was created by Alan Ballard and Paul Whaley of the University of British Columbia in the 1970s, based on language work done for a previous experimental OS called SUE. According to the HELP pages for PLUS:

PLUS is superficially quite different from Sue or Pascal; however the underlying language semantics are really very similar. Users familiar with the programming language C will also recognize much of its structure and semantics in PLUS.

PLUS on MTS

PLUS was used heavily at MTS sites as a system development language, as it provides a structured programming environment easier to use than lower level languages, while still allowing access to machine level features in a way a more generic language such as Pascal did not. The implementation also came with a large source library that made writing complex programs easier. It could generate object code both for the System/360 and both PDP/11 and Motorola 68000 systems.

The compiler was written in PLUS and the source can be found on the distribution tapes under component 1042.

Prerequisites

No special installation instructions to get this language running - just do the standard D6.0 setup as described in this guide and then sign on as a regular user such as ST01.

Compiling and running a program

The *PLUS compiler takes its input from scards and writes output to spunch, like many other language translators.

$run *PLUS scards=hello.plus spunch=-load

Hello world

Let’s show this in action. Assume we have a program in the file hello.plus, let’s look how we’d list, compile and run it.

# $list hello.plus

      1     %Title := "Hello World Program";
      2
      3     %Include(Sprint_String, Main);
      4
      5     definition Main;
      6       variable Count is Integer;
      7       do Count := 1 to 5
      8         Sprint_String("Hello, world!");
      9       end do;
     10     end Main;


# $run *plus scards=hello.plus spunch=-load
# Execution begins   07:26:15


 Hello World Program                                                                User REL.   Fri May  3/19 07:26:16     Page    1


      1.       1 |%Include(Sprint_String, Main);                                                               hello.plus

 No messages for global String_Types.
 Global size 0 bytes.

 No messages for global Numeric_Types.
 Global size 0 bytes.

                   ****************************************************************************************
                   *                                                                                      *
                   *  procedure Main                                                                      *
                   *     parameter is Par (ref).                                                          *
                   *     result is Rc.                                                                    *
                   *     external name is "MAIN    ".                                                     *
                   *                                                                                      *
                   ****************************************************************************************

  24810.       1 |definition Main;
      6.       2 |   variable Count is Integer;
      7.       3 |   do Count := 1 to 5
      8.       1 |      Sprint_String("Hello, world!");
      9.      25 |   end do;
     10.      26 |end Main;

 No messages for procedure Main.
 215 bytes code generated; 424 bytes stack required.

 String_Types   Numeric_Types   Main   Mts_Io_Types   Main                                                                 Page    1


 Plus/370 Compilation -- University of Michigan -- Version 28/16                    User REL.   Fri May  3/19 07:26:16     Page    2

                                                   C r o s s    R e f e r e n c e

       +------------------------------------------------+             Sprint_String         macro       1:8       1:4
       | References are of form   page:coordinate,...   |             Sprint_Varying        macro       1:7       1:7
       |                                                |             Standard_String_Length
       | Codes used are:                                |                                   constant    1:2       1:3,4,5
       |    D - procedure definition                    |             Str                   macro parm  1:8       1:23,24
       |    S - store reference                         |             Str                   macro parm  1:9       1:6
       |    @ - pointer dereferenced                    |             String_Length_Type    type        1:3       1:8
       |    A - address taken                           |             String_Types          global      1:1
       |    E - equated or opened                       |             Transmitted_Length    field       1:8
       |                                                |             Varying_String        type        1:5       1:5
       | *  indicates procedures and globals with errors|             Varying_String_Length field       1:8
       +------------------------------------------------+             Varying_String_Structure_Type
                                                                                            type        1:6
 +-------------------------------------------------------------+      Varying_String_Text   field       1:9
 |   Symbol                Usage      Decl      References     |
 +-------------------------------------------------------------+

   Actual_Length         field       1:8
   Buff                  parameter   1:15
   Count                 variable    1:2       1:3S
   Fdub                  field       1:17
   Fixed_String          type        1:4       1:9
   Integer               type        1:6       1:15,2,19
   Len                   parameter   1:16
   Len                   variable    1:22      1:23S,24A
   Line                  variable    1:5       1:6S,23,24A
   Lio_Number            field       1:19
   Liounit               field       1:15
   Lnum                  parameter   1:18
   Main                  procedure   1:17      1:1D
   Main_Procedure_Type   type        1:12      1:17
   Maximum_Integer       constant    1:4       1:5,6
   Maximum_Length        field       1:8
   Maximum_Short_Integer constant    1:2       1:3,7
   Minimum_Integer       constant    1:5       1:6
   Minimum_Short_Integer constant    1:3       1:7
   Mods                  parameter   1:17
   Mts_Fdub_Kind         constant    1:10      1:16
   Mts_Fdub_Type         type        1:2       1:17
   Mts_Io_Extended_Modifiers_Type
                         type        1:5
   Mts_Io_Length_Type    type        1:6
   Mts_Io_Modifiers_Type type        1:4
   Mts_Io_Types          global      1:1
   Mts_Io_Unit_Type      type        1:11
   Mts_Line_Number_Type  type        1:3       1:18
   Mts_Lio_Number_Kind   constant    1:10      1:18
   Mts_Liounit_Kind      constant    1:10      1:14
   Mts_Unit_Kind_Type    type        1:10      1:13
   Notification          result      1:19
   Numeric_Types         global      1:1
   Par                   parameter   1:14
   Rc                    result      1:15
   Short_Integer         type        1:7       1:8,16,22
   Sprint                procedure   1:21      1:24
   Sprint_Procedure_Type type        1:13      1:21


                                                                                                                           Page    2


 Plus/370 Compilation -- University of Michigan -- Version 28/16                    User REL.   Fri May  3/19 07:26:16     Page    3


 The following libraries were specified for this compilation:

   *PLUS.SOURCELIB       9 members included.


 Total code generated:             215 (bytes)
 Total warning messages:             0
 Total error messages:               0
# Execution terminated   07:26:15  T=0.075

# $run -load
# Execution begins   07:26:23
 Hello, world!
 Hello, world!
 Hello, world!
 Hello, world!
 Hello, world!
# Execution terminated   07:26:23  T=0.001

In the next article, we’ll look at the features of PLUS in more detail.

Further information

A paper describing Project SUE can be found at the ACM website.

The main language tutorial and reference is at Bitsavers along with the source library reference.

Site Update, December 2019

Mon, 30 Dec 2019 18:42:21 +0000

I’ve switched the blog engine for this site from Ghost to Hugo. All existing links should work, but please leave a comment or email me if anything is broken.

Expect some new posts soon, starting with a look at the PLUS language.

GPSS - Introduction and Barber Shop Simulation

Sun, 07 Jan 2018 01:28:53 +0000

_{Barber shop simulation GPSS block diagram from General Purpose Simulation System/360: Introductory Concepts and Case Studies by Thomas J. Schriber, October, 1968.}

We’ll now look at GPSS, a simulation language included in MTS. Due to the specialized nature of this language I’ll only devote a single post to it - but it’s a very interesting language, so let’s dive in!

General Purpose Simulation System

GPSS, General Purpose Simulation System, is a language to simulate discrete systems to see how they perform over time. Sample uses include modeling a checkout at a supermarket or how a manufacturing assembly line will work. The programmer defines how transactions are created (eg a shopper), what resources are available (eg how many checkouts and how long they take to process) and how transactions move through the system. When run, it simulates a clock and processes these transactions, giving output that shows the performance of the system, eg how long on average a shopper had to queue for and how busy the checkouts where during a simulated day.

GPSS on MTS

GPSS was created by Geoffrey Gordon in around 1961 and was originally implemented on IBM systems. The version we have on MTS, GPSS/360, is available as *GPSS. Later versions of GPSS such as GPSS/H did run on MTS and may be available in future distributions (see this message at the MTS Archive).

Prerequisites

No special installation instructions to get this language running - just do the standard D6.0 setup as described in this guide and then sign on as a regular user such as ST01.

A barber shop simulator

As a sample program, let’s look at the Barber Shop: First Model from General Purpose Simulation System/360: Introductory Concepts and Case Studies by Thomas J. Schriber.

We are modeling a barber shop with the following qualities:

The shop contains one barber and one barber’s chair, open for eight hours in a day.
Customers arrive on average every 18 minutes, with the arrival time varying between 12 and 24 minutes.
If the barber is busy, the customer will wait in a queue.
Once the barber is free, the next customer will have a haircut.
Each haircut takes between 12 and 18 minutes, with the average being 15 minutes.
Once the haircut is done, the customer will leave the shop.

We want to answer these questions:

How utilised is the barber through the day?
How long does the queue get?
On average, how long does a customer have to wait.

The manual uses a block diagram notation to show how this is simulated - you can see this at the top of this page. The equivalent GPSS program looks like this:

       SIMULATE
       GENERATE   18,6       CREATE CUSTOMERS
       QUEUE      2          CUSTOMERS QUEUE UP IF NECESSARY
       SEIZE      3          ENGAGE THE BARBER WHEN HE BECOMES AVAILABLE
       DEPART     2          CUSTOMER LEAVES THE QUEUE
       ADVANCE    15,3       CUSTOMER GETS HIS HAIR CUT
       RELEASE    3          RELEASE THE BARBER
       TERMINATE  0          LEAVE THE BARBER SHOP
       GENERATE   480        GENERATE A TIMER AFTER 8 HOURS OF SIMULATED TIME
       *
       TERMINATE  1          SHUT OFF THE RUN
       START      1          CARRY OUT THE SIMULATION
       END                   RETURN CONTROL TO THE OPERATING SYSTEM

The text at the end of each line is a comment; starting a line with * means the rest of the line is a comment; we use this just to separate the two parts of the program as explained below.

GPSS works in units rather than absolute time, so we shall say that 1 time unit is equal to 1 minute. Programs can be read from top to bottom: the simulator runs by advancing the clock one time unit and working out where transactions are in the system.

The first line, SIMULATE, denotes the start of the code.

GENERATE 18,6 means generate a transaction - a barber shop customer - every 18 minutes ± 6 minutes.

QUEUE 2 defines a queue with ID 2, denoting the queue where customers will wait.

SEIZE 3 defines a facility with ID 3. The facility is the barber and this line means if the barber is free, the next customer occupies the barber until released.

DEPART 2 says that the customer leaves the queue when occupying the barber.

ADVANCE 15,3 means that transactions in this state only move on after 15 minutes ± 3 minutes - modeling the time taken for a haircut. After that RELEASE 3 shows that the customer no longer occupies the barber and TERMINATE 0 ends the transaction, showing that the customer has left the shop.

That is all that is needed for the basic simulation, but if run like this it would never stop, as we have not modeled the 8 hour period the shop is open.

To do this we generate a new transaction with GENERATE 480, which means generate a transaction after 480 minutes, ie 8 hours. The next line, TERMINATE 1, stops the simulation after this transaction is generated.

With that done, the last two lines start the simulator and returns control to MTS when it is done.

Running the program using `*GPSS`

*GPSS takes the input file on scards and outputs to *sink* by default. Assuming the simulation defined above is stored in barb1.gpss, this is how it would look:

We start off with the program listing, where GPSS denotes which lines are components of the simulation with a block ID. So GENERATE 18,6 is on line 3 but is block 1.

$run *gpss scards=barb1.gpss
Execution begins   16:07:50


     GPSS/360    VERSION 1  MODIFICATION LEVEL 4    MTS MODEL (AN104)    16:07:50  11-03-17

     LINE# CARD#  BLOCK#  *LOC   OPERATION  A,B,C,D,E,F,G    COMMENTS

     1.000     1                 SIMULATE
     2.000     2          * BARBER SHOP SIMULATOR
     3.000     3  1              GENERATE   18,6       CREATE CUSTOMERS
     4.000     4  2              QUEUE      2          CUSTOMERS QUEUE UP IF NECESSARY
     5.000     5  3              SEIZE      3          ENGAGE THE BARBER WHEN HE BECOMES AVAILABLE
     6.000     6  4              DEPART     2          CUSTOMER LEAVES THE QUEUE
     7.000     7  5              ADVANCE    15,3       CUSTOMER GETS HIS HAIR CUT
     8.000     8  6              RELEASE    3          RELEASE THE BARBER
     9.000     9  7              TERMINATE  0          LEAVE THE BARBER SHOP
    10.000    10          *
    11.000    11  8              GENERATE   480        GENERATE A TIMER AFTER 8 HOURS OF SIMULATED
    12.000    12  9              TERMINATE  1          SHUT OFF THE RUN
    13.000    13                 START      1          CARRY OUT THE SIMULATION
    14.000    14                 END                   RETURN CONTROL TO THE OPERATING SYSTEM

Next, GPSS shows how many transactions were in each block at the end of the simulation and in total.

RELATIVE CLOCK          480  ABSOLUTE CLOCK          480
 BLOCK COUNTS
 BLOCK CURRENT    TOTAL    BLOCK CURRENT    TOTAL    BLOCK CURRENT    TOTAL    BLOCK CURRENT    TOTAL    BLOCK CURRENT    TOTAL
     1      0        27
     2      0        27
     3      0        27
     4      0        27
     5      1        27
     6      0        26
     7      0        26
     8      0         1
     9      0         1

We can see that 27 transactions were generated in block 1, which means 27 customers entered the shop during the day. Blocks 8 and 9 had 1 transaction, which is expected as this was the timing transaction. Why does block 5 have one current transaction while all others are zero? Block 5 is the ADVANCE statement, representing the haircut, and this means one customer was in the chair at the end of the simulated day.

GPSS then prints out statistics on the facility, or the barber in our simulation:

 FACILITY        AVERAGE         NUMBER        AVERAGE          SEIZING    PREEMPTING
               UTILIZATION      ENTRIES       TIME/TRAN        TRANS. NO.  TRANS. NO.
        3          .816              27          14.518            1

So our barber was used 81.6% of the day, and each haircut took on average 14.518 minutes.

We then see details of the queue:

 QUEUE      MAXIMUM     AVERAGE     TOTAL       ZERO     PERCENT      AVERAGE      $AVERAGE      TABLE     CURRENT
           CONTENTS    CONTENTS    ENTRIES    ENTRIES     ZEROS     TIME/TRANS    TIME/TRANS    NUMBER    CONTENTS
     2            1        .085        27         16       59.2         1.518         3.727
  $AVERAGE TIME/TRANS = AVERAGE TIME/TRANS EXCLUDING ZERO ENTRIES

MAXIMUM CONTENTS means there was never more than one customer in the queue. Although 27 customers entered the queue, 16 were zero entries - this means they entered and immediately left the queue, ie the barber was unoccupied when they entered the shop. For those that did wait in the queue, the average wait was 3.727 minutes; including the zero entries, the average time for all customers to wait was 1.518 minutes.

Finally, GPSS prints usage statistics and exits:

CPU TIME USED (SECONDS)

  ASSEMBLY:      .001

TOTAL BLOCK EXECUTIONS:     189

MSEC/BLOCK AVG CPU TIME:   .003

Execution terminated   16:07:50  T=0.004  RC=0  $0.00

It’s interesting to compare this to the printout in the manual from 1968. Our run took 0.004 seconds of CPU time, compared to 4.5 seconds then. And of course our run had no charge, whereas the run from 1968 would have cost 41¢.

The manual goes on to refine the model further - dealing with the customer left in the chair, and simulating more complex scenarios - but we will leave it at that for now.

Further information

Full source code for the program described above can be found on github.

The original IBM manuals for GPSS/360 don’t appear to be available anywhere online. The best reference I’ve found is, as mentioned above, General Purpose Simulation System/360: Introductory Concepts and Case Studies at Deepblue.

Modern implementations of GPSS on Windows are sold by Wolverine Software and Minuteman Software; both offer a free student version with limited model sizes.

Several other simulation languages have been created, eg Simula; a list of languages for discrete event simulations can be found at Wikipedia.

System/360 Assembly Language - Caesar Cipher

Sun, 17 Dec 2017 01:59:09 +0000

In the last part of this series we’ll write a real program in assembly language.

The problem

We’ll implement the Caesar cipher from Rosetta Code. This is a very simple cipher where the key indicates how much to rotate the alphabet by. So with a key of 2, ABC XYZ would be encoded as CDE ZAB. The solution should handle both encoding and decoding; decoding simply needs a rotation by the key in the opposite direction.

Finding a algorithm

This appears quite simple at first. Take each letter’s code, add the key and return the new letter, accounting for wrap around at Z.

However, this assumes that letters are coded in a contiguous manner, as they are in ASCII. The System/360 uses EBCDIC, and if you look at the code chart on Wikipedia you’ll see that A, B, C, … I are contiguous, but there’s then a gap of 7 characters before J, K, … R, then another gap and so on.

Now you could account for this but it would be very fiddly in assembler. Instead, let’s try another way.

What if we transformed A, B, C into offsets 0, 1, 2. Next, add the key and use that as an index into a table of letters repeated to allow wrap around. This should work, but how to implement it?

Turning letters into offsets

The first step is turning A, B, C into 0, 1, 2. There’s a useful opcode called TR that can help us here.

TR WORK,OFFSETS

This will take each byte in WORK, look up its position in OFFSETS and update WORK to be the value found there. So if WORK[0] is ‘A’ (193 in EBCDIC), find the value at OFFSETS[193], which we could arrange to be 0, and then update WORK[0] to be that value.

For this to work, we need to set up OFFSETS correctly. This can be done with some trickery with DC:

OFFSETS  DC    256AL1(*-OFFSETS)
         ORG   OFFSETS+C'A'
         DC    X'000102030405060708'
         ORG   OFFSETS+C'J'
         DC    X'090A0B0C0D0E0F1011'
         ORG   OFFSETS+C'S'
         DC    X'1213141516171819'
         ORG

The first line defines

an address A, 32 bits
converted to length of 1 byte with L1
repeated 256 times
with value at each time *-OFFSETS, where * is the current location

The effect of this is to create a block of memory 256 bytes long with values 0, 1, 2, …, 255.

The next line uses ORG to set the location counter to OFFSETS+C'A', ie the position where A would be in the EBCDIC table. We then overwrite a part of the 256 byte block with the bytes 00, 01, 02, …, 09, creating the offset to replace letters A - I with. We do this again for the letter run starting with J and S.

Turning offsets into letters

To go the other way, ie change an offset like 0, 1 into letters A, B, we define a block of letters:

FLAT0    DC    C'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
FLAT     DC    C'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
FLAT1    DC    C'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

We do this contiguously three times to allow for forward and reverse rotations with the key, so FLAT+1 gives us B and FLAT-1 gives us Z. Doing it this way allows easy access; we could just use one block of letters and deal with rotated offsets past the ends with extra logic, but I don’t mind giving up memory for ease of access here.

Byte access to memory

The final piece we need is a way to access bytes in memory. For this we can read a byte (insert a character) with IC, eg:

         IC    4,WORK(1)

This will set register 4 to the value in memory at the byte addressed by WORK + 1.

To store a character back into memory, STC can be used in a similar way.

The ROT subroutine

With this we have enough to define the subroutine to rotate a message by a given key:

* ROT subroutines implements Caesar cipher message letter rotation
*
* Parameters:
* R0 - Key for cipher. 1 to 25 to encode, -1 to -25 to decode
* WORK - Buffer containing message to encode/decode of length MSGLEN
*        Will be overwritten with encoded/decoded message
* Return values:
* None
*
         ENTRY ROT                Subroutine entry for ROT
ROT      ENTER 12,SA=RSAVE        Use R12 for base address
         TR    WORK,OFFSETS       Translate letters into offsets
         L     1,=F'0'            Loop start value
         L     2,=F'1'            Loop increment
         LA    3,L'MESSAGE-1      Loop final value
LOOP     IC    4,WORK(1)          Get message byte at loop index
         C     4,MAXOFF           Is it an offset?
         BH    STORE              If no, don't change it
         LA    10,FLAT            Load base of flat letter array
         AR    10,0               Add the key displacement
         IC    4,0(4,10)          Fetch into R4 FLAT+KEY+OFFSET
STORE    STC   4,WORK(1)          Store char back into work
         BXLE  1,2,LOOP           Loop if index <= final
         EXIT

We use a predefined area of memory WORK to do the transformation rather than passing in an address, again just for convenience.

Note the explicit use of addressing in IC 4,0(4,10). The second parameter means use register 10 as the base address and add the contents of register 4 to the displacement 0.

One other observation is that the BXLE loop is only needed as we want to skip over non-alphabetic characters in the message. If we knew the message can only contain A-Z, we could do something like TR WORK,FLAT+KEY to do the whole message in one go.

Putting it together

We need a couple more things: first the definition of the message and key, and working areas:

*
* Inputs to program
*
MESSAGE  DC    C'THE FIVE BOXING WIZARDS JUMP QUICKLY!'
KEY      DC    F'7'
*
* Working buffers
*
ENC      DS    CL(L'MESSAGE)
DEC      DS    CL(L'MESSAGE)
WORK     DS    CL(L'MESSAGE)
RSAVE    DS    18F                Save area
*
* Constants
*
MAXOFF   DC    F'25'

And finally, a test call to encode and decode the message, using MVC to copy a block of memory to another location:

CAESAR   START 0                  Program at relative address 0
         USING CAESAR,12          R12 will contain program addr
         LR    12,15              Load R12 with absolute addr
*
* Encode the plain-text message to ENC
         MVC   WORK,MESSAGE       Copy message to WORK
         L     0,KEY              Set key
         CALL  ROT                Encode the message
         MVC   ENC,WORK           Copy encoded message to ENC
*
* Decode the encoded message to DEC
         L     0,KEY              Set the key
         LNR   0,0                Negate the key for decoding
         CALL  ROT                Decode the message
         MVC   DEC,WORK           Copy decoded message to DEC
*
* Print results and exit
         SPRINT MESSAGE           Print the original message
         SPRINT ENC               Print the decoded message
         SPRINT DEC               Print the encoded message
         SYSTEM                   Exit program

Assembling and running the program

$ run *asmg scards=caesar.asm spunch=-load sercom=*sink* par=test

...

$run -load
Execution begins   18:29:02
THE FIVE BOXING WIZARDS JUMP QUICKLY!
AOL MPCL IVEPUN DPGHYKZ QBTW XBPJRSF!
THE FIVE BOXING WIZARDS JUMP QUICKLY!
Execution terminated   18:29:02  T=0  RC=0  $0.00

Thoughts on the program and assembly

I think that was the hardest program to write of all the languages so far. The documentation is very good, but terse - I can imagine reading the Principle of Operation several times would pay off greatly. Also having to flip between Principles, the Assembler F reference and MTS documentation rather than having everything in one place was tough. But it was very rewarding to get the program running.

I’m not entirely happy with the final design I came up with - I’m sure there’s an easier or more efficient way. I’d love to hear from experience System/360 assembly language programmers out there how you’d implement this.

Further information

Full source code for this program can be found on github.

System/360 Assembly Language - Features

Sun, 10 Dec 2017 01:17:33 +0000

_{Functions of the central processing unit, from A Programmer’s Introduction to IBM System/360 Assembler Language}

In the previous post we got a simple assembly language program running. Let’s now look in more detail at how to program in System/360 assembly language. Although a lot of this material is common across other System/360 operating systems and assemblers, it does contain specifics for MTS and Assembler G.

This only covers the surface of the subject: see the end of this post for some of what was missed and how to find more information.

Architecture overview

The IBM System/360 and its derivatives has the following basic architecture.

32 bit words, with access to 16 bit halfwords and 8 bit bytes.
Big-endian, using 2’s compliment for signed values.
16 general purpose 32 bit registers, 4 64 bit floating point registers, plus support for BCD arithmetic.
24 bit memory addressing.
A 64 bit program status word (PSW), which contains the address of the current instruction being executed, condition codes and interrupt masks.

Most System/360 models did not support virtual memory, but the one used for MTS did.

Assembly language

The assembly language defined by IBM is line based, with the following components separated by whitespace:

An optional label, which must start in column 1 if present.
An opcode, assembler directive or macro indicating the operation to perform.
An optional set of operands separated by commas.
An optional comment.
An optional identification sequence, in columns 73-80, commonly used to number each statement.

Apart from the first and last element, which columns are used is not important, but by convention they are lined up.

An example

Let’s look at lines from the ‘Hello, world’ example from the last post to illustrate these features.

This line loads registers 12 with the contents of register 15.

         LR      12,15             LOAD R12 WITH ABSOLUTE ADDR

The next line loads register 3 with the value found at the address with label RUNS.

         L       3,RUNS            R3 COUNTS DOWN NUMBER OF RUNS

Looking at the line labeled RUNS, we can see the value pointed to defined as a constant using the assembler directive DC. Constants of different types are represented with quotes, so F'5' means a fullword (32 bit quantity) with a value of 5. X'BEEF0' would be a 20 bit value composed of the 5 hex digits BEEF0 each taking up 4 bits.

RUNS     DC      F'5'              NUMBER OF RUNS TO MAKE

DC stands for data constant, and arranges a value to be placed at a location in memory after the previous line. DS can be used to arrange data storage, allowing the program to write values back to memory.

Finally, here is a macro call, which will take the string as parameter and arrange a subroutine call to the SPRINT service provided by MTS:

LOOP     SPRINT 'Hello, world!'    PRINT THE MESSAGE

Operation formats, base registers and addressing

Next let’s see how the assembler constructs machine instructions from parts of this program. The listing sent to sprint when running the assembler contains a dump of memory locations and assembled code for each line. For example, here’s the line where the RUNS constant is stored (I’ve omitted some columns from the listing for clarity). Here we can see the fullword quantity 5 being stored at address 3c.

LOC    OBJECT CODE  SOURCE STATEMENT
00003C 00000005     RUNS     DC      F'5'

The load statement L 3,RUNS looks like this:

LOC    OBJECT CODE   SOURCE STATEMENT
000002 5830 C03C     L       3,RUNS

Breaking down the object code:

Opcodes on System/360 are a single byte: here 58 is the opcode for L, load.
The next four bits, 3, represents the register to load into.
The next four bits, 0 is the index register
The next four bits, C, is the base register.
The final 12 bits, 03C, is the displacement.

The address to load from is base register + index register + displacement. In this example, the index register is 0 which indicates it is not being used, so at run time the system will find the value at offset 3c from whatever is in the base register.

The base register is present in nearly all addressing operations and ensures that System/360 is relocatable: at run time, the start of this piece of code is loaded into memory somewhere and a register is set to that address so all further address arithmetic can use it.

In our example, this was set up with assembler directives at the start of the program:

HELLO    START   0
         USING   HELLO,12
         LR      12,15

Here, START 0 means the program will be placed at offset 0 in the block of memory being composed. USING HELLO,12 states that register 12 (C) will be the base register. Finally, LR 12,15 loads register 12 with the contents of register 15: this is part of the calling convention for MTS, so when the program starts it knows it can find its own start address in register 15. Using USING allows the assembler to take care of the base register for you, but you can also specify it and the index register directly.

This sequence of opcode and operands is called RX format. Other opcodes use other formats; for example, the LR 12,15 is in RR format, where the one byte opcode is followed by two 4 bit register operands. Other formats can take an immediate value and an address, or two addresses.

Loads and stores and binary arithmetic

Armed with this knowledge, it’s fairly easy to understand the basic instruction set described in the IBM System/360 Principles of Operation manual. Let’s look at the load instructions for example:

Name	Mnemonic	Type
Load	LR	RR
Load	L	RX
Load Halfword	LH	RX
Load and Test	LTR	RX
Load Complement	LCR	RX
Load Positive	LPR	RX
Load Negative	LNR	RX
Load Multiple	LM	RS

We’ve seen L and LR already. LH loads a halfword (16 bit) quantity from the given address, sign extending it to a fullword. LTR will load a value and set condition codes, which will look at in the next section. LCR will load a value and toggle the sign; LPR and LNR will load and force positive or negative.

LM, load multiple, uses a format we’ve not seen so far, RS. This format is composed like this:

One byte opcode
Four bits register R₁
Four bits register R₃
Four bits register B₂
12 bits displacement

For LM, data is loaded from the address computed from the base register B₂ + displacement into a sequence of registers starting at R₁ and ending at R₃. So the instruction

LM 3,5,12,0

will load up the registers R3, R4 and R5 with data from the memory address in base register 12 + 0 offset, reading 3 fullword values in sequence.

For stores, we have ST for store fullword quantity in a register to memory, STH for storing a halfword and SM for storing multiple registers to a sequence in memory.

Addition opcodes are A and AR for add memory to register and add register to register. AH to add halfwords and AL/ALR to add ignoring the sign bit. Subtraction is orthogonal.

Multiplication and division result in a 64 bit value so as not to lose precision. The input register must have an even number and the results are stored in that plus the next sequential register, so

M 2,LABEL

will multiply the value of register 2 and the value found at LABEL, then store the results in registers 2 and 3.

The PSW and branches

The PSW, or program status word, is a doubleword that defines the current state of the processor. It includes fields that indicate interrupt masks, state (eg problem state), condition codes and the current instruction address.

The condition code occupies bits 34 and 35. They have the following meaning:

00 - zero
01 - negative
10 - positive
11 - carry/overflow

The condition code is set after many operations, for example add, subtract or load and test.

The branch on condition opcode can be used to branch based on its value. This comes in two formats, a RR instruction BCR where if the branch is made, the address is taken from one register, or BC which uses the base+index+displacement system.

Whether to take the branch or not is determine by a four bit mask. A mask value of 8 means branch if condition code 00 is set, mask value 4 for 01 etc. These can be added together, so a mask value of 12 means branch on either condition code 00 or 01 (zero or negative). If all four mask bits are set, the branch is unconditional, if unset, then the instruction is a no-op.

As specifying the mask each time can be tedious, the assembler provides directives for common cases such as branch if zero or branch if positive. We can see this in the ‘hello, world’ program:

         S       3,DECR            DECREMENT R3
         BP      LOOP              IF R3 POSITIVE, LOOP AGAIN

BP stands for branch if positive, and will test the condition code from the previous S subtract: if the value is positive, then jump to address labeled as LOOP.

Internally, the assembler turns BP LOOP into BC 2,LOOP(0,12), using mask 2 = condition code 10 and if positive branching to the address given by the base register 12 + LOOP.

There are also higher level branch instructions suitable for loops, for example:

         BXLE 1,2,LABEL

BXLE stands for branch on index low or equal. In this example, register 1 is incremented by the value of register 2. If register 1 is less than equal to the value in register 3, then the branch is taken.

Subroutines

Supporting subroutines or functions requires a facility to pass in parameters, jump to the called code, do an operation, and return to the calling code with any results. On most modern systems this is done via a stack, but you may have noticed this was not part of the architecture overview above, so how is this done?

The answer is that a combination of a save area in memory is used to store data plus a calling convention so the caller and callee can exchange information via registers. The actual change in location address is done by a branch when this is set up. The calling convention used is up to the programmer, but in practice IBM defines a standard calling convention so that code in different languages can operate together.

(24 March 2018: See the comment below from Jeff Ogden for more details on the calling convention.)

MTS Volume 3: System Subroutine Descriptions defines this calling convention. Simplifying greatly, for the common S-type routines used by most MTS library functions:

Register 1 points to an address where a list of parameters for the called program is stored..
Register 13 points to a save area, described below.
Register 14 points to the next instruction in the calling program that the called program should return to after execution is done.
Register 15 points to the entry point of the called program.

The save area is a portion of memory with a specific format, owned by the calling program where the called program can save registers and other data. For example, word 6 is used to store the contents of register 0. It is the responsibility of the called program to save data in the save area and restore it before returning execution to the caller.

A byproduct of this is that recursion is not freely available like on stack based architectures, as there is a single save area per program call, multiple calls would overwrite this area. Special code is needed to dynamically allocate save areas if recursion is required.

Macros and calling the MTS system

Setting up these subroutine calls by hand would be tedious. Luckily, the assembler includes a powerful macro facility that helps abstract these away, and macros have been defined as follows:

CALL to pass parameters to a subroutine
ENTER to start a subroutine and set up registers and save area
EXIT to restore saved values and pass back a result code.

Macros are also defined for MTS system facilities. We saw this in the ‘hello world’ program in two places:

LOOP     SPRINT 'Hello, world!'    PRINT THE MESSAGE
...
         SYSTEM                    EXIT PROGRAM

We can see how these were assembled by looking at the listing file. The SYSTEM call is easiest as it takes and returns no parameters:

L     15,=V(SYSTEM)
BR    15

Register 15 is loaded with the address of the SYSTEM subroutine (which is determined at link time) and an unconditional branch is made.

The SPRINT call is more complex:

L     15,=V(SPRINT)                SUBROUTINE TO DO I/O
BAL   1,*+18+((L'###1+1)/2*2)      AROUND CONSTANTS
DC    A(*+14)                      DATA ADDRESS
DC    A(*+8)                       LENGTH
DC    A(0)                         NO MODIFIERS SPECIFIED
DC    Y(L'###1)                    LENGTH
DC    C'Hello, world!'
BALR  14,15                        BRANCH TO SUBROUTINE

The L sets up the subroutine address in register 15. A parameter list is defined with the DCs; the BAL puts the address of this in register 1 and jumps over the constants.. Finally, BALR is used to jump to the address stored in register 15, storing the current address (and other bits from the PSW) in register 14.

Other features

The information presented above should be enough to get started with assembler programming on MTS. We have not covered a number of other features supported by the system, including

Decimal and floating point arithmetic
Logical operations like AND
Byte access and character operations
I/O operations and channels
Other parts of the PSW and their use in system programs.

Further information

See the end of the last post for links to documentation to find out more about assembly language.

In the next post we’ll write a complete program in assembly.

System/360 Assembly Language - Introduction

Sun, 26 Nov 2017 02:02:54 +0000

_{Sample assembly language program form, from ‘A Programmer’s Introduction to IBM System/360 Assembler Language}

After the heights of APL, let’s turn to the lowest level language possible: System/360 assembly language.

System/360 Assembly Language

MTS runs on the IBM System/360, designed from scratch by IBM in the early 1960s as a unified successor to a number of different architectures. System programmers, and application programmers looking for maximum performance used assembler to write code as close to the bare metal as possible.

As the System/360 was a new design, the architecture is clean and fairly simple. It’s a 32 bit architecture with 24 bit addresses, 16 full word registers and 4 64 bit floating point registers. Binary Coded Decimal (BCD) arithmetic and I/O operations are also supported.

Assemblers on MTS

MTS ran originally on a System/360-67, and later on 370 and Amdahl CPUs which provided extensions to the basic instruction set that we will not consider here.

The main assembler available to us today is Assembler G (*ASMG). This is a basic assembler, derived from Assembler F provided by IBM for OS/360 with extensions by the University of Waterloo for improved performance.

At the time of MTS D6, the most common assembler in use was Assembler H. This has a considerable number of improvements to the assembly language supported in Assembler G; however, this is not available in the MTS distribution due to copyright reasons.

ASSIST, Assembler System for Student Instruction & Systems Teaching, was an assembler and emulator used by students to learn assembly. As it emulates the underlying machine it can provide additional debug information and run time control, at the expense of performance. It is available on the MTS distribution as *ASSIST. Finally, *ASMT is a specialised assembler compatible with features on IBM’s time sharing system TSS. We will not consider either of these further in these blog posts.

Prerequisites

No special installation instructions to get this language running - just do the standard D6.0 setup as described in this guide and then sign on as a regular user such as ST01.

Running a program using `*ASMG`

*ASMG will take a file of assembly language instructions from scards and write output to spunch. A program listing can be sent to sprint and errors to sercom if these are set on the command line. Extra parameters can be set with par, for example par=test will add debugging information to the object file.

Linking is done at run time by MTS, so if you are just using the system libraries the object file can be run directly with $run.

Hello world

Let’s see how to run a simple program to print ‘Hello, world!’ five times using assembly language.

The source file (with line numbers) looks like this:

# list hello.asm
       1     HELLO    START   0                 PROGRAM AT RELATIVE ADDRESS 0
       2              USING   HELLO,12          R12 WILL CONTAIN PROGRAM ADDR
       3              LR      12,15             LOAD R12 WITH ABSOLUTE ADDR
       4              L       3,RUNS            R3 COUNTS DOWN NUMBER OF RUNS
       5     LOOP     SPRINT 'Hello, world!'    PRINT THE MESSAGE
       6              S       3,DECR            DECREMENT R3
       7              BP      LOOP              IF R3 POSITIVE, LOOP AGAIN
       8              SYSTEM                    EXIT PROGRAM
       9     RUNS     DC      F'5'              NUMBER OF RUNS TO MAKE
      10     DECR     DC      F'1'              DECREMENT FOR LOOP
      11              END     HELLO             END OF CODE

Here’s how to run the assembler. We send errors to *sink* so they are displayed immediately and a full program listing to -hello.l.

# $run *asmg scards=hello.asm spunch=-load sercom=*sink* sprint=-hello.l par=test
. *** *ASMG has been changed to use *ASMGSYSMAC for the default macro
. *** library instead of *SYSMAC.  It will no longer work with *SYSMAC.
# Execution begins   18:19:08 
 
  ASSEMBLER (G) DONE           18:19:08   30 SEP 17 
 
  NO STATEMENTS FLAGGED IN THIS ASSEMBLY 
# Execution terminated   18:19:08  T=0.091

We can ignore the *ASMG has been changed... message; NO STATEMENTS FLAGGED means that it worked OK.

Finally, let’s run the assembled program.

# $run -load
# Execution begins   18:19:17 
  Hello, world!
  Hello, world!
  Hello, world!
  Hello, world!
  Hello, world!
# Execution terminated   18:19:17  T=0

Further information

A good place to start is A Programmer’s Introduction to IBM System/360 Assembler Language, which gives an overview of the System/360 architecture and then teaches different aspects of assembly language programming using examples.

A full description of how the System/360 works and the opcodes available is in IBM System/360 Principles of Operation.

OS Assembler Language is a reference guide to assembly language. *ASMG is documented in MTS Volume 2X from page 27 onwards.

MTS Volume 14: 360/370 Assemblers in MTS details the differences between Assembler G and Assembler H, macro libraries, structured programming macros and the ASSIST assembler.

MTS Volume 3: System Subroutine Descriptions describes the ‘standard library’ of routines available to assembler programmers on MTS.

APL - Knuth Shuffle

Sun, 12 Nov 2017 02:50:12 +0000

In the final part of this series, let’s create a real program in APL. As before, we’ll show both the original and transliterated version so we can run the program on MTS’s APL.

The problem

We’ll implement Knuth Shuffle (also known as Fisher/Yates shuffle) from Rosetta Code. This produces a random permutation of a vector.

Using deal

Dyadic ?, or deal, looks an ideal candidate here. Recall from the previous part that x ? y means take x unique items from the population 1 … y. This means that x ? x will give a random permutation of all the values 1 … x, which we can use as vector indices.

What else will we need?

We’ll need to define a monadic function that takes the vector to be shuffled as input and returns a new, shuffled vector.
We need to know the length of the vector, for which we can use rho (⍴ or $RH).
We need to access a series of vector contents by their index, which we can do with [ … ].

Putting this together:

∇S ← SHUFFLE1 V                     "S = SHUFFLE1 V    
S ← V[(⍴ V) ? ⍴ V]                  S = V[($RH V) ? $RH
∇                                   "

Let’s try to run this and see if it works:

        SHUFFLE1 11 22 33
11  33  22  
        SHUFFLE1 11 22 33
22  11  33  
        SHUFFLE1 11 22
22  11  
        SHUFFLE1 11 22
22  11  
        SHUFFLE1 11 22
11  22  
        SHUFFLE1 ,11
11

In the last example we need to use ravel (,) to change the input scalar 11 into a vector of length 1 containing 11.

This function will also work on strings, which are treated as vectors of characters:

        SHUFFLE1 'FACE'
FCEA  
        SHUFFLE1 'FACE'
ACFE

Implementing the algorithm

What if we wanted to implement the algorithm itself, rather then just use deal? Let’s start by looking at the pseudocode given on Rosetta Code. For a vector with indices 0 - last:

for i from last downto 1 do:
    let j = random integer in range 0 ≤ j ≤ i
    swap items[i] with items[j]

What language features will we need from APL?

The temporary variables i and j mean we will need to declare local variables in our function.
Looping can be done by a sequence of instructions with the branch operator (→ or $GO) testing whether we have reached the start of the vector or not.
By default, APL vectors are indexed from 1 … length so we’ll need to account for that in the loop.
The algorithm needs a random number to determine what to shuffle, for which we can use the monadic form of ?.
We need to swap two elements of the vector. I thought this might need a separate function at first that uses a temporary to swap, but after some review of how indexing works in APL I realised we can use v[x,y] = v[y,x] to swap elements at x and y.

Here’s the complete program:

∇S ← SHUFFLE2 V;I;J                 "S = SHUFFLE2 V;I;J
I ← ⍴ V                             I = $RH V
→ (3,7)[1 + I ≤ 1]                  $GO (3,7)[1 + I $LE 1]
J ← ? I                             J = ? I
V[I,J] ← V[J,I]                     V[I,J] = V[J,I]
I ← I - 1                           I = I - 1
→ 2                                 $GO 2
S ← V                               S = V
∇                                   "

Line 2 is tricky: it branches to lines in the vector in round brackets based on the expression in the square brackets. If I is less than or equal to 1 then the expression evaluates to 2, so control jumps to line 7 (S ← V) where the output value is assigned and the function ends. Otherwise it will continue to line 3 and swap an element.

Running this on some test cases shows this works as expected.

Ideally we’d like to use idiomatic APL and avoid a loop altogether. Modern APLs have control structures like repeat, but I can’t see an easy way to do this in APL\360 - if you can, please add a comment!

Performance

Let’s do a test by running each of these implementations 60,000 times with the same input (1 2 3). We can use code like this:

∇RUN1;I                             "RUN1;I
I ← 60000                           I = 60000
SHUFFLE1 1 2 3                      SHUFFLE1 1 2 3
I ← I - 1                           I = I - 1
→ 2 × I > 0                         $GO 2 * I $GT 0
∇                                   "

On my system, SHUFFLE1 takes 7.3s to run and SHUFFLE2 24.6s, which we’d expect as SHUFFLE1 uses the system provided deal function.

I also ran a quick check for randomness by printing the results to a file and seeing how many times each permutation occurred. Over 60,000 runs we’d expect each permutation to appear around 10,000 times; SHUFFLE1 was within 0.5% of that and SHUFFLE2 0.6%.

Internally, ? uses a pseudo-random number generator so true randomness cannot be achieved. Also with a 32 bit word, the number of possible states is 2^32, which limits the number of combinations that can occur. For example, if we wanted to shuffle a deck of 52 cards there are 52! combinations, much more than 2^32.

Final thoughts on APL

APL’s use of a large number of symbols is what first strikes you when learning the language. I found by going through the tutorials that you start picking them up quite quickly, and it’s not hard to write simple programs. However, reading other people’s programs can be difficult, given its compact form and right-to-left structure; I imagine that understanding a large APL code base would take some time.

The language itself is unique and even beautiful; some times I feel like I’m writing mathematics rather than coding. If you have the opportunity then I’d recommend trying it out.

The transliterations needed on emulated MTS add another level of difficulty and unless you want to experience the historical aspects of running APL like this I’d recommend learning APL with a modern implementation that can use APL symbols directly. There are several commercial implementations that run on modern hardware, for example Dynalog. The GNU project also has GNU APL. Several languages have been derived from APL, including K, used for financial analysis.

Further information

Full source code for this program can be found on github.

Jeff Atwood’s Coding Horror blog has a good post on shuffling with a follow-up on the dangers of mis-implementing the algorithm.

Eugene McDonnell wrote an interesting article on How the Roll Function Works in APL\360 and other APLs, giving insight on its implementation.

To see some amazing APL one-liners in action, check out Sixteen APL Amuse-Bouches.

APL - Language features

Sun, 05 Nov 2017 00:42:39 +0000

After the introduction to APL in the last post, let’s now look in more detail on how APL works.

As the emulated system does not support entry and display of APL symbols, we will have to use transliterations, eg * for the multiply symbol ×. The code samples below show the original version on the left and the transliterated version on the right. An appendix at the end of this post lists all symbols used and their transliterations.

The interpreter

Similar to the last language we looked at, PIL, when APL starts up it allows you to enter expressions and get results immediately. The prompt is eight leading spaces and results are printed in the first column.

        21 × 2                        21 * 2
42                            42
a "string"

Monadic and dyadic functions

We can enter simple arithmetic functions and get results as expected.

        21 + 2                        21 + 2
23                            23            
        21 − 2                        21 - 2
19                            19            
        21 ÷ 2                        21 / 2
10.5                          10.5

These are all dyadic functions, ie they take a left and right parameter. Many APL functions also have monadic versions which take only one parameter on the right. Let’s look at how the four basic arithmetic functions work:

        +21                           +21   
21                            21            
        −21                           -21   
−21                           _21           
        ×21                           *21   
1                             1             
        ÷21                           /21   
0.04761904762                 0.04761904762

Plus and minus work as expected; note that negative numbers are displayed with a leading underscore to represent the − symbol. Multiply and divide give more interesting results. Multiply gives the signum of its parameter: -1 if negative, 0 if zero or 1 if positive. Divide gives the reciprocal of its parameter.

The modulus operator (∣ or $|) works the opposite way around from what you may be used to from other languages, so 10 ∣ 12 is 2.

Order of execution is strictly right to left; using brackets allows you to specify what operators works on what parameters

        2×3+2                         2*3+2   
10                            10              
        ÷2×3+2                        /2*3+2  
0.1                           0.1             
        (2×3)+2                       (2*3)+2 
8                             8

Variables and types

Values can be assigned to a variable with ← (=). Variable names need to start with a letter. Underlined letters can also be used; these are transliterated to lower case letters.

        X ← 3                         X = 3    
        Y ← 22                        Y = 22   
        Z ← X × Y                     Z = X * Y
        Z                             Z        
66                            66

As well as single numbers, you can have vectors of numbers. These are entered by separating the elements with spaces. Operators work on vectors as well.

        X ← 1 2 3                     X = 1 2 3       
        Y ← 10 100 1000               Y = 10 100 1000 
        X × Y                         X * Y           
10  200  3000                 10  200  3000

If the dimension of the parameters differ, APL will extend the shorter vector as appropriate - so 1 2 3 × 2 will give 2 4 6.

Strings are introduced using quotes; internally APL treats them as vectors of characters.

Booleans are represented as numbers with a value of 0 or 1. These are returned by comparison functions like equal, greater or equal (=, ≥ or =, $GE). Logical operators like and (∧ or &) can operate on these.

        3 ≥ 2                         3 $GE 2              
1                             1                            
        (3 ≥ 2) ∧ (2 = 2)             (3 $GE 2) & (2 $EQ 2)
1                             1

Vector functions

The rho function (⍴ or $,) gives the dimension of a vector when used moadically. Used dyadically, it can create a matrix from a vector on its right side by giving the shape on the left side.

        ⍴ 10 20 30                    $, 10 20 30               
3                             3                                 
        X ← 1 2 3 4 5 6 7 8           X = 1 2 3 4 5 6 7 8 
            9 10                          9 10
        2 5 ⍴ X                       2 5 $, X                  
1   2   3   4   5             1   2   3   4   5                 
6   7   8   9  10             6   7   8   9  10

Comma (,) used dyadically is called catenate, and adds to a vector.

        x ← 1 2 3 4 5                 x = 1 2 3 4 5 
        x , 6                         x , 6         
1  2  3  4  5  6              1  2  3  4  5  6

Monadic comma (known as ravel) turns a scalar into a vector

         ,1                            ,1  
 1                             1

A vector of length 1 looks like a scalar when displayed. We can tell them apart with double rho, which gives the rank.

         ⍴⍴ 1                          $,$, 1 
 0                             0              
         ⍴⍴ ,1                         $,$, ,1
 1                             1

Iota (⍳, which can be transliterated as any of $IO, $IN or $.) creates a sequence when used monadically and gives index positions when used dyadically. Square brackets can be used to extract elements based on index positions.

        ⍳ 5                            $IO 5           
1  2  3  4  5                  1  2  3  4  5           
        X ← 'ABCDEFGHIJ'               X = 'ABCDEFGHIJ'
        X ⍳ 'CAFE'                     X $IN 'CAFE'    
3  1  6  5                     3  1  6  5              
        X ⍳ 'CAZE'                     X $IN 'CAZE'    
3  1  11  5                    3  1  11  5             
        X[X ⍳ 'CAFE']                  X[X $IN 'CAFE'] 
CAFE                           CAFE

More APL functions

There are over 50 APL functions so it would be difficult to go through them all here, but let’s take a brief tour to show some of them in action.

Ceiling (⌈ or $CE, $MA) and floor (⌊ or $FL, $MI) rounds up/down when used monadically and finds the max/min when used dyadically

         ⌈ 2.3                         $CE 2.3             
 3                             3                           
         ⌊ 2.3                         $FL 2.3             
 2                             2                           
         3 ⌈ 2                         3 $CE 2             
 3                             3

Factorial (!) means take m of n when used dyadically:

        !5                             !5                   
120                            120                          
        2 ! 4                          2 ! 4                
 6                             6

Rotation (⌽, $RO):

        ⌽ 1 2 3                        $RO 1 2 3                   
3  2  1                        3  2  1                             
        2 ⌽ 1 2 3                      2 $RO 1 2 3                 
3  1  2                        3  1  2

Take (↑, $TA) and drop (↓, $DR):

        3 ↑ ⍳ 10                       3 $TA $IO 10                
1  2  3                        1  2  3                             
        3 ↓ ⍳ 10                       3 $DR $IO 10                
4  5  6  7  8  9  10           4  5  6  7  8  9  10

Grade up (⍋ or $GU) gives sorted indices, with grade down doing sort in reversed order.

        X ← 2 14 1 42                  X = 2 14 1 42               
        ⍋ X                            $GU X                       
3  1  2  4                     3  1  2  4                          
        X[⍋ X]                         X[$GU X]                    
1  2  14  42                   1  2  14  42

? used monadically is known as roll, producing a random number between 1 and the right hand argument. Used dyadically, it is known as deal: x ? y means take x unique items at random from the population 1 .. y.

        ?6                             ?6                     
3                              3                              
        ?6                             ?6                     
5                              5                              
        3 ? 6                          3 ? 6                  
6  2  3                        6  2  3                        
        3 ? 6                          3 ? 6                  
3  4  5                        3  4  5

Decode (⊥ or $DE, $BA) converts bases. Encode (⊤ or $EN, $RP) goes the other way. Below we show 2 hours 30 minutes decoded into number of minutes and then re-encoded.

        60 60 ⊥ 2 30                   60 60 $DE 2 30         
150                            150                            
        60 60 ⊤ 150                    60 60 $EN 150          
2  30                          2  30

Operators

An operator in APL differs from a function in that it takes a function on its left hand side. One example is reduction (/ or %): in the example below we give it the plus function which will sum up the elements on the right

        +/ 1 2 3 4                     +% 1 2 3 4                 
10                             10

Let’s try it with -:

        -% 1 2 3 4                     -% 1 2 3 4  
-2                             _2

Why does it return -2? This is due to the right to left associativity of APL: we could expand this as 1 - (2 - (3 - 4)).

Defining your own functions

You can define your own functions with del (∇ or "), Starting a line with del creates a function: the rest of the line specifies the variable that will contain the return value, the function name and its parameters. On subsequent lines, APL will prompt you for the next statement with the line number. A del on its own will close the function. A simple example for a monadic function called INCR that increments its right hand side:

        ∇ C ← INCR A                   " C = INCR A                 
<1>     C ← A + 1              <1>     C = A + 1                    
<2>     ∇                      <2>     "                            
        INCR 3                         INCR 3                       
4                              4

Dyadic functions are created by giving variables before and after the function names. For example, the hypotenuse function:

        ∇ C ← A HYP B                  " C = A HYP B
<1>     C ← ((A⋆2) + (B⋆2))    <1>     C = ((A@2) + (B@2))
          ⋆ 0.5                          @ 0.5
<2>     ∇                      <2>     "
        3 HYP 4                        3 HYP 4
5                              5

Apart from the parameters, any variables used in defined functions will be global by default. To set up local variables, add a semicolon and the variable names on the function definition line.

        ∇ Z ← X FOO Y; A               " Z = X FOO Y;
<1>     A ← X + Y              <1>     A = X + Y     
<2>     Z ← A + 2              <2>     Z = A + 2     
<3>     ∇                      <3>     "             
        3 FOO 5                        3 FOO 5       
10                             10

Flow control in a function can be introduced with the branch function (→ or $GO), which takes the line number to branch to on the right hand side. Branching to line number 0 is equivalent to returning from the function: we saw the in part 1 of this series with the line

→ 2 × N < 5                    $GO 2 * N $LE 5

which would branch to line 2 if N was less than 5, else return from the function.

After defining a function, you can list its contents by entering del, the function name, quad (⎕ or #) in square brackets then del, all on the same line.

∇FOO[⎕]∇                       "FOO[#]"

You can edit or append lines in a function by replacing quad in the above example with a line number. Line numbers can include decimal points, eg to insert a line between current lines 1 and 2 you’d do ∇FOO[1.5]∇

To delete an entire function you need to use the erase system command with the function name, eg )ERASE FOO.

System commands and workspaces

System commands, starting with ), manipulate the APL environment. )OFF will quit APL, )FNS and )VARS will list currently defined functions and variables respectively.

To manage sets of functions and variables, APL has the concept of workspaces. The current set can be saved to a named workspace, eg FOO by the user with the command )SAVE FOO and then loaded later with )LOAD FOO. APL will also automatically save the current set to the workspace CONTINUE on exit and load it again at startup. To wipe out the current running set, use )CLEAR; to delete from disk user )DROP ws.

There are also system workspaces, organised into libraries identified by numbers. Use )LIB n to see the workspaces in library n and then )LOAD n ws to load a names workspace. For example, let’s look at the workspace APLCOURSE in library 1. This defines a function DESCRIBE which explains its contents.

        )LIB 1
ADVANCEDE  
APLCOURSE  
CLASS  
NEWS  
PLOTFORMA  
TYPEDRILL  
WSFNS  
EIGENVALU  
BRFNS  
        )LOAD 1 APLCOURSE
SAVED  16.13.05 08%08%68  
        )FNS
B1X     CHECK   DESCRIBE        DIM     DRILL   DYAD1   DYAD2   EASY  
EASYDRILL       FORM    FUNDRILL        GET     INPUT   QUES    RANDOM 
REDSCAPATCH     REPP    TEACH  
        DESCRIBE
  
THE MAIN FUNCTIONS IN THIS LIBRARY WORKSPACE ARE:  
  
                         TEACH  
                         EASYDRILL  
  
ALL OTHER FUNCTIONS ARE SUBFUNCTIONS AND ARE NOT  
SELF-CONTAINED.  
SYNTAX                         DESCRIPTION  
______                         ___________  
TEACH           AN EXERCISE IN APL FUNCTIONS USING SCALARS  
                AND VECTORS.  THE FUNCTION PRINTS OUT THE  
                CHOICES AND OPTIONS AVAILABLE.  EXAMPLES  
                ARE SELECTED AT RANDOM WITH A RANDOM  
                STARTING POINT.  
  
EASYDRILL       THIS IS THE SAME AS TEACH EXCEPT THAT THE  
                PROBLEMS SELECTED ARE GENERALLY SIMPLER IN  
                STRUCTURE.  PROBLEMS INVOLVING VECTORS OF  
                LENGTH ZERO OR ONE ARE EXCLUDED.

Workspace 6 contains a resource management game called KINGDOM.

In the next post we’ll look at implementing a real program in APL.

Further information

This post has only scratched the surface of APL. See the Further Information section in the APL introduction post for more resources to learn about APL.

Appendix: Transliterations

This is a copy of the table UM Computing Center Memo 382, excluding characters that are marked as not in use.

Meaning	APL Symbol	Transliteration
And	∧	&
Branch	→	$GO $>
Ceiling	⌈	$CE $MA
Circular functions	○	$$ $CI $PI
Comma	,	,
Comment / lamp	⍝	$* $CO
Compression	/	%
Compression axis 1	⌿	$C1
Deal / random	?	?
Decode	⊥	$DE $BA
Del	∇	"
Delta	Δ	$"
Delta underlined	⍙	$U"
Divide	÷	/
Drop	↓	$DR $DO
Encode	⊤	$EN $RP
Equal	=	$EQ
Expansion	\	$%
Expansion axis 1	⍀	$X1
Exponentiation	⋆	@
Factorial	!	! $FA $BC
Floor	⌊	$FL $MI
Grade down	⍒	$GD
Grade up	⍋	$GU
Greater or equal	≥	$GE
Greater than	>	$GT
Ibeam	⌶	$IB $SY
Iota	⍳	$IO $IN $.
Less or equal	≤	$LE
Less than	<	$LT
Locked function	⍫	$L"
Logarithm	⍟	$@ $LO $LN
Membership	∈	$EP $ME
Minus	−	-
Modulus	∣	$MO
Multiply	×	*
Nand	⍲	$N&
Negation / overbar	−	_ $-
Nor	⍱	$N $WR
Not	~	$NO
Not equal	≠	$NE
Null	∘	$:
Or	∨	\| $OR
Period	.	.
Plus	+	+
Quad	⎕	#
Quad-quote	⍞	$#
Quote	'	'
Random	?	?
Rho / dimension	⍴	$, $RH $DI
Rotation	⌽	$RO $RV
Rotation axis 1	⊖	$R1
Semicolon	;	;
Specification	←	=
Take	↑	$TA $UP
Transposition	⍉	$TR
Underlined letters	A - Z</u	a - z _A - _Z

APL - Introduction

Sun, 22 Oct 2017 12:20:47 +0000

We now turn our attention to APL, a unique symbolic programming language that can be run on MTS.

APL, A Programming Language

The concepts behind APL came from work done by Kenneth E. Iverson at Harvard in the late 1950s. He wrote the book A Programming Language from which APL got its name. He moved to IBM in the early 1960s and helped produce the first working version of the language. IBM distributed versions of APL in the 1960s and 1970s, during which time the language was refined into APL2. Implementations were made for other architectures, including microcomputers in the 1980s.

APL is unique for its use of special symbols for functions and the ability to operate on multi-dimensional arrays. Put together, this allows a small amount of code to do a large amount of work. An example (from Wikipedia to compute the prime numbers from 1 to R:

(~R∊R∘.×R)/R←1↓ιR

APL on MTS

The version of APL on MTS is based on APL\360, developed at IBM in the late 1960s. This was adapted to use the local MTS file system and devices, and portions for multi-user support were removed as they were not needed on MTS. Later versions of IBM APL did run on MTS but are not available on the D6 distribution due to copyright reasons.

APL symbols were supported using teletypewriters with a custom keyboard layout and typeballs that could display these symbols on paper.

_{APL Keyboard layout from Wikipedia. CC-SA 3.0}

Not all users would have this special teletypwriter, so APL supports the standard keyboard and printer character set using transliterations for symbols. For example, the divide operator ÷ is replaced with / and the ceiling operator ⌈, which finds the maximum of its arguments, is replaced with either $MA or $CE.

The hardware used by MTS for APL is not supported on Hercules so we will need to use these transliterations when running MTS under emulation.

Prerequisites

Unlike other languages seen so far, we do need to set up APL before using it by installing it from the D5 tapes. The below method was adapted from work done by user halfmeg on the H390-MTS list.

Start with a regular D6.0 setup as described in this guide. Ensure that MTS is not running before following these steps.

Get a copy of the D5 tapes from Bitsavers and extract into a temporary directory.

Locate the files d5.0t1.aws and d5.0t2.aws under the extraction directory and copy these to the Tapes directory under your MTS install

Edit your hercules.cnf and add these lines. These tape devices are unused in the stock D6.0 install; if you have already assigned these for your own use then change the device names here and in the instructions below.

# Add D5 tapes needed to restore APL
018B   3420   Tapes/d5.0t1.aws   ro  # T90B, D5.0T1
018C   3420   Tapes/d5.0t2.aws   ro  # T90C, D5.0T2

The batch instructions to restore APL from these disks is available as a card deck from my github repo on MTS languages. Download that file and copy it to Units/RDR1.txt under your Hercules install, replacing the existing file. Note that the whitespace in the first line is important, so clone the git repo or download the file as raw text.

Start up MTS as normal, including HASP. When it is running, type devinit c from the Hercules console to load the card deck. You should see the below printed on the MTS console if this worked.

00051 MTS **** Remove tape from T90B (6250 BPI)
00051 MTS **** Remove tape from T90C (6250 BPI)

The output from the batch job can be found on the printer in Hercules file Units/PTR2.txt. Examine it for any errors; you can ignore lines like You restored files saved before FEB. 22, 1988. You should see that job extracted files from the tape and set permissions appropriately.

Finally, test that it works by logging into a normal user account (eg ST01) and running

$run *APL,par=sp,noball

The APL start up message should appear. Type )LIB 1 and you should see this listing of library files:

 ADVANCEDE
 APLCOURSE
 CLASS
 NEWS
 PLOTFORMA
 TYPEDRILL
 WSFNS
 EIGENVALU
 BRFNS

Type )OFF to exit APL.

When you next shutdown MTS, you can comment out the two D5.0 tapes in hercules.cnf to free up these devices for future use.

Running a program using `*APL`

*APL is an interactive environment where you can enter expressions and program lines. To start APL, run *APL with the parameters sp (to print spaces after each operator) and noball (to indicate we are not using the special APL typeball.

APL prompts with six leading spaces. You can enter expressions and get results back immediately, aligned in column 1.

System commands start with ). )SOURCE will read lines from a given text file and execute them. )CONTINUE will save a copy of the current workspace to a binary file which will automatically be loaded next time you start APL. )OFF will exit APL.

Hello world

As an example, here’s a simple program to print ‘Hello, world!’ five times. This uses a simple loop - there’s probably a more concise way to do this.

First, create a file called hello.apl containing the following lines:

"HELLO
N=1
'Hello, world!'
N=N+1
$GO 2 * N $LE 5
"

Then start APL and load the text file:

# $run *apl par=sp,noball
# Execution begins   16:30:56 
SAVED  16.30.28 05%27%17
        )SOURCE HELLO.APL

After you enter the )SOURCE command APL will read the file but will not prompt you it has completed. Press the ATTN key to interrupt APL and return control to you. You can then enter HELLO to run the loaded program:

        HELLO
Hello, world!
Hello, world!
Hello, world!
Hello, world!
Hello, world!
        )OFF
  16.31.16 05%27%17 CONTINUE
     16.31.16 05%27%17
CONNECTED    0.00.19
CPU TIME     0.00.00
# Execution terminated   16:31:15  T=0.034

In the next post we’ll look at the APL language in more detail.

Further information

IBM’s APL\360 Primer is a great first read as it introduces the APL\360 system and APL language in a tutorial form. The APL\360 User’s Manual can then be consulted for more in-depth information.

A classic introduction to APL is “APL 360: An Interactive Approach” by Gillman and Rose. A copy can be found at the Software Preservation Group of the Computer History Museum.

UM Computing Center Memo 382 is a guide to the implementation of APL\360 on MTS. I recommend reading the printed copy of this memo from the above source as it includes the hand written APL symbols missing on the source copy.

PIL - Roman numerals

Sun, 15 Oct 2017 03:06:39 +0000

In the final part of this series, let’s create a real program in PIL.

The problem

We will implement arabic to roman number conversion from Rosetta Code.

The algorithm we’re going to use is similar to the one used there for BASIC:

Have a table of all distinct roman numbers ordered by size, including the -1 variants like IV. So roman(0) = “M”, roman(1) = “CM”, roman(2) = “D” etc.
Have another table with the same indices for their arabic equivalents. arabic(0) = 1000, arabic(1) = 900, arabic(2) = 500 etc.
Loop through each index. For each, if the input value is greater than the value of the arabic table at that value, accumulate the roman equivalent at the end of the output string and decrease the input value by the arabic amount. Keep doing this until the remaining input value is smaller than the arabic number.
So for input 2900 the steps would be
- index 0, output -> “M”, input -> 1900
- index 0, output -> “MM” , input -> 900
- index 1, output -> “MMCM”, input -> 0 and end

The solution

As PIL is an interpreted language I’ll show a lightly reformatted transcript of my session as I build up the program in separate parts (and make mistakes along the way). Let’s get started!

# $run *pil
# Execution begins   20:09:19
  PIL/2: Ready

The tables

First we need to set up the tables for arabic numbers in part 1. I will use the number command so that PIL prompts me with line numbers followed by an underscore automatically.

*number 1, 0.01
&*1.0  _arabic(0) = 1000
&*1.01 _arabic(1) = 900
&*1.02 _arabic(2) = 500
&*1.03 _arabic(3) = 400
&*1.04 _arabic(4) = 100
&*1.05 _arabic(5) = 90
&*1.06 _arabic(6) = 50
&*1.07 _arabic(7) = 40
&*1.08 _arabic(8) = 10
&*1.09 _arabic(9) = 9
&*1.10 _arabic(10) = 5
&*1.11 _arabic(11) = 4
&*1.12 _arabic(12) = 1
&*1.13 _$unnumber

The unnumber command exits numbered line prompting mode. It needs to be prefixed with $ to be executed immediately rather than be entered as part of the program.

Let’s run that immediately so we can check it looks correct

*do part 1
*type arabic
  arabic(0) =  1000.0
  arabic(1) =  900.0
  arabic(2) =  500.0
  arabic(3) =  400.0
  arabic(4) =  100.0
  arabic(5) =  90.0
  arabic(6) =  50.0
  arabic(7) =  40.0
  arabic(8) =  10.0
  arabic(9) =  9.0
  arabic(10) =  5.0
  arabic(11) =  4.0
  arabic(12) =  1.0

We can then do the same for the roman numbers.

*number 2, 0.01
&*2.0 _roman(0) = "M"
&*2.01 _roman(1) = "CM"
&*2.02 _roman(2) = "D"
&*2.03 _roman(3) = "CD"
&*2.04 _roman(4) = "C"
&*2.05 _roman(5) = "XC"
&*2.06 _roman(6) = "L"
&*2.07 _roman(7) = "XL"
&*2.08 _roman(8) = "X"
&*2.09 _roman(9) = "IX"
&*2.1 _roman(10) = "V"
&*2.11 _roman(11) = "IV"
&*2.12 _roman(12) = "I"
&*2.13 _$unnumber
*do part 2

The main loop

Let’s now make the main loop to convert the number. We’ll do it in three parts, first the loop over the indices. I put in some comments fir the function.

*number 5, 0.01
&*5.0 _* Main entry point to arabic -> roman converter
&*5.01 _* Input: a (arabic number to convert)
&*5.02 _* Output: r (roman number equivalent of a)
&*5.03 _for i = 0 to 12: do part 6
&*5.04 _done
&*5.05 _$unnumber

Next, the loop for each arabic number. We can use a for with a dummy variable and the while controlling how often it is run.

*number 6, 0.01
&*6.0 _for j = 0 while a >= arabic(i): do part 7
&*6.01 _done
&*6.02 _$unnumber

Finally, in part 7 build up the roman number string and decrease the arabic number.

*number 7, 0.01
&*7.0 _r = r + roman(i)
&*7.01 _a = a - arabic(i)
&*7.02 _done
&*7.03 _$unnumber

Let’s see what these look like now.

*type part 5, part 6, part 7

  5.0    * Main entry point to arabic -> roman converter
  5.01   * Input: a (arabic number to convert)
  5.02   * Output: r (roman number equivalent of a)
  5.03   for i = 0 to 12: do part 6
  5.04   done


  6.0    for j = 0 while a >= arabic(i): do part 7
  6.01   done


  7.0    r = r + roman(i)
  7.01   a = a - arabic(i)
  7.02   done

Trying it out

We can set up the input number in a then call part 5 to convert. The output should go into r.

*a = 13
*do part 5
  Error at step 7.0: r = ?

Ah, r is not initialised so cannot be appended to. We can patch part 5 and try again.

*5.025 r = ""
*do part 5
*type r
  r = "XIII"
*type a
  a =  0.0

Great! There is a side effect though, the input value in a is wiped out as PIL does not have local variables.

Thinking about it, we are relying on the tables being initialised when we run part 5. We should really make it stand-alone by calling part 1 and 2 first.

*5.026 do part 1
*5.027 do part 2

Making it interactive

We should have a way to prompt for a number and then display the conversion.

*number 10, 0.01
&*10.0 _demand a
&*10.01 _do part 5
&*10.02 _type r
&*10.03 _$unnumber

*do part 10
& a = ? _1992
  r = "MCMXCII"

Unit tests!

It may be anachronistic, but we should have some unit tests to see if the conversion works. First let’s define a unit test handler in part 20 that takes the arabic number in a, the expected result in rExpected and then checks this matches.

*number 20, 0.01
&*20.0 _do part 5
&*20.01 _if r = rExpected, then type "OK", r; else type "ERROR', r, rExpected
  Error at step 20.01: SYMBOLIC NAME TOO LONG
&*20.02 _if r = re, then type "OK", r; else type "ERROR", r, re
&*20.03 _done
&*20.04 _$unnumber

rExpected is too long for a variable number so we use a shorter name instead, re.

Let’s test the tester out.

*re = "XLII"
*a = 42
*do part 20
  Error at step 20.01: SYMBOLIC NAME TOO LONG

Ah, the bad line is still there, so delete that and try again.

*delete step 20.01
*do part 20
  ERROR
  r = ""
  re = "XLII"

Wait, that’s not right, why is the output in r blank?

 *type r
  r = ""
 *type a
  a =  0.0

Oh OK, a is clobbered. Let’s set it up again.

*a = 42
*do part 5
*type r
  r = "XLII"
*do step 20.02
  OK
  r = "XLII"
*do step 20.02
  OK
  r = "XLII"
*type part 20

  20.0    do part 5
  20.02   if r = re, then type "OK", r; else type "ERROR", r, re
  20.03   done

*a = 42
*re = "XLII"
*do part 20
  OK
  r = "XLII"

That fixed it. Try the error case.

*a = 42
*re = "XXX"
*do part 20
  ERROR
  r = "XLII"
  re = "XXX"

With that done, set up the tests.

*number 21, 0.01
&*21.0 _a = 2009
&*21.01 _re = "MMIX"
&*21.02 _do part 20
&*21.03 _a = 1666
&*21.04 _re = "MDCLXVI"
&*21.05 _do part 20
&*21.06 _a = 3888
&*21.07 _re = "MMMDCCCLXXXVIII"
&*21.08 _do part 20
&*21.09 _done
&*21.1 _$unnumber

And run them.

*do part 21
  OK
  r = "MMIX"
  OK
  r = "MDCLXVI"
  OK
  r = "MMMDCCCLXXXVIII"

All green. However we did not test all cases such as zero, negative numbers, non-integral numbers etc.

Save and load

To confirm the program is all done and we are not relying on anything in the environment, save it to disk, quit and come back into PIL and try re-running.

*create "roman.pil"
  FILE "ROMAN.PIL" IS CREATED
*save as "roman.pil", all parts
  SAVE COMPLETED
*stop
# Execution terminated   18:51:16  T=0.279

# $run *pil
# Execution begins   18:51:37
  PIL/2: Ready
*load "roman.pil"
*do part 10
& a = ?  _42
  r = "XLII"
*do part 21
  OK
  r = "MMIX"
  OK
  r = "MDCLXVI"
  OK
  r = "MMMDCCCLXXXVIII"
*stop

The complete listing

*type all parts

  1.0    arabic(0) = 1000
  1.01   arabic(1) = 900
  1.02   arabic(2) = 500
  1.03   arabic(3) = 400
  1.04   arabic(4) = 100
  1.05   arabic(5) = 90
  1.06   arabic(6) = 50
  1.07   arabic(7) = 40
  1.08   arabic(8) = 10
  1.09   arabic(9) = 9
  1.1    arabic(10) = 5
  1.11   arabic(11) = 4
  1.12   arabic(12) = 1

  2.0    roman(0) = "M"
  2.01   roman(1) = "CM"
  2.02   roman(2) = "D"
  2.03   roman(3) = "CD"
  2.04   roman(4) = "C"
  2.05   roman(5) = "XC"
  2.06   roman(6) = "L"
  2.07   roman(7) = "XL"
  2.08   roman(8) = "X"
  2.09   roman(9) = "IX"
  2.1    roman(10) = "V"
  2.11   roman(11) = "IV"
  2.12   roman(12) = "I"

  5.0    * Main entry point to arabic -> roman converter
  5.01   * Input: a (arabic number to convert)
  5.02   * Output: r (roman number equivalent of a)
  5.025  r = ""
  5.026  do part 1
  5.027  do part 2
  5.03   for i = 0 to 12: do part 6
  5.04   done

  6.0    for j = 0 while a >= arabic(i): do part 7
  6.01   done

  7.0    r = r + roman(i)
  7.01   a = a - arabic(i)
  7.02   done

  10.0    demand a
  10.01   do part 5
  10.02   type r

  20.0    do part 5
  20.02   if r = re, then type "OK", r; else type "ERROR", r, re
  20.03   done

  21.0    a = 2009
  21.01   re = "MMIX"
  21.02   do part 20
  21.03   a = 1666
  21.04   re = "MDCLXVI"
  21.05   do part 20
  21.06   a = 3888
  21.07   re = "MMMDCCCLXXXVIII"
  21.08   do part 20
  21.09   done

Final thoughts

JOSS is a simple but well designed language - it’s easy to pick up, has a carefully chosen set of features and does the job it’s supposed to do well. Compared to BASIC it seems much more intuitive as a simple language for non-specialists who want to get numeric calculations done quickly. The lack of functions and local variables, plus the heavily interactive nature of the language makes it harder to write larger programs, but given the first version was running in 1963 it’s quite an impressive feat of engineering.

PIL, the version of JOSS implemented on MTS, improves the usability of the original language, eg by not requiring a period at the end of each statement. There is enough integration with the operating system to make it usable. It would be interesting to know what type of use it got at UM.

Several languages were inspired by JOSS, including FOCAL on PDP-8s. It’s also one of the influences on MUMPS, which is still in use today.

Further information

Full source code for this program can be found on github.

PIL - Language features

Sun, 08 Oct 2017 08:54:19 +0000

In the last post we saw some of the history of PIL and how to run it on MTS. We’ll now take a closer look at the features of PIL. Examples shown can be entered directly into PIL after starting it with $run *pil.

Direct mode

PIL starts up in direct mode, where statements entered are immediately executed when you press RETURN. * is used by PIL as the prompt to enter input. You can use the TYPE statement and simple arithmetic expressions to make PIL act as a calculator:

* type 22 * 2
  22 * 2 =  44.0
* type 2 ** 16
  2 ** 16 =  65536.0

On MTS, PIL is case-insensitive for keywords and lines can optionally end with a period. Errors are immediately reported, usually starting with Eh?.

* TYPE 2+2.
  2+2 =  4.0
* TYPE
  Eh? IMPROPERLY FORMED STATEMENT

If the last character entered on the line is - then input will continue on the next line before it is executed. The prompt will change to & to show this continuation. * at the start of line can be used to make comments.

 * type 1 + 2 + 3 +-
 & 5 + 6
   1 + 2 + 3 +5 + 6 =  17.0
 * * comment here
 *

Variables and types

Variables can be introduced by the optional keyword SET followed by a variable name and an assignment.

* set a = 2
* b = 3
* type a, b, a+b
  a =  2.0
  b =  3.0
  a+b =  5.0

PIL understands three types: numerical, which are stored as floating point values, character strings and Boolean values.

* a = 1 / 3
* b = "PIL"
* c = The True
* type a, b, c
  a =  0.3333333
  b = "PIL"
  c = The True

Booleans constants are ‘The True’ or ‘The False’ - something I’ve not seen in any other language. Strings can be up to 255 characters long and can be entered with single or double quotes as delimiters. Floats have 7 digits of precision and can be entered with exponential notation. Volume 12 mentions type 9.999999e64 as the maximum value but on the version I’m running it seems 62 is the maximum exponent.

* type 9.999999e62
  9.999999e62 =  9.999999E+62
* type 9.999999e63
  Eh? EXPONENT OUT OF RANGE

Variable names are up to 8 characters long, are case sensitive and are distinguished from keywords, as this silly example shows.

* set set = 1
* set SET = 2
* type set, SET
  set =  1.0
  SET =  2.0

Arrays are allowed with any number of dimensions, though once set the number of dimensions cannot be changed.

* x(1, -2) = 3
* x(3, 44.0) = 4
* type x
  x(1,-2) =  3.0
  x(3,44) =  4.0
* x(3,4,5) = 42
  Eh? ??-

Expressions

Arithmetic expressions work mostly as expected. The absolute value can be taken by surrounding an expression with |; exponentiation is done with **. Functions for arithmetic operations such as square root, cosine, log etc generally have a short and long form and do not need parentheses unless needed to resolve ambiguities.

* type 1 + |-41|
  1 + |-41| =  42.0
* type the square root of 9
  the square root of 9 =  3.0
* type sqrt of 16
  sqrt of 16 =  4.0
* type sqrt of 25+1
  sqrt of 25+1 =  6.0
* type sqrt of (25+1)
  sqrt of (25+1) =  5.09902

There are functions for min/max, random numbers and extracting parts of a number, as well as special functions to get time (in 300ths of seconds since midnight), date, cpu/elapsed time and storage used.

* type the min of (1,2,3)
  the min of (1,2,3) =  1.0
* type the time, the date, the elapsed time, the cpu time
  the time =  1.963908E+07
  the date =  17133.0
  the elapsed time =  7.819461E+07
  the cpu time =  464.0
* type the total size, the size
  the total size =  188.0
  the size =  165.0

Boolean functions are similar to other languages, with # standing in for logical or.

* type 2 >= 3
  2 >= 3 = The False
* type 2 $lt 3
  2 $lt 3 = The True
* type the true # the false
  the true # the false = The True
* type the true & the false
  the true & the false = The False

Character expressions include length, case conversion, comparison and extraction.

* type the l of "abc"
  the l of "abc" =  3.0
* type the upper of "abC"
  the upper of "abC" = "ABC"
* type the first 3 characters of "abcde"
  the first 3 characters of "abcde" = "abc"
* type 2 $fc "abcde" + "X" + 1 $lc "abcde"
  2 $fc "abcde" + "X" + 1 $lc "abcde" = "abXe"
* type "aaa" > "AAA"
  "aaa" > "AAA" = The False

Finally, the type of an expression can be found and run time evaluation performed.

* type the mode of 42, the mode of the true, the mode of "abc"
  the mode of 42 =  1.0
  the mode of the true =  2.0
  the mode of "abc" =  3.0
* type the value of "2*21"
  the value of "2*21" =  42.0

Control flow

There’s an IF statement with an optional ELSE clause. The IF and ELSE can be omitted but the punctuation is required.

* if 1 < 2, then type 'yes'; else type 'no'
  yes
* if 1 > 2, type 'yes'; type 'no'
  no

For loops have a range or an increment and an optional clause to terminate.

* for i = 1 to 5: type i ** 2
  i ** 2 =  1.0
  i ** 2 =  4.0
  i ** 2 =  9.0
  i ** 2 =  16.0
  i ** 2 =  25.0
* for i = 1 by 2 to 10: type i ** 2
  i ** 2 =  1.0
  i ** 2 =  9.0
  i ** 2 =  25.0
  i ** 2 =  49.0
  i ** 2 =  81.0
* for i = 1 by 2 while i < 20: type i
  i =  1.0
  i =  3.0
  i =  5.0
  i =  7.0
  i =  9.0
  i =  11.0
  i =  13.0
  i =  15.0
  i =  17.0
  i =  19.0

Indirect mode

Lines entered that start with a number are treated as stored instructions, broken down by part and step, that can be run later. Here we define a program in part 1 consisting of four steps.

* 1.0 i = 5
* 1.1 type i
* 1.2 i = i * i
* 1.3 type i

This can then be run with DO, which will execute all steps in a part.

* do part 1
  i =  5.0
  i =  25.0

Variables set in a program remain after execution is completed and it is possible to run a single step at a time.

* type i
  i =  25.0
* do step 1.2
* do step 1.3
  i =  625.0

Steps can call other parts with DO: execution will resume after the part is finished. It’s also possible to transfer execution with TO which will not return. DONE will return from the current part.

* type part 2, part 3
 
  2.0    i = 3
  2.1    do step 3
  2.2    i = 5
  2.3    do step 3
  2.4    i = 7
  2.5    to step 3
  2.6    type 'not reached'
 
 
  3.0    type i
  3.1    done
  3.2    type 'also not reached'
 
* do part 2
  i =  3.0
  i =  5.0
  i =  7.0

The above also shows it is possible to list out programs with TYPE PART. You can see all entered parts with TYPE ALL PARTS. With TYPE ALL STUFF you will see all variables and parts defined.

DELETE can be used to remove a step or a variable definition.

I/O and system access

We’ve seen TYPE used to display variables. You can prompt for a value to be entered with DEMAND

* delete part 1
* 1.0 demand i
* 1.1 i = i * 10
* 1.2 type i
* do part 1
 i = ?_ 3
  i =  30.0

There is also a formatting facility for input and output that is covered in the manual.

Programs can be saved to disk for future list with SAVE. This takes a file name (which must already exist) and what to save. For example:

save as 'x.pil', all stuff

will save all parts and variables to x.pil. File format is plain text so it can be edited outside of PIL if needed. LOAD 'x.pil' will then load the file back into PIL.

The implementation of PIL on MTS includes access to system facilities such as file creation and device access. For example, CREATE 'x.pil' will create a new file.

In the next post we’ll see how to construct a larger PIL program.

Further information

MTS volume 12 has a complete reference to PIL as implemented on MTS.

If you can find a copy of the book ‘History of Programming Languages’, edited by Richard Wexelblat, this has a great section about JOSS talking about its design principles.

PIL - Introduction

Sun, 01 Oct 2017 01:32:55 +0000

_{Screenshot of a teletypewriter running PIL, from 2 4 Using the Michigan Terminal System 6 01.}

In this series of posts we’ll look at the Pittsburgh Interpretative Language, or PIL, a simple interpreted language that can be used to do calculations and build small programs interactively.

The Pittsburgh Interpretative Language

PIL was developed at the University of Pittsburgh for the System/360 in the late 60s. It was based on one of the first interpreted languages JOSS that originated at the RAND Corporation in 1963. PIL improves on JOSS by providing improved debugging capabilities and error reporting.

The design goals for PIL were, according to MTS Volume 12:

PIL is oriented toward problem-solving, with program development and debugging facilities having highest priority. For the beginning user, PIL was designed to be clear, unambiguous, and hence, easily learned. For the experienced programmer, the language offers increased flexibility with statement structure and expanded capabilities for the solution of non-numeric problems. For the researcher, PIL reduces the amount of time and effort that must be expended in problem solving.

PIL can be used as a simple desktop calculator with variables

* set a = 3
* set b = 4
* type the square root of (a*a + b*b)
the square root of (a*a + b*b) =  5.0

It can also be used to build simple programs interactively that can then be run:

* 1.01 demand a
* 1.02 demand b
* 1.03 type the square root of (a*a + b*b)
* do part 1
 a = ?_ 3
 b = ?_ 4
  the square root of (a*a + b*b) =  5.0

PIL on MTS

PIL on MTS is based on the second version of PIL, PIL/2. It was modified to integrate well with MTS files and system services.

Prerequisites

No special installation instructions to get this language running - just do the standard D6.0 setup as described in this guide and then sign on as a regular user such as ST01.

Running a program using `*PIL`

Running the command *PIL on MTS will start the PIL interpreter. It is intended to be used in an interactive way where you enter commands and see the output directly. It can be used in batch mode by feeding commands into source but this is not the intended mode of operation. Inside the interpreter, programs and data can be loaded and saved with the load and save as statements.

Hello world

Let’s see how to run a simple program to print ‘Hello, world!’ five times using PIL.

# $run *pil
# Execution begins   09:56:53 
  PIL/2: Ready
* for i = 1 to 5: type "Hello, world!"
  Hello, world!
  Hello, world!
  Hello, world!
  Hello, world!
  Hello, world!
* stop
# Execution terminated   09:59:06  T=0.004

After starting PIL, enter the for statement at the * prompt. Output is shown immediately after the command is entered. Type stop to return to MTS.

In the next post we’ll look at the language in more detail.

Further information

MTS volume 12 has a tutorial and reference for the PIL language and describes how it is integrated with MTS.

The video pictured at the top of this post, 2 4 Using the Michigan Terminal System 6 01, shows simple operation of PIL on a teletypewriter, starting from 21 minutes into the video.

The Pitt time-sharing system for the IBM system 360: Two year’s experience. describes the operation of PIL at the University of Pittsburgh.

JOSS: Introduction To A Helpful Assistant is a very readable paper from the RAND Corporation on the language that inspired PIL.

The source code and implementation notes for PIL can be found in component 566 on tape 6.0T2 in the D6.0 distribution.

Source code for the hello world program can be found on github.

RATFOR & FLECS - Emirp primes

Sun, 15 Jan 2017 00:34:40 +0000

For the final post in this series, let’s write a real program in RATFOR and FLECS and see how they compare with the original FORTRAN. We’ll be implementing the reverse-primes emirp program we did before.

FLECS version

C     FLECS PROGRAM TO DISPLAY EMIRPS
C
C     *** TEST IF A NUMBER IS PRIME ***
      LOGICAL FUNCTION PRIME(N)
      INTEGER N
C     DEAL WITH NUMBERS <= 3
      IF (N .LE. 1) GOTO 200
      IF (N .EQ. 2 .OR. N .EQ. 3) GOTO 100
C     CHECK IF DIVISIBLE BY 2 OR 3
      IF (MOD(N,2) .EQ. 0) GOTO 200
      IF (MOD(N,3) .EQ. 0) GOTO 200
C     SEE IF DIVISIBLE BY 5, 7, ..., UP TO APPROX SQRT(N)
      DO (I=5,999999,2)
      IF (I*I .GT. N) GOTO 100
      IF (MOD(N,I) .EQ. 0) GOTO 200
      FIN
 100  PRIME = .TRUE.
      RETURN
 200  PRIME = .FALSE.
      RETURN
      END
C
C     *** REVERSE AN INTEGER'S DIGITS ***
      INTEGER FUNCTION REVRSE(N)
      INTEGER N
      INTEGER M,R
C     M IS COPY OF N FROM WHICH WE TAKE DIGITS
C     R IS REVERSED DIGITS
      M = N
      R = 0
C     LOOP UNTIL NO MORE DIGITS
      UNTIL (M .LT. 1)
C     TAKE LAST DIGIT FROM M AND APPEND TO R
      R = R * 10
      R = R + MOD(M, 10)
      M = M / 10
      FIN
      REVRSE = R
      RETURN
      END
C
C     *** TEST IF AN INTEGER IS AN EMIRP ***
      LOGICAL FUNCTION EMIRP(N)
      INTEGER N
C     EXTERNAL FUNCTIONS
      INTEGER REVRSE
      LOGICAL PRIME
C     R CONTAINS REVERSED DIGITS OF N
      INTEGER R
      R = REVRSE(N)
C     N AND R MUST BOTH BE PRIME AND NOT THE SAME VALUE
      IF (N .NE. R)
      IF (PRIME(N))
      IF (PRIME(R))
      EMIRP = .TRUE.
      RETURN
      FIN
      FIN
      FIN
      EMIRP = .FALSE.
      RETURN
      END
C
C     *** DISPLAY AN INTEGER ***
      SUBROUTINE SHOW(N)
      INTEGER N
      WRITE(6,50) N
 50   FORMAT(I10)
      RETURN
      END
C
C
C     *** MAIN ENTRY POINT ***
C     I IS COUNT OF EMIRPS FOUND
C     N IS NUMBER TO TEST
C     EXTERNAL FUNCTION
      LOGICAL EMIRP
      INTEGER I,N
      TEST-1
      TEST-2
      TEST-3
      STOP
C
C     *** SHOW FIRST 20 EMIRPS ***
      TO TEST-1
      N = 0
      I = 0
      WHILE (I .LT. 20)
      N = N + 1
      IF (EMIRP(N))
      CALL SHOW(N)
      I = I + 1
      FIN
      FIN
      FIN
C
C     *** SHOW EMIRPS BETWEEN 7,700 AND 8,000 ***
      TO TEST-2
      DO (N=7700,8000)
      IF (EMIRP(N)) CALL SHOW(N)
      FIN
      FIN
C
C     *** SHOW 10,000TH EMIRP ***
      TO TEST-3
      N = 0
      DO (I=1,10000)
      REPEAT UNTIL (EMIRP(N)) N = N + 1
      FIN
      CALL SHOW(N)
      FIN
C
      END

Apart from the FORMAT specification and the PRIME function we’ve eliminated all line numbers. PRIME could be written without line numbers but with the multiple paths out of the function that would need their own RETURN I think it’s better this way.

The internal procedures come in handy, eliminating the need for subroutines for TEST1-3, though this does make N and I global which makes me a little uneasy if this was a larger program.

We use the block structure often, with UNTIL, WHILE and REPEAT ... UNTIL; this simplifies code, though without indentation it’s a little hard to follow; the output of the preprocessor is useful here to show what it thinks the indentation should be, for example:

  86           TO TEST-1
  87           .  N = 0
  88           .  I = 0
  89           .  WHILE (I .LT. 20)
  90           .  .  N = N + 1
  91           .  .  IF (EMIRP(N))
  92           .  .  .  CALL SHOW(N)
  93           .  .  .  I = I + 1
  94           .  .  ...FIN
  95           .  ...FIN
  96           ...FIN

The compiler diagnostics also helped a lot with catching errors with missing FINs.

RATFOR

Now let’s try writing the RATFOR version.

######################################################################
# Ratfor program to display emirps
######################################################################

######### Test if a number is prime #########
logical function prime(n)
    integer n  # Number to test

    # Deal with numbers <= 3
    if (n < 1) goto 200
    if (n == 2 | n == 3) goto 100

    # Check if divisible by 2 or 3
    if (mod(n,2) == 0) goto 200
    if (mod(n,3) == 0) goto 200
      
    # See if divisible by 5, 7, ..., up to approx sqrt(n)
    for (i = 5; i < 1000000; i = i + 2) {
        if (I*I > n) goto 100
        if (mod(n,i) == 0) goto 200
    }

 100  prime = .true.
      return
 200  prime = .false.
      return
end

######### Reverse an integer's digits #########
integer function revrse(n)
    integer n  # Number to reverse
    integer m  # Copy of n from which we take digits
    integer r  # Reversed digits
    m = n
    r = 0
    while (m >= 1) {
        # Take last digit from m and append to r
        r = r * 10
        r = r + mod(m, 10)
        m = m / 10
    }
    revrse = r
    return
end

######### Test if an integer is an emirp #########
logical function emirp(n)
    integer n       # Number to test
    integer revrse  # External function
    logical prime   # External function
    integer r       # Reversed digits of n
    r = revrse(n)
    emirp = .false.
    # n and r must both be prime and not the same value
    if (n .ne. r & prime(n) & prime(r)) {
        emirp = .true.
    }
    return
end

######### Display an integer #########
subroutine show(n)
    integer n
    write(6,50) n
50  format(i10)
    return
end

######### Show first 20 emirps #########
subroutine test1
    logical emirp   # External function
    integer i       # Count of emirps found
    integer n       # Number to test
    n = 0
    for (i = 1; i <= 20; i = i + 1) {
        repeat {
            n = n + 1
        } until (emirp(n))
        call show(n)
    }
    return
end

######### Show emirps between 7,700 and 8,000 #########
subroutine test2
    logical emirp   # External function
    integer n       # Number to test
    for (n = 7700; n <= 8000; n = n + 1) {
        if (emirp(n)) {
            call show(n)
        }
    }
    return
end

######### Show 10,000th emirp #########
subroutine test3
    logical emirp   # External function
    integer i       # Count of emirps found
    integer n       # Number to test
    n = 0
    for (i = 1; i <= 10000; i = i + 1) {
        repeat {
            n = n + 1
        } until (emirp(n))
    }
    call show(n)
    return
end

######### Main entry point #########
call test1
call test2
call test3
stop
end

I feel right at home with the braces and the C style for loops, though I miss the increment operator ++. prime would be much better if I could just return (.true.) but that does not work on the version of RATFOR on MTS so we keep the line numbers and gotos.

With the above, plus the free form input (which was supported on MTS FORTRAN anyway) and the operators like < it was easy to write. However, I got precisely zero diagnostics from the RATFOR preprocessor, with all my typos caught by the FORTRAN compiler, from which I’d have to find the problem in the original source. Easy enough in a small program but would be painful in larger ones.

Final thoughts

RATFOR and FLECS both make writing FORTRAN easier and more pleasant at the cost of an extra step in the development process, and I found both succeed at that. RATFOR is clearer and easier to get started with (especially coming from a C background today); the implementation is almost aggressively simple, as the authors admit in their paper, and I wonder how well it would scale for writing larger programs. FLECS has a more robust implementation but a more diffuse design, such as two versions of switch; features like printing a neatly indented output would certainly help on MTS or its contemporaries but the language lacks the cosmetic features that make RATFOR easier to read.

Neither are much used today; FORTRAN 77 and beyond took some of these ideas and built them into the core language. The idea of translating a richer language into a widely used but less expressive language is still alive though: think of Coffeescript or Typescript producing Javascript.

Further information

Full source code for these programs can be found on github.

RATFOR & FLECS - Language Features

Sun, 30 Oct 2016 00:46:24 +0000

_{From the UM Computing Center Newsletter, Volume 5 Number 14, 24 September 1975, via Google Books. Proposal 2) seems to indicate a different preprocessor was being considered for UM as well as FLECS, I wonder if this was RATFOR or something else?}

Hi and welcome back. Today let’s continue our exploration of RATFOR and FLECS by comparing the language features they add to vanilla FORTRAN. The quotes below are from the RATFOR paper and FLECS manual, links to which are provided at the end of this post. Code samples for FORTRAN and FLECS are shown in upper case, RATFOR in lower case.

Design

RATFOR attempts to retain the merits of FORTRAN (universality, portability, efficiency) while hiding the worst FORTRAN inadequacies. The language is FORTRAN except for two aspects - [control flow and syntactic sugar] … Throughout, the design principle which has determined what should be in RATFOR and what should not has been RATFOR doesn’t know any FORTRAN.

RATFOR focuses on control flow - if statements, blocks, looping - and cosmetics such as free form input, comments and other features that make FORTRAN more pleasant to write. By not knowing any FORTRAN, the design limits what features can be made available but also keeps it simple to implement and reduces the temptation to change FORTRAN into a different language altogether.

FLECS is a language extension of FORTRAN which has additional control mechanisms . These mechanisms make it easier to write FORTRAN by eliminating much of the clerical detail associated with constructing FORTRAN programs. FLECS is also easier to read and comprehend than FORTRAN.

FLECS also tries ti improve FORTRAN’s control statements, taking ideas from several different languages including Pascal and Lisp. It has less cosmetic additions than RATFOR but adds the concept of internal procedures and includes features in the translator that help the programmer see the structure of their program.

Structure

RATFOR allows blocks of statements to be introduced within braces where FORTRAN would only allow a single statement. The fixed column format in classic FORTRAN is relaxed so any indentation is allowed. Multiple statements can appear on the same line if they are separated by semicolons.

if (x > 100) {
   call error(x)
   err = 1; return
}

FLECS also has blocks which extend from the start of a control statement to the keyword FIN. It retains the fixed formatting of FORTRAN but prints a nicely indented view of the program when translating. So the example above would be entered as this in FLECS:

      IF (X .GT. 100)
      CALL ERROR(X)
      ERR = 1
      FIN

and the translator would print

IF (X .GT. 100)
.  CALL ERROR(X)
.  ERR = 1
...FIN

This is useful when entering programs via cards where it is difficult to get indentation right.

It’s possible to have a single statement after a control structure in which case the FIN is not needed:

IF (X .GT. 100) CALL ERROR(X)

RATFOR comments are introduced with # and apply from that point to the end of the line, less restrictive than C in FORTRAN and FLECS which must be in the first column.

% will stop RATFOR processing the rest of the line, passing it through to FORTRAN directly. FLECS will look for a FLECS statement in column 7 and if found will translate the line; if not found it will pass through the whole line to FORTRAN.

Textual substitution

RATFOR allows constants to be set with define SYMBOL VALUE; any use of SYMBOL in the RATFOR program will be replaced with VALUE in the generated FORTRAN program.

include FILE will insert a copy of FILE at that point in the program, just like C’s #include.

Operators

RATFOR allows the now-familiar symbols <, <=, !=, | etc to be used instead of .LT., .LE., .NE., .OR. etc. FLECS retains the FORTRAN operators.

Strings

Text in RATFOR programs in single or double quotes is converted to FORTRAN nH strings. Backslash escapes the next character. FLECS keeps FORTRAN strings.

Conditionals

FORTRAN has a simple iF statement where only one statement can be executed if the condition is true. RATFOR extends this by allowing else and nested ifs. An else clause is attached to the nearest if.

if (x > 0) {
  if (x > 10)
    write(6, 1) x
  else
    write(6, 2) x
else
  weite(6, 3)

FLECS has IF and for negative tests UNLESS. It also has WHEN … ELSE for a single positive and negative test.

The switch statement added in RATFOR looks like C but does not have break; the switch is exited after each case or default is executed. FLECS’s equivalent is SELECT, so comparing the two:

switch (x) {
  case 1: y=3
  case 2, 3: y=5
  default y=0
}

      SELECT (X)
      (1) Y=3
      (2) Y=5
      (3) Y=5
      (OTHERWISE) Y=0
      FIN

FLECS has CONDITIONAL which looks a lot like LISP’s cond:

      CONDITIONAL
      (X.LT.-5.0)  U = U+W
      (X.LE.1.0)   U = U+W+Z
      (X.LE.10.5)  U = U-Z
      (OTHERWISE)  U = 0
      FIN

Looping

The FORTRAN DO loop has to have a line number marking the point where the loop will restart:

      DO 10 i = 1, n
      x(i) = 0.0
      y(i) = 0.0
      z(i) = 0.0
 10   CONTINUE

RATFOR replaces this with a block:

do i = 1, n {
  x(i) = 0.0
  y(i) = 0.0
  z(i) = 0.0
}

It also allows break to exit a loop early and next to restart the loop like C’s continue. It can be followed by an integer to say how many levels to apply, so break 2 would move out of a two level do statement immediately.

RATFOR also adds a while and for statement that look like C’s - these allow immediate exit from the statement if the condition is true on entry, unlike in FORTRAN DO where the statement is always executed at least once (in the IBM implementation at least) and the conditional is tested at the end of the statement. A version of C’s do … while is provided as repeat … until.

The FLECS equivalent for the above do loop would be:

      DO (I = 1, N)
      X(I) = 0.0
      Y(I) = 0.0
      Z(I) = 0.0
      FIN

FLEC’s WHILE construct is similar to RATFOR’s, with the conditional tested before the loop starts. By using REPEAT WHILE the body of the loop is executed at least once and the test made at the end of the loop. UNTIL can be used instead of WHILE in both cases to indicate that the loop ends when the conditional becomes true

      X = 0
      UNTIL (X.EQ.5)
      X = X + 1
      FIN

Return

To return a value from a function in FORTRAN and FLECS you must assign a value to the name of the function:

INTEGER FUNCTION DECREMENT(I)
INTEGER I
DECREMENT = I - 1
RETURN
END

In the RATFOR paper it says you can give return a value:

integer function decrement(i)
integer i
return (i-1)
end

However, note this is not supported in the version supplied with MTS - it will just pass through such a return statement causing an error from the FORTRAN compiler.

Internal procedures

FLECS allows a group of statements to be defined as a procedure with TO which can then be called by giving its name. No parameters are passed - it uses global variables to communicate. The below example will print 5.

      INTEGER X
      X = 1
      INCREMENT-IT
      DOUBLE-AND-INCREMENT
      WRITE(6,50) X
      STOP
 50   FORMAT(I10) 
      TO INCREMENT-IT X = X + 1
      TO DOUBLE-AND-INCREMENT
      X = X * 2
      INCREMENT
      FIN
      END

Procedure names must include at least one hyphen and recursion is not allowed.

Operation

RATFOR runs as a simple translator, taking a RATFOR input file and producing a FORTRAN output file that must then be fed to the FORTRAN compiler. FLECS, as modified at UM, will both translate and call the FORTRAN compiler, producing machine code output that can be run directly.

Error handling

RATFOR will catch some errors, such as missing closing braces, but will otherwise delegate problems with the program to the FORTRAN compiler to catch, as it does not understand FORTRAN syntax. This could be difficult to trace back to the source of the error as the FORTRAN compiler would show the error in the generated FORTRAN, not the RATFOR original.

FLECS will find syntax errors and remove them from the program, allowing translation to continue at the cost of possibly causing further errors; it will not move on to compilation in this case.

Implementation

Not surprisingly given its authors’ roots, RATFOR was originally written in around 1000 lines of C using yacc. The authors say it took less than a week to implement. As C was not widely available in the mid 70’s, a version of RATFOR in RATFOR was produced that would generate around 2500 lines of basic FORTRAN so it could be used anywhere.

The FLECS implementation comes in at around 2200 lines of FLECS and took around six months to develop according to comments in the source code.

Further information

See Kernighan’s RATFOR paper or the FLECS User’s Manual (in component 673/22; I’ve uploaded a copy here) for more information on the languages.

RATFOR & FLECS - Introduction

Sun, 24 Jan 2016 02:57:16 +0000

Most programmers will agree that FORTRAN is an unpleasant language to program in, yet there are many occasions when they are forced to use it.

From the introduction to ‘RATFOR — A Preprocessor for a Rational FORTRAN’ by Brian W. Kernighan

FORTRAN was the lingua franca for mainframe programmers in the 1960s and 1970s, but as Kernighan states it’s not always easy to program in - the main reasons are lack of good control structures and the fixed line format. As a result, a number of preprocessors were developed that translated enhanced code down to plain FORTRAN that could then be compiled anywhere a compiler was available.

In this series of posts, we’ll look at two preprocessors available on MTS: RATFOR and FLECS. MTS also had OVERDRIVE, but this is not available on D6.0 due to copyright reasons.

Prerequisites

No special installation instructions to get these preprocessors running - just do the standard D6.0 setup as described in this guide and then sign on as a regular user such as ST01.

RATFOR

RATFOR was developed by Brian Kernighan at Bell Telephone Labs in 1974; its syntax was (not surprisingly) inspired by the C programming language, with keywords like for, while and until. It was used as the language for examples in Software Tools and became one of the most popular preprocessors in use. Versions are still available today that run on Unix systems.

Preprocessing using `*RATFOR`

The version on MTS is called *RATFOR and takes a RATFOR program as input on scards and writes FORTRAN source to spunch. The generated file can then be compiled with *FTN.

Hello world

Here’s a terminal log of how to compile and run a simple hello world program in RATFOR. This assumes the source code is in file hello.r.

# $list hello.r

      1     # *** Simple hello world program ***
      2     #
      3     integer i
      4     for (i = 0; i < 5; i = i + 1)
      5     {
      6        write(6, 200)
      7     }
      8     stop
      9     200 format("Hello, world!")
     10     end

# $run *ratfor scards=hello.r spunch=-hello.f
Execution begins   21:56:08
Execution terminated   21:56:08  T=0.004

# #list -hello.f

      1           INTEGERI
      2           CONTINUE
      3           I=0
      4     23000 IF(.NOT.(I.LT.5))GOTO 23002
      5           WRITE(6,200)
      6     23001 I=I+1
      7           GOTO 23000
      8     23002 CONTINUE
      9           STOP
     10     200   FORMAT(13HHello, world!)
     11           END

# $run *ftn scards=-hello.f spunch=-load
Execution begins   21:56:36
 No errors in MAIN
Execution terminated   21:56:36  T=0.008

# #run -load
Execution begins   21:56:39
 Hello, world!
 Hello, world!
 Hello, world!
 Hello, world!
 Hello, world!
Execution terminated   21:56:39  T=0.001

FLECS

FLECS was written in the early 1970s by Terry Beyer at the University of Oregon. It provides a smaller set of control structures that RATFOR but the syntax is closer to FORTRAN. Keywords include IF...THEN...ELSE and CONDITIONAL and multi-line statements are supported. It does not appear to have been used much past the introduction of FORTRAN77, but a a version is still available today for HPUX.

Compiling using `UNSP:FLX`

At the time D6.0 was released, FLECS was unsupported at UM so is available as the file FLX in UNSP:. The preprocessor does not used scards and spunch; instead, all parameters need to be passed in to par. Unlike RATFOR, FLECS can call the FORTRAN compiler directly to generate object code. In the listing below, PAR=SOURCE=hello.fl,P=*SINK*,FTNSOURCE,LOAD=-load would read source from hello.fl, print diagnostics to *SINK including the FORTRAN source generated, and write compiled output to -load.

Hello world

Here’s a terminal log of how to compile and run a simple hello world program in FLECS. This assumes the source code is in file hello.fl.

# $list hello.fl

      1     C *** SIMPLE HELLO WORLD PROGRAM ***
      2     C
      3           DO (I = 1,5)
      4           WRITE (6,20)
      5           FIN
      6           STOP
      7        20 FORMAT(13H HELLO, WORLD)
      8           END

# $run UNSP:FLX PAR=SOURCE=hello.fl,P=*SINK*,FTNSOURCE,LOAD=-load
Execution begins   21:47:21
 FFI(CT206)


 (FLECS VERSION 22.38)  MTS Version CT155 21:47:21    JAN 21, 1916    Page   1

 MTS Line#        Indented Source Listing...

      1     C *** SIMPLE HELLO WORLD PROGRAM ***
      2     C
      3           DO (I = 1,5)
      4           .  WRITE (6,20)
      5           ...FIN
      6           STOP
      7        20 FORMAT(13H HELLO, WORLD)
      8           END

   0.001 seconds CPU time used.  Translation rate is 480000 lines per CPU minute.

 There were   NO MAJOR ERRORS and   NO MINOR ERRORS in the above module.
 No preprocessor errors in module  1.


  MICHIGAN TERMINAL SYSTEM FORTRAN G(21.8) MAIN 01-21-16 21:47:21 PAGE P001

    0001              DO 99998 I = 1,5             3.000
    0002              WRITE (6,20)                 4.000
    0003        99998 CONTINUE                     5.000
    0004              STOP                         6.000
    0005           20 FORMAT(13H HELLO, WORLD)     7.000
    0006              END                          8.000
     *OPTIONS IN EFFECT*  ID,EBCDIC,SOURCE,NOLIST,NODECK,LOAD,NOMAP
     *OPTIONS IN EFFECT*  NAME = MAIN    , LINECNT =       57
     *STATISTICS*    SOURCE STATEMENTS =        6,PROGRAM SIZE =      344
     *STATISTICS*  NO DIAGNOSTICS GENERATED
 No errors in MAIN

 NO STATEMENTS FLAGGED IN THE ABOVE COMPILATIONS.
Execution terminated   21:47:21  T=0.018

# $run -load
Execution begins   21:47:31
 HELLO, WORLD
 HELLO, WORLD
 HELLO, WORLD
 HELLO, WORLD
 HELLO, WORLD
Execution terminated   21:47:31  T=0.001

Further information

The Wikipedia article on RATFOR has a basic introduction to language features and the history of its development. Kernighan’s paper on RATFOR goes into more detail on the language.

Not much appears to exist on the Internet describing FLECS, but the D6.0 MTS tapes does include the complete User’s Manual (in component 673/22) and the interface to MTS.

MTS Volume 6 describes the FORTRAN compilers on MTS, which are needed to compile the RATFOR preprocessor’s output.

SNOBOL - Date formats

Sun, 11 Oct 2015 03:16:45 +0000

Let’s implement a simple program in SNOBOL on MTS to print today’s date in different formats.

The problem

The problem is quite simple: take today’s date and display it in ISO format (eg 2015-10-11) and a human readable format (eg Sunday, October 11, 2015). Further details and implementations in other languages can be found on Rosetta Code.

Getting today’s date

There’s a built in function in SNOBOL to return the date as an eight character string. Interestingly, the SNOBOL 4 Programming Language says this returns ‘MM/DD/YY’ but on MTS it returns ‘MM-DD-YY’. Let’s get this and store in a variable.

        NOW = DATE()

Breaking the date into components

We take the date and extract the month, day and year using SNOBOL’s pattern matching facility and assign it to variables DAY, MONTH, and YEAR.

        PART = SPAN("0123456789")
        SEP  = "-"
        NOW (PART . MONTH) SEP (PART . DAY) SEP (PART . YEAR)

Y2K strikes again

The value returned from DATE() has a two digit year, so let’s assume we are running this in the 21st century.

        CENTURY = 2000
        CYEAR = YEAR + CENTURY

Displaying in ISO format

So displaying the date in ISO format is now simply a case of concatenating the day, month and four digit year and then outputting it.

        ISO = CYEAR SEP MONTH SEP DAY
        OUTPUT = ISO

Day of the week

We now turn to the human readable form but there is a slight problem - we need to know which day of the week it is, eg Monday, and there is no facility in SNOBOL to calculate this. There may be a MTS external library we could call to get this, but instead we will use Gauss’ algorithm to derive the day as a number from 0 (Sunday) to 6 (Saturday).

* GYEAR is the 4 digit year, unless Jan or Feb then subtract 2
* GMONTH is MONTH-2 modulus 12, Jan is 11, Feb is 12
        GT(MONTH, 2)               :S(G1)F(G2)
G1      GYEAR = CYEAR
        GMONTH = MONTH - 2         :(GX)
G2      GYEAR = CYEAR - 1
        EQ(MONTH, 1)               :S(G3)F(G4)
G3      GMONTH = 11                :(GX)
G4      GMONTH = 12                :(GX)
GX      WDAY = REMDR(DAY, 7)
* Calculate the month term 
        MT = (2.6 * GMONTH) - 0.2
* Add the month term - the 0.00005 is needed due to lack of FP precision
        WDAY = WDAY + REMDR(CONVERT(MT + 0.00005, 'INTEGER'), 7)
        WDAY = WDAY + 5 * REMDR(REMDR(GYEAR, 4), 7)
        WDAY = WDAY + 4 * REMDR(REMDR(GYEAR, 100), 7)
        WDAY = WDAY + 6 * REMDR(REMDR(GYEAR, 400), 7)
        WDAY = REMDR(WDAY, 7)

Month and day names

We will need a way of translating a month and day number into a name, eg January or Monday. SNOBOL’s arrays can be used for this. Note that the DAYS array is indexed from 0 to 6 instead of 1 to 7.

        MONTHS = ARRAY("12")
        MONTHS<1> = "January"
        MONTHS<2> = "February"
* ...
        MONTHS<11> = "November"
        MONTHS<12> = "December"


        DAYS = ARRAY("0:6")
        DAYS<0> = "Sunday"
        DAYS<1> = "Monday"
* ...
        DAYS<5> = "Friday"
        DAYS<6> = "Saturday"

Displaying in readable format

We now have all the components to display the date in readable format.

        READABLE = DAYS<WDAY> ", " MONTHS<MONTH> " " DAY ", " CYEAR
        OUTPUT = READABLE

Running the program

Here’s what the output of the program looks like.

# $run *snobol4 5=date.sn
# Execution begins   21:09:05

 SNOBOL4 (VERSION 3.10, APRIL 1, 1973)
 (MTS IMPLEMENTATION MAY 1, 1975)

 0 SYNTACTIC ERROR(S) IN SOURCE PROGRAM


 2015-10-11
 Sunday, October 11, 2015


 NORMAL TERMINATION AT LEVEL  0
 LAST STATEMENT EXECUTED WAS   53


 SNOBOL4 STATISTICS SUMMARY
              38 MS. COMPILATION TIME
               1 MS. EXECUTION TIME
              41 STATEMENTS EXECUTED,       0 FAILED
              21 ARITHMETIC OPERATIONS PERFORMED
               1 PATTERN MATCHES PERFORMED
               0 REGENERATIONS OF DYNAMIC STORAGE
               0 READS PERFORMED
               2 WRITES PERFORMED
            0.02 MS. AVERAGE PER STATEMENT EXECUTED

# Execution terminated   21:09:05  T=0.045

Final thoughts on SNOBOL

Using SNOBOL feels close to modern scripting languages such as Perl, Python or Ruby. I really like the pattern matching facilities where you can do things like EXPR = TERM | *EXPR OP TERM which is much more powerful than regular expressions; I don’t think there is any modern language that has this built in. The lack of control flow processing apart from GOTO is annoying; later versions of the language such as SPITBOL addressed this. I imagine that it was also rather slow when running on a mainframe, especially as it had to be compiled each time it was run.

I don’t think SNOBOL is much in use today, but the maintainer of SPITBOL is still active.

Further information

Full source code for this program is on github.

SNOBOL - Language features

Sun, 30 Aug 2015 02:54:54 +0000

Hello again. Let’s take a closer look at the SNOBOL language: to run these on MTS see the instructions in the previous article.

Statements

There is only one statement format in SNOBOL, but each part of the statement is optional:

label subject pattern = replacement :goto

An example will make this clearer. This will read lines from input and print to output until QUIT is found anywhere in the input line.

BEGIN  LINE = INPUT
       LINE "QUIT"     :S(END)
       OUTPUT = LINE   :(BEGIN)
END

The first line BEGIN LINE = INPUT has a label (BEGIN) and assigns the subject variable LINE to the replacement value INPUT, which is a special keyword meaning take a line from the input device.

The second line has the subject LINE and matches that against the pattern "QUIT". If the match was a success, the goto statement :S(END) will jump to the final line with the end label.

The third line prints the value of the replacement, LINE, by assigning it to the subject, which is the special keyword OUTPUT. The goto here is unconditionally back to BEGIN.

The fourth line contains just the label END.

Dynamic variables

SNOBOL is the first language we’ve seen on MTS that has dynamic typing. Variables do not need to be pre-declared and their values can change types easily. In the below, J starts off containing a string but then is changed so it contains an integer; 42 is printed.

J = "ABC"
A = 20
B = "22"
J = A + B
OUTPUT = J

You cam also refer to and create variables indirectly via the $ operator. The below will print “123”.

A = 'B"
B = "123
OUT = $"A"

Arrays, tables and data types

Arrays can be defined and initialised with ARRAY, eg for a tic-tac-toe board you could do:

BOARD = ARRAY("3,3", " ")
BOARD<2,2> = "O"
BOARD<1,1> = "X"

Associative arrays can be defined with TABLE

DIRECTORY = TABLE()
DIRECTORY<"John"> = 123

User defined data types can be created, eg for a 2D point type, the below will print 4:

DATA("POINT(X,Y)")
P = POINT(3, 4)
OUTPUT = Y(P)

Control flow

The only control flow available in SNOBOL is goto. Each statement evaluates to either success or failure, and a jump to another statement can be made based on this result or unconditionally. In the below, a different jump for success and failure is defined on the third line.

START X = INPUT
      X "YES" :S(START)F(END)
      OUTPUT = "This is not reached"
END

Pattern matching

The above example is a simple pattern matching test: if the variable X contains YES then the statement is successful. SNOBOL has many more pattern matching constructs: some are showed below along with a string that would be a successful match.

Simple concatenation of strings matches the sequence, either | or ANY can be used for alternation.

"HAMLET"      "ML" "ET"
"THE TEMPEST" "TOMP" | "TEMP"
"MACBETH"     "MA" ANY("CDY") "BETH"

Patterns can be grouped together with brackets:

"A MIDSUMMER'S NIGH DREAM"   "MID" ("SUMMER" | "WINTER")

ARB matches and arbitrary number of chars

"OTHELLO"     "H" ARB "LO"

LEN matches a fixed length run of characters

"HENRY IV PART I"     "HENRY " LEN(2) " PART " LEN(1)

SPAN matches a run of anything from a set of characters, BREAK the opposite

"PERICLES"   "PER" SPAN("CIXZ") BREAK("ABCDE") "ES"

BAL matches an string which has balanced parentheses (including no parentheses), so the pattern

"TO BE" BAL "."

would match “TO BE (OR NOT TO BE).” and “TO BE OR NOT TO BE.” but not “TO BE ((OR NOT TO BE).”

By default, SNOBOL will match at any position on the line; it can be forced to match from a certain column by setting the variable &ANCHOR.

Patterns can be defined and referred to later; a pattern can be referred to recursively in the same pattern with *.

A more complex example is below, which will match simple arithmetic expressions, eg Z=21 or X+Y*Z=42.

BEGIN LINE = INPUT
      &ANCHOR = 1
      NUM     = SPAN("0123456789")
      TERM    = ANY("XYZ")
      OP      = ANY("+-*/")
      EXPR    = TERM | *EXPR OP TERM
      LINE    EXPR "=" NUM            :S(END)
      OUTPUT = LINE                   :(BEGIN)
END

Replacement and assignment

If any of the above patterns matches, simple replacement can be done by using pattern = replacement, so the below will replace the first occurrence of A with Z.

 LINE = INPUT
 LINE "A" = "Z"
 OUTPUT = LINE
END

Assignment of a substring to a variable can be done with the binary operator . (which will match if the whole pattern matches) or $ (which will match even if the whole pattern fails. So for the line below, AQQQZ will cause FIRST to be A and LAST to be Z, but AQQQ will cause neither to be set.

LINE ANY("ABC") . FIRST BREAK("XYZ") ANY("XYZ") . LAST

Instead, if you do

LINE ANY("ABC") $ FIRST BREAK("XYZ") ANY("XYZ") $ LAST

then AQQQ will cause FIRST to be set to A. Note that QQQZ will not match to LAST in either case.

Built in functions

SNOBOL has a number of built in functions. Function parameters are passed by value and the function can return a value.

LT, GT, EQ etc for numeric equality
LGT compares two values lexically and returns true if the first is after the second
INTEGER to test if a value is an integer
IDENT and DIFFER to compare two values and return true (or false for DIFFER) if they have the same type and value
SIZE for string size, DUPL(n, x) to create a string of size n by repeating the value of X
TRIM to remove trailing blanks
EVAL(x) will evaluate the expression in the string x at run time; APPLY(f, a, b…) will take the string f and run its value as a function, passing in variables a, b etc.

User defined functions

It is possible to define functions, but the syntax is clumsy. First you need to define a function with DEFINE("name(args)locals", "entrypoint"). args and locals are a list of arguments and local variables used by the function. The label entrypoint sets the start of the function, if omitted it will use name as the entrypoint.

Next, define the function at the label given by name. The return value can be set by assigning to the function name, and the function is exited by goto-ing RETURN.

A simple example:

       DEFINE("CENTRE(S)L,P")

BEGIN  LINE = TRIM(INPUT)
       CENTRED = CENTRE(LINE)
       OUTPUT = CENTRED        :(END)

CENTRE L = (80 - SIZE(S)) / 2
       P = DUPL(".", L)
       CENTRE = P S P          :(RETURN)
END

This will input a string and then pad it with leading and trailing dots to make it display on the centre of a line.

Functions can be recursive in SNOBOL.

Further information

The language reference manual “The SNOBOL4 Programming Language”, linked at snobol4.org, has complete information on the language and was used to assemble this. Take a look at the example programs in the appendix for a taste of what can be done in SNOBOL.

SNOBOL - Introduction

Sun, 26 Jul 2015 03:15:07 +0000

In this series we’ll look at SNOBOL, a unique pattern matching language, and its implementation on MTS.

SNOBOL overview

SNOBOL (StriNg Oriented and symBOlic Language) was developed at Bell Labs in the 1960s to help with a symbolic manipulation project. It had powerful pattern matching and string manipulation features but had a simple syntax: it has no control flow instructions apart from goto and variables are dynamically typed and don’t need declarations. It started to spread to other sites and was taught at some universities in the 197-s. The original implementation was for the IBM 7090 but versions were ported to the IBM S/360 and DEC PDP/10. Its use started to die out in the 1980s but its creators went on to work on the ICON language and it influenced later text manipulation languages such as AWK and Perl.

SNOBOL on MTS

The main implementation that we will run here is the *SNOBOL4 interpreter. Also available on the D6.0 tapes is *SNOBOL4B which has an extension to the core language for printing blocks, two- and three-dimensional visualisations of data.

MTS originally had a number of other implementations of SNOBOL that are not available on the D6.0 tapes due to copyright reasons:

*SPITBOL - a fast SNOBOL 4 compiler from the Illinois Institute of Technology.
*SNOSTORM - a SNOBOL preprocessor written at UM to add structured programming features

(Note that SPITBOL/360 has now been GPL’d and should be eligible for inclusion in future distributions of MTS - see here.)

Prerequisites

No special installation instructions to get SNOBOL running - just do the standard D6.0 setup as described in this guide and then sign on as a regular user such as ST01.

Using `*SNOBOL`

*SNOBOL4 will read the source code for the program and then any input from unit 5 (by default *source* ie standard input). If you want to take the source code from a file prog.sn and then enter input from the keyboard you could do something like:

# $run *snobol4 5=prog.sn+*source*

Other parameters to *SNOBOL4 are listed in MTS Volume 9.

Hello world

Here’s a transcript of a session where we run a Hello world program. This assumes the source code is contained in the file hello.sn. Note that the code is not free format: only goto labels and comments (starting with *) are allowed in the first column.

# $list hello.sn

      1     * SNOBOL program to print Hello World
      2           I = 1
      3     LOOP  OUTPUT = "Hello, world!"
      4           I = I + 1
      5           LE(I, 5) : S(LOOP)
      6     END

# $run *snobol4 5=hello.sn

 SNOBOL4 (VERSION 3.10, APRIL 1, 1973)
 (MTS IMPLEMENTATION MAY 1, 1975)

         * SNOBOL program to print Hello World
 *1            I = 1
 *2      LOOP  OUTPUT = "Hello, world!"
 *3            I = I + 1
 *4            LE(I, 5) : S(LOOP)
 *5      END

    0 SYNTACTIC ERROR(S) IN SOURCE PROGRAM

 Hello, world!
 Hello, world!
 Hello, world!
 Hello, world!
 Hello, world!

 NORMAL TERMINATION AT LEVEL  0
 LAST STATEMENT EXECUTED WAS    4

SNOBOL4 STATISTICS SUMMARY

               5 MS. COMPILATION TIME
               2 MS. EXECUTION TIME
              16 STATEMENTS EXECUTED,       1 FAILED
               5 ARITHMETIC OPERATIONS PERFORMED
               0 PATTERN MATCHES PERFORMED
               0 REGENERATIONS OF DYNAMIC STORAGE
               0 READS PERFORMED
               5 WRITES PERFORMED
            0.13 MS. AVERAGE PER STATEMENT EXECUTED

Further information

MTS Volume 9 describes the SNOBOL compilers available on MTS and includes a basic tutorial on the language.

snobol4.org has lots of information about SNOBOL’s history, implementations and links to books including the main reference manual for the language, “The SNOBOL4 Programming Language”.

PL/I - Radix sort

Sun, 12 Jul 2015 03:49:43 +0000

For the final part of this series on the PL/I programming language as implemented on MTS, let’s implement radix sort from Rosetta Stone.

The problem

Radix sort is intended as a fast way to sort an array of integers by grouping them by digits that share the same value. Digits can be defined depending on the numeric base and the sort can take place from either the most significant digit or the least. Here we’ll sort by most significant digit and use base 2. so we are comparing by bits.

The algorithm we’ll use sorts in place. Starting at the largest bit it will group the numbers into one range where the bit is 1 and another where it is 0 by swapping values in the array. It will then recursively sort each range by the next smallest bit.

The solution

Here’s how the implementation looks; this was based on the C version at Rosetta Code.

RADIX_SORT: PROCEDURE(FROM, TO, BIT, ARR) RECURSIVE;
  DECLARE (FROM, TO) FIXED DECIMAL;
  DECLARE BIT FIXED BINARY(16);
  DECLARE ARR(*) FIXED BINARY(16);

  DECLARE (LEFT, RIGHT) FIXED DECIMAL;
  DECLARE TEMP FIXED BINARY(16);

  /* Exit early if bit down to zero or range is zero */
  IF (BIT = 0) | (TO <= FROM) THEN RETURN;

  LEFT = FROM;
  RIGHT = TO;

  LOOP:
  /* Find the leftmost with the bit set */
  DO WHILE ((LEFT < RIGHT) & ((ARR(LEFT) & BIT) = 0));
    LEFT = LEFT + 1;
  END;

  /* Find the rightmost with the bit not set */
  DO WHILE ((LEFT < RIGHT) & ((ARR(RIGHT) & BIT) ¬= 0));
    RIGHT = RIGHT - 1;
  END;

  /* If found one of each, swap and loop again to look for more */
  IF LEFT < RIGHT THEN BEGIN;
    TEMP = ARR(LEFT);
    ARR(LEFT) = ARR(RIGHT);
    ARR(RIGHT) = TEMP;
    GO TO LOOP;
  END;

  /* If nothing found, make the first sub search do the full range */
  IF ((BIT & ARR(LEFT)) = 0) & (LEFT <= TO) THEN
    LEFT = LEFT + 1;

  /* The two ranges bounded by LEFT are now sorted by BIT.
   * Sort each range by the next least significant bit */
  BIT = BIT / 2;
  CALL RADIX_SORT(FROM, LEFT-1, BIT, ARR);
  CALL RADIX_SORT(LEFT, TO, BIT, ARR);
END RADIX_SORT;

The definition of the function is marked as RECURSIVE, similar to other languages like ALGOL, as otherwise calling the function from itself will not work.

We pass in an array of fixed point numbers of up to 16 bits in length with the dimensions of the array bounded by FROM and TO. The initial call will set BIT to be 2^15. To handle an array of any size we can use * in the declaration DECLARE ARR(*) FIXED BINARY(16);.

Although PL/I has logical operators - and is &, or is |, not is ¬ - it does not seem to have the Boolean not operator like ! in C, so we have to write (ARR(LEFT) & BIT) = 0 rather than something like ! (ARR(LEFT) & BIT).

We’ll also need a procedure to print the array which will be called before and after the sort.

SHOW_ARR: PROCEDURE(LABEL, ARR);
  DECLARE LABEL CHARACTER(80) VARYING;
  DECLARE ARR(*) FIXED BINARY(16);
  PUT FILE (SCARDS) LIST(LABEL);
  PUT FILE (SCARDS) SKIP;
  PUT FILE (SCARDS) LIST(ARR);
  PUT FILE (SCARDS) SKIP;
END SHOW_ARR;

Finally, we set up the main function

TEST: PROCEDURE OPTIONS(MAIN);
  DECLARE RADIX_SORT ENTRY (FIXED DECIMAL, FIXED DECIMAL,
                            FIXED BINARY(16),);

  DECLARE NUMS(10) FIXED BINARY(16);
  NUMS(1) = 3;       NUMS(6) = 1630;
  NUMS(2) = 42;      NUMS(7) = 4;
  NUMS(3) = 910;     NUMS(8) = 2721;
  NUMS(4) = 3241;    NUMS(9) = 684;
  NUMS(5) = 99;      NUMS(10) = 11;

  CALL SHOW_ARR('Before', NUMS);
  CALL RADIX_SORT(1, 10, 1000000000000000B, NUMS);
  CALL SHOW_ARR('After', NUMS);

  /* Definition of RADIX_SORT and SHOW_ARR follow inside TEST here. */
END TEST;

Note that we need to declare the signature of RADIX_SORT before we use it.

We can now compile and run the program.

# $run *pl1f scards=radix.pl1 spunch=-load
# Execution begins   20:03:01 

  PROCEDURE TEST: SYNTAX CHECK COMPLETED. COMPILATION CONTINUES.


   NO ERRORS OR WARNINGS DETECTED.
# Execution terminated   20:03:02  T=0.128 

# $run -load+*pl1flib
# Execution begins   20:03:03 
  'Before' 
          3        42       910      3241        99      1630         4      2721
        684        11 
  'After' 
          3         4        11        42        99       684       910      1630
       2721      3241 
   
# Execution terminated   20:03:03  T=0.003

Final thoughts about PL/I

To a C programmer, PL/I appears the most familiar of the languages we’ve seen so far, from the comments style and semicolon as line terminators to the storage classes and system level access, but with a more ALGOLy syntax. Writing the above I certainly found it expressive and easy to use, but it lacks even the minimal type checking found in C and I wasn’t quite sure what conversions were going on behind the scenes.

In its historical context, PL/I never really took off - it was tough to implement a compiler and too much identified with IBM to be adopted widely. It was important in the development of MULTICS and it nearly had a renaissance when it was made available for OS/2 in the 1990s, but ultimately it did not gain enough adoption from programmers to be truly successful.

For MTS at UM, according to the Introduction to programming and debugging in MTS, it was the third most popular language (8% by frequency of use) in 1984, but way behind FORTRAN and PASCAL. It would be interesting to know what types of users it had - teaching, business or scientific research? It does not seem to have been used by MTS system programmers much, going by the lack of components in PL/I on the D6.0 tapes.

Further information

Full source code for this program is on github.

Go back to the first article in the series on PL/I or see the other languages being looked at.

PL/I - Language features 2

Sun, 28 Jun 2015 11:12:56 +0000

Let’s continue our look at the PL/I language.

Storage classes

There are four storage classes in PL/I. AUTOMATIC (the default) and STATIC are much like in C:

CONTROLLED variables are assigned space dynamically with ALLOCATE and released with FREE. Unlike C malloc/free, allocations are stacked so you can reallocate space and the program will remember the last allocation after it is freed. For example, the below will print 20 then 10.

TEST: PROCEDURE OPTIONS(MAIN);
  DECLARE A FIXED BINARY(16) CONTROLLED;

  ALLOCATE A;
  A = 10;
  ALLOCATE A;
  A = 20;
  PUT FILE (SCARDS) LIST(A);
  FREE A;
  PUT FILE (SCARDS) LIST(A);
  FREE A;
END TEST;

Use of controlled variables before they are allocated or after they are freed will lead to a runtime error.

BASED variables are similar to CONTROLLED variables but also allow pointer style access.

Variables (and procedures) can also be declared EXTERNAL if they are defined elsewhere in the program.

Procedures and functions

Procedures can be declared at file level, within other procedures, or even within DO blocks. They are introduced with PROCEDURE and executed using CALL. Parameters are passed by name so the procedure can alter them; you can also pass an expression and the compiler will introduce a temporary variable. The below will print 41.

TEST: PROCEDURE OPTIONS(MAIN);
  DECLARE A FIXED BINARY(16);
  A = 41;
  CALL INCR(A);
  CALL INCR(A+1);
  PUT FILE (SCARDS) LIST(A);

  INCR: PROCEDURE(X);
    DECLARE X FIXED BINARY(16);
    X = X + 1;
  END INCR;

END TEST;

A function is a procedure that returns a value, so the above could also be written as:

TEST: PROCEDURE OPTIONS(MAIN);
  DECLARE A FIXED BINARY(16);
  A = 41;
  A = INCR(A);
  PUT FILE (SCARDS) LIST(A);

  INCR: PROCEDURE(X) RETURNS(FIXED BINARY(16));
    DECLARE X FIXED BINARY(16);
    RETURN(X + 1);
  END INCR;

END TEST;

Note that brackets are needed around the expression being returned.

Preprocessor

The source file can be augmented at compile time by using preprocessor directives, which start with %. On MTS, to use this facility you must set the MACRO parameter in the compiler command (eg $run *pl1f scards=in.pl1 spunch=-load par=macro).

%INCLUDE otherfile copies the contents of otherfile into the file currently being compiled.

%DECLARE can be used for macro replacement. %DEACTIVATE will undefine a macro variable allowing it to be used by the program again. The following will print 42.

%DECLARE A CHARACTER, B FIXED;
%A = 'B + 2';
%B = 40;

TEST: PROCEDURE OPTIONS(MAIN);
  DECLARE X FIXED BINARY(16);
  X = A;
  PUT FILE (SCARDS) LIST(A);
END TEST;

So far so much like the C preprocessor. But you can also do compile time programming using labels, %IF and %GOTO. The below will substitute the middle section with X = X + 1;, X = X + 2; etc and prints 10.

TEST: PROCEDURE OPTIONS(MAIN);
  DECLARE X FIXED BINARY(16);
  X = 0;
  
  %DECLARE N FIXED;
  %N = 1;
  %LABEL1:;
  X = X + N;
  %N = N + 1;
  %IF N < 5 %THEN %GO TO LABEL1;

  PUT FILE (SCARDS) LIST(X);
END TEST;

There is also a %DO loop and the ability to create compile time %PROCEDURES.

Further information

There’s a lot more we haven’t covered. PL/I has extensive I/O operations in both stream and record formats. There is support for multi-tasking, although much of this is not available on MTS.

There is surprisingly little on the internet about PL/I, outside of IBM. There’s an (opinionated) comparison between C and PL/I. The experience Multics had using PL/I is also interesting.

PL/I - Language features 1

Sun, 07 Jun 2015 03:29:03 +0000

Let’s look at the PL/I language in more details. Before we start, PL/I is a big language, and we are going to need two posts to even scratch the surface.

Format

PL/I is free format, but the IBM implementation requires use of upper case letters for keywords and identifiers. By default, characters after the 72nd column are ignored by the IBM compiler but this can be changed by a command line switch.

Comments are introduced with /* and ended with */ like in C.

Keywords are not reserved words, so you can do things like the below, where IF is an identifier; this will print 4. Also note that = is used for assignment or comparison, depending on context.

TEST: PROCEDURE OPTIONS(MAIN);
  DECLARE IF FIXED BINARY(16);
  IF = 3;
  IF IF = 3 THEN IF = 4; ELSE IF = 5;
  PUT FILE (SCARDS) LIST(IF);
END TEST;

Variables and constants

Arithmetic data

Arithmetic data can be either fixed point or floating, both using in decimal or binary as its base. An example of each of these combinations:

TEST: PROCEDURE OPTIONS(MAIN);
  DECLARE XB FIXED BINARY(16);
  DECLARE XD FIXED DECIMAL(8,2);
  DECLARE FB FLOAT BINARY(8);
  DECLARE FD FLOAT DECIMAL(5);
  XB = 42;
  XD = 123.45;
  FB = 10110.01B;
  FD = 123.45678;
  PUT FILE (SCARDS) LIST(XB, XD, FB, FD);
END TEST;

which will print

42      123.45  2.22E+01  1.2345E+02

Note that for the binary items, the number in brackets specifies the number of bits to be used for storage; for decimals, it is the precision, so FD has been truncated.

In the above, you can see that B can be used as a suffix for binary constants. There is also a L suffix for pre-decimalisation British currency where the elements designate pounds, shillings and pence. This is converted into pence for storage.

TEST: PROCEDURE OPTIONS(MAIN);
  DECLARE AMT FIXED BINARY(16);
  AMT = 1.5.2L;
  PUT FILE (SCARDS) LIST(AMT);
END TEST;

I think no other language has this, and it may reflect that PL/I was originally designed at IBM’s labs in England.

You can also declare complex variables and use the I suffix in constants, and there are PICTURE definitions for string representations of numeric data similar to COBOL.

Strings

Strings can be defined with either a fixed length or maximum length (with the VARYING keyword). A repeating constant can be introduced with a prefix number, as the below:

TEST: PROCEDURE OPTIONS(MAIN);
  DECLARE A CHARACTER(20);
  DECLARE B CHARACTER(20) VARYING;
  A = 'HELLO';
  B = (3)'PL1 ';
  PUT FILE (SCARDS) LIST(A,B);
END TEST;

which prints:

'HELLO               ' 'PL1 PL1 PL1 '

There are also bit strings, eg DECLARE C BIT(8); C = '1010'B.

Arrays and structures

Arrays can be defined by adding dimensions after the variable name, eg DECLARE TABLE(10,20) FIXED DECIMAL(16);

Structures are collections of variables using a hierarchical format, for example

TEST: PROCEDURE OPTIONS(MAIN);
  DECLARE 1 MEAL,
            2 NAME CHARACTER(20) VARYING,
            2 CUISINE CHARACTER(20) VARYING,
            2 RESTAURANT,
              3 NAME CHARACTER(20) VARYING,
              3 ADDRESS CHARACTER(80) VARYING,
            2 COST FIXED DECIMAL(5,2);
  MEAL.NAME = 'Dinner';
  MEAL.CUISINE = 'Italian';
  MEAL.RESTAURANT.NAME = 'Alfredo';
  MEAL.ADDRESS = '123 Foo Road';
  MEAL.COST = 123.45;
  PUT FILE (SCARDS) LIST(MEAL);
END TEST;

Note that when qualifying a structure member we can omit levels if it is not ambiguous, eg MEAL.ADDRESS.

Once a structure has been set up, other variables can be instantiated with the same type using LIKE, eg DECLARE PARTY LIKE MEAL;.

Other types and attributes

As well as statement labels, which can be used for GO TO targets, there are special types for multitasking called events and tasks, but these are not supported by MTS.

An alias to another variable can be set up with DEFINED, eg DECLARE A FIXED BINARY(16); DECLARE B DEFINED A; means B and A point at the same variable.

Other attributes on types include ALIGNED and UNALIGNED and an initial value set at declaration with INITIAL;

Not covered here are variable lifetimes and pointers, which I will come back to in the next part.

Expressions

Expressions work mostly as expected, with conversions allowed implicitly between types - which leads to some complex rules given the number of built in types. || can be used as the string concatenation operator. Whole arrays or structures can be used as parameters to an expression.

Statements

Multiple assignments can be made on the left hand side of an expression, eg A,B = 2*21.

Control flow statements include IF ... THEN ... ELSE and looping via DO, which allows variable and condition testing as in the below:

TEST: PROCEDURE OPTIONS(MAIN);
  DECLARE I FIXED BINARY(16);
  DECLARE S FIXED BINARY(16);

  DO I = 1 TO 5, 10 TO 15;
    PUT FILE (SCARDS) LIST(I);
  END;
  PUT FILE (SCARDS) SKIP;

  S = 0;
  DO WHILE (S < 10);
    S = S + 1;
    PUT FILE (SCARDS) LIST(S);
  END;
  PUT FILE (SCARDS) SKIP;

  S = 0;
  DO I = 2 TO 10 BY 2 WHILE (S < 10);
    S = S + I;
    PUT FILE (SCARDS) LIST(S);
  END;
  PUT FILE (SCARDS) SKIP;
END TEST;

while will print

          1         2         3         4         5        10        11  
         13        14        15 

          1         2         3         4         5         6         7  
          9        10 

          2         6        12

The STOP and EXIT statements can be used to terminate program execution immediately. There is also exception support for a set of predefined cases, such as end of file, using ON, eg ON ENDFILE(SCARDS) GO TO DONE;

In the next post we will look at pointers, block structure and the pre-processor along with other topics.

Further information

The original IBM documentation for the PL/I language and PL/I F compiler can be found at bitsavers.

PL/I - Introduction

Sun, 24 May 2015 03:08:35 +0000

In this series we’ll look at PL/I, or Programming Language 1, an ambitious multi-purpose language developed by IBM.

PL/I overview

PL/I was intended to be a programming language for all users - scientific, business and systems. It was originally developed by IBM in the mid ’60s and spread to other mainframes, Multics and DEC systems. A subset of the language was used to create CP/M and IBM produced a version for OS/2 on PCs that was competitive with C. A standardised specification was produced by ECMA and ANSI from the early ’70s. Although it gained some popularity (it was even used as a teaching language at some universities) it never really took off in any of the fields it was intended for.

Language-wise, it is a procedural imperative language drawing inspiration from FORTRAN, COBOL and ALGOL. Due to its intended wide coverage, it is a very large language with a number of interesting features, some of which were incorporated into later languages such as C.

PL/I on MTS

There were three PL/I environments originally available on MTS:

*PL1F was derived from the IBM OS/360 F version 5 compiler with modifications for MTS. This is the only version available on the D6.0 tapes today and the one we will look at here. The MTS documentation refers to this as *PL1 but this name is not available; use *PL1F.
*PL1OPT was the IBM optimising compiler for PL/I and is not available due to copyright reasons. It took many of the compiler optimisation techniques developed for the FORTRAN H compiler and also offered a checkout facility for improved debugging.
*PLC was a load-and-go processor developer at Cornell. It had the unique feature that any input would compile (but maybe not produce the desired results) due to automatic substitution of syntax errors. A binary version exists but was not distributed with the D6.0 version of MTS due to copyright concerns. It may be available in future versions; see this discussion at the MTS Archive for further information.

There are also a number of utility programs for PL/I *PL1SCAN does a quick syntax check of a program and *PL1TIDY formats a PL/I source file.

Prerequisites

No special installation instructions to get PL/I running - just do the standard D6.0 setup as described in this guide and then sign on as a regular user such as ST01.

Using `*PLIF`

*PLIF will read source from scards (by default *source* ie standard input) and will write object files to spunch. Unlike some other MTS compilers you need to provide a filename for spunch as there is no default. You should destroy or empty the contents of the object file before recompiling.

Other compilation parameters are listed in MTS Volume 7.

To run PL/I programs you need to concatenate the runtime library *PL1LIB with the object file.

Hello world

Here’s a transcript of a session where we run a Hello world program. This assumes the source code is contained in the file hello.pl1.

# $list hello.pl1

      1     /* Hello world program in PL/I */
      2     HELLO: PROCEDURE OPTIONS(MAIN);
      3       DECLARE I FIXED BINARY(16);
      4       DO I = 1 TO 5;
      5           PUT FILE (SCARDS) LIST('Hello, world!');
      6           PUT FILE (SCARDS) SKIP;
      7     END HELLO;

# $destroy -load
 File "-LOAD" has been destroyed.

# $run *pl1f scards=hello.pl1 spunch=-load
# Execution begins   12:18:31


  PROCEDURE HELLO: SYNTAX CHECK COMPLETED. COMPILATION CONTINUES.


  NO ERRORS OR WARNINGS DETECTED.
# Execution terminated   12:18:31  T=0.087

# $run -load+*pl1lib
# Execution begins   12:18:34
 'Hello, world!'
 'Hello, world!'
 'Hello, world!'
 'Hello, world!'
 'Hello, world!'

# Execution terminated   12:18:34  T=0.002

Further information

MTS Volume 7 describes the PL/I compilers available on MTS.

The original IBM documentation for the PL/I language and PL/I F compiler can be found at bitsavers.

A good introduction to PL/I is the PL/I Primer.

The Wikipedia article gives an extensive history and list of implementations.

Updated 10 June 2020: corrected status of *PLC as per MTS Archive.

The great FORTRAN-LISP shootout

Sun, 10 May 2015 03:25:39 +0000

One of the reasons LISP did not become more popular for scientific computing was the perception that it was slower than FORTRAN. In this post I will compare the performance of the LISP and FORTRAN implementations on MTS using a simple problem.

The problem and some caveats

We’ll use the finding emirp primes problem introduced in the FORTRAN posts on this blog as the subject. To make it simpler we will just look at the third test, finding the 10,000th emirp.

So some caveats before we start. Benchmarks are notoriously difficult to get right and this is only a single sample. I’m not an expert at optimising LISP or FORTRAN so there may well be better ways of implementing this. Finally, the UTILISP implementation is from the 1980s, MTS LISP is from the 1970s and the FORTRAN G and H compilers date from at least the 1960s so this is not a historically accurate recreation.

Having said that, it’ll be interesting to see how they stack up, so let’s start.

FORTRAN

We’ll use the source code for the FORTRAN emirp implementation discussed before, taking out the first and second test.

We compile without optimisations first (ie using FORTRAN G) and then try again with FORTRAN H. The results look like this:

# run *ftn scards=emirp3.f
# Execution begins   11:39:08 
  No errors in PRIME 
  No errors in REVRSE 
  No errors in EMIRP 
  No errors in SHOW 
  No errors in TEST3 
  No errors in MAIN 
# Execution terminated   11:39:08  T=0.045 
# run -load
# Execution begins   11:39:10 
     948349
# Execution terminated   11:39:19  T=9.05 
#
# $run *ftn scards=emirp3.f par=opt=h
# Execution begins   11:39:49 

  **** No errors for  PRIME ****      SAT MAY 09/15 11:39:49 

  **** No errors for REVRSE ****      SAT MAY 09/15 11:39:49 

  **** No errors for  EMIRP ****      SAT MAY 09/15 11:39:49 

  **** No errors for   SHOW ****      SAT MAY 09/15 11:39:49 

  **** No errors for  TEST3 ****      SAT MAY 09/15 11:39:49 

  **** No errors for   MAIN ****      SAT MAY 09/15 11:39:49 
# Execution terminated   11:39:49  T=0.074 
# run -load
# Execution begins   11:39:54 
     948349
# Execution terminated   11:39:59  T=4.281

So 9.05s for FORTRAN G and 4.28s for FORTRAN H.

MTS LISP

Let’s try the original MTS LISP first. It’s fairly easy to translate using the (GO) form to do looping.

;; Checks if n is prime using a simple division test
(DEFUN PRIME-P (N)
  (COND
   ;; Deal with numbers <= 3
   ((LESS N 2) NIL)
   ((LESS N 4) T)
   ;; Check if divisible by 2 or 3
   ((EQUAL (REMAIN N 2) 0) NIL)
   ((EQUAL (REMAIN N 3) 0) NIL)
   ;; See if divisible by 5, 7, ..., up to approx sqrt(n)
   (T (PROG (I RESULT)
            (SETQ I 5)
A           (SETQ RESULT (COND ((GREATER (TIMES I I) N) 'PRIME)
                               ((EQUAL (REMAIN N I) 0) 'NOT-PRIME)
                               (T (SETQ I (ADD I 2)) NIL)))
            (COND ((NOT RESULT) (GO A)))
            (EQ RESULT 'PRIME)))))

;; Return a number that has the reversed digits in n
(DEFUN REVERSE-DIGITS (N)
  (PROG (REVERSED)
        (SETQ REVERSED 0)
        ;; Take last digit from n and append to reversed
        (PROG ()
B             (SETQ REVERSED (TIMES REVERSED 10))
              (SETQ REVERSED (ADD REVERSED (REMAIN N 10)))
              (SETQ N (IDIVIDE N 10))
              (COND ((GREATER N 0) (GO B))))
        ;; CAR needed to evaluate REVERSED otherwise PROG will return
        ;; the symbol REVERSED
        (CAR REVERSED)))

;; Check if a number is an emirp, ie both it and its reversed digits
;; are prime.
(DEFUN EMIRP-P (N)
  (PROG (REVERSED)
        (SETQ REVERSED (REVERSE-DIGITS N))
        (AND (NOT (EQUAL N REVERSED)) (PRIME-P N) (PRIME-P REVERSED))))

(DEFUN EMIRP-10K ()
  (PROG (N COUNT LAST)
        (SETQ N 0)
        (SETQ COUNT 0)
        (SETQ LAST 0)
C       (COND ((EMIRP-P N)
               (SETQ COUNT (ADD COUNT 1)) (SETQ LAST N)))
        (SETQ N (ADD N 1))
        (COND ((LESS COUNT 10000) (GO C)))
        (CAR LAST)))

(EMIRP-10K)
(STOP)

We’ll first execute it through the interpreter:

# $run *lisp scards=emirp.l
# Execution begins   12:41:27
      WELCOME TO LISP/MTS
 >    PRIME-P
 >    REVERSE-DIGITS
 >    EMIRP-P
 >    EMIRP-10K
* GC: COLLECTED 23370 CELLS
...
* GC: COLLECTED 23370 CELLS
>    948349
# Execution terminated   12:47:15  T=347.517

Next we’ll compile the functions. Add (COMPILE PRIME-P) and so on for all the functions and rerun

# $run *lisp scards=emirp.l
     WELCOME TO LISP/MTS
>    PRIME-P
>    REVERSE-DIGITS
>    EMIRP-P
>    EMIRP-10K
* COMPILE        04-17-79 RESTORED
>    (PRIME-P)
>    (REVERSE-DIGITS)
>    (EMIRP-P)
>    (EMIRP-10K)
* GC: COLLECTED 23370 CELLS
...
* GC: COLLECTED 23370 CELLS
>    948349
# Execution terminated   12:56:39  T=72.347

OK, so we are down from 348s to 72s (the compilation itself takes less than 0.5s). Not bad, but still 17 times slower than FORTRAN H.

UTILISP

Let’s see how UTILISP compares. We do need to change the program in quite a few places to match the different built in functions (eg + instead of ADD) but at least we can now use the do macro to create more expressive loops.

;; Checks if n is prime using a simple division test
(defun prime-p (n)
  (cond
   ;; Deal with numbers <= 3
   ((<= n 1) nil)
   ((<= n 3) t)
   ;; Check if divisible by 2 or 3
   ((= (remainder n 2) 0) nil)
   ((= (remainder n 3) 0) nil)
   ;; See if divisible by 5, 7, ..., up to approx sqrt(n)
   (t (do ((i 5 (+ i 2)) (result nil))
          (result (eq result 'prime))
          (setq result (cond ((> (* i i) n) 'prime)
                             ((= (remainder n i) 0) 'not-prime)
                             (t nil)))))))


;; Return a number that has the reversed digits in n
(defun reverse-digits (n)
  (do ((reversed 0) (m n (// m 10)))
      ((< m 1) reversed)
      ;; Take last digit from n and append to reversed
      (setq reversed (* reversed 10))
      (setq reversed (+ reversed (remainder m 10)))))


;; Check if a number is an emirp, ie both it and its reversed digits
;; are prime.
(defun emirp-p (n)
  (let ((reversed (reverse-digits n)))
    (and (neq n reversed) (prime-p n) (prime-p reversed))))


;; Return the 10,000th emirp
(defun emirp-10k ()
  (do ((n 0 (+ n 1)) (count 0) (last 0))
      ((eq count 10000) last)
      (cond ((emirp-p n) (setq count (+ count 1)) (setq last n)))))

;; Run the test
(print (emirp-10k))
(quit)

And let’s run it through the interpreter.

# $run *utilisp 0=emirp.ul
# Execution begins   18:18:02 
  948349
# Execution terminated   18:21:30  T=208.35

So that’s 40% quicker than the MTS LISP interpreted version. Let’s try compiling the forms, which we can just do by putting

(compile prime-p reverse-digits emirp-p emirp-10k)

after the definitions and then adding the fix parameter to the command line to reserve memory for the compiler (again compilation takes less than 0.5s of the total):

$ run *utilisp 0=emirp.ul par=fix=100
# Execution begins   18:32:27 
  ; Loading Utilisp Compiler System Version(82-11-09)
  948349
# Execution terminated   18:32:54  T=27.788

Much better - 3 times faster than the MTS LISP compiled version but 7 times slower still than FORTRAN H.

Summary of results and final thoughts

Program	Time (s)
FORTRAN G	9.05
FORTRAN H	4.28
MTS LISP interpreted	347.52
MTS LISP compiled	72.35
UTILISP interpreted	208.35
UTILISP compiled	27.79

Compiled UTILISP puts up a good showing and it’s definitely usable for light numerical tasks but in the end FORTRAN wins on pure performance. The UTILISP implementation is much faster than MTS LISP for both interpreted and compiled code, which you’d expect given the amount of knowledge creating fast LISP implementations that was built up between the release of the two programs.

Another factor evident from this test was the lack of LISP standardisation (pre-Common Lisp) makes porting programs between implementations a chore, whereas FORTRAN was relatively standardised.

Any suggestions for optimising the code? Please let me know in the comments.

In the next post, in a couple of weeks, we’ll look at PL/1.

Further information

Full source code for the programs shown here is on github.

UTILISP - Language features

Sun, 03 May 2015 02:46:34 +0000

Let’s look at some of the language features in UTILISP compared to the original MTS LISP.

Strings

UTILISP brings support for strings, which can also be treated as a sequence of bytes that can be accessed independently.

> (setq s "hello world")
  "hello world"
> (string-length s)
  11
> (sref s 1)
  133
> (sset s 1 134)
  134
> s
  "hfllo world"
> (string-search "world" s)
  6
> (cutout s 0 2)
  34950

In the last expression, we take the first two bytes of s and extract it as an integer. There’s also bref and bset which can be used to access individual bits in a string.

Numbers

UTILISP has both fixed and floating point numbers; arithmetic operators for floating point numbers have $ at the end of the keyword to distinguish them.

> (setq f 0.0)
  +0.0000000?+00
> (setq i 0)
  0
> (0= i)
  T
> (0= f)
 
  @@@ ILLEGAL ARGUMENT TYPE
  +0.0000000?+00 -- C#/0=
> (0=$ f)
  T

Vectors and references

Vectors are implemented as a primitive data type: they are created with vector and addressed with vref and vset. Vectors can contain any LISP data types. Here we create a four element vector, initially filled with the number 42 in each slot.

> (setq v (vector 4 42))
  V#-8057044
> v
  V#-8057044
> (vector-length v)
  4
> (vref v 0)
  42
> (vset v 0 43)
  43
> (vset v 1 "hello")
  "hello"

You can set references, which are pointers to elements of the vector which can then be dereferenced or updated through the reference.

> (setq r (reference v 3))
  R#-8057028
> (deref r)
  42
> (setref r 99)
  99
> (vref v 3)
  99

mapv can be used to operate on each element of a vector; it passes a reference to each element.

> (mapv v (function (lambda (r) (print (deref r)))))
  43
  "hello"
  42
  99
  V#-8057044

There is also a hash function that could be used to build efficient lookup tables using vectors.

> (hash 32)
  32
> (hash "hello")
  373277

Macros

UTILISP has macro support similar to modern LISPs, with selective quoting and evaluation via backtick and comma. Here we define a macro that will change a variable to nil if it is currently t.

> (defmacro t-to-nil (v) 
      `(cond ((eq ,v t) (setq ,v nil))))
  T-TO-NIL
> (setq a 1)
  1
> (setq b t)
  T
> (t-to-nil a)
  NIL
> (t-to-nil b)
  NIL
> a
  1
> b
  NIL

Scope and closures

UTILISP has dynamic scope and no lexical-let. There also seems to be no funarg implementation although this was available in Maclisp. It is possible to mimic closures with macros:

> (defun make-adder (init)
   (let ((sym (gensym)))
     (set sym init)
     `(lambda ( val) (cond (val (setq ,sym (+ ,sym val))) (t ,sym)))))
  MAKE-ADDER
> (setq aa (make-adder 40))
  (LAMBDA (VAL) (COND (VAL ?) (T G0002)))
> (funcall aa 1)
  41
> (funcall aa 2)
  43

INFANT

One interesting macro package that comes with UTILISP is INFANT (Infix Antidote), which allows infix notation for arithmetic expressions via !:

> (! 2 + 3 * 4)
  14

Further information

MTS Volume 22 describes the UTILISP implementation and how to run it on MTS.

UTILISP - Introduction

Sun, 26 Apr 2015 03:52:21 +0000

Let’s look at the other LISP implementation on MTS, University of Tokyo Lisp or UTILISP.

UTILISP overview

UTILISP was originally developed at the University of Tokyo in 1980 for S/360 compatible mainframes. It was worked on there by students and staff for the following decade, moving to 68000 and SPARC processors along the way. It was distributed to several sites in Japan and the rest of the world and was used for AI research. One reason for its popularity was the speed of its compiled code.

Language wise, it is similar to Maclisp; it uses dynamic scope and has macro facilities.

UTILISP on MTS

UTILISP was made available on MTS at UM in 1984 as *UTILISP: it has some light customisation to make it work with MTS and an initial version of an MTS Volume was produced based on the original UTILISP documentation.

One key program produced using UTILISP was a Prolog implementation, PROLOG/KR; this is also available on MTS and I will look at this later.

Prerequisites

No special installation instructions to get UTILISP running - just do the standard D6.0 setup as described in this guide and then sign on as a regular user such as ST01.

Using `*UTILISP`

UTILISP is an interpreted environment. Running *UTILISP on its own will allow you to start entering expressions which will be immediately evaluated. It’s possible to load expressions from a text file by providing it as the 0 parameter to *UTILISP; after the file is read you will remain in the LISP expression reader. To run a complete program and return to MTS afterwards, make the last expression be (quit).

There is an editor available via (edit fn) but it’s easier to do this outside of UTILISP.

One improvement over *LISP is that there is online help, though not using the MTS help system: as an example, type (help car) to view a brief description of how the car function works.

Like *LISP, it’s possible to compile expressions to machine code with (compile fn); note that you have to provide some fixed space memory to UTILISP at startup by setting FIX, eg with the command $run *utilisp par=fix=100. There does not seem to be a way to write the current system state or compiled functions back to disk, however.

Hello world

Here’s a transcript of a session where we run a Hello world program. This assumes the source code is contained in the file hello.ul.

# $list hello.ul
 
       1     ;; Hello world program for UTILISP
       2     (do ((i 0 (1+ i)))
       3         ((= i 5))
       4         (print "Hello, world!"))
       5     (quit)

# $run *utilisp 0=hello.ul
# Execution begins   12:01:48 
  "Hello, world!"
  "Hello, world!"
  "Hello, world!"
  "Hello, world!"
  "Hello, world!"
# Execution terminated   12:01:48  T=0.035

Further information

MTS Volume 22 describes the UTILISP implementation and how to run it on MTS.

This paper describes the history of UTILISP.

LISP - 4 bit adder

Sun, 29 Mar 2015 02:59:32 +0000

The problem

For this sample program we will simulate a four bit adder chip by constructing it from a series of AND, OR and NOT gates. See Rosetta Code for full details.

Constructing the solution

LISP provides AND, OR and NOT functions and we can use T and NIL to represent true and false. First task is to make an XOR gate:

(DEFUN XOR (A B)
  (OR (AND A (NOT B))
      (AND B (NOT A))))

Next we make a half-bit and single bit adder. These return a result and a carry bit which can be fed into the next stage of the full adder. We create a cons cell containing the result and carry bit for the return type.

(DEFUN HALF-ADDER (A B)
  (CONS (XOR A B) (AND A B)))

(DEFUN ADDER (A B C0)
  (PROG (S1 S2)
        (SETQ S1 (HALF-ADDER C0 A))
        (SETQ S2 (HALF-ADDER (CAR S1) B))
        (CONS (CAR S2) (OR (CDR S1) (CDR S2)))))

We then connect the adders together to form a four bit adder. As this version of LISP’s NTH returns the remainder of the list from the given position, we need a convenience function BIT to access individual values.

(DEFUN BIT (L N)
  (CAR (NTH L (ADD1 N))))

(DEFUN ADDER-4 (A B)
  (PROG (X1 X2 X3 X4)
        (SETQ X1 (ADDER (BIT A 3) (BIT B 3) NIL))
        (SETQ X2 (ADDER (BIT A 2) (BIT B 2) (CDR X1)))
        (SETQ X3 (ADDER (BIT A 1) (BIT B 1) (CDR X2)))
        (SETQ X4 (ADDER (BIT A 0) (BIT B 0) (CDR X3)))
        (CONS (MAPCAR 'CAR (LIST X4 X3 X2 X1)) (CDR X4))))

The adder takes as input, and returns, a list of binary values, eg (NIL T NIL T) for 5. It would be convenient to have a function that can convert an integer into such a list: we can do this recursively.

(DEFUN DEC-BIN (X)
  (PROG (BIT)
        (SETQ BIT (NOT (ZERO (LAND X 1))))  
        (COND ((LESS X 2) (LIST BIT))
              (T (APPEND (DEC-BIN (SHIFT X -1)) BIT)))))
  
;; Pad binary list L to length N by adding NILs in front
(DEFUN PAD (N L)
  (COND ((LESS (LENGTH L) N) 
         (REPEAT '(SETQ L (CONS NIL L)) (SUB N (LENGTH L))))
        (T L)))

Finally, we write a test function to take two integers (assuming each is between 0 and 15) and add them, printing the sum:

(DEFUN TEST-ADDER-4 (A B)
  (PROG (AB BB RES)
        (SETQ AB (PAD 4 (DEC-BIN A)))
        (SETQ BB (PAD 4 (DEC-BIN B)))
        (SETQ RES (ADDER-4 AB BB))
        (PRIN1 AB) (PRIN1 '+) (PRIN1 BB)
        (PRIN1 '=) (PRIN1 (CAR RES))
        (PRIN1 'carry)  (PRIN1 (CDR RES))
        (TERPRI)))

(TEST-ADDER-4 3 2)

Here PRIN1 prints a single item and a space; TERPRI ends the current line.

Getting it working

The LISP REPL helps here, as you can revise functions and test them until they work; this was fairly simple to get working, though DEC-BIN was tricky until I separated out PAD into its own function. I struggled with the LISP editor and found it easier to apply changes back to the file using *EDIT as each was done.

Let’s see it in action:

# $run *lisp scards=4bitadd.l
# Execution begins   20:02:38 
     WELCOME TO LISP/MTS
>    XOR
>    HALF-ADDER
>    ADDER
>    BIT
>    ADDER-4
>    DEC-BIN
>    PAD
>    TEST-ADDER-4
>    (NIL NIL T T) + (NIL NIL T NIL) = (NIL T NIL T) carry NIL
>    NIL
# Execution terminated   20:02:38  T=0.007

Final thoughts on MTS LISP

I like Lisp a lot and even though this is a very basic Lisp compared to Common Lisp (or even Emacs Lisp) it still feels a lot higher level than the ALGOL/FORTRAN family of languages we have seen so far. One issue that we don’t have, as we are running on fast modern computers, is speed: LISP was much slower than FORTRAN for numeric work and garbage collection was very slow.

In the next post, which will be in mid-April, we’ll look at the other LISP in MTS - UTILISP.

Further information

Full source code for this program is on github.

Comparing MTS LISP to modern Lisps

Sun, 22 Mar 2015 03:35:24 +0000

LISP is quite different from the languages we’ve looked at so far - but I will not give an introductory description, as there are plenty of resources on the Internet by better writers than me - instead I will look at how MTS LISP differs from more modern Lisps.

In the examples below, input is prefixed with a * and output with >.

Representation

MTS LISP assumes all keywords are in uppercase, but is otherwise free format. Do note that if you put the comment character ; in the first column this will be treated as a carriage control instruction to advance to the start of the next page in listings, so best prefix this with a space.

Types

As in other LISPs, the primitive data structure is the atom, which have values and property lists; atoms can be combined in s-expressions to form binary trees or lists. Here we define three atoms, a, b, c:

* (SETQ A 42)
>    42
* (SETQ B 'A)
>    A
* (SETQ C (CONS A B))
>    (42 . A)

There are no strings, but you can double-quote atom names to get printable output:

* (SETQ GREETING '"Hello, world!")
>    Hello, world!
* (PRINT GREETING)
>    Hello, world!

Arrays are simulated using functions: for a 2x2 array:

* (DEFINE (A ARRAY (2 2)))
>    A
* (SETA (A 1 2) 42)
>    42
* (PRINT (A 1 2))
>    42

Standard functions

Many familiar Lisp functions for list manipulation, arithmetic and control flow are available in this version; a brief sample:

* (SETQ L1 (LIST 1 2 (SUB 10 7)))
>       (1 2 3)
* (SETQ L2 (LIST 1 2 (SHIFT 2 2)))
>       (1 2 8)
* (CADR L2)
>       2
* (RPLACA L2 42)
>       (42 2 8)
* (DELETE 8 L2)
>       (42 2)
* L2
>       (42 2)
* (MAPC 'PRINT L2)
>       42
*       2
>       NIL

Functions and scope

As expected, you can use LAMBDA to define an anonymous function and DEFUN to attach a lambda function to an atom

* ((LAMBDA (A) (ADD A 2)) 40)
>       42

* (DEFUN FACTORIAL (N) (COND ((LESS N 2) 1)
*                            (T (TIMES N (FACTORIAL (SUB1 N))))))
>       FACTORIAL
* (FACTORIAL 5)
>       120

*LISP has dynamic scoping; variables defined in a function, or in a PROG, replace the current definitions for the life of the expression, including calls to other functions. See below, where the definition of X in the PROG is available in the GETX function.

* (SETQ X 42)
>       42
* (DEFUN GETX () X)
>       GETX
* (GETX)
>       42
* (PROG (X) (SETQ X 3) (GETX))
>       3
* (GETX)
>       42

There is no let or lexical binding in *LISP, hence no lexical closures. It may be possible to do dynamic closures but there does not seem to be function or funargs available which is needed to implement this.

There are also no macros (like defmacro) which can be expanded and evaluated at run time; there is a basic macro facility called READMACRO and PRINTMACRO where a function can be called whenever a designated atom is encountered while reading or printing.

GOTO in LISP

This rather blew my mind: a GOTO in LISP? The below will loop and read input until the user enters a number larger than 99. A and Z are labels:

(PROG (X)
A   (SETQ X (READ))
    (COND ((GREATER X 99) (GO Z))
          (T (GO A)))
Z   (PRINT 'DONE))

There is also (RETURN x), which will break out of the enclosing PROG immediately.

Super parentheses

Lisp is famously parenthesis-heavy: today we have text editors that can show matching pairs and indent code automatically but contemporary users of LISP would have had to do this by hand. To help out, *LISP defines the angle-brackets {} as super-parentheses: whenever an opening brace is encountered, the depth is remembered and when the matching close is found, the depth returns to that level. For example:

* (SETQ A (CAR (CDR (CDR (LIST 'A 'B 'C 'D)))))
>       C

* (SETQ A <CAR (CDR (CDR (LIST 'A 'B 'C 'D>)
>    C

Worlds

*LISP has a facility similar to database transactions where you can store the current state, change data and then either commit or rollback. (NEWWORLD) will return a ticket to the current state; you can then change data with special versions of LISP primitives such as SETQ2 or RPLACA2. (REALWORLD) can then be used to commit or (GETWORLD x) to roll back to the state at the time of ticket x.

* (SETQ2 A '42)
> NEWWORLD       04-15-82 RESTORED
>    42
* (SETQ W (NEWWORLD))
>    (((0 *UNDEF* . 42)) (NIL))
* (SETQ2 A 33)
>    33
* A
>    33
* (GETWORLD W)
>    NIL
* A
>    42

Further information

Chapter 3 of Successful Lisp is a good introduction to Lisp if you’ve not used it before; it’s written for Common Lisp users but most is applicable here.

LISP - Introduction

Sun, 15 Mar 2015 04:16:52 +0000

I’m still trying to restore ALGOL 68 from D4.0 and although I’ve had some great help from the folks on the H390-MTS list I have not yet got a working system running. While I continue to work on this, let’s look at a completely different language - LISP.

LISP overview

LISP is one of the oldest high level languages still in use today, with the original version developed by John McCarthy at MIT in 1958. It combines procedural, functional and metaprogramming elements and has a unique syntax based on balanced parentheses that make it unlike any other language of its time.

LISP gained popularity in the 1960s and 70s during the AI boom, when the language evolved rapidly and there was even special hardware built in order to run it efficiently. This died down towards the end of the 20th century, but it remains influential with concepts from LISP such as lambdas recently being added to languages such as Java and C++. Common Lisp implementation continue to be used today, and LISP has been used as an extension language, most famously in Emacs and AutoCAD.

LISP on MTS

The primary LISP environment in MTS, *LISP, was developed at the Mental Health Research Institute at UM. (Not an organisation you’d think would be implementing a programming language; the Wikipedia article on Brian Wilcox, one of MTS LISP’s authors, mentions that it was developed in order to play the game of Go.). It is based on LISP 1.5, one of the earliest versions of LISP that was in wide use, with some extensions drawn from later LISPs and customisations for MTS.

There are a number of other LISPs available on MTS, such as the University of Tokyo’s UTILISP, that I will look at later.

Prerequisites

No special installation instructions to get LISP running - just do the standard D6.0 setup as described in this guide and then sign on as a regular user such as ST01.

Using `*LISP`

LISP is an interpreted environment. Running *LISP on its own will allow you to start entering expressions which will be immediately evaluated. It’s possible to load expressions from a text file by providing it as the scards parameter to *LISP; after the file is read you will remain in the LISP expression reader. To run a complete program and return to MTS afterwards, make the last expression be (STOP).

There is a rudimentary line editor available via (EDIT fn) but it’s easier to do this outside of LISP.

You can also save the current state of the system (to a binary file) with (CHECKPOINT filename) and reload it in a later session with (RESTORE filename).

It’s possible to compile expressions to machine code with (COMPILE fn) but this is unlikely to be worthwhile as MTS on Hercules is fast enough.

Hello world

Here’s a transcript of a session where we run a Hello world program. This assumes the source code is contained in the file hello.l.

# $list hello.l
 
       1      ; LISP Hello World program
       2     (REPEAT '(PRINT '"Hello, world!") 5)
       3     (STOP)
# $run *lisp scards=hello.l
# Execution begins   20:54:36 
     WELCOME TO LISP/MTS
>    Hello, world!
>    Hello, world!
>    Hello, world!
>    Hello, world!
>    Hello, world!
>    Hello, world!
# Execution terminated   20:54:36  T=0.002

Note the message is actually printed six times, as the value of the REPEAT expression is printed by the interpreter.

Further information

MTS Volume 8 describes the LISP language and its implementation in MTS *LISP.

The original LISP 1.5 reference from MIT gives a more formal description of the original version of the language.

John McCarthy’s paper on the History of Lisp gives context on how and why LISP came about.

ALGOL W - Priority queue

Sun, 01 Mar 2015 03:13:42 +0000

For our sample ALGOL W program we’ll implement a simple priority queue.

The problem

A priority queue can be used to store items tagged with a priority value and then retrieve them in order of priority. Several operations need to be implemented

Check if the queue is empty
Insert an item
Peek at what the highest priority item is
Remove the highest priority item from the queue and return it

See Rosetta Code for full details.

Implementation

We will use a binary heap to implement the queue: this allows O(log n) inserts and removals, and O(1) for peeking at the highest priority item, as the queue is kept in priority order after each operation.

Rather than doing this from scratch I’m going to base the solution on Robert Sedgewick and Kevin Wayne’s Java implementation.

Interface

First let’s define the data structures and interfaces available for users of the priority queue.

Each item can be modeled as a record with an integer priority; the data associated with it is a string here but could be anything else

record Item(integer Priority; string Task);

The public interface can then be described using the following procedure prototypes:

logical procedure PQ_Is_Empty;
procedure PQ_Insert(reference(Item) value New_Item);
reference(Item) procedure PQ_First;
reference(Item) procedure PQ_Delete_First;

Test driver

To test our program, we need to insert some items in random order and then see if they dequeue in priority order:

    % Insert some tasks in random order %
    PQ_Insert(Item(3, "Clean drains"));
    PQ_Insert(Item(4, "Feed cat"));
    PQ_Insert(Item(5, "Make tea"));
    PQ_Insert(Item(1, "Solve RC tasks"));
    PQ_Insert(Item(2, "Tax return"));

    % Remove top priority item from queue and print %
    while not PQ_Is_Empty() do
    begin
        reference(Item) First;
        First := PQ_Delete_First;
        write(Priority(First), Task(First));
    end

Data structure and constraints

To store the queue, the binary heap implementation needs an array of items and an indication of its current size, which we can define as:

reference(Item) array PQ(1::PQ_Capacity);
integer PQ_Size;

PQ_Capacity is the maximum size of the queue, which we’ll define as a constant; it does not seem possible to resize an array in ALGOL W. We’ll make the array and size global variables for simplicity: a better, if more verbose solution, would be to pass the data structure to each interface function, eg

reference(Item) procedure
    PQ_Delete_First(reference(Item) array PQ(1::PQ_Capacity), integer PQ_Size;

It would also have been nice to encapsulate both PQ and PQ_Size into a record, but ALGOL W records do not allow arrays as members. One way we could combine this into one variable is to make the array have bounds 0::PQ_Capacity and store the current size at location 0.

Public function implementation

It’s then fairly simple to define the public functions:

% Initialise a queue %
procedure PQ_Init();
begin
    PQ_Size := 0;
end;

% Return true if the queue is empty %
logical procedure PQ_Is_Empty();
begin
    PQ_Size = 0
end;

% Add a new item to the queue %
procedure PQ_Insert(reference(Item) value New_Item);
begin
    % Add to end of array and swim down to maintain %
    % priority order %
    PQ_Size := PQ_Size + 1;
    PQ(PQ_Size) := New_Item;
    PQ_Swim(PQ_Size);
end;

% Return the first item in the queue by priority %
reference(Item) procedure PQ_First;
begin
    PQ(1)
end;

% Return the first item and delete from queue %
reference(Item) procedure PQ_Delete_First;
begin
    reference(Item) First;
    
    PQ_Exchange(1, PQ_Size);
    First := PQ(PQ_Size);
    PQ_Size := PQ_Size - 1;
    PQ_Sink(1);
    % Just to be safe, null out reference at end %
    PQ(PQ_Size+1) := null;
    First
end;

Private functions

These call a number of private functions - note that privacy is not enforced in ALGOL W however. First, to keep the heap organised, we need PQ_Swim and PQ_Sink:

procedure PQ_Swim(integer value K);
begin
    while K > 1 and PQ_Greater(K div 2, K) do
    begin
        PQ_Exchange(K, K div 2);
        K := K div 2;
    end;
end;

procedure PQ_Sink(integer value k);
begin
    logical Done;
    Done := false;

    while 2*K <= PQ_Size and not Done do
    begin
        integer J;
        J := 2 * K;
        if J < PQ_Size and PQ_Greater(J, J+1)
        then
            J := J + 1;
        if PQ_Greater(K, J)
        then begin
            PQ_Exchange(K, J);
            K := J;
        end
        else begin
            Done := true;
        end;
    end
end;

These need to call primitive functions to exchange and compare:

logical procedure PQ_Greater(integer value I; integer value J);
begin
    Priority(PQ(I)) > Priority(PQ(J))
end;

procedure PQ_Exchange(integer value I; integer value J);
begin
    reference(Item) Temp;
    Temp := PQ(I);
    PQ(I) := PQ(J);
    PQ(J) := Temp;
end;

A diversion - procedures without parameters

While writing this I got confused about the prototype for procedures without parameters; instead of

reference(Item) procedure PQ_First;
...
result := PQ_First;

I was writing

reference(Item) procedure PQ_First();
...
result := PQ_First();

and got what looked like garbage as the Item reference returned.

Trying to reproduce this with a simple example yielded the same problem:

# $run *algolw
= begin
: integer procedure three;
: begin
: 3
: end;
:
: write(three);
: end.
: $endfile
  Options (UN022) :- main, debug 

  (MAIN)    0.016 seconds to compile,  size 448 bytes 

  Execution begins ...
                3

  0.001 seconds in execution

# $run *algolw
= begin
: integer procedure three();
: begin
: 3
: end;
:
: write(three());
: end.
: $endfile
  Options (UN022) :- main, debug 

  (MAIN)    0.016 seconds to compile,  size 504 bytes 

  Execution begins ...
          8632304

  0.001 seconds in execution

Is the second example legal ALGOL W? I don’t think it is, based on the Stanford specification you need something in the parameter list - but there was no error from the compiler.

Running the program

Once that was fixed, compiling and running the program was simple.

# $run *algolw scards=pqueue.alw par=deck
Options (UN022) :- main, debug
 Object program:  "-AWLOAD"

 (MAIN)    0.041 seconds to compile,  size 4280 bytes

# $run -awload

              1  Solve RC tasks
              2  Tax return
              3  Clean drains
              4  Feed cat
              5  Make tea

 0.001 seconds in execution

Final thoughts on ALGOL W

ALGOL W definitely feels more polished and easy to use compared with ALGOL 60: the lack of stropping is a relief. It’s not the most powerful language - the restrictions on references stop it being much use for system programming - but I can see it would make a good choice as a teaching language. Apart from the issue I had above, the MTS compiler is much easier to use than the IBM ALGOL 60 one - I liked that it warns you if you use goto or pass by name.

Why didn’t ALGOL W become more popular? I think there were several factors

Only initially available on S/360 machines
Not as good performance as FORTRAN
Did not become the official replacement for ALGOL 60
Wirth did not work further on ALGOL W, moving on to Pascal, which does feel similar.

Next up, I will attempt to look at ALGOL 68 - if I can get it restored from the D4 tapes and running on D6.0.

Further information

Full source code for this program is on github.

ALGOL W - Language features

Sun, 22 Feb 2015 03:44:17 +0000

Let’s look at ALGOL W in more detail, focusing how it differs from ALGOL 60.

Representation

ALGOL W is free format and case insensitive, though the convention was to have keywords in lower case and identifiers Like_This. Identifiers can be up to 255 characters long.

Keywords are reserved words so no stropping is required. A standard EBCDIC character set is used so there is no need for a different reference and hardware representation.

As well as the comment syntax from ALGOL 60, comments can be started with % and then terminated with either % or ;.

The final statement in a program or separately compiled unit (ie the last end) should end with a period.

% This is an ALGOL W program %
begin
    integer Population_Count;
end.

New data types

As well as the existing types from ALGOL 60 such as real and integer, ALGOL W provides long real, complex, bit and proper string types:

begin
    complex C;
    bits B;
    string(50) S;
    c := 1 + 2I;
    b := #0000010F;
    s := "Hello, world";
end.

Bit values are padded to 32 bits. String variables have to be declared with their length, such as 50 above; if the length is not provided the default is 16.

New operators

div does integer division and rem yields the remainder after division. As well as the logical operators like and, there are also shl and shr for bitwise left and right shifts.

begin
    write(#1 shl 2);
    write(42 rem 20);
end.

The above will print #00000004 and 2.

Records and references

Records group together simple variables like a struct in C. References can point to records but not fundamental types. A reference can be initialised, at which point memory for the record is allocated. After initialisation, fields can be accessed by field(variable).

begin
    record Person(integer Age; real Height; string(40) Name);
    reference(Person) P, Q;
    P := Person(30,, "N Wirth");
    Q := Person;
    Age(Q) := 42;
    write(Name(P));
    write(Age(Q));
end.

Note for the initialisation of P we leave Height uninitialised, and although memory for Q is allocated it is not initialised at all. This example will print “N Wirth” and 42.

References can be used to point at records but not fundamental types. null can be used to refer to an non-existent record. So a simple linked list could be defined as below, which will print 20.

begin
    record List(integer Data; reference(List) Next);
    reference(List) L;
    L := List(10, null);
    Next(L) := List(20, null);
    write(Data(Next(L)));
end.

A reference can point to more than one type of record; which one can be determined at run time with the is operator.

begin
    record A(real Aa);
    record B(integer Bb);
    reference(A, B) R, S;
    R := A(3.0);
    S := B(4);
    S := R;
    if S is A then write("Got an A") else write("Got a B");
end.

The above will print “Got an A”. I think there is no garbage collector, so the memory allocated for the B is leaked.

`while` and `case`

As well as the three types of for statements from ALGOL 60, ALGOL W has a while statement. The below will print 256.0

begin
    real X;
    X := 2.0;
    while X < 100 do
    begin
        X := X * X;
    end;
    write(X);
end.

case allows switching by integer value; the below will print “Two”. Note there is no default case, so if J < 1 or > 4 there will be a runtime error.

begin
    integer J;
    string(10) Word;
    J := 2;
    Word := case J of ("One", "Two", "Three", "Four");
    write(Word);
end.

Procedures

The syntax for procedures differs from ALGOL 60 as types and calling conventions are specified in the function header:

begin
    real procedure Fn(real X; integer value Y);
    begin
        X * Y
    end;
    write(Fn(3.0, 2));
end.

The default calling convention, as used in the above, is by name, but *ALGOLW will give you a warning suggesting you use another convention instead.

Putting value after the type means pass by value. There is a new calling convention, result, which is for pass-out variables. value results allows both pass-in and pass-out without the side effects of pass by name.

begin
    procedure P1(integer value A; integer result B; real value result C);
    begin
        A := 10;
        B := A;
        C := C + A
    end;

    integer A, B;
    real C;
    A := 1; B := 2; C := 3.0;

    P1(A, B, C);
    write(A, B, C);
end.

The above will display 1, 10, 13.

Input/Output and library

There’s an extensive input/output library that has been customised for MTS.

Basic input/output allows reading and writing each from a single channel. The below program will expect input formatted like this:

1001 "Niklaus" "Wirth"
Inventor of ALGOL W

begin
    integer ID;
    string(20) First, Last;
    string(80) Description;

    read(ID);
    readon(First, Last);
    readcard(Description);
end.

More complex formatting and carriage control can be specified. There is also support for reading/writing to more than one channel, and indexed access.

The standard library contains mathematical functions and access to operating system information like time and date.

Further information

MTS volume 16 describes the language and the MTS extensions in detail.

Another introduction to the language can be found at everything2.

ALGOL W - Introduction

Sun, 15 Feb 2015 02:47:29 +0000

As discussed in the previous post, there were discussions on how to extend ALGOL after the experience of implementing ALGOL 60 on different systems. One such proposal was formulated by Niklaus Wirth and C A R Hoare. It did not get approved by the ALGOL committee, who chose what eventually became ALGOL 68 instead, so Wirth developed his proposal at Stanford and released it as ALGOL W.

ALGOL W overview

ALGOL W builds upon ALGOL 60 rather than making sweeping changes: its enhancements include

A simpler representation - no stropping of keywords
String, bits, complex and record types
References to records are allowed
The while keyword
A larger standard library, including input/output

ALGOL W on MTS

ALGOL W was originally implemented at Stanford in a high level assembly language called PL360, which I will look at later; this was augmented with S/360 assembler support routines at the University of Newcastle, UM and elsewhere to build the MTS compiler *ALGOLW.

It was the most popular of the ALGOL dialects on MTS, used for teaching programming fundamentals to students at several sites, and is well integrated with the operating system. The compiler features both a ‘compile, load and go’ mode suitable for learning the language and a traditional output to object deck option.

Prerequisites

No special installation instructions to get ALGOL W running - just do the standard D6.0 setup as described in this guide and then sign on as a regular user such as ST01.

Compiling using `*ALGOLW`

For compile, load and go mode just run *ALGOLW and type the desired program in directly. Finish it with $endfile and the system will compile it, print any errors and if OK will execute it once before returning you to the MTS prompt.

For object mode, run *ALGOLW with the command line option par=deck. It will read source from scards (by default *source* ie standard input) and will write object files to spunch (by default the temporary file -awload). The object file can then be $run directly without referencing any library.

Other *ALGOLW compilation parameters are listed in MTS Volume 16.

Hello world - compile, load and go

Here’s a simple program to print “Hello, world!” five times using the compile, load and go model. After I run *algolw I can type a compiler control statement at the = prompt but instead I enter begin, signaling that source code is being entered. *algolw prompts for the remainder of the program with :.

# $run *algolw
= begin

 Compilation begins ...
:    integer I;
:    for I := 1 until 5 do
:        write("Hello, world!");
:end.
:$endfile

 Options (UN022) :- main, debug

 (MAIN)    0.012 seconds to compile,  size 416 bytes


 Execution begins ...


 Hello, world!
 Hello, world!
 Hello, world!
 Hello, world!
 Hello, world!

 0.001 seconds in execution

Hello world - object file

Here I use the two step process of compiling to an object file and then running it. Assume the source code is in file hello.alw.

# $list hello.alw

     1     begin
     2         % Hello World program for ALGOL W %
     3         integer I;
     4         for I := 1 until 5 do
     5         begin
     6              write("Hello, world!");
     7         end
     8     end.

# $run *algolw scards=hello.alw par=deck

 Options (UN022) :- main, debug
 Object program:  "-AWLOAD"

 (MAIN)    0.007 seconds to compile,  size 416 bytes

# $run -awload

 Hello, world!
 Hello, world!
 Hello, world!
 Hello, world!
 Hello, world!

 0.001 seconds in execution

Further information

MTS volume 16 contains a very readable description of the language, the compiler options and how it integrates with MTS.

Wirth’s Turing award lecture, From programming language design to computer construction, puts ALGOL W in context with Wirth’s other work on Pascal and Modula 2.

The original ALGOL W reference manual from the Stanford implementation can be found here.

ALGOL 60 - Josephus problem

Sun, 08 Feb 2015 04:33:41 +0000

For our ALGOL 60 sample program we’ll have a quick look at implementing a solution to the Josephus problem.

The problem

Imagine n prisoners standing in a circle, numbered sequentially from 0 to n-1. An executioner walks around the circle, starting at prisoner 0, and kills every kth prisoner, removing them from the circle. As this continues, the circle becomes smaller and smaller; the last prisoner remaining is freed.

An example for n=11 prisoners and k=3. Prisoners 2, 5 and 8 will be killed on the first trip round the circle. On the second trip, it’s goodbye to prisoners 0, 4 and 9. Continuing this leaves prisoner 6 as the survivor.

The task, given any n and k (both which should be greater than zero), find the prisoner who is freed.

See Rosetta Code for a full description and sample code in other languages.

Solution

There’s a fairly simple iterative solution to the main function to determine the last survivor:

    'COMMENT' Find surviving prisoner from circle of N;
    'COMMENT' after killing each Kth prisoner;
    'INTEGER' 'PROCEDURE' JOSEPHUS(N, K);
    'VALUE' N, K;
    'INTEGER' N, K;
    'BEGIN'
        'INTEGER' INDEX, PRISONER;
         PRISONER := 0;
        'FOR' INDEX := 1 'STEP' 1 'UNTIL' N 'DO'
        'BEGIN'
            JOSEPHUS := PRISONER := MODULUS(PRISONER + K, INDEX);
        'END'
    'END'

It would seem that we could just use JOSEPHUS as the variable and not need PRISONER but ALGOL only allows return value variables to appear on the left hand side of an expression.

Next, we need to define the MODULUS function to give the remainder after dividing two integers

    'COMMENT' Finds the remainder of X and Y for positive values;
    'INTEGER' 'PROCEDURE' MODULUS(X, Y);
    'VALUE' X, Y;
    'INTEGER' X, Y;
    'BEGIN'
        MODULUS := X - (Y * (X '/' Y));
    'END'

Note that we use the integer division operator ÷ (written as '/' in the IBM hardware representation) as the regular division operator / on integers will round either up or down depending on the value.

Finally, for the main program we can call the JOSEPHUS function and output the integer result: we use 41 prisoners and k=3:

'BEGIN'
    'COMMENT' Main program;
    OUTINTEGER(1, JOSEPHUS(41, 3));
'END'

So writing this was fairly easy. Quoting all keywords still feels unnatural so I normally put them in after writing out the program in full. I had to look up the difference between the two division operators but expressing the main flow was simple. What tripped me up on first compile was the comment syntax: I was using COMMENT abc which the compiler appeared to accept but would sometimes swallow the next line. Fixing this to quote the COMMENT and terminate the line with a semicolon fixed this (eg 'COMMENT' abc;).

Running the solution

Let’s see how this looks when we compile and run the program. Don’t forger to destroy or empty the output object file first otherwise you will get strange results after each recompile.

# $destroy -load
 File "-LOAD" has been destroyed.

# $run *algol scards=josephus.al spunch=-load
Execution begins   21:39:02
 i
  LEVEL 1JUL67                            OS ALGOL F                       DATE  FEB 05 1915
                                       SOURCE PROGRAM                               PAGE 001
   SC     SOURCE STATEMENT
  00000   'BEGIN'
  00000       'COMMENT' Finds the remainder of X and Y for positive values;
  00000       'INTEGER' 'PROCEDURE' MODULUS(X, Y);
  00001       'VALUE' X, Y;
  00002       'INTEGER' X, Y;
  00003       'BEGIN'
  00003           MODULUS := X - (Y * (X '/' Y));
  00004       'END'
  00004
  00004       'COMMENT' Find surviving prisoner from circle of N;
  00005       'COMMENT' after killing each Kth prisoner;
  00005       'INTEGER' 'PROCEDURE' JOSEPHUS(N, K);
  00006       'VALUE' N, K;
  00007       'INTEGER' N, K;
  00008       'BEGIN'
  00008           'INTEGER' INDEX, PRISONER;
  00009            PRISONER := 0;
  00010           'FOR' INDEX := 1 'STEP' 1 'UNTIL' N 'DO'
  00010           'BEGIN'
  00010               JOSEPHUS := PRISONER := MODULUS(PRISONER + K, INDEX);
  00011           'END'
  00011       'END'
  00011
  00011       'COMMENT' Main program;
  00012       OUTINTEGER(1, JOSEPHUS(41, 3));
  00013   'END'
 i
                                       IDENTIFIER TABLE                             PAGE 002
  PBN SC    PBN      NAME   TYPE  DM DSP       NAME   TYPE  DM DSP       NAME   TYPE  DM DSP
            SURR                  PR LN                     PR LN                     PR LN

  001 00000 000      JOSEPH I P   02 074       MODULU I P   02 070

  002 00000 001      MODULU I P   02 070       X      I  V     020       Y      I  V     028

  003 00005 001      INDEX  I        030       JOSEPH I P   02 074       K      I  V     028
                     N      I  V     020       PRISON I        034
 i
                                   STORAGE REQUIREMENTS (DECIMAL)                   PAGE 003

  OBJECT MODULE SIZE 840 BYTES.
  DATA STORAGE AREA SIZES
    PBN   BYTES       PBN   BYTES       PBN   BYTES       PBN   BYTES       PBN   BYTES
    001      36       002      48       003      68
Execution terminated   21:39:02  T=0.016

# $run -load+*algollib
Execution begins   21:39:10
         +30



 END OF ALGOL PROGRAM EXECUTION

Execution terminated   21:39:10  T=0.003

We can see in the compiler identifier table output that although we can use long identifiers they are truncated to six characters.

Final thoughts on ALGOL 60

There’s a lot to like in ALGOL 60: the language definition is more precise than the informal descriptions used before; the block structure and variable scoping; the powerful control statements. As a programmer with a C background it appears much more familiar then FORTRAN.

However it does feel like an interim release rather than a fully developed language; I think this is partially due to its academic origins rather than from a computer company looking to sell its hardware. The different language representations and call-by-name are a bit too clever and the emphasis on machine independence went too far - the lack of any I/O means that no useful program could be portable. Another factor not evident when running MTS today is that the FORTRAN development environment and compilers are much more advanced so for any computationally expensive workload you would have been better off with FORTRAN.

With the experience of implementing compilers in ALGOL 60, the group responsible for the original report looked at what changes should be made for the next version of ALGOL. In the next post I’ll look at one of these, ALGOL W.

Further information

Full source code for this program is on github.

ALGOL 60 - Language features

Sun, 01 Feb 2015 02:43:31 +0000

ALGOL 60 and the Revised Report

As mentioned in the previous post, ALGOL was designed by an international committee of computer scientists: their goal was to create a universal language for expressing algorithms without recourse to hardware specific features.

The result of their discussions was the ALGOL 60 Report, with a slightly corrected version known as the Revised Report released a few years later. This was one of the first attempts to formally specify a language, using Backus-Naur form (JW Backus and Peter Naur were both on the ALGOL committee).

Representations

ALGOL was intended as a universal language, but at the time of its creation there was no universal character set such as Unicode or even ASCII; as a result, the report defines three representations of the language:

A reference language used by the committee in the report to describe ALGOL
Publication language, which modifies the reference language for use in handwritten or published documents
Hardware representations, which modifies the reference language based on the character set of the hardware it is running on.

An example is the exponentiation operator.

In the reference language the upwards facing arrow ↑ is used, eg a ↑ b.
In the publication language, superscript is used for the exponent, eg a^b.
In the hardware representation used by IBM, 'POWER' or ** is used, eg a ** b.

One of the most important differences in representation were basic symbols like begin or end. In the reference and publication language these were usually underlines, eg begin. In many hardware representations, including IBM’s, they were enclosed in quotes eg 'BEGIN',

A summary of the differences between the reference language and the IBM hardware representation is shown below; in some cases there is more than once choice for the hardware representation.

Reference   Hardware       Hardware alt
×           * 
↑           'POWER'        **
÷           '/'
>           'GREATER'      >
<           'LESS'         <
≤           'NOTGREATER'   <=
≥           'NOTLESS'      >=
≠           'NOT EQUAL'    ¬=
≡           'EQUIV'
⊃           'IMPL'
∧           'AND'          &
∨           'OR'           |
¬           'NOT'
:            :             ..
;            ;             .,
₁₀          '
[           (/
]           /)
‘           '('
’           ')'

The “₁₀” is a scale factor like “E” in the C language, eg 1234 could be expressed as “1.234₁₀3”;

In the rest of this post, I will use the reference language in the body text and the IBM hardware representation in the monospaced examples.

Blocks and statements

ALGOL 60 is free format, with statements separated by semicolons. It is possible to group statements into a block, marked by begin and end and optionally labeled. Comments are started with the keyword comment and ended with a ;; this is not needed at the end of blocks.

'COMMENT' Block example;
'BEGIN'
    X: 'BEGIN'
        FN1(10);
        FN1(20);
    'END' this is the end of the X block
'END' and this the unnamed block

Types and variables

ALGOL 60 supports integer, real and Boolean types and variables. There is no restriction in the standard on variable name length, but *ALGOL limits them to six characters. All variables must be declared with their types and variable lifetime is the block. The standard does define a storage class called own, similar to C’s static, but this is not supported by the IBM compiler.

The below will print “3 4 3”:

'BEGIN'
    'INTEGER' I, J;
    I := 3;
    OUTINTEGER(1, I);
    'BEGIN'
        'INTEGER' I;
        'BOOLEAN' STATE;
        I := 4;
        OUTINTEGER(1, I);
    'END'
    OUTINTEGER(1, I);
'END'

Multi-dimensional arrays can be declared, with variable bounds:

'INTEGER' 'ARRAY' A(/-1:+1, M:N/);
A(/0,15/) := 42;

Strings are supported only as constant parameters to function; it is not possible to declare string variables.

OUTSTRING(1, '('This is a string')');

Expressions

The usual arithmetic expressions are available; it’s possible to include an if/else in such expressions. Unusually, Boolean expressions include operators for implies and equivalent.

'BEGIN'
    'INTEGER' X, Y;
    'BOOLEAN' A, B;
    X := 3;
    Y := 4;
    A := 'TRUE';
    B := 'FALSE';
    OUTINTEGER(1, X + Y - ('IF' A 'OR' B 'THEN' 1 'ELSE' 2));
'END'

The above will print 6.

Control statements

As well as the regular goto statement, the switch statement allow selection of a statement label to jump to.

if … then … else can be used for conditional execution. Another if cannot follow the then unless it is contained in a block. to prevent ambiguity of which if then else is attached to.

The for statement is used for repetition: there are three forms:

'BEGIN'
    'INTEGER' J;
    'FOR' J := 1, 2, 3 'DO' OUTINTEGER(1, J);
    'FOR' J := 10 'STEP' 5 'UNTIL' 20 'DO' OUTINTEGER(1, J);
    'FOR' J := 100, J*2 'WHILE' J 'LESS' 500 'DO' OUTINTEGER(1, J);
'END'

This will print

1, 2, 3
10, 15, 20
100, 200, 400

Procedures

Procedures support pass by value or pass by name parameters. Pass by value is familiar: a copy is made of the parameter for those identified with value in the procedure preamble. The following will print 42:

'BEGIN'
    'INTEGER' 'PROCEDURE' ADD2(X, Y);
    'VALUE' X, Y;
    'INTEGER' X, Y;
    'BEGIN'
        ADD2 := X + Y;
    'END'

    OUTINTEGER(1, ADD2(20, 22));
'END'

Pass by name is similar to pass by reference in C++ or Java in that it allows output to be made to parameters; it also enables Jensen’s device. Take for example the below:

'BEGIN'
    'PROCEDURE' INC(A, B);
    'INTEGER' A, B;
    'BEGIN'
        A := A + 1;
        B := B + 1;
    'END'

    'INTEGER' 'ARRAY' X(/10/);
    'INTEGER' J;

    X(/1/) := 10;
    X(/2/) := 20;

    J := 1;
    INC(J, X(/J/));

    OUTINTEGER(1, J);
    OUTINTEGER(1, X(/2/));
'END'

This will print 2 (as J has been incremented by the line A := A + 1) and 21 (as X[J] was passed in by name, it was evaluated as X[2] in the line B := B + 1).

Standard functions and input/output

There are a small number of standard functions defined by the language, mostly mathematical (eg ABS, SIGN, SQRT, SIN, LN). The ENTIER function accepts a real number as parameter and returns an integer.

No input/output functions are defined at all in the standard, due to the desire for the language to be device independent and as at the time there was no common agreement of what input/output facilities could be provided across all available hardware. The IBM compiler provides PUT and GET for low level I/O, SYSACT for stream manipulation and a number of functions for input or output of variables, eg ININTEGER, OUTREAL.

Further information

The Revised Report on the Algorithmic Language Algol 60 is the standard for the language. Donald Knuth wrote an article on the remaining troublespots in ALGOL 60 on some of the ambiguities in the standard.

The original IBM documentation for the compiler contains most of the text of the Revised Report annotated with examples using IBM’s representation.

Updated 6-Feb-2015 to fix comment syntax

ALGOL 60 - Introduction

Sun, 25 Jan 2015 09:43:30 +0000

In this series of posts we’ll look at ALGOL, one of the foundational languages for modern programming, and the ALGOL 60 implementation on MTS.

The ALGOL family of languages and ALGOL 60

Most programming languages spring from a single person or a company; ALGOL is fairly unique in that it was originally designed by a committee of European and American computer scientists in the mid 1950s. The first version to be widely implemented was ALGOL 60, which is what we will look at here. A large number of improvements to ALGOL 60 were proposed or developed: one, by Niklaus Wirth, became ALGOL W. The next standardised version was ALGOL 68 but this was not widely adopted.

Although it is not in wide use today, ALGOL introduced many influential concepts to programming languages, such as block scoping, so can be considered the ancestor of languages such as Pascal and C.

ALGOL 60 on MTS

The ALGOL compiler provided by IBM for S/360 machines is available on MTS under the name *ALGOL. This follows the ALGOL 60 specification fairly closely. A number of small changes were made to the compiler to make it work under MTS.

There are also ALGOL W and ALGOL 68 compilers on MTS, the former being the most popular version in use at the time of D6.0; I will look at these in later posts.

Prerequisites

No special installation instructions to get ALGOL 60 running - just do the standard D6.0 setup as described in this guide and then sign on as a regular user such as ST01.

Compiling using `*ALGOL`

*ALGOL will read source from scards (by default *source* ie standard input) and will write object files to spunch. Unlike some other MTS compilers you need to provide a filename for spunch as there is no default.

One gotcha is that *ALGOL will not clear out the file used for writing object code, so you need to run $empty on it before recompiling each time.

Other *ALGOL compilation parameters are listed in MTS Volume 2X.

To run ALGOL 60 programs you need to concatenate the runtime library *ALGOLLIB with the object file. Say your object code is in the file -load then to run it you would do:

# $run -load+*algollib

Hello world

Here’s a simple program to print “Hello, world!” five times.

'BEGIN'
'COMMENT' Hello World program for ALGOL 60;
    'INTEGER' I;
    'FOR' I := 1 'STEP' 1 'UNTIL' 5 'DO'
    'BEGIN'
         OUTSTRING(1, '('Hello, world!')');
         SYSACT(1, 14, 1);
    'END'
'END'

Indentation is not important except to make the program readable. Note the quotation marks around keywords like 'INTEGER' to distinguish them from identifiers: this is known as stropping.

OUTSTRING and SYSACT are not part of ALGOL 60 but are library functions provided by IBM; the SYSACT call here is used to start a new line on the output device.

Here’s a terminal log of how to compile and run the program. This assumes the source code is in file hello.al.

# $run *algol scards=hello.al spunch=-load
 i
  LEVEL 1JUL67                            OS ALGOL F                       DATE  JAN 11 1915
                                       SOURCE PROGRAM                               PAGE 001
   SC     SOURCE STATEMENT
  00000   'BEGIN' 
  00000       'COMMENT' Hello World program for ALGOL 60; 
  00000       'INTEGER' I;
  00001       'FOR' I := 1 'STEP' 1 'UNTIL' 5 'DO'
  00001       'BEGIN'
  00001           OUTSTRING(1, '('Hello, world!  ')');
  00002           SYSACT(1, 14, 1);
  00003       'END'
  00003   'END'
 i
                                       IDENTIFIER TABLE                             PAGE 002
  PBN SC    PBN      NAME   TYPE  DM DSP       NAME   TYPE  DM DSP       NAME   TYPE  DM DSP
            SURR                  PR LN                     PR LN                     PR LN

  001 00000 000      I      I        018
 i
                                   STORAGE REQUIREMENTS (DECIMAL)                   PAGE 003

  OBJECT MODULE SIZE 540 BYTES.
  DATA STORAGE AREA SIZES
    PBN   BYTES       PBN   BYTES       PBN   BYTES       PBN   BYTES       PBN   BYTES
    001      48

# $run -load+*algollib
 Hello, world!
 Hello, world!
 Hello, world!
 Hello, world!
 Hello, world!

 END OF ALGOL PROGRAM EXECUTION

If you change the source file and want to recompile, remember to do %empty -load.

Further information

As always, the Wikipedia page provides a good overview of the language’s history and key features.

There is no MTS Volume on ALGOL 60 (there is one on ALGOL W, however). Some information on the *ALGOL compiler and *ALGOLLIB library can be found in the MTS Volume on obsolete commands.

The original IBM documentation for the compiler can be found at Bitsavers.

Updated 6-Feb-2015 to fix comment syntax.

MAD - Mergesort

Sun, 18 Jan 2015 02:49:06 +0000

For our sample program in MAD, let’s look at a classic sorting algorithm, mergesort.

The task

The task description and pseudo-code can be found at Rosetta Code.

The implementation

Let’s write this as two parts: a driver program to set up a vector of integers and the actual function to do mergesort. The mergesort function should be able to take any vector size as input.

The driver

For the driver we’ll just define a vector of integers and call the mergesort function. We could extend this to read the integers from a file if needed. We’ll also need a way to display the vector before and after the sort, which we’ll factor into a separate internal function.

     CONSTANT LENGTH = 15
     VECTOR VALUES NUMBERS = 9, 12, 3, 1, 6, 8, 2, 5, 14, 13, 11, 7, 10, 4, 0

     PRINT COMMENT "Before sort"
     DISPLAY.(NUMBERS, LENGTH)

     MERGESRT.(0, LENGTH, NUMBERS)

     PRINT COMMENT "After sort"
     DISPLAY.(NUMBERS, LENGTH)

*    Display each value in V
     INTERNAL FUNCTION DISPLAY.(V, LEN)
          INTEGER V(1), LEN
          LOOP FOR I=0, 1, I >= LEN
               PRINT RESULTS V(I)
          END LOOP
          FUNCTION RETURN
     END OF FUNCTION

     END OF PROGRAM

The mergesort function

The mergesort function is recursive, so we need to use an external function with the RECURSIVE keyword to signal this fact to the MAD compiler so it can set up a dynamic call stack. If we don’t do this, the program will still compile but will die with a protection exception when run.

     RECURSIVE EXTERNAL FUNCTION MERGESRT.(LEFT, RIGHT, V)
          INTEGER LEFT, RIGHT, V(1)
          INTEGER LSTART, LEND, RSTART, REND

*         Return if nothing left to sort
          IF (RIGHT - LEFT <= 1)
               FUNCTION RETURN
          END IF

*         Define left and right halves
          LSTART = LEFT
          LEND = (LEFT + RIGHT) / 2
          RSTART = LEND
          REND = RIGHT

*         Recursively sort left and right
          MERGESRT.(LSTART, LEND, V)
          MERGESRT.(RSTART, REND, V)

*         Merge two halves
          MERGE.(LSTART, LEND, RSTART, REND, V)
          FUNCTION RETURN
*         Merge function definition will go here; see below
     END OF FUNCTION
     END OF PROGRAM

Note that we define V as having length 1: this is to allow us to subscript V, but it’s up to us to manage its actual length.

External functions need an END OF PROGRAM as well, as they are effectively compiled separately from the main routine even if they are in the same file.

Next we need the merge subroutine. As this is private to MERGESRT., we can define it as an internal function of MERGESRT.: the definition can go inside the external function definition as shown above. The code looks like this.

          INTERNAL FUNCTION MERGE.(LSTART, LEND, RSTART, REND, V)
               INTEGER LSTART, LEND, RSTART, REND, V(1)
               INTEGER LLEN, RLEN, I, L, R
               POINTER LHALF, RHALF, LHP, RHP
               CONSTANT SZ = 4

*              Allocate a temp buffer for each half
               LLEN = LEND - LSTART
               RLEN = REND - RSTART
               ALLOCATE (LLEN * SZ)->LHALF
               ALLOCATE (RLEN * SZ)->RHALF

*              Copy values into temporaries
               LHP = LHALF
               LOOP FOR I=LSTART, 1, I >= LEND
                    LHP.IND.INTEGER = V(I)
                    LHP = LHP + SZ
               END LOOP
               RHP = RHALF
               LOOP FOR I=RSTART, 1, I >= REND
                    RHP.IND.INTEGER = V(I)
                    RHP = RHP + SZ
               END LOOP

*              Merge values back into V
               L = 0
               R = 0
               LHP = LHALF
               RHP = RHALF
               LOOP FOR I=LSTART, 1, L >= LLEN .OR. R >= RLEN
*                   If left < right, move left, else move right
                    IF (LHP.IND.INTEGER < RHP.IND.INTEGER)
                         V(I) = LHP.IND.INTEGER
                         L = L + 1
                         LHP = LHP + SZ
                    ELSE
                         V(I) = RHP.IND.INTEGER
                         R = R + 1
                         RHP = RHP + SZ
                    END IF
               END LOOP

*              Handle leftover values
               LOOP WHILE L < LLEN
                    V(I) = LHP.IND.INTEGER
                    I = I + 1
                    L = L + 1
                    LHP = LHP + SZ
               END LOOP
               LOOP WHILE R < RLEN
                    V(I) = RHP.IND.INTEGER
                    I = I + 1
                    R = R + 1
                    RHP = RHP + SZ
               END LOOP

               RELEASE LHALF
               RELEASE RHALF
               FUNCTION RETURN
          END OF FUNCTION

We need a temporary buffer to hold each half of V while merging. MAD does not allow run time dimensioning of vectors, so we can either make these fixed size or use dynamic memory. I’ve chosen the latter to make the solution more generic: we allocate a chunk of memory which is determined by the size of each half and SZ which is a constant denoting the size of a MAD integer in bytes:

               ALLOCATE (LLEN * SZ)->LHALF

We then use pointer arithmetic to read or write integers, eg

                    RHP.IND.INTEGER = V(I)
                    RHP = RHP + SZ

At the end of the function we must remember to free the allocated memory with RELEASE.

Putting it together

We’re now ready to compile and run the program.

# $run *gom scards=mergesrt.mad
  No errors in MAIN 
  No errors in MERGESRT
  No errors in MAIN 
# $run -load
  Before sort

  NUMBERS(0)      =           9 
  NUMBERS(1)      =          12 
  NUMBERS(2)      =           3 
...
  NUMBERS(12)     =          10 
  NUMBERS(13)     =           4 
  NUMBERS(14)     =           0 

  After sort

  NUMBERS(0)      =           0 
  NUMBERS(1)      =           1 
  NUMBERS(2)      =           2 
...
  NUMBERS(12)     =          12 
  NUMBERS(13)     =          13 
  NUMBERS(14)     =          14

Final thoughts on MAD

Given that it was first designed at about the same time as FORTRAN, MAD feels much more powerful and flexible to use, while still having an easily understandable syntax, by borrowing ideas from early discussions of ALGOL/IAL. It’s a pity it did not see wider adoption as it might have made FORTRAN programmer’s lives easier.

The introduction to the GOM manual has an interesting section on why it was re-implemented for MTS:

This language is currently known as GOM (for Good Old MAD) to distinguish it from the ill-fated MAD/1 which was designed as an extensible language and which, although it provided many ideas which have been borrowed, was incredibly ugly and never extended itself into usability.

Why at this point in time resurrect the language? The main impetus was that a language was needed for writing Grungy Little Programs and pieces of the operating system. In both cases, the programs are often machine-dependent, and require matching previously established data structures and interfaces that are not “standard”, in the sense of being used by most high-level languages. Fortran is not usually general enough, and PL1 suffers from its “environment” and in many cases is not general enough either.

Rather than invent a new language, MAD was chosen as a base because it provided a happy medium between the insufficiencies of Fortran and the excesses of PL1, and because the semantic implications of the various constructs were known. That did not, however, prevent judicious tailoring of the language to better fit the current programming practices and problems.

Further information

Full source code for this program is on github.

MAD - Language features

Sun, 11 Jan 2015 03:35:14 +0000

In this post we’ll look at the MAD language (as implemented by GOM on MTS) in more detail. As MAD is quite a large language, compared to FORTRAN or BASIC, I will only go over some of its interesting or unusual features; for a good overview of the language you may want to read the Wikipedia article first.

Complete examples below (those ending with END OF PROGRAM) have been tested using *GOM on MTS D6.0; do note that initial blanks are needed for lines which do not contain statement labels.

Synonyms and abbreviations

There are a number of synonyms for MAD keywords, (eg TRANSFER TO for GO TO, and spaces are not generally needed. For example a goto label X could be expressed as:

GOTO X
GO TO X
TRANSFER TO X
TRANSFERTOX

GOTOX would not work as this is ambiguous, as it could be a references to the variable GOTOX. The TRANSFERTOX works as this is longer than a variable name could be.

Keywords can be abbreviated by taking the first and last letter and inserting a ': for example T'O for TRANSFER TO’. The compiler can optionally produce a listing of the input with these expanded by setting the sprint parameter.

Constant qualification

Constants can be qualified to a particular type or format with a suffix: some examples

1B - Boolean true
100@X - hex integer 100, ie decimal 256.
12@L1 - one byte integer
"HI"@L4 - character string of length 4, right padded with blanks

Statement label vectors

As well as simple labels as seen in FORTRAN, you can have vectors of statement labels. For example, the below will print “Two”:

     INTEGER J
     J = 2
     GOTO L(J)
L(1) PRINT COMMENT "One"
     GO TO DONE     
L(2) PRINT COMMENT "Two"
     GO TO DONE     
L(3) PRINT COMMENT "Three"
DONE END OF PROGRAM

Conversions

MAD does implicit conversions by assigning to a variable of different type. You can cast to another type without conversion using .AS.

     INTEGER IM, C1, C2
     FLOATING POINT F
     F = 123.45
     IM = F
     C1 = F.AS.INTEGER
     C2.AS.FLOATING POINT = F
     PRINT RESULTS IM, C1, C2
     END OF PROGRAM

This will print:

     IM = 123  C1 =  1115386675  C2 =  1115386675

Character expressions and strings

Strings are expressed as character vectors; sub-elements of a vector can be addressed using block notation, with ... standing for range, with optional first and last subscript, and | for length. For example:

     CHARACTER HELLO(5),H1(3),H2(2)
     HELLO(...) = "Hello"
     H1(...) = HELLO(2...4)
     H2(...) = HELLO(1|2)
     PRINT COMMENT H1
     PRINT COMMENT H2
     END OF PROGRAM

Will print “llo” and “el”.

Conditionals

The conditional statement allows else clauses and there is an implicit block structure for each clause:

     INTEGER X
     X = 3
     IF X > 1 .AND. X <= 3
          PRINT COMMENT "Yes"
          PRINT RESULTS X
     ELSE
          PRINT COMMENT "No"
     END IF
     END OF PROGRAM

Loops

As we saw in the hello world example, the basic loop takes an initial variable, increment and condition which when true will mark the end of the loop. So the below will print “Hello, world!” five times

     LOOP FOR I=1, 1, I > 5
          PRINT COMMENT "Hello, world!"
     END LOOP
     END OF PROGRAM

There is also a THROUGH variant which is more like a FORTRAN loop: this will print “Hi” and “There” five times then “Done”.

     THROUGH L, FOR I=1,1,I>5
     PRINT COMMENT "Hi"
L    PRINT COMMENT "There"
     PRINT COMMENT "Done"
     END OF PROGRAM

and a LOOP WHILE b and LOOP UNTIL b which implement while loops.

Dynamic memory and pointers

Addresses can be referenced with .LOC. and indirection done with .IND. followed by the type (which does not have to be the original type of what is being pointed to). It’s possible to do pointer arithmetic also. The below example will print the result “42”.

     INTEGER Q
     Q = 0
     POINTER P
     P = .LOC.Q
     P.IND.INTEGER = 42
     PRINT RESULTS Q
     END OF PROGRAM

A dynamic record defines a simple structure made up of data fields

     DYNAMIC RECORD (POINT) X,Y
     INTEGER X, Y

To use this you need to point it at an existing memory location or allocate new space with ALLOCATE and free memory with RELEASE. You can then use : to address fields:

     DYNAMIC RECORD (POINT) X,Y
     INTEGER X, Y
     POINTER P
     ALLOCATE (POINT)->P
     P:X = 10
     P:Y = 20
     PRINT RESULTS P:Y / P:X
     RELEASE P
     END OF PROGRAM

The USING keywords allows you to select a pointer, after which references to a record’s fields will be done through that pointer. As an example, the above could be rewritten as:

     DYNAMIC RECORD (POINT) X,Y
     INTEGER X, Y
     POINTER P
     ALLOCATE (POINT)->P
     USING POINTER P, FOR POINT
     X = 10
     Y = 20
     PRINT RESULTS Y / X
     RELEASE P
     END OF PROGRAM

The USING will continue until another USING replaces it, or you do STOP USING POINTER.

Functions

MAD supports external (definition can provided at link time) or internal functions. Functions have a number of interesting features:

Names must end with a . so they are recognised by the parser
Optional or variable number of arguments are supported
It’s possible to have multiple entry points into a function
As well as a return value it’s possible to set a return code to signal unusual conditions

A example showing how an internal function can be defined and called, using the return code feature:

     INTERNAL FUNCTION NEGATE.(X)
          NORMAL MODE IS INTEGER
          IF X = 0
               FUNCTION RETURN 0, RC=1
          ELSE
               FUNCTION RETURN - X
          END IF
     END OF FUNCTION

     INTEGER X, X1, R
     READ DATA FROM UNIT 5
     X1 = NEGATE.(X)->R
     IF R = 0
          PRINT COMMENT "Zero is still zero"
     ELSE
          PRINT RESULTS X1
     END IF
     END OF PROGRAM

Input/output

In the previous example, the READ DATA FROM UNIT 5 requires that you set unit 5 to a FDname on the run command. But how does it know where to put the input? It expects the input format to be a set of name=value pairs separated by commas and terminated by an asterisk, which it will use to set variables. So a sample run of the above program, taking input from the keyboard, would look like:

# $run -load 5=*source*
# Execution begins   10:47:49 
  X=42*

          X1      =         -42 
# Execution terminated   10:47:55  T=0.001

You can also use READ AND PRINT DATA to input as above and then echo the values entered.

For output, PRINT RESULTS will print data in a similar way to the format used by READ DATA’; PRINT COMMENT can be used to output a string.

It’s also possible to do formatted input/output, similar but not identical to FORTRAN.

Further information

See the GOM Manual for a full specification of the language and how it differs from the original version of MAD.

MAD - Introduction

Sun, 04 Jan 2015 03:31:41 +0000

In this series of posts we’ll look at one of the less widely known languages available on MTS - MAD, or the Michigan Algorithm Decoder.

The MAD language

Originally developed in 1959 at UM for the IBM 704, MAD is an imperative language influenced by ALGOL. It was implemented for a number of mainframes and operating systems in the 1960s, including MIT’s CTSS where it was used to develop MAIL and RUNOFF.

MAD on MTS

GOM, or Good Old MAD, is the version available on the MTS D6.0 distribution. It is a re-implementation of MAD for the IBM S/360 with some changes to the language to bring it up to date. It was used to write the messaging system on MTS.

There was also a complete redesign of MAD called MAD/I, but this is not available on D6.0 due to copyright reasons.

Prerequisites

No special installation instructions to get GOM running - just do the standard D6.0 setup as described in this guide and then sign on as a regular user such as ST01.

Compiling using `*GOM`

*GOM will read source from scards (by default *source* ie standard input) and will write object files to spunch (by default the temporary file -load).

Other *GOM parameters are listed in the GOM manual.

Hello world

Here’s a terminal log of how to compile and run a simple hello world program. This assumes the source code is in file hello.mad. Note that comments are introduced with a * in column 1; all other statements (apart from line labels) must not start in column 1 but otherwise indentation is not important.

# $list hello.mad
       1     * HELLO WORLD PROGRAM
       2          LOOP FOR I=1, 1, I > 5
       3               PRINT COMMENT "Hello, world!"
       4          END LOOP
       5          END OF PROGRAM
# $run *gom scards=hello.mad
  No errors in MAIN 
# $run -load
  Hello, world!
  Hello, world!
  Hello, world!
  Hello, world!
  Hello, world!

Further information

The Wikipedia article is a good overview of the language and its implementations. An article on the MTS Archive gives more background on the history of MAD.

The GOM manual can be downloaded in PDF format from the UM Deepblue archive or the original FORMAT source can be found on the D6.0 distribution tapes under component 659/22 (restore to eg file GOMMAN.WF and then $run *format scards=gomman.wf sprint=-print, copy -print *print* to get an ASCII text copy). This describes the language in detail and how it differs from MAD.

An interesting book from 1962 by one of the designers of MAD, Bernard Galler, is “The Language of Computers” which can be found at Bitsavers. This takes a number of problems and describes from first principles how these can be turned into algorithms and how we might come up with a computer language to express them - and over the course of the book elegantly explains MAD.

Eric S Raymond has produced a transpiler (MAD to C) that runs on Unixes - source code can be found at gitorious.

FORTRAN - Calculating emirps

Sun, 28 Dec 2014 03:18:26 +0000

Let’s look at an example of a complete program in FORTRAN and compare running it using the different compilers available on MTS.

The problem

Emirps are prime numbers that when their digits are reversed they make a different prime. An example is 13, which when reversed is the prime 31. The task on Rosetta Code is to:

show the first twenty emirps.
show all emirps between 7,700 and 8,000
show the 10,000th emirp

Writing the program

I think it’s interesting to describe how I wrote the program and got it to work. On modern systems I would tend to dive in and start writing small pieces of code and associated tests, TDD style. On MTS I favour writing the program offline first, import it into MTS and then get it working - this is partially due to being less comfortable with the MTS editor but also to match the usage pattern for MTS when it was in use; then terminal time was expensive so you would try to get more done before reaching for the computer.

So I started by sketching out what routines I’d need

Three subroutines TEST1-3to test each of the tasks given in the problem
A function EMIRP to test if a number was an emirp. This would reverse the digits and if different from the original, test if both were prime.
A function PRIME to test if a number was a prime
A function REVRSE to reverse a number

I used Emacs on my host OS to write the routines - was pleasantly surprised to find it still supports FORTRAN 66 syntax. This took around 45 minutes.

The prime number test I used was a brute force approach so not particularly efficient:

C     *** TEST IF A NUMBER IS PRIME ***
      LOGICAL FUNCTION PRIME(N)
      INTEGER N
C     DEAL WITH NUMBERS <= 3
      IF (N .LE. 1) GOTO 200
      IF (N .EQ. 2 .OR. N .EQ. 3) GOTO 100
C     CHECK IF DIVISIBLE BY 2 OR 3
      IF (MOD(N,2) .EQ. 0) GOTO 200
      IF (MOD(N,3) .EQ. 0) GOTO 200
C     SEE IF DIVISIBLE BY 5, 7, ..., UP TO APPROX SQRT(N)
 10   DO 20 I=5,999999,2
         IF (I*I .GT. N) GOTO 100
         IF (MOD(N,I) .EQ. 0) GOTO 200
 20   CONTINUE
 100  PRIME = .TRUE.
      RETURN
 200  PRIME = .FALSE.
      RETURN
      END

Reversing the digits was done by taking the modulus of the number with 10 and then appending each digit to the end:

C     *** REVERSE AN INTEGER'S DIGITS ***
      INTEGER FUNCTION REVRSE(N)
      INTEGER N
      INTEGER M,R
C     M IS COPY OF N FROM WHICH WE TAKE DIGITS
C     R IS REVERSED DIGITS
      M = N
      R = 0
C     LOOP UNTIL NO MORE DIGITS
 10   IF (M .LT. 1) GOTO 100
C     TAKE LAST DIGIT FROM M AND APPEND TO R
      R = R * 10
      R = R + MOD(M, 10)
      M = M / 10
      GOTO 10
 100  REVRSE = R
      RETURN
      END

The emirp function was then a simple case of calling the two functions:

C     *** TEST IF AN INTEGER IS AN EMIRP ***
      LOGICAL FUNCTION EMIRP(N)
      INTEGER N
C     EXTERNAL FUNCTIONS
      INTEGER REVRSE
      LOGICAL PRIME
C     R CONTAINS REVERSED DIGITS OF N
      INTEGER R
      R = REVRSE(N)
C     N AND R MUST BOTH BE PRIME AND NOT THE SAME VALUE
      IF (N .EQ. R) GOTO 200
      IF (.NOT. PRIME(N)) GOTO 200
      IF (.NOT. PRIME(R)) GOTO 200
 100  EMIRP = .TRUE.
      RETURN
 200  EMIRP = .FALSE.
      RETURN
      END

The test functions are simple loops: here I show just the second test as an example.

C     *** SHOW EMIRPS BETWEEN 7,700 AND 8,000 ***
      SUBROUTINE TEST2
C     EXTERNAL FUNCTION
      LOGICAL EMIRP
C     N IS NUMBER TO TEST
      INTEGER N
 10   DO 100 N=7700,8000
         IF (EMIRP(N)) CALL SHOW(N)
 100  CONTINUE
      RETURN
      END

I factored out the printing to another routine as each test needs to do this:

C     *** DISPLAY AN INTEGER ***
      SUBROUTINE SHOW(N)
      INTEGER N
      WRITE(6,50) N
 50   FORMAT(I10)
      RETURN
      END

Getting it running with `*IF66`

Next I imported the program into MTS (using the emulated card reader).

I then ran *IF66 and did /compile emirp.f. Lots of syntax errors - I forgot the maximum length for identifiers was 7 characters and that I needed to declare functions used externally.

Next I tried to test the individual routines - here *IF66 was very useful, as I could call eg the reverse routine with some test input and see its output immediately. Some more problems to fix here, eg function parameters seem to be pass by reference in FORTRAN. An error in the DO-loop in the prime testing function lead to an infinite loop that I could not get out of with PA2, so a trip to the operator’s console to STOP the MTS session was needed.

Finally I got it running after about another hour. The first two tasks were quick to execute but the third, to find the 10,000th emirp, ran for over 10 minutes without returning so I killed it. Time to run this using the compilers and see how they perform.

Using the compiler

First I tried it using FORTRANG:

# $run *ftn scards=emirp.f
# Execution begins   20:05:30 
  No errors in PRIME 
  No errors in REVRSE 
  No errors in EMIRP 
  No errors in SHOW 
  No errors in TEST1 
  No errors in TEST2 
  No errors in TEST3 
  No errors in MAIN 
# Execution terminated   20:05:30  T=0.034
# $run -load
# Execution begins   20:05:34 
         13
...
     948349
# Execution terminated   20:05:43  T=8.82

So just over 0.03 seconds of CPU time to compile and nearly 9s to run all tests.

Let’s try it with FORTRANH by using the opt parameter to *ftn. Note that the output of the compiler is quite different as FORTRANH is a completely different product:

# $run *ftn scards=emirp.f par=opt=h
# Execution begins   20:06:12 
  **** No errors for  PRIME ****      WED DEC 17/14 20:06:13
  **** No errors for REVRSE ****      WED DEC 17/14 20:06:13
  **** No errors for  EMIRP ****      WED DEC 17/14 20:06:13
  **** No errors for   SHOW ****      WED DEC 17/14 20:06:13
  **** No errors for  TEST1 ****      WED DEC 17/14 20:06:13
  **** No errors for  TEST2 ****      WED DEC 17/14 20:06:13
  **** No errors for  TEST3 ****      WED DEC 17/14 20:06:13
  **** No errors for   MAIN ****      WED DEC 17/14 20:06:13
# Execution terminated   20:06:12  T=0.092 
# $run -load
# Execution begins   20:06:30 
         13
...
     948349
# Execution terminated   20:06:35  T=4.607

Compilation took almost three times as long, but the program ran 48% faster so there’s definitely some good optimisation taking place. The compilation time difference may seem insignificant, but in an environment where you are paying for CPU time and working on a large program that requires many recompiles during development the costs would mount up.

Next step would probably be to improve the algorithm for testing for primeness, but I’ll leave that for now.

Final thoughts on FORTRAN

FORTRAN 66 has not aged well - its fixed format lines, lack of character/strings, unstructured design and implicit variable types make it hard to use for large scale programming. But it’s a simple language to pick up and use, and you can see that if you want to solve a numerical problem it can be very productive. Coupled with the optimising compiler and support tools available you can understand why it was the lingua franca of its time, rather like C today.

Further information

Full source code for this program is on github.

FORTRAN - Language features

Sun, 21 Dec 2014 03:51:06 +0000

In this post I’ll look at the FORTRAN 66 language as available on MTS in more detail.

Source code format

FORTRAN originally had a fixed format for source code lines and used all upper case letters; as *FTN does not have this restriction we’ll use lower case and free format in the examples below to make them easier to read, but note that this means these examples may not work on other, non-MTS compilers.

Update 4-Dec-2015: As noted by Mike Stramba, *FTN does require source code to be in upper case, although *IF66 is happy with upper or lower case.

One unique feature is that whitespace is not important, so the variable BXX could also be referred to as B XX. Keywords are context sensitive, so you can write IF IF.GT.3 J=2 where the second IF is actually a variable.

Types and identifiers

FORTRAN supports INTEGER, REAL. LOGICAL and COMPLEX number types. Character types are not support directly, but can be accessed through FORMAT statements (see below).

Variable names can have up to six characters and must start with a letter. Variables can be explicitly declared with their type; if not declared, variables starting with letters I to N are treated as integers, otherwise they are treated as reals.

Variables can be initialised with the DATA statement.

integer count, count1
real temp
complex point
data i,count,temp,point/0, 10, 32.0, cmplx(1,2)/

Arrays and matrices can be created with DIMENSION and initialised with DATA then individual values can be accessed using (), first index 1, in column major order, so in the below X(2, 1) will be intialised with the value 2.0.

dimension x(2,2)
data x/1.0, 2.0, 3.0, 4.0/

Operators and expressions

The usual arithmetic operators appear, including ** for exponentiation. Logical operators look like .LT. for less than or .AND. for Boolean-and.

x = 2.0 ** 4.0
i = 5 + 3
j = x / i
y = x / i

In the result above, J will be set to 2 and y to 2.0.

Statements

Branching can be done with GOTO; there are three forms:

goto 100
goto l
goto (10,20,30) ll

The first will jump unconditionally to the line labeled with 100.
The second will jump to the label based on the value of L
The third will jump to line 10 if ll = 1, 20 if ll = 2 etc

The DO statement allows looping

j = 0
do 100 i=10,20,5
j = j + i
100 continue
k = j * 2

This will initialise I with 10 and then run the contents of the loop for values 10, 15, 20. After that it will jump to the line after the label 100. So for this example, K will end up with the value 90.

It’s possible to nest loops and jump out of loops, but not jump into them.

The IF statement has two forms, logical and arithmetic. The example of the logical version below will set k to 3 if i < j.

if (i.lt.j) k=3

The arithmetic version will branch to one of three labels based on whether the expression being tested is negative, zero or positive. For the example below it will branch to label 30 as the expression is positive.

J = -3
if (j + 4) 10,20,30

Input/output and formats

Inputs (READ) and outputs (WRITE) are associated with a FORMAT statement, a logical I/O unit and a list of variables. For example:

read(5,100) i1,x1,y1
100   format(i2,f5.2,f2.0)

with the input

1234.5678.90

will read from I/O unit 5 (the keyboard) i1=12, x1=34.56, y1=78.0.

Character constants, with a leading length identifier, can be used in READ or WRITE statements as we saw in the hello world example:

write (6,200)
200 format(13h HELLO, WORLD)

prints “HELLO, WORLD” on unit 6, the console.

Functions and subroutines

FORTRAN comes with a large number of built in functions for mathematical processing eg MOD, ABS, SIN. On MTS there is also a library of operating system specific functions that can be called but I will not go into these here.

You can define your own functions to pass parameters by reference and optionally return a value: for example to calculate the average of two values:

real function avg2(x,y)
real x, y
avg2 = (x + y) / 2.0
return
end

This could be called with

z = avg2(3.0, x)

There is also subroutines which run by using call. For example, the below would set x to 2.0:

x = 1.0
call add1(x)

subroutine add1(x)
real x
x = x + 1.0
return
end

Further information

FORTRAN IV reference page is a great summary of FORTRAN 66 syntax.

A contemporary IBM references for FORTRAN can be found at Bitsavers.

MTS Volume 6 describes *FTN and *IF66 in full detail, along with the other FORTRAN tools available.

FORTRAN - Introduction

Sun, 14 Dec 2014 02:44:20 +0000

^{Diagram showing fixed format for lines of FORTRAN source code, from Digital Computing, FORTRAN IV, WATFIV, and MTS (with *FTN and *WATFIV)}

For our second language we’ll look at FORTRAN, the most popular language run on MTS by far (40% by frequency of use in 1986 according to Introduction to programming and debugging in MTS, followed by Pascal at 35%). Due to its popularity it has the largest range of environments, libraries and tooling of any language available on MTS.

The FORTRAN language

FORTRAN is probably the oldest language still in wide use today. Originally developed at IBM in the early 1950s, it spread to many platforms in the 1960s and become the language of choice for scientific and mathematical applications. The first standardised version, FORTRAN 66, was a simple unstructured imperative language; later versions such as Fortran 77 and 90 added modular features and even object orientated programming constructs.

FORTRAN on MTS

Available with the D6.0 distribution are the two IBM FORTRAN IV (ie FORTRAN 66) compilers, FORTRANG and FORTRANH. The former includes better debugging support whereas the latter produces more efficient object code. Both of these compilers are available via the *FTN front end.

There is also *IF66, an innovative FORTRAN interpreter developed at the University of British Columbia, which is useful for developing and testing programs.

Due to copyright restrictions, the University of Waterloo compilers WATFOR and WATFIV are not available - these featured a unique compile-and-go model where compiler output was directly executed rather than writing an object file, which allows better diagnostic messages and reduced compilation costs.

FORTRAN 66 was already obsolete in 1986 and most new development in FORTRAN had moved on to FORTRAN 77 which was supported in MTS by the IBM compiler FORTRANV5 and UBC interpreter *IF77 - however neither of these are available in the D6.0 distribution due to copyright restrictions.

Also available are a number of FORTRAN preprocessors, such as RATFOR, and tools, such as the *DAVE data flow analyser, which I will cover in a later series of posts.

Prerequisites

No special installation instructions to get FORTRAN running - just do the standard D6.0 setup as described in this guide and then sign on as a regular user such as ST01.

Compiling using `*FTN`

You can invoke FORTRANG and FORTRANH directly, but it’s much easier to use the MTS front end *FTN.

*FTN will read source from scards (by default *source* ie standard input) and will write object files to spunch (by default the temporary file -load).

Other options can be provided using par= on the command line or interactively.

format determines the source code input format: options are IBM, LINE, EDITED or LONG with the default being EDITED. IBM format is the traditional FORTRAN fixed format shown at the diagram at the top of this post; LONG is IBM format with the maximum line length limit lifted; LINE is free format. EDITED is a compromise where the front end will try to guess what format the input is in.

opt determines the optimisation level. Choices are G, which will cause the FORTRANG compiler to be used, or 0/1/2 which will select the FORTRANH compiler with increasing levels of optimisation. H is an alias for FORTRANH with level 2 optimisation. The default for opt is G.

Other *FTN parameters are listed in the online help or MTS Volume 6.

Hello world

Here’s a terminal log of how to compile and run a simple hello world program. This assumes the source code is in file hello.f.

# $list hello.f
       1     C *** HELLO WORLD PROGRAM ***
       2     C
       3           DO 10 I=1,5
       4           WRITE (6,20)
       5        10 CONTINUE
       6           STOP
       7        20 FORMAT(13H HELLO, WORLD)
       8           END
# $run *ftn scards=hello.f
  No errors in MAIN 
# $run -load
  HELLO, WORLD
  HELLO, WORLD
  HELLO, WORLD
  HELLO, WORLD
  HELLO, WORLD

The `*IF66` FORTRAN interpreter

If you’ve used the UM BASIC interpreter, the *IF66 FORTRAN interpreter will appear familiar, with the ability to switch between editing, running and debugging programs. It integrates well with the MTS environment, allowing you to use the full MTS editor and is fully compatible with the FORTRAN compilers. It supports running of arbitrary FORTRAN statements or routines and debugging features such as atpoints, where code can be run when a breakpoint is reached.

A quick demo, using the file hello.f from before:

# $run *if66
* IF(NOV80)
* /compile hello.f
  ROUTINE NAME: MAIN 
* /list main
*     1.    C *** HELLO WORLD PROGRAM ***
*     2.    C
*     3.          DO 10 I=1,5
*     4.          WRITE (6,20) 
*     5.       10 CONTINUE 
*     6.          STOP
*     7.       20 FORMAT(13H HELLO, WORLD) 
*     8.          END
+ /edit main

You are now in the MTS editor and can type v to enter visual mode and make changes; press PA2 to exit out of the editor. I’ll now show how to run the program and also *IF66’s immediate execution of FORTRAN statements:

* /run main
  HELLO, WORLD
  HELLO, WORLD
  HELLO, WORLD
  HELLO, WORLD
  HELLO, WORLD
  /MAIN:6./ - /STOP /
+ x=40.0
+ y=sqrt(x)
+ print,y
      6.324555 
+ /stop

Definitely a useful and powerful tool, and I don’t think any other platform had such an advanced FORTRAN interpreter at that time.

In the next post, I’ll take a look at the FORTRAN language in more detail.

Further information

MTS Volume 6 describes *FTN and *IF66 in full detail, along with the other FORTRAN tools available.

Digital Computing, FORTRAN IV, WATFIV, and MTS (with *FTN and *WATFIV) is a good contemporary introduction to programming FORTRAN on MTS from two authors at the Chemical Engineering department at UM. A number of different editions were produced; the linked one is from 1976. It also includes a useful description of the IBM S/360 architecture from the viewpoint of a non-systems programmer.

IF, an interactive FORTRAN compiler (link not working as of August 2023) is a paper from 1973 giving background information on why *IF66 was developed and a demo of its use.

BASIC - Narcissistic numbers

Sun, 07 Dec 2014 01:25:49 +0000

For our sample BASIC program, let’s try to implement the Narcissistic numbers problem from Rosetta Code.

A narcissistic number is a integer where the sum of each digit raised to the power of the number of digits equals the number itself. For example, 153 is narcissistic: it has three digits 1, 5 and 3, and 1³ + 5³ + 3³ = 1 + 125 + 27 = 153.

The goal of the program is to print the first 25 narcissistic numbers.

First version

The algorithm is fairly simple

Look at each positive integer in turn
Find number of digits
Sum up each digit raised to the power of the number of digits
Compare to the number and if equals, print it
Stop after 25 narcissistic numbers found

To find the number of digits we can convert the number to a string and take its length. To extract each digit we need to divide by 10, take the integer part and multiply by 10 again and subtract the original number as there is no modulus operator.

100 rem UM BASIC program to print the first 25 narcissistic numbers 
110 let c = 0                /* Count of narcissistic numbers found 
120 *
130 rem Start of loop to find and print narcissistic numbers
140 for n = 0 to 10000000    /* Number to check for narcissism
150 if c >= 25 then: stop    /* End after 25 numbers
160 *
170 let nn = nts(n)          /* Number as a string
180 let d = len(nn)          /* Number of digits
190 let x = n                /* Copy of number
200 let y = 0                /* Result of narcissistic calculation
210 * 
220 rem Start of loop to calculate narcissistic number 
230 for i = 1 to d           /* For each digit
240 let x1 = int(x/10)       /* Get all but last digit of x
250 let x0 = x - (10 * x1)   /* Get last digit of x
260 let y = y + (x0 ** d)    /* Accumulate digit ** num digits
270 let x = x1               /* Shift off last digit from x
280 next i 
290 *
300 if int(y) <> n then 400  /* Not a narcissistic number, jump next
310 print n                  /* Print narcissistic number
320 let c = c + 1            /* Increase count found
330 *
400 next n                   /* Try next number
410 *
500 stop                     /* Fall through

And here’s the output:

0 1 2 3 4 5 6 7 8 9 153 370 371 407 1634 8208 9474 
54748 92727 93084 548834 1741725 4210818 9800817 9926315

Unfortunately this takes a long time to run - 6 minutes and 46 seconds of CPU time - so let’s see how we can improve this.

Faster version

There are several optimisations we can try:

Precompute a ** b, for a and b between 0 and 9, as we do this for each digit in the inner loop and it is likely to be an expensive operation. The precomputed powers are stored in a 2D matrix p by the routine starting on line 600. This saves 123 seconds.
Exit early from the calculation inner loop when the accumulated total is larger than the number being tested. This saves 32 seconds.
Use integer comparison to find the number of digits rather than converting to a string. This saves 54 seconds.

Here’s the final listing, taking 3m17s. There are probably further optimisations that can be made - any suggestions?

100 rem UM BASIC program to print the first 25 narcissistic numbers 
110 rem Second, faster version
120 *
130 let c = 0                /* Count of narcissistic numbers found 
140 dim p(9, 9)              /* p(x, y) will contain x ** y
150 gosub 600                /* Precompute p
160 *
170 rem Start of loop to find and print narcissistic numbers
180 for n = 0 to 10000000    /* Number to check for narcissism
190 if c >= 25 then: stop    /* End after 25 numbers
200 *
210 gosub 700                /* Get number of digits in d
220 let x = n                /* Copy of number
230 let y = 0                /* Result of calculation
240 * 
250 rem Start of loop to calculate narcissistic number 
260 for i = 1 to d           /* For each digit
270 let x1 = int(x/10)       /* Get all but last digit of x
280 let x0 = x - (10 * x1)   /* Get last digit of x
290 let y = y + p(x0, d)     /* Accumulate digit ** num digits
300 if y > n then 400        /* Bail out if too big already
310 let x = x1               /* Shift off last digit from x
320 next i                   /* Loop for next digit
330 *
340 if y <> n then 400       /* Not a narcissistic number, jump next
350 print n                  /* Print narcissistic number
360 let c = c + 1            /* Increase count found
370 *
400 next n                   /* Try next number
410 *
500 stop                     /* Fall through
510 *
520 *
599 rem Subroutine to populate p(a, b) with a ** b
600 for a = 0 to 9           /* Digit
610 p(a, 0) = 0              /* a ** 0 = 0
620 p(a, 1) = a              /* a ** 1 = a
630 for b = 2 to 9           /* Power to raise to 
640 p(a, b) = p(a, b-1) * a  /* Calc next power in series
650 next b                   /* Loop power
660 next a                   /* Loop digit
670 return
698 *
699 rem Subroutine to get number of digits in n
700 if n >= 1000000 then 800
710 if n >= 100000  then 810
720 if n >= 10000   then 820
730 if n >= 1000    then 830
740 if n >= 100     then 840
750 if n >= 10      then 850
760 goto 860
800 let d = 7
801 return
810 let d = 6
811 return
820 let d = 5
821 return
830 let d = 4
831 return
840 let d = 3
841 return
850 let d = 2
851 return
860 let d = 1
861 return

Closing thoughts on BASIC

The strength and weaknesses of the BASIC language are that it is, well, basic. With only a handful of features it is hard to get lost, but doing anything more complex than the above would be painful. From a modern programming viewpoint, the need for line numbers, restrictions on variable names and lack of types makes it quite different from what we would do now so despite some nostalgia for 80s home computing I can see why this is a bad choice for even a beginner’s programming language today. But it’s also clear to see how revolutionary BASIC was when first introduced and how it opened the door to programming for a whole new set of people.

Likewise, the self contained environment for UM BASIC makes it easy to start writing code without having to know much about MTS, but you lose the access to useful tools like a full screen editor. I think this, and the fact that better languages were available, explains why BASIC was not a popular choice for general users of MTS - according to Introduction to programming and debugging in MTS, only 2% by frequency of use in 1984.

Further information

There’s more on the mathematics of narcissistic numbers at Wolfram MathWorld.

Source code for these programs can be found on Github.

BASIC - Language features

Sun, 30 Nov 2014 00:39:38 +0000

Like many who grew up in the 1980s, my first programming language experience was on BASIC (on the VIC-20, in my case) and although I haven’t used it for 30 years I felt right at home.

The Wikipedia article defines three broad generations of BASIC

Early versions on mainframes, 1964-1980
Home computer ROM BASIC, 1980-1990
More structured versions on PCs, 1990-date

MTS BASIC falls firmly in the first camp, with a limited number of keywords, restrictions on numbers and names of variables, but with support for matrix operations that was not present in later versions of the language.

The below is a quick look at the main features in MTS BASIC; see the Further Information section for more complete guides.

Program format

Each line of the program must start with a line number - note this is different from line numbers in MTS native files and only integers are allowed.

Full line comments can be introduced with REM or *. To add a comment that lasts until the end of the line you can use /* (very confusing to C programmers!).

10 rem This is a comment
20 * This also
30 let x = 3 /* Line comment
40 let y = 4

Types and variables

BASIC has two data types (only one less than Javascript!) - floating point numbers and strings. Numeric variable names must start with a letter followed by one or two numbers; string variables names must have two identical letters followed by an optional number (ie AA - ZZ, AA1, AA2 etc). Maximum length of strings is 127 characters. Variables can be initialised with LET:

10 let A = 1.23
20 let A1 = 3
30 let AA = "Hello world"

You can have arrays and matrices of numbers which can be indexed using (), eg a(1) or b(2,3). The size can be set using the DIM statement but if not given they are size 10. Indices start at 0. The below will print 100.

10 dim a(2,2)
20 a(1,0) = 100
30 a(1,1) = 200
40 print a(1)

Strings are implemented as vectors of cells containing strings, so AA is the same as AA(0) and you can also access AA(1), AA(2) etc.

Statements

INPUT will prompt for the user to enter a value which will be assigned to a variable; PRINT will display a variable or expression, using ; or , to control formatting.

  10 input a, b
  20 print a; b, (a+b)/2

: run
? 10
? 20
  10 20          15

INP and OUT are like INPUT and PRINT but also return the value assigned to the variable.

GOTO x will jump unconditionally to line x. Note you can’t GOTO a non-executable line like a comment. There is also a rather hairy computed GOTO where they program will jump to a line based on the result of an expression.

10 goto 40
20 print "This will be printed second"
30 stop
40 print "This will be printed first"
45 let a=2
50 goto (60,60,20,60) a+1
60 print "This will not be printed"

The IF .. THEN statement will calculate an expression and then either jump to another line or execute a statement. Note that there is no ELSE.

10 let a = 5
20 if a > 1 then 40
30 print "This will not be printed"
40 if a <> 5 then: print "This will not be printed"
50 if a = 5 then: print "This will be printed"

Simple loops can be done with FOR .. NEXT with an optional STEP.

10 for i = 1 to 10
20 for j = 0 to 10 step 2
30 x = x + (i*j)
40 next j
50 next i
60 print x

GOSUB x will call a subroutine at line x; execution will resume from the current line when a RETURN statement is found.

It’s possible to temporarily transfer execution to another program with CALL or permanently transfer with CHAIN.

Simple functions can be defined with DEF, eg DEF FNS(x)=x*x for a square function. Only one parameter is allowed and the function name can only be a single character A-Z.

STOP will end a program and PAUSE will prompt the user for input before continuing.

Library functions

BASIC comes with a number of library functions. Note that you have to assign results of these functions to variables rather than printing them directly - so in the example below I can’t do PRINT CLS().

String operations include conversion to numbers (STN) and back (NTS) along with access to the surrounding environment such as UID for user ID and CLS for time of day.

10 let ss = cls()
20 print ss
30 let ss = uid()
40 print ss
: run
 0:59:02
 ST01

Numeric functions include mathematical support functions like ABS() and SIN().

Matrix and vector support is especially powerful, with the ability to enter, print and do matrix operations. The below will prompt for a 2x2 matrix, add it to its transpose and then print it.

10 dim x(2,2), y(2,2), z(2,2)
20 mat input x
30 mat let y = trn(x)
40 mat let z = x + y
50 mat print z
: run
? 1,2
? 3,4
  2              5             
  5              8

There is also limited support to read and write files - but these are special data files attached to the BASIC environment rather than general MTS files.

And that’s pretty much it for BASIC. In the next post we’ll look at a larger example of a MTS BASIC program.

Further information

MTS Volume 10 offers a complete description of the BASIC language and environment.

BASIC - Introduction

Sun, 23 Nov 2014 03:49:59 +0000

As a gentle start to this series we’ll look at something suitably basic - the BASIC language itself.

The BASIC language

Originally developed at Dartmouth in 1964, BASIC is a simple unstructured language influenced by FORTRAN and ALGOL. It was designed to be an easy to learn language for people who were not experienced computer scientists. It achieved wide popularity in the 1980s when it was included in many home computers and in the 1990s-2000s was in common use on Windows as Visual Basic and Visual Basic.NET, which included object orientated features.

BASIC on MTS

The version of BASIC in MTS was developed at the University of Michigan and appears to date from the early 1970s, with the first version appearing in D2.0. The implementation is close to Dartmouth Basic, with some minor changes such as using ** instead of ↑ for exponentiation.

Prerequisites

No special installation instructions to get BASIC running - just do the standard D6.0 setup as described in this guide and then sign on as a regular user such as ST01.

Running BASIC

Type $run *BASIC to start. Unlike other compilers on MTS, this will put you in a self-contained environment where you can create, run, debug and organise BASIC programs.

When you start BASIC you will see the : prompt. Here you can enter commands, starting with /, to control the BASIC environment. Use /open NAME to create a new program called NAME. This will start a new file in memory that will last for the rest of the session; to save the current version to disk do /save. Note the files are saved in a special, sequential format that can only easily be read by BASIC.

To enter the actual program you can type lines starting with a line number. To correct lines you can retype it; there are also / commands such as /alter to do simple line editing. Type a line number on its own to delete it. As it is a separate environment you can’t use tools like $edit to visually edit files; you could create a text file outside of BASIC and use /include FILE to import it, however.

To view the code, type /list; to execute the program, type /run. BASIC will then compile the source file and if there are no syntax errors start to execute it. If there are any run time errors you will enter the debugger which has a > prompt. Here you can /display variables, change them with /modify and either /continue or /stop execution.

To leave BASIC, type /bye, remembering to /save first if you want to keep your program. When you start BASIC again, use /permcatalog to view the programs on disk and /open to load one.

Hello world

Here’s a terminal log of how to start BASIC and create a simple program.

# $run *basic
: /open hello
&  "HELLO" has been created.
: 10 for i = 1 to 5
: 20 print "Hello World!"
: 30 next i
: /run
  Hello World!
  Hello World!
  Hello World!
  Hello World!
  Hello World!
+  Program Ends
: /save
& Done
: /bye
&  Off at 21:53:35 on 11-17-14

In the next post we’ll look at BASIC language features in more detail.

Further information

See the Wikipedia article for more details on the history of BASIC. In 2014, Dartmouth created the website BASIC at 50 which has some interesting background on the creation of the language. TIME did an article looking at BASIC’s legacy.

For the MTS version, MTS Volume 10 offers a complete description.

There’s also a great beginner’s introduction called “Fundamental Use of the Michigan Terminal System (Including Simple MTS BASIC)” by Thomas J. Schriber from the UM Business School, which is available in the Hathi Trust archives or on Google Books.

Programming languages in MTS

Sat, 22 Nov 2014 12:53:53 +0000

Summary

Language	Introduction	Features	Sample program
BASIC	Intro	Features	Narcissistic numbers
FORTRAN	Intro	Features	Emirp prime
MAD	Intro	Features	Mergesort
ALGOL 60	Intro	Features	Josephus problem
ALGOL W	Intro	Features	Priority queue
LISP	Intro	Features	Four bit adder
UTILISP	Intro	Features	LISP vs FORTRAN
PL/1	Intro	Features 1 Features 2	Radix sort
SNOBOL	Intro	Features	Date formats
RATFOR	Intro	Features	Emirp primes
FLECS	Intro	Features	Emirp primes
PIL	Intro	Features	Roman numerals
APL	Intro	Features	Knuth shuffle
Assembler	Intro	Features	Caesar cipher
GPSS	Intro	-	-
PLUS	Intro	Features	Grep
PL360	Intro	-	-

Introduction

MTS supported over 40 languages, representing a cross-section of programming tools available in 1988, from well known ones like LISP and FORTRAN to the more obscure such as GOM and PLUS.

In this series of posts I will take a look at each of these - plan of attack is 1-3 posts per language covering:

A brief introduction, how to get it working on MTS and “Hello World”
A tour of language features
A more complex example, either implementing a task from Rosetta Stone or running a classic piece of code for that language.

Some languages may warrant more or less attention, and I will also look at the programming environment such as the debugger and link editor.

Trying to do all this may be quixotic - and I may lose interest among all the FORTRAN dialects - but it will be interesting to see what was available then and how they compare to the languages of today.

I am a working programmer by trade rather than an academic so don’t expect too much deep insight or theory - and if you spot any mistakes please let me know.

For new users of MTS, follow the setup guide, log on as a regular user such as ST01 and check the ‘Prerequisites’ section in the first article for each language for how to get it running - in most cases no extra work is needed once you have MTS running.

Source code

Source code for each of the examples can be found on Github.

Coming up later

ALGOL 68
BCPL
COBOL
GM APL
ICON
LISPs
PROLOG/KR
XPLs

Specialised languages

*CSMP Continuous System Modeling Program
*UMIST An interactive text-processing language patterned after TRAC
*CLPARSEGEN A parser generator that outputs PLUS code.

Cross assemblers

I will probably not look at these, unless they are especially interesting.

*1130ASM IBM 1130 and 1800 Assembler
*11ASR PDP-11 Assembler, version AN231
*1ASR PDP-1 Assembler (obsolete in D6.0)
*8ASR PDP-8 Assembler (obsolete in D6.0)
*9ASR PDP-9 Assembler (obsolete in d6.0)
*ASMT IBM TSS Assembler (5.0T2)
*I8080ASR A relocatable cross-assembler for the INTEL 8080
*M6800ASR An absolute cross-assembler for the Motorola M6800
*M6809ASR An absolute cross-assembler for the Motorola 6809
*MCS650XASR An absolute cross-assembler for the MOS Technology MCS6500 family
*PDP11ASR A relocatable cross-assembler for the DEC PDP11
*Z80ASR A Z80 cross-assembler
UNSP:11PAL A DEC compatable PDP-11 assembler and simulator
UNSP:F8ASR A cross-assembler for the Mostek F8
UNSP:PLM A cross compiler for the INTEL 8080 PL/M language

Further information

This list is based on the information in the MTS Archive describing what languages were available at the time of D6.0 and which work today, including those where there is no license available.

$PERMIT me to talk about $FILESTATUS

Sun, 16 Nov 2014 03:13:03 +0000

The information that MTS stores about files is quite different from today’s operating systems and it also has an interesting permissions model. In this post we’ll look at this information in more detail using the $FILESTATUS and $PERMIT commands.

`$FILESTATUS`

$FILESTATUS, which can be abbreviated to $F, displays information about files. It takes three parameters:

name
format
information

Running it without any parameters lists the files owned by the current user:

 # f
   ALPHA BETA

Use ? as a wildcard to specify what files to display. Note that this will not include temporary files; to see these you will need to do f -?. To see all files under another ID use f CCID:?; this will only list files you have access to.

The information parameter allows you to see further details about each file. To see all information MTS has, use the TOTAL parameter:

# fi ? total
  ALPHA             Size=1P, MinSaves=0P, TruncSaves=0P, MaxSize=32767P, 
   ExpFac=Def, Type=Line, RPM=0, IdleDays=36525, Lines=1, Holes=1, Avlen=19, 
   MaxLen=19, AvailSpace=2969, MaxHole=2969, Create=Nov15/14, 
   LastRef=Nov15/14, LastCatalog=Nov15/14, LastData=10:30:46 Nov15/14, 
   Volume=MTS600, Owner=ST03, Loc=3380, UseCnt=3, PKey=*EXEC, 
   FullAccess=Unlim Owner, None Others 
  BETA              Size=1P, MinSaves=0P, TruncSaves=0P, MaxSize=32767P, 
   ExpFac=Def, Type=Line, RPM=0, IdleDays=36525, Lines=0, Holes=1, Avlen=0, 
   MaxLen=0, AvailSpace=2990, MaxHole=2990, Create=Nov15/14, LastRef=Nov15/14,
   LastCatalog=Nov15/14, LastData=10:30:59 Nov15/14, Volume=MTS600, 
   Owner=ST03, Loc=3380, UseCnt=1, PKey=*EXEC, Empty, FullAccess=Unlim Owner, 
   None Others

Let’s look at each of these

Size and MaxSize give the current and maximum size in pages (4096 bytes)
MTS allocates more space to a file than its contents to allow it to grow. ExpFac is the expansion factor each time it needs to grow, here the default 10%. MinSaves shows how much space would be saved if the file was resized to its minimum possible size; TruncSaves shows spaces saved if the $truncate command was run to remove unused space at the end of the file. AvailSpace gives the amount of space in bytes before the file needs to be expanded.
Type is the file type, line or sequential
RPM is the number of references to the file per month since its creation date and IdleDays the number of days since its last reference. RPM always seems to be zero and Idledays larger than 36,000 whatever the usage of the file, so I suspect something is not working correctly here. Update 14-Apr-2015: this is due to a Y2K bug, see Jeff’s comment below.
UseCnt gives the number of times the file has been used since its creation; this appears to be set correctly.
Lines, Avlen and MaxLen give the number of lines and their average and maximum lengths
Holes and MaxHole refer to holes in line file due to line replacement operations that have left spaces
Create gives the creation date, LastRef the time the file was last used, LastCatalog the time the catalog was updated for this file and LastData the last time data was changed in the file
Volume and Loc gives the disk volume and type of storage the file is on
Owner gives the file owner’s ID
PKey and the remaining information gives details on who can access the file, which we will look at further below.

Instead of showing all this you can specify individual items to display:

# fi ? lines avlen
  ALPHA             Lines=1, Avlen=19 
  BETA              Lines=0, Avlen=0

Finally, the format parameter determines how the information selected will be displayed. You can choose name=value pairs, columns or packed, with options for headers, spacing and indentation. For example:

# fi ? col spacing=3 create lastref


   File name        Create   DateLast 
                    Date     Referenc 
 


  ALPHA             Nov15/14 Nov15/14 


  BETA              Nov15/14 Nov15/14

`$PERMIT`

The $PERMIT command, or just $P, takes three parameters

files
access level
users

You can also selectively clone permissions from one file to another with the syntax $PERMIT files1 LIKE files2 EXCEPT access_level.

There are six basic categories of access level:

R - Read
WE - Write-expand - can add lines to a file but can’t change or delete existing ones
WC - Write-change - can change or delete lines from a file but can’t add new ones
T - Truncate and renumber
D - Destroy and rename
P - Permit - allow other users to change permissions

These can be combined using various aliases, for example RW allows the first three categories above, N specifies no access and U unlimited access

The users parameter allows you specify a single user ID or even a wildcard user ID (like ST0?) as well as other combinations:

ALL - all users
OTHERS - all users except those which already have access info specified
ME - access for signed in user ID
OWNER - file owner
PROJECT=xxxx - users under project ID xxxx
PKey=xxxx - see the next section

*PERMIT will show the current level of access after each command. Some examples:

# permit alpha r st01, rw st02
  Access to file "ALPHA" is now Read ST01, RW ST02, Unlim Owner, None Others
# permit alpha d st0?, read others
  Access to file "ALPHA" is now Read ST01, RW ST02, Unlim Owner, Destroy ST0?,
   Read Others

Program keys

You may want a file to be only accessible when run by a certain program. In Unix the solution is setuid, where when a program is run your user ID temporarily becomes the user ID of the program so it can access files owned by that user ID. This can lead to security issues though, eg if a buffer overrun in the program can be exploited to allow access to other files.

MTS has a better solution: each program can have a key, and access to a file can be granted to that key. You can then run a privileged program under your normal ID.

One example is the *CKID program that runs at sign on for certain shared IDs and checks which secondary IDs can use that ID. The config file, CKID:ACCESS should only be accessible to that program, so it is permitted to the pkey for *CKID:

# fi ckid:access access
  CKID:ACCESS       FullAccess=None Others, Read Pkey=*CKID

You can set this up for your own programs by setting a pkey for the executable and then permitting access. Say you have a database program MYDB which is the only way a user should access the database file DBFILE. First set a program key:

$CONTROL MYDB PKEY=MYDB

and then permit access:

$PERMIT DBFILE RW PKEY=MYDB

Further information

See the online help for $FILESTATUS and $PERMIT, and a detailed write up in MTS Volume 1.

System start-up in more detail

Sun, 09 Nov 2014 04:08:17 +0000

^{Front panel of an IBM S/360 mainframe, from ookaboo.com. License: CC BY 2.0}

This post is a more detailed look at what happens at system start-up in MTS - it’s useful to know what job is printing what messages in case something goes wrong, and also as a step towards further customisation of your MTS system.

Most of this was put together by reading the job programs and config files referenced by the Operator’s manual: if I’ve omitted or misunderstood anything please let me know in the comments and I’ll update this post.

IPL

When you start the IPL process by typing ipl 260 on the Hercules console, the system will load IPLBOOT from a special area on the disk drive on device 260, which will in turn load UMLOAD and then IPLREAD.

IPLREAD will give the familiar prompt

Do you wish to run the current system?  (YES or NO).

Typing yes at this point will cause the system to load the file *IPL.0 and then execute it.

Typing no will drop you into the command line for IPLREAD: here you can examine or change memory, or choose a different system to load. RAMROD keeps the last 3 versions of the system in *IPL.1, *IPL.2 etc, so if there was something wrong with your last change to the system you could boot the previous version with the commands

LOAD NAME=*IPL.1
START

INIT

The system will then configure itself and start the INIT job, which will print:

Time and date have been set to ...

and will start the OPER and DMGR jobs which manage the operator’s console and disk respectively.

MTS INIT

The system will then run a MTS task as user INIT, running commands from the file INIT:INITCMD. This will print the system name and prompt for the reason for rebooting, which will be written to file INIT:REASON; history of all reboots can be found in INIT:RELOADLOG.

It will then start the PDP (Paging Drum Processor) and a number of operator jobs:

*CHK to display a list of offline devices for the operator to check (the distribution comes with a number of disk devices defined, but you only need one on Hercules, so this can be ignored by pressing PA2).
*S2L to load shared components into memory, eg the editor; this will invoke the Named Address Loader *NAL. I think this also prints the PEEK initialization messages.
*CLN to clean out old system check files
*CMD to start writing command statistics to buffers.
*FSM which sets things up for file backup jobs
*STI to check the statistics file

It will also clean out any temporary files left after an unexpected reboot and start the system status display at the top of the operator’s console.

Basic start-up is now complete.

HASP

Next, the operator would start up the spooler by running HASP, and the HASP initialisation jobs MTS *HSP. The latter reads commands from STRT:HSP which defines which devices should be started:

O $START MORE RDR1
O $START PCH1
O $START TN PTR2

LAS

The penultimate step is to ’let out the lines’ by running MTS *LAS. This reads commands from STRT:LAS. It will start MTS on each of the configured terminal devices with MTS DS02 … MTS DS05. It will then run the following operator jobs:

*CLK to start the job scheduling program
*TPR which I believe is part of the tape cataloguing system
*MGR which manages email
*TCM and *FTP SERV which refer to network services we don’t have on Hercules.

Finally, start batch job processing again with the HASP command $release ex.

Further information

The Operator’s manual has further information on the start up process and many of the operator jobs.

On the distribution tapes, Component 816 has documentation on Clockwatcher.

Some useful Hercules features

Sun, 02 Nov 2014 03:24:52 +0000

^{The Hercules console panel, which you can get by pushing Escape while in the Hercules console.}

In this post we’ll look at the Hercules emulator itself in more detail including some useful features when running MTS.

Which version?

As noted at the MTS archive site, there are two versions of Hercules currently in development, 3.11 and 4.xx. Both run MTS OK, including fixes for printer support not present in older versions. 3.11 has Windows binaries at http://www.hercules-390.eu/ and source code that can be built on other platforms; 4.xx is just available in source form on Github. Apart from that it’s not clear if there are advantages in one version over the other for MTS users.

The below items were tested on both versions of Hercules running on Linux. If you encounter any other differences let me know and I’ll update this post.

One word of warning: although you can take an emulated system running on 3.11 and start it using 4.xx, it seems you cannot go the other direction: the 3.11 code will see the disk file written to using 4.xx as corrupt and try to repair it, which makes it unbootable on 3.11.

Suspend and resume

It’s possible to suspend a running instance of Hercules to disk and resume it later - useful if you need to reboot your host OS but don’t want to shut down and start up MTS again.

From the Hercules console, issue the suspend command. A file called hercules.srf.gz will be created in the same directory as the config file and Hercules will immediately exit.

When you are ready to start again, run Hercules as normal but issue the resume command rather than IPLing. You will also need to reconnect any 3270 terminals connected via socket.

This worked perfectly for me on 4.xx - the MTS clock updated itself and everything kept on running including any logged in sessions. 3.11 could suspend but not resume, at least with my build of the source code.

Shadow disks

Hercules has the concept of ‘shadow disks’, where an emulated disk’s contents can be started in one file and then continued with updates made to another file. If you take a look at the Disks directory you will see something like this on the 6.0A distribution:

$ ls -l Disks/
-r--r--r-- 1 rupert rupert 68738104 Jan 16  2012 mts600.dsk
-r--r--r-- 1 rupert rupert 13798923 Jan 18  2012 mts600_1.dsk
-rw-r----- 1 rupert rupert  6062763 Oct 28 20:16 mts600_2.dsk

The combination of mts600.dsk and the two shadow files (denoted with a _) make up the MTS600 disk file. The D6.0A distribution has been set up so mts600,dsk contains the base D6, mts600_1.dsk contains patches to bring it up to D6.0A and your updates are in _2. So you can delete the _2 file to restore the system to its initial D6.0A state.

You can use this yourself if you want to make changes to MTS and then have the ability to roll back to previous versions. To do this, shutdown MTS and make mts600_2.dsk read only. When you start up Hercules and IPL again, a new file mts5600_3.dsk will be created. To roll back, stop Hercules and remove the _3 file.

Sockets

It’s possible to define the card reader as a socket device instead of a file. This allows you to submit jobs over the network or from your host OS by connecting to a socket instead of writing to the file Units/RDR1.txt. You can use the netcat utility which is available for most OSs or you could write a program to do this.

First, edit the Hercules config file and replace the line under ‘Unit Record Devices’ for the 3505 device with something like this:

000C   3505   127.0.0.1:9090 sockdev ascii eof   # RDR1

When you start Hercules, this will listen on port 9090 on the loopback interface for incoming connections. You can change the IP and port as needed in the config file.

Once MTS is booted and HASP is started, use netcat like the below:

netcat 127.0.0.1 9090 < job.txt

Where job.txt is the batch file you want to submit, including a S8 card on the first line (See the post on using the card reader for more details on this.)

If all worked OK, netcat will not print any output, but you should see the results of the job on the printer device.

It’s also possible to define the printer as an output socket device: when something is printed it will connect to the socket defined in the config file and send the output.

Further information

See the Hercules user manual for more details on options available.

Setting the timezone by patching the system with RAMROD and *OBJUTIL

Sun, 26 Oct 2014 03:01:04 +0000

D6.0A uses the US Eastern Standard timezone by default. In this post we will look at how to set the timezone to something different, which will lead us on to how to patch the system using the RAMROD and OBJUTIL utilities.

The TABLES assembly

As MTS was run on a small number of mainframes, the timezone is set inside the resident code of the system rather than by a command. The relevant code is TABLES; you can see the source assembly code in UMPS:UMTABLES#SA

...
   359              SET   YEAR=87,TIMEZONE=EST
...

which references a macro in copy:tables*sal

  1500              MACRO
  1501              TIMEZONE &Z
...
  1517     .L4      AIF   ('&Z' NE 'EST' AND '&Z' NE 'CDT').L5
  1518     TIMEZONE DC    H'-300'            EASTERN STANDARD OR CENTRAL DAYLIGHT
  1519              AGO   .OUT
...

Normally you would change the code, assemble it and reboot. But this requires the ASMH assembler, which is a licensed IBM product that cannot be distributed with MTS. The alternative, which we will look at here, is to patch the object code with the desired value.

Roadmap

An overview of the steps we will take

Use RAMROD to extract the TABLES deck to a file
Use *OBJUTIL to patch the file, adding a new ‘card’ to change the timezone
Use RAMROD again to incorporate the file into the deck
Reboot and enjoy the correct time

`RAMROD`

RAMROD is used to keep track of a set of object decks and combine these into a file suitable for IPL. ‘Decks’ refers to the older practice of using a deck of punched cards to boot the system; on MTS thankfully this is done using files stored on disk.

A set of object decks is combined into a system. You can see the systems currently defined, and the current system, with the list systems and list current commands in RAMROD. RAMROD can be run as the MTS user as follows; RAMROD commands are given at the ~ prompt:

# $run mts:ramrod
 Using file "RMRD:ROD"
 Proceed.
~ list systems
 D6.0A-AN172 created from AN152 23:05:42 01-17-12
 AN152 created from AN062 23:29:05 01-15-12
 AN062 created from AN052 01:13:12 01-06-12
 AN052 created from D6.0SYS.600/MP 19:49:40 01-05-84
...
~ list current 
 D6.0A-AN172 created from AN152 23:05:42 01-17-12
 Patch the timezone name and timezone offset in TABLES to be EST
 and GMT minus 5 rather than EDT and GMT minus 4. (jco)

So we can see the current system is D6.0A-AN172, the comment made when creating the system (which was to set the timezone to EST) and the history of previous systems.

You can see a list of decks that make up the system with list decknames; a snippet is below:

~ LIST DECKNAMES
 CONFIG.CARD.MP (DEC08-86)
 CONFIG.CARD.COMMENTS (AUG16-85)
 LOWCORE.DEFS.MP (SEP11-87)
 SEG0.NCA (SEP17-81)
 UMLOADTV (NOV20/79)
 TABLES.MP (AN172) patched
...

TABLES.MP is the deck we want. We can see a list of the patches already applied in the below:

~ list sys cur deck tables.mp patches
 TABLES.MP (AN172) patched changed
 REP  004088  0400030001,00000240,00000030,000002A0,00000180 Rearrange OPERDEVS 01:26:36 01-06-12 MTS.
 REP  000180  01F1F0F5F2 CON1 IS A 1052 01:26:51 01-06-12 MTS.
 REP  003F8A  04,FED4 Make the timezone offset -300 (GMT minus 300 minutes or 5 hours)
 REP  003F8C  04,C5E2E340 Make the timezone name "EST"

What we want to do is extract the TABLES.MP deck to a file, so we can edit it outside the system using *OBJUTIL. Use the copy command to do this; let’s store this to the temporary file -tables:

~ copy current tables.mp -tables

Exit RAMROD for now with stop.

`*OBJUTIL`

*OBJUTIL is used to edit a deck. Pass the file to be edited as unit 0:

# $run *objutil 0=-tables
 OBJUTIL VERSION(PR137) 08:22:26 10-21-14
*

*OBJUTIL accepts commands at the * prompt. First, let’s get a listing of the values in the deck using the map command:

* map

  Symbol Type Esid Address Length AF

   Module: TABLES    Size = 0041C8
  TABLES   SD 0001 000000 003E0E     $HSPMNDV LD      0040FC 0004
...
  TIMEZONE LD      003F8A 0004       TIMZONTB LD      003F94 0004
...

The timezone is encoded as a half-word (16 bit) offset in minutes from GMT followed by a 8 character string giving the timezone name. We can use the display command to see the current values, using the type and length modifiers:

* display@type=h timezone
  TIMEZONE  'H'  -300
* display@type=c@len=8 timezone+2
  TIMEZONE+2  'C'  "EST     "

We’ve confirmed the current setting is GMT minus five hours, name “EST” padded with blanks. Let’s now set it to the value we want; I’m going to use plain GMT which is zero offset but you could use any positive or negative value. Use the modify command with the @repgen modifier to create a REP card to set each part of the value

* modify@repgen timezone H'0'
  TIMEZONE WAS 'H'  -300 NOW 'H'  +0
  Enter comment for REP card:
? Set timezone to GMT

* modify@repgen timezone+2 C'GMT     '
  TIMEZONE+2 WAS 'C'  "EST     " NOW 'C'  "GMT     "
  Enter comment for REP card:
? Set timezone name to GMT

A REP cards means we are adding a line to change the object file rather than changing the existing contents of the file. Note that it prompts for a comment after each change; terminate this with a blank line.

To be sure, we can now display the new values;

* display@type=h timezone
  TIMEZONE  'H'  +0
* display@type=c@len=8 timezone+2
  TIMEZONE+2  'C'  "GMT     "

Use stop to get out of *OBJUTIL.

Back to `RAMROD`

Run RAMROD again and create a new system from the current system to incorporate your changes:

# $run mts:ramrod
  Using file "RMRD:ROD"
  Proceed.
~ create D6.0A-CT214
  ** Fromsystem = "D6.0A-AN172"
  & OK
? ok
  Enter comments:
? 2014-10-21 Modify timezone

The new system name D6.0A-CT214 needs some explanation. The D6.0A is obvious; the CT214 comes from a convention for naming releases that is described in the distribution driver file:

            1.   The name of the system installed is changed to the "model
                 number" of the date it is installed, e.g. "AY108" for May 10,
                 1978. [2nd and 3rd letters of the month name, two digit day
                  of the month and one digit year.]

So this system I am creating was made on October 21, 2014.

Next, replace the TABLES deck with the one you just edited; supply a comment and leave the version code blank:

~ replace tables.mp from -tables
  Enter comments:
? 2014-10-21 Modify timezone to GMT
?
  Enter version code:
?
  ** REPLACE deck "TABLES.MP" from file "-TABLES" :
  & OK
? ok
  Done.

You can list the patches again, to be sure:

~ list deck tables.mp patches
 TABLES.MP (OCT21-14) patched changed
 REP  004088  0400030001,00000240,00000030,000002A0,00000180 Rearrange OPERDEVS 01:26:36 01-06-12 MTS.
 REP  000180  01F1F0F5F2 CON1 IS A 1052 01:26:51 01-06-12 MTS.
 REP  003F8A  04,FED4 Make the timezone offset -300 (GMT minus 300 minutes or 5 hours)
 REP  003F8C  04,C5E2E340 Make the timezone name "EST"
 REP  003F8A  04,0000 Set timezone to GMT
 REP  003F8C  04,C7D4E34040404040 Set timezone name to GMT

Finally, use the current command. This will check the system and write to the IPL files:

~ current
 There are 4 IPL files with prefix "*IPL.   "
 Loading system D6.0A-CT214 using the UMLOAD deck it contains.
 LOAD: Resident: 2000-5DFC8 UMLOAD Psect: B0000 Pageable: DD000-191A70 End: 1DCFFF
 Contents of IPL file "*IPL.3":
 AN052 ENTRY=56D18 PSECT=100008 VIRTUAL=B0000...191A70 VIRTUAL_START=100000 UMLOADTV=2000
 WRITTEN BY ID MTSS AT 19:55:37 THU JAN 05/84 BY
 COM 18:50 Jan 05 - Replace RSF to fix the halfword date problem.
 ** Write system "D6.0A-CT214" to IPL file "*IPL.3":
 & OK
? ok
 System "D6.0A-CT214" has been written to  IPL file "*IPL.3"
 IPL file stacked has been pushed.
 System "D6.0A-CT214" is now the current system.
 "D6.0A-CT214" : Released.
 System "D6.0A-CT214" has been Frozen.
 Done.

The moment of truth

Get out of RAMROD with stop and then reboot the system as normal. When it comes up you should get a warning that the timezone has changed, which you can just ok.

 00000   ** UMMPS/XA ** assembled 04/19/88
 00000 CONFIG CPU 0000 online
 00000 CONFIG CPU 0001 online
 00001 INIT Time and date have been set to  14:45:22 on 10-21-14.
 00002 OPERATOR   Started at 14:45:22 on 10-21-14  Model 3090 Serial 000611
 00002 OPERATOR   Using display DS01 & printer CON1 (1052)
 00004 MTS  Timezone "GMT" is different from timezone during last IPL ("EST").
 00004 MTS  If you are sure the time is set correctly, enter "OK" to proceed wit
 00004 MTS   IPL; otherwise re-IPL now.

Later on in the boot sequence you can see the new system:

00004 MTS  Reload at 14:45:56 on 10-21-14.  Model: IBM 3090/FF  Serial: 611
00004 MTS  System: D6.0A-CT214 written at 08:34:51 on TUE OCT 21/14.

And that’s it! The operator’s console will now show the correct time for your timezone, as should the display time command from MTS.

Further information

There’s a summary of this process in the D6.0A FAQ and I also found the conversation between Ron Frederick and Jeff Ogden on the H390-MTS Yahoo list useful to understand the steps required.

Original instructions to new sites on patching the system deck can be found in the D6.0-NOTES.txt file in the distribution archive.

RAMROD has a write-up in file RMRD:RAMROD*PF, with the wonderful introduction:

         Cards were made for salesmen and bridge players and in that
    domain they should have undoubtedly remained. Their passing will
    not be mourned by those enlightened programmers  who  have  seen
    fit to rise above the hardcopy world and to place their faith in
    the wonderous MAGNETIC MEDIUM.

*OBJUTIL is described in Volume 5 of the MTS documentation. You can bypass *OBJUTIL and use the patch command in RAMROD, but *OBJUTIL has much better facilities to enter number and character patches, and to check your work. Using patch you have to find the address of TIMEZONE, the ESDID where it located, and convert the offset and the timezone description (in EBCDIC, not ASCII!) to a sequence of hex characters, eg

~ PATCH DECK TABLES.MP
  Address Esdid Text <comments> :
? 3F8A 4 0000C7D4E34040404040

CMDSTAT, or why does DWB keep asking me for tapes?

Sun, 19 Oct 2014 03:42:08 +0000

If you’ve used MTS for more than a few days you will see the above message on the MTS operator’s console. In this post we will look at what to do when you get this message and what is going on behind the scenes.

The quick answer

*DWB wants to store accumulated logs and command statistics on tape as statistics files fill up. The D6.0A distribution comes with a suitable tape on drive T90A, so at the MTS operator’s console answer the tape mount request with:

OK M001 T90A

The complete session will look like this:

00050 MTS  *DWB: The CMDSTAT file to tape program has been started. ********
00050 MTS  *DWB has been started to dump the CMDSTAT file(s), if any, to tape.
00050 MTS  A tape, labeled as indicated, should be mounted when requested.
00050 MTS  See component 531 for a description of CMDSTAT.
00050 MTS SYS.:  F (1 9TP) M001 on 9TP, ring IN, 'CMDSTAT' ********************
OK M001 T90A
00050 MTS Mount check OK.Mount M001 on T90A Ring In
00050 MTS SYS., M001:Accepted on T90A
00050 MTS **** Remove tape M001 from T90A (6250 BPI)

Once it has written the statistics, the tape will go offline so the next time *DWB fires up you will also need to do a

devinit 018a

on the Hercules console before responding to the tape mount request.

The longer answer

During system startup, MTS job *CMD is run automatically. This invokes the CMDPIKUP program which runs continuously, writing statistics from memory buffers into files.

Once a file becomes full, CMDPIKUP will start MTS job *DWB. This will run the CMDTAPE program to ask for a tape to be mounted, write the file to tape, empty the file and then exit.

What files and tapes to use is determined by the file SYS:CMDDIR. This is only permitted to be read by SYS so you will have to sign on to SYS to view it. A typical file looks like this:

# list cmddir
 
       1     TA MCMD034001 ???4??t?19:46:2405-20-85
       2     FACMDSTAT1
       3     F CMDSTAT2

The first character of each line is T for tape or F for file. The second character is the status: for files

SPACE: not in use
A for active, ie the file is being written to
B for busy: CMDTAPE is copying it to tape
F for full: the file needs to be written to tape

Status for tapes is similar:

A for available but not mounted
B for busy, being written to now

The rest of the file line gives the filename being used to store statistics; the rest of the tape line specifies the tape name, next file and creation date.

So at this point, file CMDSTAT1 is being written to and no tape is in use.

When *DWB is running, the CMDDIR file would look something like:

# list cmddir

     1     TB MCMD033001 ???4??t?19:46:2405-20-85
     2     FBCMDSTAT1
     3     FACMDSTAT2

ie the tape is in use and will write out the contents of CMDSTAT1; meanwhile, CMDSTAT2 is continuing to receive new statistics.

If the mount request is not attended to and both files fill up, CMDPIKUP will create a new temporary file CMDSTATx where x is some character; this will be deleted after it is written to tape.

On Hercules using D6.0A, this all runs well; the distribution comes with an empty tape file Tapes/cmd001.awd that is attached to drive T90A ready for use. The frequency that *DWB needs to run will of course be a lot less than on a real mainframe: a note in the driver listing file says that at busy times the files would fill up in an hour and the tape would fill up in about a week.

Clearing the tape

As tapes can have unlimited size on Hercules. the tape file will get bigger and bigger as more statistics are written to it; after running MTS for 4 months my file was over 65 megabytes. I wanted a way to get that space back.

One solution would appear to be replacing the tape file with an empty tape file (eg by replacing it with the copy of cmd001.aws that came with the D6.0A distribution). However, CMDTAPE does not like the tape contents changing from underneath it and gives an error when you try to mount it.

A better solution is to set a maximum length on the tape in Hercules and use the facility in CMDTAPE to create new tapes when the existing one is full.

At the Hercules console, change the tape length with:

devinit 018a Tapes/cmd001.aws maxsizem=50

(or whatever maximum size in MB you want).

Then, when you mount the tape responding to *DWB’s request, CMDTAPE will notice it is full and say

00049 MTS  *DWB: MOUNT NEW CMDSTAT TAPE RING IN WITH RACK  M002 FOR INITIALIZAT

Create a new tape from your host OS command line:

hetinit -d Tapes/cmd002.aws CMD002

and at the Hercules console do

devinit 018a Tapes/cmd002.aws maxsizem=50

Back on the MTS operator’s console, answer *DWB’s request for a new tape with just the tape drive name

T90A

CMDTAPE will mount the tape, label with the next sequence number (so M002 in this case) and initialise it and umount it.

It will then ask for the tape to be mounted again so it can write statistics to it; devinit it again at the Hercules console and answer the mount request with the new tape name:

00049 MTS SYS.:  F (1 9TP) M002 on 9TP, ring IN, 'CMDSTAT' ********************
OK M002 T90A

You can now safely delete the old tape file cmd001.aws. Also remember to update the line in hercules.cfg for the tape to add the maxsizem parameter:

018A 3420 Tapes/cmd002.aws maxsizem=50 # T90A, a CMDSTAT tape for use by *DWB

Turning off CMDSTAT?

Most Hercules users of MTS are not using the command statistics tapes that are being produced so it would nice to turn it off altogether.

There does not seem to be an easy way to do this (we can hardly blame the MTS designers for this as they were not expecting people to run personal copies of MTS!) One potential solution mentioned on the Yahoo list H390-MTS would seem to be to rewrite CMDTAPE to only empty the CMDSTAT files and update CMDDIR, not actually write data to tape. CMDTAPE is in 360 assembly language and (I think) requires the IBM copyrighted product ASMH to assemble, so this would not be a trivial task. In the meantime, feeding tapes occasionally to *DWB is not a big deal.

Why is the job called `*DWB`?

DWB is the initials of system programmer Donald W. Boettner. There’s a note in the driver file for the CMDSTAT component 00531/015:

It would seem that Don could have thought of some name more original than his initials. Don's response: "Since no one would name an SVC after me, I was forced ... "

And that’s why I like MTS so much - you’d never see that on a commercial operating system.

Further information

The Operator’s Manual, page 317, has a complete write-up of how the CMDTAPE components fit together and what to do if there are problems.

You can see the contents of *CMD and *DWB by $LISTing them from the MTS command line. Source for CMDPIKUP and CMDTAPE can be found under component 531 of the MTS D6.0 distribution tapes.

Users and projects

Sun, 12 Oct 2014 08:57:21 +0000

Rather than be limited by the set of user IDs in the starter system, you can create one or more user IDs for yourself. This post will look in more detail how user IDs are created and used in MTS.

User and project IDs

User IDs (or ccIDs) in MTS are four characters long, optionally right padded with . if shorter (eg ACC.).

Each user ID is a member of one project, which also has a four character ID. A project can have zero or more user IDs in it. Project IDs allowed funds for students on a course or a research team to be grouped together; it also allows sharing of files within a group.

Note that unlike groups on Unix a user ID can only be a member of one project. One upshot of this on the mainframe is that a person may have several different user IDs, for example one for each course they are on. Thee is no concept of root or Administrator on MTS, but an ID can have extra privileged, eg the ability to access devices directly.

Creating a new user ID

User and project records are stored in file *ACCOUNTING and sub files matching *ACCOUNTING?. Rather than edit these directly you should use the ACCMAINT program.

Sign-on as user ACC using password aardvarks and then a secondary ID like ST01. $run ACCMAINT to start the program, setting unit 0 to be where you want output, eg *print* or *sink*.

You can now use commands like CREATE and DESTROY. Here’s a sample session where we CREate a privileged ID ABC.

# $run accmaint 0=*sink*
# Execution begins   02:55:29 


  MTS ACCOUNTING FILE MAINTENANCE
  CRE ABC.,0,,,,,10000,,,,WABC,LIBRARY=ON,PRIV=ON,PROTECT=ON,PASSWORD=secret1
 


  ABC. password is SECRET1          Name:
  ABC.             SECRET1 
  ABC.             SECRET1 
       (Hexadecimal representations:  ID=X'C1C2C34B' PW=X'E2C5C3D9C5E3F1')
...

Looking at the parameters:

0 is the university account number
10000 is the maximum disk space in pages
The project name is WABC: this must start with a W to provide system level privileges.
LIBRARY - can create a public file, eg one starting with *
PRIV - bypass checks on funds
PROTECT - run privileged commands, eg get tape devices directly with GET
Other blank fields are to control resource use and can be blank as shown.

It should also be possible to create non-privileged IDs this way but I have not worked out how to set up funds: if I enter the command

CRE BA01,0,,,,,10000,,,,BABA,PASSWORD=secret1

and then sign on as ba01 I get The funds allotted this user ID have been depleted. - if you know how to do this let me know in the comments.

Update 14-Apr-2015: see Jeff’s comment below on how to do this.

Removing a user ID

$run ACCMAINT as user ACC as before but use the DESTROY command with the user ID and the account number. For example, to remove user ABC.:

# $run accmaint 0=*sink*
# Execution begins   03:06:37 


  MTS ACCOUNTING FILE MAINTENANCE
  DES ABC,0
  *** ABC. IS TO BE DELETED.
  PLEASE CONFIRM OR ENTER "CANCEL".
  ok

Getting user and project information

There are other programs under ID ACC that may be useful; some examples:

ACCDISPLAY prompts for a user ID and prints out detailed information for the ID
ACCLISTING lists out info on all user IDs
PROJECTDISP prompts for a project ID and provides details
PROJECTIDS prompts for a project ID and lists all users in the project
PROJECTLIST shows details on all projects in the system

Run $filestatus when signed on as ACC to see the list.

Changing password

To change the password of the currently signed-on MTS ID, do SET PW. It will ask for the old password first then the new password twice for confirmation.

To change the password for an account you don’t know the password for, sign on as the user WPSW, enter a secondary sign-on ID/password and then $run program1. If you type a user ID it will reset the password to something new. An example for our new account ST03:

# $run program1
# Execution begins   03:17:16 
  ST03
  Password previously set at 04/19/88 17:19:01 EDT has been reset to YLU6GM 
  end of file
# Execution terminated   03:17:26  T=0.011

CKID and secondary sign-on

Some privileged IDs, such as MTS, are protected by requiring a secondary sign on. Access is controlled by the file CKID:ACCESS with lines of the form

priv_id secondary_id1 [secondary_id2...]

To change this file you will need to sign on as CKID. In the starter system the password for this account is not supplied, so first change its password using the instructions in the previous section.

Edit the file ACCESS using $edit (it’s wise to take a backup first). A typical line for ID MTS looks like this so you can add secondary IDs at the end or remove secondary IDs you don’t need.

MTS. ALWB DLB. DRH. DWB. KLB. MTA. SRB. WSG. W013 W030 W05Q W070 W170 ST00 ST01 ST02 ST03 ST04 ST05 ST06 ST07 ST08 ST09 AB01

You could also add new privileged IDs and who can access them by adding lines to this file. To ensure the secondary sign-on is checked at sign-on, set the sigfile (the command file run at sign-on) for the account being protected to CKID:CKID.SIG with set sigfile=CKID:CKID.SIG.

Further information

A write-up on the accounting system can be found in component 104/172 on the MTS tapes. See restoring components for details on how to do this and the FAQ question 31 on how to print the guide.

The operator's console

Sun, 05 Oct 2014 04:30:28 +0000

The operator’s console allows you to monitor and control your MTS system. Although you will likely use only a fraction of the features that a real operator would have used, it is worth getting to know how it works and what features are available.

This post has two sections: a quick tour of the screen, commands and keyboard controls followed in the “Further Information” section with a full list of commands.

The tour

Parts of the screen

The top two lines show a summary of the system’s status. An asterisk by an item means that the system is overloaded.

The next line, the third, will normally be blank but will show any system alerts. On the screenshot you can see PCH as the punch device is currently offline and I need to do a Hercules devinit to bring it back online. This line can also show HASP status alerts, such as when HASP has been started but batch job execution has not been resumed yet.

Taking up the bulk of the screen is the message area, showing results of commands you type and any job messages. If jobs require any input they will be bolded: on the screenshot you can see a tape mount request that needs a response.

The last but one line is the request area where you can type commands, and at the very bottom is the system name, date and time.

Keyboard

Note that the cursor position is important: in the screenshot above I can put the cursor in the line after ****** and response to the tape request, or put the cursor in the request area at the bottom to enter commands. When there are multiple input areas active, pressing Tab will move between them.

Don’t press SysRq, as this will ask for a dump tape and will exit the operator’s console program.

Types of commands

There are four types of commands that can be entered in the request area:

Job commands, which do not have a special prefix
HASP batch spooler commands, which start with $
System status commands, which start with /
Device commands, which start with %

Job commands include HASP and SHUTDOWN, used in the start up and shut down process.

The GOOSE, STOP and BLAST commands, in order of severity, can be useful when dealing with user terminal jobs that appear stuck. Be careful with BLAST as it can lead to file system damage.

The MTS job has three meanings useful on Hercules

To run MTS operator command files, eg MTS *LAS; a list is given below.
To start an interactive MTS session on the console for any ID, without having to give a password. Type MTS OPER then SIGNON XXX where XXX is the account you want. Can be useful for a quick command but better to use a separate terminal normally.
To restart MTS on a terminal if it has been STOPed or hung up; use MTS DSxx for this where xx is the sequence number of the 3270 connection; this is displayed at the top of each terminal connection.

HASP commands include

$release ex and $hold ex to start and stop job execution
$drain system to bring the scheduler to a halt before shutdown
$drain DEV to remove a device, like the punch, from HASP; $start DEV to add in back again
$display to show information about jobs

System status commands are similar to the user MTS command $systemstatus but replace that word with a /. So in userland you would do $systemstatus tasks to view a list of tasks but on the console you would do /tasks (or just /t). There are a number of additional subcommands only available on the console.

Device commands include %wrap to control line wrapping and %PF to set PF hotkey definitions.

Further information

System status columns

Key to the abbreviations in the system status area (taken directly from the D6.0A FAQ):

	DT   = Delta Time [time in seconds covered by the sample displayed]
	EXQ  = Execution Queue [number of batch jobs waiting to execute]
	PRT  = Print Queue [number of jobs waiting to print]
	PCH  = Punch queue [number of jobs waiting to punch]
	BP   = Batch Preferred [the number of batch jobs the system would 
	                        "like" to be running]
	AB   = Actual Batch [the number of batch jobs actually running]
	BHP  = Batch per Hour [average number of batch jobs completed per hour]
	AL   = Active lines [MTS terminal sessions]
	VP   = Virtual Pages
	RP   = Real Pages
	DPA  = Drum Pages Available [pages available on the high speed 
	                             paging devices, rather than disk]
	PA   = Paging Activity [paging I/O operations per second]
	DA   = Disk Activity [disk I/O operations per second]
	CA   = Channel Activity [channel I/O operations per second, 
	                         includes DA and a portion of PA as well as 
	                         other I/O operations]
	%PI  = Percent Processor Idle
	Q    = Global CPU Queue [jobs waiting for the CPU]
	TQ   = Tape Queue [MTS jobs waiting for one or more tapes 
	                   drives to become available]

Job commands

A summary of the job commands available is given below. Full documentation can be found starting from page 81 in the Operator’s Manual.

BLAST - forcibly kill a job if STOP will not kill it.
BROADCST - send a message to terminals attached to the system
DIS - display contents of memory locations
DMGRSTAT - manage disks
FLUSH - clear requests from HASP for I/O for a device (after draining)
GOOSE - simulates sending an ATTN to a task
G11 - g11 3211 printer config
HASP - start the spooler
HASPLING - hasp subjobs, not started by hand
INIT - initialize system, not started by hand
IT - list networks
JOBDUMP - dump a job core memory to tape
JOBS - list job status
MOD - change a location in memory
MTS - start an MTS task
OFFLINE - mark a device as logically offline
OK - determine how jobs that terminate successfully display to the console
ONLINE - mark a device as logically online
OPERATOR - start the operator console
PDP - initiate the Paging Drum Processor
PDROP - remove paging devices
PGET - set up extra paging devices
PN - printer train config
QN - printer train config
SE - print device table
SHUTDOWN - shutdown the (terminal) part of the system
SIGNONM - print a sign-on message to all users before they sign on
SOFTCHK - control the recording of soft (recoverable) machine checks
STARTUP - reverse the effects of shutdown on a terminal
STAT - collect system statistics to a tape
STATSW - dynamically change the parameters that a STAT job is using
STOP - kill a job
TABLMOD - display or modify information in the shared file table
TASKS - display status of running tasks
TMTS - run a task using the test version of MT
TN - printer train config
T11 - printer train config
UNITS - display config of channels, control units etc

MTS operator’s files

All commands below need to be run by MTS and prefixed with *, eg MTS *BBS. Many (most?) of these will not be of use on Hercules, eg those involving networking or plotting hardware. Full documentation starts from page 161 in the Operator’s manual.

AAS - Starts network tasks AA21 - AA29
ABS - Starts network tasks AB10 - AB6F
ADS - Starts network tasks AD10 - AD73
AES - Starts network tasks AE10 - AE73
AFS - Starts network tasks AF10 - AF6F
ANS - Starts network tasks AN10 - AN6F AND DSN
BBS - Babysit program to watch for user ID signon
BDL - Dump, reload PCP “AB”
CCD - To Defer Plots
CCL - Initializes Plot Tapes
CCP - Dump Plots To Tape
CCR - Reset/Startup PDP-11 “C”
CCS - Normal Startup PDP-11 “C”
CCT - Length Of Plot Session
CDL - Dump, Reload Data Conc. “C”
CHK - Checks For Offline Equipment
CLB - Retrieves Label From Tape And Inserts It In Tape Catalog
CLK - Starts Automatic Job Scheduling Program
CLN - Cleans Up machine check and unit check Info.
CLO - Reloads DC “C”-No Dump
CLR - Restarts Job Scheduling Program
CMB - Combine Statistics Tapes
CMD - Command Statistics
CPW - Change Password To Unknown
CTD - Check Disks After PM
DCS - Starts Data Concentrator C
DDL - Dump And Load Primary Communications Processor AD
DLG - Logs Disk Errors
DLO - Reloads PCP “AD”-No Dump
DMP - Initiates BATCH Job To Print Dumps
DRN - Drains HASP Remotes
DSD - Runs DASDI
DSK - Add,List,Delete Disks
DSN - Start User HASP Display - NUBS
DSO - Amount Free File Space
DSP - User HASP Status Display - CNTR
DWB - CMDSTAT + Unit Checks To Tape
EDL - Dumps & Reloads PCP AE
ELO - Loads Primary Communications Processor AE
EUP - Enables terminals on EE01 SCP in the East Engineering building
FIR - Names & Ph. #s Of Fire Fighters
FIX - Update CCID Accounting Record
FLB - Check Tape Labels
FSC - Make Copies Of File Save Tapes
FSM - File Save Merge
HGS - Show 10 Jobs With Most CPU, DSK I/O etc
HLB - Force Access To UB Host Through Host Locator
HLG - Hasp Log Collection
HLM - Force Access To UM Host Through Host Locator
HPS - HASP Status
HSP - Normal HASP Start
HUH - Merit + Concentrators, State Of
*IG.SHUFFLE - Summarizes *IG Usage
INI - .System Initialization
ITX - Intertask Communication Test-UMMPS Jobs
LAR - Reset Line Adapters-1270
LAS - Start 1270 And Misc Jobs
LBH - Tape Labeling (non-catalog)
LBL - Tape Labeling (catalog)
LIM - Time Remaining-Batch Jobs
LMT - Short Version Of MSS
LRL - Info. About Last IPL
MNS - Normal MERIT Startup
MSD - Set Time-Date Merit CCs
MSG - Cleans Up $Message System
MSS - Tape Usage History
MUP - Current State Off MERIT Computer
NDL - Dumps & Reloads Primary Communications Processor AN
NST - NAS-Manipulation Of Name Address Spaces
NUP - Enables Terminals On NUBS SCPs & Job Status Monitor
OOT - Controls NTM On UB & UM
PAG - Tests Paging Devices
PLB - Prints Identifying Info. About Plot Tape
P16 - Starts 16 PAG Jobs
RCP - MTS S-8 Cards
RES - File Save: Status & Restoration
RHB - Releases & Holds HASP Rate Classes
RIP - PN Ripple Print
RST - Restores Files
RSV - Reserves Disk Drives
SAV - Daily File Save
SDB - PCP Shutdown Msg. & Disconnect
SDM - D.C. Shutdown Msg. & Disconnect
SFT - Starts SOFTCHK-Checks For Soft MCHKS
STA - Saves Statistics On Tape
STI - Checks Condition Of Statistics Work File
SVS - Special Large, Weekly Type Filesave
SVW - Weekly File Save
TNR - TN Ripple Print
TPD - Tape & Tape Unit Diagnostics
TPS - Displays Amount And Type Of Free Tape Units
TSH - Add Tapes To Or Remove From UNSP:TAPESHARE
TSN - Weekly Full File Save Slave Stream
UNU - Enables Terminals On NUBS & UNYN SCPs & Job Stautus Monitor

HASP commands

Once the spooler has been started by running the HASP job, there are a number of commands available to control spool execution. Full details in the HASP manual.

$ACCEPT [RMID] modifier - define what output each site can accepr
$ALTER JOB n PRIO +or-M | DEFER | LOW - alter job priority
$BACKLOG [log] - display job backlog
$BACKSPACE dev n - fix paper jam by restart print from 2 pages back
$DELETE dev n - terminate the current job running on device dev
$DELETE JOB N - terminate job number N
$DISPLAY JOB n - display info about job N
$DISPLAY PRIO JOB n - display priority of job N
$DISPLAY RMTS|REMOTE NAME|REMOTE NUMBER [LOG] - display status of remote dvices
$DISPLAY {UNIT Dev N | UNITS [LOG]} - display I/O unit status
$DRAIN dev n - Allow current job on device N to finish then remove device from spooler.
$DRAIN SYSTEM - Allow all current jobs to finish but do not execute any new jobs
$FORMS Paper,devn - Define papet type on device
$HOLD *...* - Hold access to the pseudodevices *PRINT*, *PUNCH*, *BATCH*
$HOLD EX - Hold execution of batch jobs (but allow printing/punching)
$HOLD JOB n or ALL or LOW or DEFER - Put a hold on batch jobs
$INTERRUPT dev n - Interrupt the printing of the job on device N and put it back on the queue,
$LIST - Define level of log messages to be printed.
$LOCATE JOB n - Find out execution info for job N
$LOCATE User CCID - Find out execution info for jobs from user CCID
$LOGIO ON/OFF DEVn - Log all message for a device
$LOG MESSAGE - Send a message to the log file
$NEWHASPLING dev n - Start a new HASP internal job
$PASSWORD - Set password for remote station
$QUE [MAIN] - Show queue information
$REFUSE [RMID] modifier - define what output each site can accepr
$RELEASE *...* - Release access to the pseudodevices *PRINT*, *PUNCH*, *BATCH*
$RELEASE EX - Release execuion of batch jobs
$RELEASE REMOTE JOB n or ALL or LOW or DEFER - Release jobs put on hold
$REPEAT dev n - repeat printed output for job printing to device N
$RERUN JOB n - Terminate job N and place back on the queue
$RESTART dev n - Terminate job running on device N and immediately rerun
$RMSG (nn Or Rmid Or All) Message - Communicate with remote stations
$ROUTE TYPE for-id to-id - Define routing for output of job
$SETUC [RMID] On|off - Set upper-case option for remote stations
$SIGNOFF - Stop a remote terminal after completion of current read/punch
$SPACE dev n - Stop carriage control and single space output for job running on device N (useful for runaway print jobs)
$START modifier dev n - Add a device back under HASP control
$START SYSTEM - Start HASP operation (done as part of MTS *HSP)
$STATUS [log] N - Show status of device N
$STOP dev n - Stop execuion of current job on device N and remove device from HASP
$TEST - Check console is working

System status commands

Full documentation can be found starting from page 456 in the Operator’s Manual.

/ALTER - Change system scheduling parameters or virtual memory
/AREAL - Change real memory contents
/ATTN - Send attention interrupt to a task
/BLAST - Force kill a job
/DEVICE - Display info on a device
/DISPLAY LOCK n - Display locks, eg stat job lock
/DISPLAY - Display predefined variables
/DREAL - Display real memory contents
/FIO - Force a fake I/O interrupt
/JOB - List details of jobs
/KILL - Kill a job
/LOAD - Print load info, like the top 2 lines of the operator console
/OPER - Print output of operator’s console or send command to console
/QUEUE - Display queue status
/SCREEN - Display job status in TV screen like format
/TAPEQUEUE - Control and list the tape queue
/TASKS - Print task information
/USERS - Prints user information

There are also some synonyms, eg /MODIFY for /ALTER.

Device commands

Like on MTS terminals, device commands start with %, but the set of available commands is different. Full details are on p331 of the Operator’s Manual.

%3270 devn - switch console device to be devn
%ACCEPT ALL|job - control if messages are displayed by jobs
%EMPTY - Empties the screen.
%FAST - Switches terminal into fast mode; not of use on Hercules.
%IGNORE jobn - control if messages are displayed by jobs
%PF? - Lists PF key definitions
%PFn=def - Redefines program function key PFn to be def
%PTR devn - Switches the console printer device
%REFRESH - Makes sure that the screen is up to date.
%RESTART - Switch back to main terminal from backup.
%SLOW - Switches terminal into slow mode; not of use on Hercules.
%WRAP ON|OFF - Control line truncation

References

Operator’s Manual
HASP Manual

MTS System Admin

Sun, 05 Oct 2014 04:00:04 +0000

In this series of posts we will look at the operator console, system admin commands and Hercules features.

A quicker way to mount tapes

Sun, 28 Sep 2014 04:03:18 +0000

To wrap up this series of posts on tapes I will show a quick way to mount them that does not require switching to the operator’s console and responding to the mount request.

Example

Say you wanted to mount the D6.0T1 distribution tape which is on T904. Normally you would issue the $mount command from a user terminal:

$mount mts:tape1 9tp *t* vol=6.0T1 lbltype=vlo

and then switch over to the operator’s console to say

OK TAPE1 T904

Instead you can do this from your MTS session:

$get >t904
$control *afd* volume=6.0T1
$control *afd* lbltype=vlo

You can then run any program that uses the tape by pointing it to pseudodevice *afd*, for example:

$run *fs 0=*afd*

When finished you need to $release *afd* as usual. Once you release it, the tape will not go offline like for normal mounts so you don’t need to devinit it on the Hercules console before using it again.

So although this is much quicker to use than regular $mount, there are a number of drawbacks:

You have to be a privileged user to $get a tape device - so with the starter set of users you can sign on as MTS and do this but account ST01 would not work
You can only have one FDname open at a time whereas you can $mount multiple tapes and give them different pseudodevice names. If you try to $get a second tape it will release the first one and reassign *afd* to the new tape.
You need to remember to issue the $control commands to identify the tape, otherwise you will get errors trying to run programs against *afd*

The `$get` command

$get is a MTS command but is not mentioned in MTS Volume 1 - you will need to get the System Edition which lists privileged and obsolete commands.

*afd* stands for Active File or Device and is described in the last chapter of the manual. It provides a lower level way of accessing FDnames than regular MTS commands like $edit or $copy.

Once *afd* is activated, lines typed at the terminal which do not start with a $ are interpreted as data lines which are written to *afd*. Assuming the defaults of line files and auto numbering off, if you type a line at the command prompt starting with a number it will be added to *afd* using that line number rather than being interpreted as a MTS command.

An example using a regular file will make this clearer:

$get -gettest
# Ready.
10welcome
20MTS
15to
release
# "*AFD*": ... AFD released.
$list -gettest
 
      10     welcome
      15     to
      20     MTS

Further information

See MTS Volume 1: System Edition for a write-up of $get and *afd*. The D6.0A FAQ also has some examples of using $get.

Making your own tapes

Sun, 21 Sep 2014 16:43:46 +0000

^{A 9 track magnetic tape, from the Museum of Obsolete Media}

In this post we’ll look at how to create your own emulated tapes to transfer data between MTS and your host operating system. For an introduction to tapes on MTS take a look back at this earlier article.

The `lbltp` program

You will need to install the lbltp program on your host OS. This allows reading from and writing to emulated tape files compatible with Hercules.

The version at Bitsavers contains source and executable for Mac and Windows. On Linux, get the latest version from Mike Alexander’s SVN repo and build locally:

$ svn checkout https://svn.msalexander.com/repo/utilities/lbltp/trunk lbltp
$ cd lbltp
$ mkdir build
$ cd build
$ make -f ../Make/makefile
$ sudo cp lbltp /usr/local/bin

Documentation can be found in the Writeup directory. Type lbltp to start the program, give it commands at the Please enter request prompt and type stop to exit.

Set up a spare tape drive

The starter version of D6.0 comes with a number of tape drives defined and loaded with the distribution tapes. You could use these to mount your own tapes but it is easier to set up a new tape drive.

Make sure MTS and Hercules are shut down then edit the Hercules.cfg file. In the tapes section add a line like this:

0C70 3420 * # User tape drive

This defines a 3420 model tape drive at address 0C70 which corresponds to MTS device T920. The * means no tape is loaded when Hercules starts up.

Creating a new tape from MTS

Let’s create a new tape, mount it for writing and use *FS to store a couple of files which we can then read from the host OS.

First you will need to create a blank tape file. You can use the hetinit program that comes with Hercules to do this. Change directory to Tapes and issue the following command from your host OS:

hetinit -d new.aws NEW

This will create a file new.aws with tape volume name NEW.

Next, issue a mount request for this new tape from MTS:

$mount mts:tape1 9tp *t* vol=NEW ring=in

Note the ring=in parameter as we are going to write to the tape. We are using regular labeled tapes so we don’t need the lbltype=vlo parameter used for distribution tapes.

Switch to the Hercules console and issue a devinit command to initialise the tape drive with the file:

devinit 0c70 Tapes/new.aws

Go now to the MTS operator’s console and respond to the mount request:

OK TAPE1 T920

If all goes well your MTS session will respond that the tape was mounted. You can now run *FS to add files to the tape. Note the par=init parameter as this is a new tape:

$run *fs 0=*t* par=init
# Execution begins   11:24:36 
= save alpha
= File 1 "ALPHA(1)" ... has been saved
= save gamma
= File 2 "GAMMA(1)" ... has been saved
= stop
= Do you want *FS to dismount the tapes it used?
? yes
= "*T*": (MTS.:TAPE1) T920 released.
# Execution terminated   11:24:46  T=0.058

Reading the tape from your host OS

You can now use lbltp to open the tape file and extract files to your host OS. Below is a sample session showing how to do this:

ITD Tape Utility version 1.3

Please Enter Request
open new.aws
Open input or output tape?
input

Please Enter Request
list
         Listing for IBM labeled *FS tape NEW 
FS file     1  ALPHA                            blks=1 recs=2 bytes=78
FS file     2  GAMMA                            blks=1 recs=13 bytes=366
Logical End of Tape reached.

Please Enter Request
copy file=1-2
Copying FS file 1 ALPHA to alpha.
   1 blocks 2 records 78 bytes             2 records 80 bytes
Copying FS file 2 GAMMA to gamma.
   1 blocks 13 records 366 bytes             13 records 379 bytes

Please Enter Request
stop

Note that lbltp takes care of EBCDIC to ASCII conversion, but line numbers from MTS are not preserved.

Creating a tape from your host OS

Now let’s try to do it the other way, creating a tape with some files from your host OS and transferring these into MTS.

One problem is that lbltp only supports reading *FS formatted tapes, not writing to them. So we will have to write a regular labeled tape and use lower level tape positioning commands on MTS to extract files.

(I think it should be technically possible to extend lbltp to support writing *FS tapes; could be an interesting project.)

The below lbltp session shows how to create a new tape and add two files. Note that you have to give an explicit filename command before adding each file to the tape.

ITD Tape Utility version 1.3

Please Enter Request
initialize send.aws volume=SEND

Please Enter Request
filename delta

Please Enter Request
copy input=delta output
Copying file delta to send.aws file 1 DELTA.
             3 records 37 bytes   1 blocks 3 records 37 bytes 

Please Enter Request
filename epsilon

Please Enter Request
copy input=epsilon output
Copying file epsilon to send.aws file 2 EPSILON.
             4 records 29 bytes   1 blocks 4 records 29 bytes 

Please Enter Request
stop

Reading the tape from MTS

Now we need to mount the tape on MTS. On the Hercules console (note the ro parameter):

devinit 0c70 Tapes/send.aws ro

From MTS:

$mount mts:tape1 9tp *t* vol=SEND

On the MTS operator’s console:

OK TAPE1 T920

The tape is now mounted on pseudodevice *T*. To get a listing of files, there’s a useful MTS program called *LABELSNIFF we can run, giving the tape pseudodevice as parameter 0:

# run *labelsniff 0=*t*
# Execution begins   10:50:15 


  Tape = *t* User ID REL. 10:50:15 19 Sept 1914

  Tape name=MTS.:TAPE1
  IBM labeled  6250-bpi 9TP Volume=SEND 
  LP=on BLK=on RING=out DTCHK=on RETRY=10

  File                    Block Record  Tapelen  Record 
     # Data set name      count  count   (feet)  format 

     1 DELTA                  1       3    1.10 VBS(32760,32767) 
     2 EPSILON                1       4    1.08 VBS(32760,32767) 
 
  Total tape length = 2.18 feet.
 
  <*><*><*>  End of tape  <*><*><*> 
# Execution terminated   10:50:23  T=0.029

(For those of us who have never used real tapes it’s interesting to visualise files having a length in feet!)

Now to extract the files. For each file we will need to use a $control command to position the tape and then use the MTS $copy command to read from the tape and write to a file. We will also need to create the files we want to write to. For example:

$control *t* posn=epsilon
$create epsilon
$copy *t* epsilon

You don’t have to copy to a file; if you just wanted to display the file you could do $list *t*.

When finished, you will need to release the tape:

$release *t*
# "*T*": (MTS.:TAPE1) T920 released.

Further information

MTS Volume 19 has extensive information on using tapes. I also found the tutorial guide made by the UM Computer Centre Introduction to Magnetic Tapes - Getting It on Tape useful.

There’s a program on MTS called *UNIXTAR that looks like it can read and write tar format files, so one alternative that I have not tested is to create a tar file on the host OS, add this as the single file on a tape and use *UNIXTAR to extract all the files in one step.

Finding MTS components from the driver file

Sun, 14 Sep 2014 05:04:06 +0000

The driver listing file contains details of all MTS components that are available on the distribution tapes. It can be found in the file doc/D6.0-LIST.txt on your host operating system after unzipping the distribution.

Each component has one or more sub-components which represent individual files. For example, 528 is the component for the Algol-W compiler and it has 66 sub-components; 548 is the component for the *FS program and it has 9 sub-components. Individual items are identified as component/sub-component, eg 548/9.

The driver listing has 2 or 3 lines per sub-component giving details like file type, location and size followed by a more detailed description.

Unpacking the file

To make browsing the driver file easier I’ve converted the file to a tab-separated format, one line per sub-component, which you can download here. This can then easily be loaded into a spreadsheet or database for viewing.

The Perl code I wrote to do this can be found at this Github gist - it could be adapted to produce output in a different format if needed.

Example: the `*FS` program

Let’s look at component 548, the *FS program itself, in more detail. The subname field gives a brief description of each file, with a longer write-up in description. type indicates the type of file: the first letter is the class, eg S for source code, O for object files; further letters give more details, so type SA is assembler source code, type SF is Fortran source code etc.

If the sub-component is on the disk already, its filename will be given in the disk_name column; if it has to be restored from tape this will be blank. So for component 548 we can see the Makefile (548/1), compiled program (548/8) and helpfile (548/9) are on the disk already; the other components, which are source or object files, are not.

The tape_6250 and file_6250 show where to find these files in the distribution tape. So for these items they can be found on 6.0T2 files 478-486, and could be restored by mounting the 6.0T2 tape, running *FS and executing the command restore (478) (486).

The location column shows what file names each sub-component had when it was saved to tape; note that *FS does not use this when restoring the file so you will have to sign on to the correct user and rename files to get them to match their original location.

For example, sub-component 548/2 has location W930:FS#SA so you would need to sign on as user W930, restore the file (*FS gave it the name FS.BASE_S002 when I tried this) and then run the MTS command $rename FS.BASE_S002 FS#SA.

Further information

See the file D6.0-NOTES.txt in the MTS distribution documentation for further information on the driver file list format.

Restoring files from tapes

Sun, 31 Aug 2014 05:08:17 +0000

^{From “Introduction to Magnetic Tapes” by the UM Computer Centre, 1986, archived at the Hathi Trust Digital Library}

On the mainframe, tapes were a cheap, high capacity solution to store files that were not always in use. An example from 1993 at UM - a tape costing $7 could store 165MB of data; storing the same amount on disk would cost $168 per month. Tapes are also portable and could be used to exchange data between different computers. The downside was tapes are slow - they had to be mounted manually and as access was sequential it could take several minutes to find a piece of data towards the end of the tape.

Running under Hercules, the main use for tapes is to restore files from the MTS distribution and to transfer files to and from your host OS. Hercules emulates tapes using files on your local disk in AWS format.

In this post we’ll look at how to mount a MTS distribution tape and restore a file. First off we need to know some of the terminology used to describe tapes and tape operations.

Background and terminology

Tape formats and parameters

Tapes come with a number of different lengths, tracks and densities, which together determine their size. Typically MTS at the time of the D6 release was using 9 track tapes with 6250 BPI density. length varying from 100 to 2400 feet. On Hercules these parameters are not important as the tape capacity can be as much as the free disk space you have available, but you will find references to them if you read the original documentation.

Tapes had a snap-in ring which if set in would allow writing to the tape; you will see references to RING IN and RING OUT on MTS tape commands and prompts which translates to read/write and read/only access. It is possible to specify an emulated tape drive as read only on Hercules, which means the tape can only be mounted as RING OUT.

Typically a tape would have a physical label (ie written on the tape case) and a rack ID (used to find the tape from storage). These are not present on Hercules. The volume label, which is written electronically in the header of the tape data, is available on Hercules.

At a low level, blocks of data can be written to tape in various formats depending on the type of data and what other non-MTS system would use the tape. We will restrict ourselves for now to looking at tapes written in a format understandable by *FS, the file save and restore program on MTS.

Tape drives and the mounting process

A mainframe has multiple tape drives. When a user requests a tape, an operator would locate the tape (eg from a rack) and load it into a suitable free drive. The operator would then indicate to the user’s program which device the tape was mounted on, or if any other condition (no free drives, tape could not be found etc). If mounted the user’s program would then read from the assigned tape device.

After the user’s program had finished with the tape it would release it, which would signal to the operator that the tape could be dismounted and stored back in the rack, or physically delivered to the user.

Emulated tapes on Hercules

Tape drives and the tapes initially loaded on them are defined in the Hercules configuration file hercules.cfg. For example, here are two drives from the default config:

	0184   3420   Tapes/d6.0t1.aws   ro  # T904, *FS D6.0 distribution tapes #1
	0185   3420   Tapes/d6.0t2.aws   ro  # T905,  " #2

The first line shows that a model 3420 emulated tape drive is at address 0184. Its name will be T904 on MTS. The initial tape loaded on the drive is Tapes/d6.0t1.aws which is mounted read only (ring out).

It is possible to get Hercules to change the tape loaded in a drive by using the devinit command on the Hercules console, which we will look at in a future post.

Mounting a tape - user request

So after that introduction let’s mount a tape and extract a file. The tape we want is the D6.0T1 tape. From the MTS command line enter the following:

$MOUNT MTS:TAPE1 9TP *T* LBLTYPE=VLO VOL=6.0T1

Let’s go through the parameters:

MTS:TAPE1 is a dummy name; on a real mainframe you would enter the rack ID where the tape would be found. You can use TAPE1 to TAPE9 here if you are mounting multiple tapes at the same time.
9TP is the type of tape drive, which will always be 9 track.
*T* is the pseudodevice that you want the tape to be made available on. You can use any name not already defined here (eg *MYTAPE* would be OK but not *SOURCE*).
LBLTYPE=VLO indicates the format of the tape, which is Volume Label Only for this particular tape.
VOL=6.0T1 is the electronic volume label.

Note that you don’t specify what tape drive will be used; this is the job of the operator to provide in the next step.

After entering this command MTS will print your tape request and change the prompt to % to indicate it is waiting for the tape to be mounted by the operator.

# MTS:TAPE1 9TP *T* LBLTYPE=VLO VOL=6.0T1
%

Mounting a tape - operator action

Switch over to the MTS operator’s console. You will see a new prompt similar to the below:

 00040 MTS ST01:  T (1 9TP) (TAPE1) on 9TP, (6250), ring OUT, '' ***************

Respond as follows

OK TAPE1 T904

This tells MTS that the request for TAPE1 can be fulfilled by using device T904, which from the Hercules config file you know is the correct device for the 6.0T1 tape. You can also type other commands to reject or defer the request - see the Operator’s Manual for more detail.

Once you type the OK response, MTS will check that there is a tape in the drive, the ring is set correctly and the volume label matches the request. If all checks out you will see the following:

00040 MTS Mount check OK.Mount (TAPE1) TAPE1 on T904 Ring Out
00040 MTS ST01, TAPE1:Accepted on T904

If instead you got a ’not ready’ message then you will need to bring the tape device back online - from the Hercules config file this is device 0184 so on the Hercules console type devinit 0184.

Once the tape is mounted, back on the user MTS session you will see

*T* (TAPE1): Mounted on T904

Now pseudodevice *T* can be used to access the tape’s contents.

Using `*FS`

On the user session, start the *FS program with *T* as its parameter:

$RUN *fs 0=*T*

The prompt will change to =. You can use help to see the commands available. Let’s look for the ASMG user guide: type

= list ASMG.USER?

The response you will get is:

= FS list for tape MTS.:TAPE1 on T904. Density= 6250 Volume=6.0T1 Lbltype=VLO O


= File D             File Name           Ver# Type  Lrecl  Size   Dev    Date a
=
=  230   ASMG.USER'S_GUIDE.P.093            1 Seq      80    41  Page  JULY 03,

So this is file 230 on the tape. To restore a copy to your current user’s file area, type restore (230) (the brackets are needed) and then stop to execute the restore. When done, *FS will ask you if you want to release (unmount) the tape and will then return to the command line prompt.

= File 230 "ASMG.USER'S_GUIDE.P.093(1)" ... has been restored to ASMG.USER093

You can now print or view the file ASMG.USER093.

Unmounting

If you didn’t release the tape in the *FS session, you can do it from the command line by typing $release *T*. A message will be printed on the operator’s console telling you to remove the tape, which you can ignore.

If you want to mount the same tape again, remember to devinit the device from the Hercules console.

Further information

Commands to mount and use tapes can be found using online help (eg HELP MOUNT) or MTS volume 1.

A more detailed look at how tapes are formatted and used can be found in MTS volume 19.

Commands that the operator can use to accept or reject tape mount requests can be found in the Operator’s Manual.

In future posts I will look at how to find and restore files from the distribution tapes in more detail and how to create your own tapes.

Updated 14-Apr-2015: corrected LBLTYPE note

Submitting batch jobs from the reader

Sun, 24 Aug 2014 03:55:11 +0000

^{The IBM 29 card punch, from a film at the Deep Blue collection at the University of Michigan}

In the previous post we looked at submitting batch jobs from the terminal; this time we will submit jobs from outside MTS using the emulated card reader. Using this method you can create jobs using a text editor on your host OS, submit to MTS and collect output without having to sign on interactively.

On Hercules, the emulated card reader accepts ASCII format text files, with each line representing one card. On MTS, the HASP batch scheduler reads cards from the reader and sets up batch jobs, with any output going to the printer.

Compared to submitting jobs from the terminal, you will need two additional items: a S8 card and full sign-on details.

S8 cards

For the first card in your job you will need a S8 card. This acts a header for batch jobs submitted to the reader and includes the number that will be used as the batch sequence ID.

According to the FAQ, these were handed out to users at the computer centre in UM for users to attach to their jobs and were then returned as a receipt when the job had finished.

You can create S8 cards by running the operator job *RCP and directing output to the card punch.

Switch to the MTS operator’s console. Enter $DRAIN PCH1 to get HASP to let go of the punch then MTS *RCP. Enter >PCH1, NO and two six digit numbers to select the range of IDs. Then $START PCH1 to give control of the punch back to HASP. The console should look like the below.

$DRAIN PCH1
$*OK
MTS *RCP
00053..MTS *RCP
00053 MTS  MTS RECEIPT CARD PROGRAM 
00053 MTS  ENTER THE NAME OF THE PUNCH
>PCH1
00053 MTS  ENTER YES IF RECEIPT CARDS WANTED, NO IF ONLY DECK CARDS WANTED
NO
00053 MTS  ENTER SIX DIGIT STARTING RECEIPT NUMBER
100000
00053 MTS  ENTER SIX DIGIT ENDING RECEIPT NUMBER
100100
00053 MTS  ALL RECEIPT CARDS HAVE BEEN PUNCHED
$START PCH1

If you take a look at the punch file Units/PCH1.txt, the first three lines should look like the below:

\                 100000               DECK                             100000 .
\                 100001               DECK                             100001 .
\                 100002               DECK                             100002 .

You can now cut lines from this file and paste into your batch job file at the top. It is possible to reuse cards/IDs once the job using an ID has finished, but it’s best to use a new S8 card for each job.

Sign-on details

For interactive submission you could use $signon * as MTS knew what user ID submitted the request. For card reader submission you need to supply the user name, eg $signon st01, and in the next card supply the password.

Putting it together

So as an example let’s do the simple calculation job again.

Create a file on your host operating system. For the first line, cut the first S8 card from the punch file. For the second and third line provide the sign-on ID and password. The rest of the job is as before.

The file should look something like this:

\                 100000               DECK                             100000 .
$signon st01
st01
$calc
a = 10  
b = 13  
c = 7  
n = (a * b) / c  
list  
$endfile
$signoff

Submitting the job and collecting output

Copy your batch file to Units/RDR.txt, overwriting the current contents.

Switch to the Hercules operator’s console and type devinit c to bring the reader online.

HASP will read the job, execute it and print output to the printer file. Look in Units/PTR2.txt and you will see output like the below, surrounded by the usual header and footer:

$SIGNON ST01
No Charges
Last signon was at 21:55:55, Sun Aug 23/14
User ST01 signed on at 22:38:11, Sun Aug 23/14



$calc
A        = 10
B        = 13
C        = 7
N        = 18.5714285714285694
$signoff

Copying files into MTS

You can use this batch job submission technique to send files into MTS. Say you want to send this file

Hello world
Welcome to MTS!

to the file DELTA owned by ST01. You could create a batch job similar to the below:

\                 100001               DECK                             100001 .
$signon ST01
ST01
$create delta
$copy *source* delta
Hello world
Welcome to MTS!
$endfile
$signoff

Further information

See the Operator’s manual for details of the *RCP job.

To see how physical cards were punched by users before submitting them to MTS take a look at the film Basic Operation of the IBM 29 Card Punch from 1967 at UM.

Submitting batch jobs from the terminal

Sun, 17 Aug 2014 03:02:50 +0000

On a mainframe, batch jobs allowed users to execute long running jobs without tying up their terminal - and reduce the cost of running jobs by scheduling them to quieter parts of the day.

On Hercules, where you can run a number of terminals and don’t get charged for your work, the benefits are less obvious - but it is interesting to learn how batch jobs were processed and it also opens up the possibility of submitting jobs from your host OS to MTS without having to log on.

Creating a job

For a simple example we’ll use the $calc command to do some calculations.

Create a file - any name will work but we’ll use calc.run and edit it, inserting the below contents:

$signon *
$calc
a = 10
b = 13
c = 7
n = (a * b) / c
list
$endfile
$signoff

The first line should be a $signon command. As you are submitting from the terminal and are already logged in you don’t need to provide username or password and the * means run under the current user. On this line you could also set options to limit the amount of resources used or control printing.

After that come the commands to execute, which are processed just like they were entered from the keyboard. So here we start the $calc command then provide it a number of commands up to the $endfile which exits $calc.

The last line of the file should be $signoff to show the job has ended.

Submitting to HASP

To submit the job, you copy the command file to the *BATCH* pseudodevice:

$copy calc.run *batch*

HASP will receive the contents of the file and schedule the job, giving you a job number eg

> *BATCH* assigned receipt number 600026
  *BATCH* 600026 released.

At this point, the command file is no longer needed as HASP will make a copy.

Getting the results

On a single user system you should be able to get the results immediately. Check the printer file Units/PTR2.txt and you will see the output after the usual header page:

$SIGNON ST01
No Charges
Last signon was at 10:50:32, Thu Aug 13/14
User ST01 signed on at 15:19:43, Sat Aug 16/14



$calc
A        = 10
B        = 13
C        = 7
N        = 18.5714285714285694
$signoff

Further information

The chapter called “Batch use of MTS” in MTS Volume 1 gives an overview of running batch jobs, including setting extra parameters and controlling the queue.

In a future post I will look at submitting jobs using the card reader.

Editing files

Sun, 10 Aug 2014 04:00:52 +0000

So far we’ve been using $COPY *SOURCE* file to create text files - for more complex editing we need to get to grips with the MTS editor. This post will give a quick introduction focusing on the visual editing mode.

Coming from a Unix or Windows background, the MTS editor will use an unfamiliar set of keys but once you learn them it is easy to use. There are some interesting features such as an integrated, editable copy and paste/command execution area, and the ability to remember locations and jump to them quickly.

Starting up and exiting

Enter $EDIT gamma to start editing file gamma. Remember you have to $CREATE the file in MTS if it does not exist already.

Initially you will be in command mode with a : prompt; type VISUAL or just V to enter visual mode.

Hit PA2 to get out of visual mode and PA2 again to quit the editor and get back to the MTS command line.

The editor makes heavy use of the PF function keys so check with your 3270 terminal emulator documentation on how to access these. Often they are bound to PC function keys, ie PF1 can be issued by pressing F1.

Screen arrangement

On entering visual mode for a new file the screen will look like this:

The bottom line shows a ruler and the last but one line shows the cost of the edit session (not applicable on Hercules of course) and the work field, used to hold copied text and enter commands. The rest of the screen is used to view and edit text.

Entering text

You can start typing text immediately. The cursor keys allow you to move back and forth in the line; the delete and backspace keys work as expected also.

Insert will switch to overwrite mode; on my emulator at least I find I need to press Enter to switch it off.

Press Newline to start a new line; the line number will not be displayed immediately. Press Enter to ask the editor to refresh the screen and set the line number.

Tab will move to the start of the next line; Backtab will move to the start of the current line if in the middle of a line, else the previous line.

If you move the cursor down a number of lines and start typing then press Enter, the line number given will reflect the gap and the text will move up so no gap is displayed.

Scrolling around

For documents larger than one screen, press PF1 to scroll up one page and PF4 to scroll down. PF7 will scroll down one line. HOME will move to the top of the window.

Moving the cursor up from the top of the screen or down from the bottom will not scroll; instead the cursor will wrap around to the bottom or top.

The editor can remember your location in the file and return to it after you have moved. To set memory location 1, press PF3 two times in a row. After you have moved, press PF3 once to return to that location. PF6 and PF9 can be used similarly to set and return to memory locations 2 and 3. Initially the memory locations are defined as:

Memory 1 - first line of file
Memory 2 - line 1000 of file
Memory 3 - last line of file

Copy and paste and the work field

A form of copy and paste is done using the work field at the bottom of the screen. Press PF2 to copy from the cursor to the end of the line to the work field. Press PF5 to paste the contents of the work field at the cursor position.

You can jump to the work area with SysReq and edit what’s there to control what is pasted..

You can also enter line-orientated commands in the work area and execute them with PF8.

Note that instead of using this you can use the native functions provided by your host operating system to copy and paste.

Insert and delete lines

EraseEOF will delete the rest of the line or the whole line if the cursor is at the start of a line.

PF10 will insert a new line below the current line. Repeatedly pressing it will insert 2x the number of blank lines each time, so press twice for two lines, three times for four lines, four times for eight lines and so on.

There is no predefined key to split a line into two. To do this, type VSPLIT into the work area. Move the cursor back to the place you want to split and press PF8 to execute the split command.

Line numbering

The editor will handle line numbers. If you have line 1 and line 2 entered but want to add a line in between (by pressing PF10) it will use line number 1.5. Remember you can use the $RENUMBER command back at the MTS command prompt to turn an uneven sequence of lines into 1, 2, 3 etc.

Line extensions

When you reach the right end of the screen while typing a line the editor will not let you continue. Press PF11 to extend the line onto the next row of the screen and you can keep typing.

Saving and undo

There is no explicit save command - the file is saved back to disk when the screen is refreshed (eg on scrolling or with Enter) or when you exit visual mode. Because of this it is a good idea to make a backup of important files before you start editing them.

It is possible to undo all changes done in the current editing session. Switch back to command line mode (with PA2) and type UNDO at the : prompt.

Summary of PF keys

PF1 Scroll up ten lines
PF2 Append rest of line to work area
PF3 Memory 1
PF4 Scroll down ten lines
PF5 Insert contents of work area in current line
PF6 Memory 2
PF7 Scroll up one line
PF8 Executes contents of work area as command
PF9 Memory 3
PF10 Insert line
PF11 Extend current line
PF12 Move to the previous position

Command mode

The editor also contains a rich command mode which I will not go into in depth here. Some simple examples:

: PRINT
Print the current line

: +1
Move forwards one line

: ALTER 'aa'bb'
Find the first occurrence on the current line of aa and replace with bb

: ALTER@ALL 'cc'dd'
Replace all occurrences of cc with dd on the current line

: ALTER@ALL /FILE 'ee'ff'
Replace all occurrences of ee with ff in the whole file~

More information

See MTS Volume 18, The MTS File Editor for complete documentation; also look at the online help by typing HELP from the editor command mode prompt.

Extracting files using the card punch

Tue, 05 Aug 2014 12:36:49 +0000

^{FortranCardPROJ039.agr by Arnold Reinhold. Licensed under CC BY-SA 2.5 via Wikimedia Commons}

Punched cards were a way to get code and data into and out of the IBM mainframe. Under Hercules you can use the emulated card punch as a way to get ASCII format text files out of the system.

Setup

As per printing in MTS you will need HASP up and running to use the card punch.

Submitting the request

To send files to the card punch, direct them the *PUNCH* pseudodevice in the same was as you direct print files to *PRINT*. Use $LIST to include line numbers and $COPY to send file as is.

Note that there is a maximum of 80 characters per line and carriage control characters will not format the output.

For example, say you have a file ALPHA with two lines:

Hello world!
Welcome to MTS.

To send this file to the punch do:

# copy alpha *punch*
> *PUNCH* assigned receipt number 600020
  *PUNCH* 600020 released, 3 cards, croute=CNTR.

As for print jobs, the system will assign a job number, here 60020. The punch prints one card per line with an extra card first as a header.

Collecting output

From your host computer, look at the file Units/PCH1.txt.

 COM  -0-     &&  &&   jjjaaa              -0-     &&  &&   jjjaaa      M 600020
Hello world!
Welcome to MTS.

The first line is the header card, showing the job number. The rest of the file is the same as the file you sent from MTS.

Clearing the card punch

After you submit a job, the card punch will go offline and will not punch any further jobs until you clear it. On the mainframe this was presumably to allow the operator to separate different card outputs and arrange delivery.

On the operator’s console you can see that the punch needs attention as the letters PCH1 will be displayed in bold on the third line.

To clear the punch, go to the Hercules console and type devinit 000d. This will bring the punch back online and the next job will be punched - replacing the contents of host file PCH1.txt.

Further information

Although you could use the card reader to move data from the outside world into the MTS system, the default set up is that HASP uses it to receive batch jobs. This will be covered in a future post.

Another way to get data into and out of the system is using emulated tapes which we will also look at later.

Printing in MTS

Sun, 27 Jul 2014 04:38:56 +0000

MTS has a rich set of options for handling printed output, suitable for a mainframe with many users sharing multiple printers.

Running under Hercules, the printer is emulated by writing ASCII text output to a file. Once you issue a print job within MTS you can view the file from your host operating system. This is a useful way to extract text files from MTS.

Setup

In order to get printing working you need the print device to the configured correctly (see part 1) and HASP needs to be running (see part 2). Once this is done you can direct output to the *PRINT* pseudodevice and HASP will spool this for printing. With the default D6.0A configuration this will print to the file Units/PTR2.txt.

If you have problems with this see the D6.0A FAQ question 21 for an alternative way to print.

Printing text files

The LIST command takes a second argument to determine where to send the output. By specifying *PRINT* you can send this to the print queue.

LIST alpha *PRINT*

MTS will respond with the receipt number for the print job, for example:

> *PRINT* assigned receipt number 600011
> *PRINT* 600011 released, 3 pages, route=CNTR.

On a real shared mainframe it may take time for your job to reach the front of the queue and complete printing (although mainframe line printers were very fast), but on Hercules your output will be available almost immediately.

Switch back to your host operating system and look at the printer file - you will see output like this.

There is a header page in large type showing the username and print receipt number first, then the actual output (2 lines here) and finally a footer page with a summary of the job.

Carriage control

Some MTS files have carriage control instructions: these are characters in the first column of each line telling the output device driver how to format the file, eg overprint or centre line.

For these files you need to use $COPY to send the file to the printer (or screen).

For example, let’s look at the first ten lines of the *CCMEMOS file. If we use $list *ccmemos(1,10) *print* we get the below output; note the carriage control characters like 1, - and 0 in the first column after the line number.

Listing of *CCMEMOS(1,10) at 23:08:07 on JUL 26, 1914 for CCid=REL. on MT       
                                           Page    1

     1     1
     2     -
     3                                      *CCMEMOS
     4     0                               April 1988
     5     0         Current Computing Center Memos are available for checkout o
r
     6          in filing cabinets at all Campus Computing Sites.
     7     0         The Computing Center's Documentation Support Staff (313-763
-
     8          7624) or $MESS send to CC_Doc_Support_Staff, will mail  CC  Memo
s
     9          to  individual  users  who  cannot  pick  up copies at one of th
e
    10          public stations, for example, those who live out-of-town. We wil

If instead we use the command $copy *ccmemos(1,10) *print* we get this formatted output.

                                *CCMEMOS

                               April 1988

         Current Computing Center Memos are available for checkout or
    in filing cabinets at all Campus Computing Sites.

         The Computing Center's Documentation Support Staff (313-763-
    7624) or $MESS send to CC_Doc_Support_Staff, will mail  CC  Memos
    to  individual  users  who  cannot  pick  up copies at one of the
    public stations, for example, those who live out-of-town. We will

Print options

MTS has a large number of options to adjust how print output is processed. Many of these are no longer applicable (eg which physical printer to send it to, where the operators should deliver the hard copy). Look at the online help for SET to learn more.

Text formatters

MTS comes with a number of formatters that will take a marked up file and return output with carriage control.

FORMAT
TEXT360
TEXTFORM
Donald Knuth’s TeX (appears available but not installed on D6.0A

I may come back to these in a future post.

Further information

As always, MTS Volume 1 has a good introduction to getting printed output.

MTS Volume 15 has more information on TEXT360 and FORMAT.

Pseudodevices and redirection

Sat, 19 Jul 2014 05:06:00 +0000

As we saw in working with files it is usually possible to give a pseudodevice name such as *SOURCE* instead of a filename. This post will go over what pseudodevices are available and also how redirection of command input/output works.

Pseudodevices

The following pseudodevices come as standard on the D6.0 distribution:

*MSOURCE* is the master source of input, either the keyboard for interactive sessions or the card reader for batch. It cannot be redefined.
*MSINK* is the master output destination, either the screen for interactive sessions or the printer for batch. It cannot be redefined either.
*SOURCE* is the current source of input, initially *MSOURCE, and can be redefined.
Similarly *SINK* is the current output destination, initially *MSINK, and can be redefined.
*DUMMY* is the empty device, similar to /dev/null/ on Unix.
*PUNCH* is the card punch device - on Hercules this is emulated by writing to a file. If output is sent to *PUNCH* during an interactive session, a new batch job will be set up to do this.
*PRINT* is the print device. Again on Hercules this is emulated by writing to a file.
Output to *BATCH* creates a new batch job with the data sent used as the commands to execute.
*IMPORT* and *EXPORT* were used for BITNET connections and are not available on Hercules.
*TAPE1* to *TAPE9* are used as logical device names when mounting a tape on the emulated system.

You can also create your own pseudodevices using the MTS $MOUNT and $CREATE commands.

Redirection using `$SOURCE` and `$SINK`

You can use the MTS commands $SOURCE and $SINK to change the default input and output from *MSOURCE* and *MSINK*. In the below example I redirect output to the temporary file -sinkfile and then run $FILESTATUS. The output of the command is stored there and not displayed on screen. Finally I run $SINK PREVIOUS to restore the output to *MSINK*.

 # sink -sinkfile
 # filestatus
 # sink previous
 # list -sinkfile
  
        1      filestatus
        2      ALPHA
        3      BETA
        4      sink previous

Logging input/output with `$LOG`

The MTS command $LOG will create a copy of input/output.

# log -logfile
# filestatus alp?
  ALPHA
# log off
  Logging of *MSINK* on -LOGFILE terminated.

# copy -logfile


> $Log Output: REL., Job#=40, Host=MT, 22:16:47 Sun Jun 28/14
> #filestatus alpha
>  ALPHA
> #log off

The $DISPLAY LOGSTATUS command can be used to show what logging is currently in effect.

Logical I/O units

Logical I/O units provide a way for a program to access files without having to specify them in advance. For example, a program may read from logical I/O unit SCARDS which you could define to be a file called ALPHA using SCARDS=ALPHA.

There is a common set of I/O units defined for each program, such as SCARDS and also a free set of I/O units numbered 0-99. The common set of I/O units and their defaults are:

SCARDS is used for input and defaults to *SOURCE*.
SPRINT is used for printed output and defaults to *PRINT*.
SPUNCH is used for output and defaults to *PUNCH*.
SERCOM and GUSER default to *MSOURCE* and *MSINK*.

The example below shows the *SORT command being run with input coming from the file ALPHA and output going to *SINK*, ie the screen. The PAR= part of the command line is the parameters for the sort rather than an I/O device; here CH,A means sort by characters ascending,

# list alpha
 
       1     Line B
       2     Line C
       3     Line A
# run *sort scards=alpha spunch=*sink* par=sort=ch,a
# Execution begins   22:41:56 
  Line A
  Line B
  Line C
  Statistics:  3 input/ 0* intermediate files
# Execution terminated   22:41:56  T=0.012

Further information

See MTS Volume 1 or the online help topics such as Pseudodevices and LOG.

A tour of MTS commands

Thu, 03 Jul 2014 12:43:20 +0000

Once how you’ve learnt how to work with files in MTS it’s easy to use the built in MTS commands - there are less than 50 commands and they follow the same basic syntax.

This post will give a quick tour of the commands available in MTS. I’ve grouped them by topic and provided a very brief summary for each.

As always, you can optionally start commands with $, commands can be abbreviated, eg FILESTATUS to FI, and there are some command synonyms shown with / below, such as HELP/EXPLAIN.

General commands

COMMENT - ignored line, can also use *
DISPLAY - show parameters and settings
HELP/EXPLAIN - interactive help system
MTS - return to MTS command mode from another program
SET - set MTS global options

SET and DISPLAY respectively set and show a large number of different settings such as printer settings, passwords, how MTS displays help etc.

File commands

COPY - copy lines to files
CREATE - create a new file
DESTROY - remove a file
DUPLICATE - create a duplicate of a file, making a new file if needed
EDIT - edit a file
EMPTY - remove contents of a file or set of files
FILEMENU - interactive selection of files
FILESTATUS - view information about files
LIST - display files
LOCK - lock a file
LOCKSTATUS - display status of locks on files
PERMIT - grant access to files
RENAME - rename a file or set of files
RENUMBER - renumber a line file
TRUNCATE - remove unused space at end of file
UNLOCK - unlock a file

A quick illustration of the difference between COPY and DUPLICATE:

# create x
  File "X" has been created.
# copy *source* x
> Hello world
> Welcome to MTS
> Goodbye!
> $endfile
# list x
 
       1     Hello world
       2     Welcome to MTS
       3     Goodbye!
# create y
  File "Y" has been created.
# copy x(2,3) y
# list y
 
       1     Welcome to MTS
       2     Goodbye!
# duplicate x z
  File "X" has been duplicated as "Z"; size=1 page; access=Unlim Owner,
   None Others
# list z
 
       1     Hello world
       2     Welcome to MTS
       3     Goodbye!

EMPTY effectively deletes a file and then recreates it with no contents. TRUNCATE will remove space allocated to the file but not used - handy for when disk usage was paid for but less so on an emulated system.

Sessions

LOG - log session to a file
SIGNOFF - log out of the system
SIGNON - log into the system

Run programs

RERUN - reissue the previous RUN command, optionally changing parameters
RUN - run a program
SINK - send output to a file/device
SOURCE - take input from a file/device

Devices and queues

CONTROL - operations on files and devices, eg rewind a tape
CANCEL - stop batch or print jobs
MOUNT - mount tapes
RELEASE - stop using a pseudodevice like tape

System information

SYSTEMSTATUS - show system status, eg tasks or queues

Utilities

CALC - desktop calculator

Programming

ALTER/MODIFY - change contents of a register or shared memory
DEBUG - load a program and enter debug command mode
DUMP - print out register and CPU information
IF - test a condition, usually for use in a batch file
LOAD - load a program into memory but don’t execute it yet
MAKE - keep interrelated files in an consistent state
RESTART/START - restart a program, eg after an error
SDS - transfer control to debug mode
UNLOAD - remove a previously loaded program from memory

Other commands of less use for Hercules users

ACCOUNTING - view resources used and charges
FSMESSAGE - full screen message/email system
FTP - file transfer protocol
MESSAGE - line driven email system
NET - create a network connection

Networking on MTS needed special hardware, so the messaging and network system commands will not be of much use.

Further information

There is online help for each command which you can access directly eg HELP CALC. Full documentation on how to use the commands and what command line parameters are available is available in MTS Volume 1.

In future posts I will go into more detail on some of the more complex or interesting commands.

Working with files

Sun, 29 Jun 2014 02:53:22 +0000

Working with files in MTS can seem quite different compared to other systems. There are features missing that are considered as standard today - directories, automatic creation of new files - but there are also features in MTS that are more powerful than Unix or Windows.

For example, the single command

$copy A(2,10,2)+B(*l)@bkwd C

copies the even numbered lines from 2-10 from A together with all lines from B in reverse order and stores in C. These operators apply to the file, not the command, so can be used on any MTS command line where they make sense.

Types of files

Permanent files need to be created explicitly. Maximum name length is 12 characters and as in Unix a file extension is entirely optional. Permanent files are private to each user unless access is explicitly granted to another user. If access is granted you can use the notation user:file to refer to the file.
Temporary files must start with - and names must be 8 characters or less. These do not need to be explicitly created but are automatically destroyed by the system when you log out or a batch job that creates them finishes.
Public files must begin with a * and their names must be 16 characters or less. These are generally system wide programs or libraries.
It’s also possible to refer to a pseudodevice instead of a file. These start and end with * - an example was seen in the up and running guide, copy *source* file, which copies input from the keyboard to a file.

The MTS documentation refers to FDnames - this means either a filename or a pseudodevice name. (Update: as Jeff notes in his comment below, FDnames also include devices and other modifiers such as line number ranges.)

Line files

By default files in MTS are line orientated - an individual line can be accessed directly rather than having to read from the start of the file. Each line can be up to 32k long. Line numbers can be negative and can contain up to three digits after the decimal point; the range allowed is -2147483.648 to 2147483.647.

You can specify part of a file by using (start, end, increment) after the file name, where each component is optional. You can use *f to refer to the first line in the file and *l for the last line. Some examples:

A(5,10) - all lines between 5 and 10 inclusive from A
A(5) - all lines from 5 onwards from A
A(*f, 5) all lines from start of file to line 5 inclusive
A(1,10,2) - lines 1, 3, 5, 7 and 9 from A

File options

You can add extra options while processing files by using operators starting with @. Some useful options:

@uc converts the file to upper-case
@trim removes trailing spaces
@bkwd processes the file in reverse order

Concatenation

You can explicitly concatenate two or more files using the + operator, eg copy a+b c.

There is also an implicit concatenation similar to the way the C language handles #include preprocessor directives, but working on all types of file.

This operation depends on the contents of the file. If a file contains a line such as $continue with b then the contents of b are effectively inserted at that point and the rest of the current file is ignored. A line such as $continue with b return will include all of file b at that point and then return to processing the rest of the current file.

Using the 3270 terminal

Wed, 25 Jun 2014 13:06:20 +0000

The 3270 terminal operates a little differently from command line interfaces you may be used to on Unix or Windows. This article will go over the basics of using the 3270 (via an emulator) and how the device is supported in MTS.

Line mode

One of the most important differences is that normally the terminal operates in line mode - the host system will not receive any input until you send the line by pressing Enter.

A very small number of programs on MTS support binary mode, where each key is processed as it is pressed - an example is the editor in visual mode. (Update: see Jeff Ogden’s comment below for a more precise description of how the terminal interacts with the operating system.)

Special keys

As well as the regular alphanumerical keys the 3270 has a number of special keys used by MTS. On an emulated terminal there is normally a way to bring up a keypad with these keys - above is the keypad on the x3270 emulator. Depending on the emulator there are also keyboard shortcuts, eg Alt-C invokes Clear on x3270.

PA1 sends an attention interrupt that will normally make a program stop what it is doing, similar to Ctrl-C on Unix/DOS.
PA2 sends an end of file or cancel signal, similar to Ctrl-D on Unix and Ctrl-Z on DOS.
Clear will refresh the screen. This is especially useful when you disconnect a terminal session then reconnect.
The PF keys act as soft function keys

Device Commands

You can send special device commands to the display driver. These can normally be entered at any time, not just at the # prompt. Device commands all start with a % and can be abbreviated like MTS commands. Note that device commands will not appear in the terminal history after you press Enter.

%? will display the current terminal settings with output similar to the below.

    Roll mode   Rate=5   Duplex=on    Width=078   Timeout=off
    Dcc="%"   Keyboard=lc    Hex=off "'"   Buffer=04    Tabs=off "?"    


    PA1 = attention interrupt             PA2 (CNCL) = end of file        
    CLEAR = refresh screen                SYS REQ = pause / continue      

 PF1 =%Wb=*                PF2 =$Copy *msource*@sp * PF3 =%?              
 PF4 =%Wf=*                PF5 =%Mode=page           PF6 =%Enter          
 PF7 =%Wf                  PF8 =%Mode=line           PF9 =%Mode=roll      
 PF10=%Wl                  PF11=%Wl=60               PF12=%Wr=60          
 PF13=%Wb=*                PF14=$Copy *msource*@sp * PF15=%?              
 PF16=%Wf=*                PF17=%Mode=page           PF18=%Enter          
 PF19=%Wf                  PF20=%Mode=line           PF21=%Mode=roll      
 PF22=%Wl                  PF23=%Wl=60               PF24=%Wr=60

Function keys

The output of %? will list the current function keys. You can redefine these with %PFn cmd, so for example if you wanted PF2 to display file information using the $filestatus command you could enter

%pf2 $filestatus

Note that you do not need to press Enter after using a function key.

Scrolling

The mode determines how the screen will display output when there is more than one screen of text. Available modes area:

%roll where the screen will scroll up slowly when the bottom of the page is reached. This is the default mode.
%line is similar to roll but the screen will be cleared, previous output moved up and further output starts from the middle.
%fast where the whole output is displayed quickly with no scrolling or pausing.
%page where a page of output is displayed at a time. To move to the next page you press the SysReq or Attn key - however I have not got those keys to work, at least on x3270; instead I redefined PF3 to act as the pause/continue key using %pf3 %pause.

You can adjust the rate of scrolling with %rate N where N is a number between 1 (slowest) and 9 (fastest), default being 5.

You can scroll the display backwards and forwards using %wb and %wf; these are conveniently bound to PF1 and PF4.

Other useful commands

%activity will display the current task’s status and resource utilisation.
%grab will start a second command session using the same terminal. You can then switch between the two sessions by using %flip.
%quit will force a disconnect - useful if your session has crashed.
%reset will return all device settings you have changed back to their defaults.
%timeout off will prevent your terminal from being logged out after 30 minutes of inactivity.

More information

See the 3270 chapter in MTS Volume 4: Terminals and Networks in MTS on the MTS Archive for a full description of how to use the terminal and other device commands.

Note that the operator’s console uses a different set of device commands; see the Operator’s Manual for more details.

Using MTS

Wed, 25 Jun 2014 13:05:55 +0000

Now that you have your MTS system up and running it’s time to look at how to work with MTS as a regular user at the terminal or via batch.

The terminal

Using the 3270 terminal

Files and commands

Input/output

Tapes

Up and running 4 - Shutdown and where to next

Sun, 22 Jun 2014 03:04:10 +0000

After you have finished using MTS you should shut the system down cleanly. The final part of this guide shows how to do this and what to do next.

Shutdown

Switch back to the 3270 operator’s console (the picture below shows this on the right with the Hercules console on the left).

First you need to stop the HASP batch system. Enter $HOLD EX and then $DRAIN SYSTEM to prevent new jobs running and complete those that are in progress. Output should look like the below.

Next, get MTS to shutdown all terminals and operator jobs with SHUTDOWN ALL. This will take a few seconds to run and will print a message when complete. Type /t m to check if any tasks are still running; if there are not then it will report specified jobs not found like the below. If it does report jobs running see question 30 in the distribution FAQ.

Now switch back to the Hercules console and type stopall to stop the emulated CPUs and quit to exit Hercules.

Where to go next

When you want to start MTS again follow the steps in part 2 of this guide.

The FAQ included with D6.0A has answers to many of the questions you will have when first running MTS, such as how to install more software or add a user ID.

The original documentation included with D6.0 is also interesting

D6.0-MTS-DOC.txt gives a high level overview of MTS.
D6.0-LIST.txt has information about extra software and files on the distribution tape. D6.0-LOG.txt.
D6.0-NEWSYS.txt contains instructions on how to set up MTS from scratch - aimed at original mainframe installations but section 13 is also useful for Hercules operation of MTS.
OperatorsManual-MTSD6.0-1988.pdf is the original operator’s manual used at UM - the sections on how to use the operator’s console will be useful and it’s also interesting to learn how it was operated as a production system.
HASPManual-MTSD6.0-1988.pdf describes how to operate the HASP batch scheduling system in more detail.

The MTS Volumes at the MTS Archive are the official documentation for MTS and are well worth a read. Note that some of these post-date the D6.0 distribution so there will be minor differences in operation. The following volumes are especially useful when starting out with MTS:

MTS Volume 1: The Michigan Terminal System
MTS Volume 2: Public File Descriptions
MTS Volume 4: Terminals and Networks in MTS
MTS Volume 18: The MTS File Editor
MTS Volume 19: Magnetic Tapes

The End

I hope this series of posts has sparked your interest in MTS and will lead to you exploring more. In future posts I will look at some tips and tricks in getting MTS to bend to your whim.

If you have any comments or problems getting MTS to work please leave a comment and I will try to help.

Up and running 3 - Using MTS

Fri, 20 Jun 2014 13:25:25 +0000

Once you have booted the system you can now use MTS. This part of the guide will show you how to sign on as a user and the basics of interactive usage of MTS.

Sign on to MTS

Switch to the user 3270 console and enter signon st01. User st01 is one of the regular user IDs set up as part of the distribution.

Enter the password at the next prompt; the password is the same as the user name st01. You can ignore the message about the previous login attempt as this appears to be a side-effect of the distribution..

The distribution comes with a set of regular user IDs, st01 to st09, password the same as the user name, and shared IDs with greater privileges such as mts or acc. For shared IDs you login with the ID eg mts, password aardvarks; the system will then prompt for a secondary sign-on with ID? to which you should enter one of the regular IDs such as st01 and its password at PW?.

Privileged IDs can get direct access to hardware and system files. For this session we do not need this so just sign on as st01 for now.

MTS commands

For this first session, let’s look at some simple commands to put text in a file and display it on the screen.

Some important differences between files on MTS and other systems such as Windows or Linux:

You need to create a regular file explicitly with the $create command before using it.
Files are by default structured as a series of numbered lines rather than containing an arbitrary sequence of characters
There is no concept of directories in MTS. Each user effectively only has a single place to put files. It is possible to grant access to your files so other users can access them.

So first let’s create a file called alpha. At the # prompt enter $create alpha; the output should be as below.

# $create alpha
  File "ALPHA" has been created.

Note that filenames and commands are not case sensitive; you could have also typed $CREATE Alpha. You can also leave off the $ when typing MTS commands

Next, let’s put some text into the file. To do this, rather than using a text editor, we will just take input from the keyboard and copy it to a file. To do this we can use the $copy command with *source* as the first parameter; *source* is a pseudo-device representing the keyboard in interactive sessions.

# $copy *source* alpha
>

Note that the prompt now changes to > to denote that the system is taking keyboard input inside a command. Enter some lines of text and end by typing $endfile which acts a special marker to tell MTS to stop taking input.

> Hello World!
> Welcome to MTS
> $endfile

Now let’s display the file you have created using the $list command. Note that the line numbers are displayed.

# $list alpha
 
       1     Hello World!
       2     Welcome to MTS

To show information about your files, similar to dir on Windows or ls on Unix, use the filestatus command. As this is a lot to type, we can use the facility in MTS that allows you to abbreviate command names - in this case we can type fi instead of filestatus.

# fi alpha
  ALPHA             Type=Line, IdleDays=36525, RPM=0, UseCnt=3, Owner=ST01, 
   Create=Jun17/14, LastRef=Jun17/14, LastCatalog=Jun17/14, 
   LastData=09:38:32 Jun17/14, FullAccess=Unlim Owner, None Others

Typing fi or filestatus without a filename would list all the files under the user ID.

Finally, let’s remove the file using the $destroy command. MTS will prompt for confirmation.

# $destroy alpha
  File "ALPHA" is to be destroyed.  Please confirm:
? yes
  Done.

Your session so far should look similar to the below screenshot.

Getting help

MTS has a comprehensive built-in help system - type $help to access.

Use the numeric options at the bottom of the screen to navigate between pages - so in this case to look at MTS commands you would enter 3.

The 3270 terminal special key PA2 can be used to learn more about the help system itself. If an entry has more than one page you can use the + or - keys (followed by the Enter key) to navigate. Use the 3270 terminal PA1 key to exit.

Running other commands

Apart from the built-in MTS commands, such as $destroy or $copy you can run other programs on the system. Many of these programs are available as public file IDs which start with a *. To run these you use the MTS $run command followed by the program. Below we show a simple heads-or-tails guessing program with the public file name *coinflip.

Signing off

When you’ve finished using MTS type $signoff. MTS will print a summary of the CPU, disk and other resources used during the session before returning to the sign-on screen. Note that when run on a real mainframe there would be a charge for all resources used which would make you careful about what you consumed - but on your own PC everything is free.

Next steps

You can sign on and try more commands; you can also start other 3270 terminals and sign on.

Move on to part 4 of this guide to learn how to shut down MTS safely.

More information

The chapter ‘A Brief Overview of MTS’ in Volume 1 of the MTS documentation on Bitsavers is a good short tour of MTS and using the system.

Up and running 2 - Booting the system

Wed, 18 Jun 2014 12:56:43 +0000

OK, you’ve got the software and files installed in part 1. You can now boot the system for the first time.

Start Hercules and a 3270 console

Go to the d6.0A directory
Start Hercules
The Hercules console should appear and show it has recognised the tapes and disks mentioned in the config file
Start a 3270 terminal emulator and connect to localhost:3270. This will act as the MTS operator’s console. It will display the Hercules logo to show it is connected to Hercules but no operating system is running on the emulator.
The screen should now look something like the below; here I have the Hercules console on the left and the operator’s console on the right.

Boot from the emulated disk

From the Hercules console, issue the command ipl 260. IPL stands for Initial Program Load and will tell the emulator to boot from the disk known as device 260.
If everything is working correctly, a message should appear on the 3270 terminal asking if you want to load the system.

Start the boot process

Switch over to the 3270 operator’s console - all commands from this point on should be entered there rather than the Hercules console unless otherwise specified.
Type yes to the prompt on the 3270 console
A message may appear warning about the time difference since the last boot. Enter ok to accept and continue.
You will be prompted to enter your initials and a reason for booting - you can put anything here.

More messages will appear as the system boots. Eventually it will stop and ask you to check offline devices with this message:

00007 MTS ** Just cancel after you have checked the offline devices.

This is expected as you do not have (or need) all the disk drives on the system specified in the distribution. To cancel, press the PA2 key on the 3270 operator’s console. Where to find this depends on the emulator - on tn3270 text terminals it may be Control-A followed by 2; on x3270 terminals try Alt-2 or use the keypad available by pressing the toolbar button on the top right of the terminal.
If that worked, the following message will appear:

*** Cancelled ***

Wait for the boot process to complete - the final message should be

00019 MTS PEEK initialization complete

Start the batch scheduler and user terminals

On the 3270 operator’s console, type HASP to start the batch scheduler and then MTS *HSP
Start a second 3270 terminal and connect to localhost:3270. This will act as the user terminal.
On the operator console, type MTS *LAS to activate the terminal.
The screen should now look like the below; I have the user terminal to the left of the operator console.
On the operator console, type $RELEASE EX to allow the batch scheduler to start jobs.

Ready for use

Congratulations, you now have a running MTS system! Move on to the next section for a brief tour of how to use MTS.

More information

Take a look at the file README-D6.0A.txt in the D6.0A distribution if you have problems during the boot process or want to learn more about what it is doing.

I’ve also written a more detailed look at the start-up process in this post.

Up and running 1 - Installation

Mon, 16 Jun 2014 13:44:25 +0000

This part of the guide will show you what programs you need to install and what files to download to get your MTS system running.

Software

You will need to install the Hercules S/370 emulator and a 3270-compatible terminal emulator.

Hercules

The Hercules S/370 emulator is needed to run MTS. Go to the Hercules web site to download the latest version - source code is available for Unix derivatives and pre-built binaries for Windows.

I would recommend you get the latest version (currently 3.12) as previous versions have an issue that prevent batch printing working correctly. Hercules 4 will also work: see this discussion.

Prepackaged versions are available for Linux, eg Debian and Ubuntu, but these tend to be older versions so best to get the source code and compile it yourself on these platforms.

Follow the installation procedure to get the source or binaries installed. You do not to follow the configuration or DASD creation procedures using this guide.

3270 terminal emulator

^{_{From "IBM 3277 Display" by Gavin Eadie - picasaweb.google.com. Licensed under CC BY-SA 1.0 via Wikimedia Commons.}}

The IBM 3270 terminal acts as the operator’s console and for user sign-on sessions. Unless you have an old one lying around, you will need to install an emulator that can connect to Hercules.

The MTS archive has a good guide on what emulators are available - pick one for your platform. To use MTS effectively you will need to be able to use special keys like PA1 - see the documentation for your emulator to find out how to do this.

Files

You will need the D6.0A MTS distribution, the virtual tape files from the D6.0 distribution and the up-to-date Hercules configuration file.

MTS D6.0A distribution

MTS was distributed as sets of tapes; the latest version was D6.0 from 1988. D6.0A is an updated, packaged, version of D6.0 that includes bug fixes and minor changes to get it running smoothly on Hercules. Work is underway to get a bootable version of MTS from the time it was shut down in the 1990s, but for now D6.0A is the latest available.

The best source at present for this is a collection at archive.org. You want the file d6.0A.zip.

Unzip the file and change directory to the mts/d6.0A directory.

MTS D6.0 tape files

The D6.0A distribution only contains enough to get a bootable version of MTS; to install other software from the distribution you will need the tape files from D6.0. Get this from Bitsavers

Unpack this somewhere else and copy mts/d6.0/*.aws to your mts/d6.0A/Tapes directory created in the previous step.

Note that the archives were created on a Mac, so if you are not on that platform you will see directories like __MACOSX and files starting with .. You can safely ignore or delete these.

Updated Hercules config file

The version of the Hercules configuration file in D6.0A has a minor bug; pick up the latest version of the file fixing this from the MTS archive.

This file is enough to get MTS started but there are many options that can be tweaked. The only change I’d recommend to make now is to enable printer support if you have Hercules 3.10 or later; search for PTR2, uncomment the first line and comment out the next two lines with # as below:

000E 1403   Units/PTR2.txt lpp=66 fcb=1:11,4:1,5:5,8:10,14:6,19:4,24:7,34:2,44:6,49:4,54:7,63:8,66:3 optprint # PTR2
#000E 1403  Units/PTR2.txt nofcbcheck  # PTR2
#000E 1403  Units/PTR2.txt             # PTR2

Copy this file to mts/d6.0A, overwriting the previous version of hercules.conf, eg:

cp /path/to/MTSD6.0A.cnf hercules.cnf

Both D6.0 and D6.0A include a directory mtsDistDocs containing useful information which you should save elsewhere to read later.

Ready to boot

If you’ve completed the above steps, the contents of your d6.0A directory should have at least the following files:

hercules.cnf
Disks/mts600.dsk
Disks/mts600_1.dsk
Tapes/cmd001.aws
Tapes/d6.0dr1.aws
Tapes/d6.0dr2.aws
Tapes/d6.0dr3.aws
Tapes/d6.0t1.aws
Tapes/d6.0t2.aws
Tapes/d6.0t3.aws
Tapes/d6.0t4.aws
Tapes/d6.0t5.aws
Tapes/d6.0t6.aws
Tapes/d6.0util.aws
Units/PCH1.txt
Units/PTR2.txt
Units/RDR1.txt

If so, you are ready to move on to the next stage - booting the system for the first time.

Get up and running with MTS

Mon, 16 Jun 2014 13:42:52 +0000

OK, this will be a four part guide to getting MTS installed and how to start to use the system.

The aim is not to explain in detail what each step does, but I will provide links to further information to learn more.

An alternative way to get started quickly with MTS is to use Buddy Bell’s website which has an emulated terminal logged in to a student account.

Why try MTS?

Sun, 15 Jun 2014 05:51:53 +0000

MTS, the Michigan Terminal System, is an operating system running on IBM System/360 compatible mainframes dating from the 1960s. It ran at a number of universities in the US, UK and Canada until the late 90s, It provided batch and interactive access with a large number of programs and tools included in the standard distribution.

It’s now possible to run MTS without having your own mainframe, thanks to two projects:

The Hercules S/390 emulator (http://www.hercules-390.eu/) runs on Linux, Windows and Mac and simulates the hardware and peripherals such as disks and tapes needed to run MTS.
The complete source code, object code and a wealth of documentation is freely available under the Creative Commons Attribution 3.0 license (CC BY 3.0).

So why should you try MTS today?

Learn how mainframes were operated and the experience of being a user on a large shared system with limited resources.
Experiment with some of the programming languages available in the distribution - eg Algol. APL, BCPL, MAD, Plus, PL/1, SNOBOL.
History is often neglected in computer science - by learning more about the past we get a better understanding of why things are like they are today. Compared to today, where there is only really Windows and Unix derivatives (Linux, BSD, Mac), back in the 60s and 70s there was an explosion of new operating systems and ideas and it’s important to get a flavour of what was going on then.

Learning more about MTS

First read the Wikipedia article and items linked from there.

Next go to the MTS Archive - this site has done an amazing job of finding and uploading manuals, tutorials, memos and newsletters about MTS. I had never used MTS before this year and the information on this site was sufficient to understand the system and get it running. The original site archive.michigan-terminal-system.org, is currently down so the above link points to a copy at archive.org.

Then grab a copy of Hercules, a 3270 terminal emulator and the D6.0A distribution of MTS and get it working on your PC.

The Up and Running guide on this blog goes through the process in more detail.

This blog

In this blog I will provide tips and tricks for using MTS and share what I have discovered running the system. There are four main sections.

Up and Running - how to install and run MTS for the first time.
Using MTS - a tour of MTS commands, input/output and using tapes.
MTS System Admin - a closer look at configuring MTS and its services.
Programming Languages - a review at many of the programming languages installed with MTS, including language features and creating simple programs.

I’d love to have your feedback, so if you have any suggestions, questions or corrections please leave a comment or email me.

Try MTS

Site Update, August 2023

PL360 - Introduction and a hypotenuse program

PL360

PL360 on MTS

Prerequisites

Hypotenuse program

Compiling and running the program

Final thoughts

Further information

PLUS - Grep

Grep

Pattern matching

Driving the pattern matcher

Grep_Initialize in detail

Grep_Match and Grep_Terminate

Calling the Grep routines

Compiling and running the program

Areas for improvement

Final thoughts on PLUS

Further information

PLUS - Language Features

Format

Variables and types

Procedures

Expressions and control structures

Constants, macros and compiler directives

Input/output and the standard library

Further information

PLUS - Introduction

PLUS

PLUS on MTS

Prerequisites

Compiling and running a program

Hello world

Further information

Site Update, December 2019

GPSS - Introduction and Barber Shop Simulation

General Purpose Simulation System

GPSS on MTS

Prerequisites

A barber shop simulator

Running the program using *GPSS

Further information

System/360 Assembly Language - Caesar Cipher

The problem

Finding a algorithm

Turning letters into offsets

Turning offsets into letters

Byte access to memory

The ROT subroutine

Putting it together

Assembling and running the program

Thoughts on the program and assembly

Further information

System/360 Assembly Language - Features

Architecture overview

Assembly language

An example

Operation formats, base registers and addressing

Loads and stores and binary arithmetic

The PSW and branches

Subroutines

Macros and calling the MTS system

Other features

Further information

System/360 Assembly Language - Introduction

System/360 Assembly Language

Assemblers on MTS

Prerequisites

Running a program using *ASMG

Hello world

Further information

APL - Knuth Shuffle

The problem

Using deal

Implementing the algorithm

Performance

Final thoughts on APL

Further information

`Grep_Initialize` in detail

`Grep_Match` and `Grep_Terminate`

Calling the `Grep` routines

Running the program using `*GPSS`

Running a program using `*ASMG`

Running a program using `*APL`

Running a program using `*PIL`

Preprocessing using `*RATFOR`