RATFOR & FLECS - Introduction

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

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

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

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

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

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 ther series on PL/I or see the other languages being looked at.

PL/I - Language features 2

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.