#### pl/i

4 posts

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;
``````

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 SHOW_ARR('After', NUMS);

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

# 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
``````

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.

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.

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,
2 COST FIXED DECIMAL(5,2);
MEAL.NAME = 'Dinner';
MEAL.CUISINE = 'Italian';
MEAL.RESTAURANT.NAME = 'Alfredo';
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.

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 docuimentation 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; according to the MTS Archive the source and object code for this has been lost. It had the unique feature that any input would compile (but maybe not produce the desired results) due to automatic substitution of syntax errors.

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;

# 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

# 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.