Marcel van der Veer · Algol 68 Genie
Learning Algol 68 Genie
Learning Algol 68 Genie

Comprehensive Algol 68 programming guide, which includes the Revised Report.
The Algol 68 Genie project

The development of Algol played an important role in establishing computer science as an academic discipline. The Algol 68 Genie project preserves and promotes Algol 68 out of educational as well as scientific-historical interest, by making available a recent checkout compiler-interpreter written from scratch by Marcel van der Veer. Algol 68 Genie is free software distributed under the GNU General Public License.

A detailed description of Algol 68 is in the book Learning Algol 68 Genie which contains an informal introduction to the language, a manual for Algol 68 Genie, and the Revised Report on Algol 68. A hyperlinked HTML version of the Revised Report is available on this page.

About Marcel

Running Algol68C on MVS

Marcel van der Veer



Recently, Algol68C Release 1.3039 was made public for download. This release is derived from the compiler that was in service to the mid 1990's on IBM mainframes. The new release is meant to run on either MVT or MVS. This report documents the installation of the new release on emulated MVS/370.

The test system is my personal MVS/370 system named BUFF, the TSO logon screen of which is depicted to the right.

                      Emulated SYSTEM/370 Mainframe Service


                   BBBBBBBBBB    UU        UU  FFFFFFFFFFFF  FFFFFFFFFFFF
                  BBBBBBBBBBB   UU        UU  FFFFFFFFFFFF  FFFFFFFFFFFF
                 BB        BB  UU        UU  FF            FF
                BB        BB  UU        UU  FF            FF
               BB       BB   UU        UU  FF            FF
              BBBBBBBBBB    UU        UU  FFFFFFFF      FFFFFFFF
             BBBBBBBBBB    UU        UU  FFFFFFFF      FFFFFFFF
            BB       BB   UU        UU  FF            FF
           BB        BB  UU        UU  FF            FF
          BB        BB  UU        UU  FF            FF              _      _
         BBBBBBBBBBBB  UUUUUUUUUUUU  FF            FF            ." \\`.  (v)
        BBBBBBBBBBB    UUUUUUUUUU   FF            FF            ( \\ \\_\_ )\
                                                                 \\ _"  //\  )
                                                                  `/ // /// /
                                                                  (//  .__-"
                                                                    "-" |\


 Enter logon userid [reconnect]
 ====>
                                                                 MVS/370 ONLINE 

Introduction

Being the author of Algol 68 Genie I am interested in having access to other Algol 68 compilers for reference purposes. Of course we have algol68toc that descends from Algol68RS, but there are also two versions of Algol68C available on the web, the oldest one being Version 247 and the most recent one being Algol68C Release 1.3039. These two compilers run on operating systems MVT 21.8F and MVS 3.8J that can be run free-of-charge on Hercules, the well-known IBM mainframe emulator. MVT and MVS developed into z/OS, which is backward compatible with its predecessors. The free-of-charge versions of MVT and MVS lack program products as ISPF, but TSO is available.

A68C Version 247 appeared in 1976, at about the same time as the Revised Report. In 1976, the language implemented by A68C still differed notably from the Revised Report language. The recent Release 1.3039 however is a much better approximation, and stems from Release 1.303 that I used under VM/CMS in the 1980's to do scientific calculations. The new release does however "preserve" idiosyncracies like allocating three registers to address three 4kB code pages, by which an unsegmented program cannot exceed 12kB in length. All but small programs must still be segmented.

Since Algol68C and FLACC were an inspiration for me to write Algol 68 Genie, I installed Release 1.3039 on MVS. This page documents two ways to install this compiler.

What does running Algol68C look like?

For the moment I am content to run A68C programs in batch. Next JCL batch job is a typical example: the paradigm ZEROIN algorithm to search for roots of a function, which was also contained in the Mathematisch Centrum Algol 68 Test Set. Note that in below listing, A68.SYSIN indicates that the following lines are read by job step A68 in A68CCLG as file SYSIN. Job step A68 is the actual compilation.

//ZEROIN JOB 1,'ZEROIN',CLASS=A,MSGCLASS=A,MSGLEVEL=(1,1)
//ZEROIN EXEC A68CCLG
//A68.SYSIN DD *
BEGIN 
  PROC zero in = (REF REAL x, y, PROC (REAL) REAL f, tol) BOOL:
    BEGIN   
      REAL a := x, b := y;
      REAL fa := f(a), fb := f(b);
      REAL c := a, fc := fa;
      WHILE (ABS fc < ABS fb | 
                (a := b, fa := fb); 
                (b := c, fb := fc); 
                (c := a, fc := fa));
            REAL tolb := tol(b), m := (c + b) * .5;
            ABS (m - b) > tolb
      DO REAL p := (b - a) * fb, q := fa - fb;
         (p < 0 | (p := - p, q := - q));
         (a := b, fa := fb);
         fb := f(b := IF p <= ABS q * tolb
                      THEN (c > b | b + tolb | b - tolb)
                      ELIF p < (m - b) * q
                      THEN p / q + b
                      ELSE m
                      FI);
         IF ABS (SIGN fb + SIGN fc) = 2
         THEN (c := a, fc := fa) 
         FI
      OD;
      (x := b, y := c);
      ABS (SIGN fb + SIGN fc) < 2
    END;
            
  REAL eps = 3 * small real;
  
  PROC test = (REAL x0, y0, PROC (REAL) REAL f, STRING s) VOID:
    BEGIN   
      print((new line, "Expression: ", s, new line,
             "Zero to be found between ", x0, " and", new line, y0, new line));
      IF REAL x, y;
         zero in(x := x0, y := y0, f, (REAL p) REAL: eps + eps * ABS p)
      THEN print(("f(", x, ") =", new line, f(x)))
      ELSE print("no solution found")
      FI;
      print(new line)
    END;
          
  test(-10, 10, (REAL x) REAL: x ** 2 - 1, "x ** 2 - 1");
  test(-1, 0, (REAL x) REAL: exp(x) - x ** 2, "exp(x) - x ** 2");
  test(0, 1, (REAL x) REAL: cos(x) - x, "cos(x) - x")
END
//
I can issue batch jobs to the reader that on my emulated system sits on device number 00C. So if my batch job would be file jcl/zeroin.jcl, I would type at the Hercules console:

 Command ==> devinit 00c jcl/zeroin.jcl eof

Alternatively, I can issue the batch job from TSO. I would log on as user marcel, hence my high level qualifier would also be MARCEL. Then if my batch job would be file MARCEL.ZEROIN.JCL, I would type at the TSO terminal:

 submit zeroin.jcl                                                              

This job writes on the MVS console:
 
 00  $HASP100 ZEROIN   ON READER1     ZEROIN
     IEF677I WARNING MESSAGE(S) FOR JOB ZEROIN   ISSUED
   - $HASP373 ZEROIN   STARTED - INIT  1 - CLASS A - SYS BUFF
   - CCI001C A68     /A68C    /00:00:00.26/00:00:00/00000/1       /ZEROIN
   - CCI001C Z370    /Z370    /00:00:00.05/00:00:00/00000/1       /ZEROIN
   - CCI001C LKED    /IEWL    /00:00:00.09/00:00:00/00000/1       /ZEROIN
   - CCI001C GO      /PGM=*.DD/00:00:00.01/00:00:00/00000/1       /ZEROIN       
   - $HASP395 ZEROIN   ENDED
     $HASP309    INIT  1 INACTIVE ******** C=A
     $HASP150 ZEROIN   ON PRINTER2       206 LINES
     $HASP160 PRINTER2 INACTIVE - CLASS=A
     $HASP250 ZEROIN   IS PURGED

and produces on the printer:
Algol68C Release 1.3039
Unused space 25936

Z370 version 303.7
Program=1388 Data=248

Expression: x ** 2 - 1
Zero to be found between  -1.0000000000000000E +1 and
+1.0000000000000000E +1
f( -9.9999999999999999E -1) =
-2.7755575615628914E-17

Expression: exp(x) - x ** 2
Zero to be found between  -1.0000000000000000E +0 and
+0.0000000000000000E +0
f( -7.0346742249839178E -1) =
-2.3592239273284576E-16

Expression: cos(x) - x
Zero to be found between  +0.0000000000000000E +0 and
+1.0000000000000000E +0
f( +7.3908513321516066E -1) =
+1.3877787807814457E-17
Note that the compiler's signature reveals its relation to the release I used on VM/CMS as is apparent from next line printer listing that I retrieved from my 1987 MSc thesis:

Acquiring a MVS/370 system

The question is whether you want a prebuilt turnkey-system or want to set up and tailor your own installation. Volker Bandke has posted a great ready-to-run Tur(n)key system. You can download this as an ISO image and be running MVS within minutes. For the DIY people among us, like me, Jay Moseley has written excellent instructions on how to set up your own system. This does not have you up and running within minutes, but setting it up yourself is a great learning experience. Note that Jay's system is not the same one as Volker's. The installation of Algol68C as described here was done on Jay's system, but should work equally well on Volker's offering.

Using the Hercules emulator on GNU/Linux I set up an emulated MVS system following Jay Moseley's instructions. Setting up a basic system takes about one evening of entertaining work. I did borrow material from Volker's system to set up mine. For historic reasons I named my installation BUFF and devised a corresponding netsol logon screen as presented in the heading of this report (note that the turkey refers to the original MVS mascot). BUFF is a quite modest 6-DASD set up on which I installed memories of my computing past like FORTRAN H and DUCHESS, a strong 1970's chess program that competed with Chess, Kaissa and Belle. Of course I installed nice tools as Rob Prins's RPF and Greg Price's IMON370 and QUEUE. BUFF mainly runs simulation software using FORTRAN source code that I wrote as a graduate student, and later as a PhD student.

Below screen shows how the A68C distribution files are installed on my particular MVS installation:
 Datasets starting with SYS2                 41---------------------------------
 Cmd =>
 C Dataset name               Volume Ref.dt Org  RECFM RECL   BLK Ext  Size Free
   SYS2.A68CLIB.LANGREF       SYSRES 84.290 PO   FB      80  2480   1    90   13
   SYS2.A68CLIB.MCRA68TS      SYSRES 84.291 PO   FB      80  3120   1    75    4
   SYS2.A68CLIB.MISC.DOC      SYSRES 84.290 PO   FB      80  2480   1    30   12
   SYS2.A68CLIB.MISC.JCL      SYSRES 84.291 PO   FB      80  2480   1    30   24
   SYS2.A68CLIB.MISC.SRC      SYSRES 84.290 PO   VB     136  2498   1    30   24
   SYS2.A68CLIB.MOD           MVSRES 84.291 PO   U        0  4096   1   120   75
   SYS2.A68CLIB.SYS           MVSRES 84.291 PO   VB     136  2498   1    10    4
   SYS2.CMDLIB                MVSRES 84.290 PO   U        0 19069   1   600  560
   SYS2.CONTROL               MVSRES 84.249 PO   FB      80  3120   1    30   29
   SYS2.DUCHESS.BK            SYSRES 84.290 PO   FB      80  6400   1    48   12
   SYS2.DUCHESS.BOOK          SYSRES 84.290 PS   F     6272  6272   1    19    0
   SYS2.DUCHESS.CLIST         SYSRES 84.290 PO   VB     255  4240   1     5    3
   SYS2.DUCHESS.HELP          SYSRES 84.290 PO   FB      80   800   1     8    2
   SYS2.DUCHESS.LOAD          SYSRES 84.291 PO   U       80  6400   1    75   40
   SYS2.DUCHESS.MACLIB        SYSRES 84.290 PO   FB      80  6400   1    10    3
   SYS2.DUCHESS.SOURCE        SYSRES 84.290 PO   FB      80   800   1   118   36
   SYS2.FORTRAN.PROGRAMS      SYSRES 84.291 PO   FB      80  3120   1    75   38
   SYS2.HELP                  MVSRES 84.291 PO   FB      80 19040   1    60   54
   SYS2.LINKLIB               MVSRES 84.271 PO   U        0 19069   1   600  421
   SYS2.MACLIB                SYSRES 84.290 PO   FB      80 19040   1    60   15
   SYS2.PASCAL.PASLIB         SYSRES 84.290 PO   U        0  1024   1    18    4 
Note that the libraries not needed for A68C execution are not on MVSRES. I added SYS2.A68CLIB.MCRA68TS myself, this dataset is not in the A68C distribution.

Algol68C installation directions

Two routes for installing Algol68C are described here: a conventional approach and what I will call a SYSCPK approach. Both routes start with the same procedure: mounting the Algol68C media which is the subject of below step.

Mounting the source disk, A68C01

I downloaded the DASD image, and did not use the AWS tape image. The idea was to mount the disk on MVS and browse its contents before deciding how to approach the issue. The disk is compressed, and I decompressed it since I do not use compressed disks on my system, and named it dasd/a68c01.3330. Mounting the disk was done by attaching it on the Hercules console:


 Command ==> attach 131 dasd/a68c01.3330

Note that the device number, in my example 131, must be some free device number fit for a 3330, this depends on how your MVS system is configured. Once attached, on the MVS console I first put the disk online:

 v 131,online

and then I mounted it:

 m 131,vol=(sl,a68c01),use=private

Note that throughout this report I assume that MVS succesfully does what you ask it to do. Check this please, condition codes should typically be 0. I mounted the disk PRIVATE so MVS does not place data on it of its own accord. You can make the disk resident by adding it to member VATLST00 in SYS1.PARMLIB. The disk's VOLSER (label) is A68C01, but since it is not catalogued, there is no high-level qualifier - you don't need it anyway.

I inspected A68CLIB.MOD using AMBLIST:

//LIST JOB 2,'AMBLIST',CLASS=A,MSGCLASS=A,MSGLEVEL=(1,1)
//LIST EXEC PGM=AMBLIST
//SYSPRINT DD SYSOUT=*
//SYSLIB   DD DSN=A68CLIB.MOD,UNIT=3330,
//            VOL=SER=A68C01,DISP=SHR
//SYSIN    DD *
 LISTLOAD OUTPUT=XREF
//
and on Linux grepped the extensive printer output to find the member names:

         MEMBER NAME   $BAS3039                             MAIN ENTRY POINT  003B58
         MEMBER NAME   $CON3039                             MAIN ENTRY POINT  000000
         MEMBER NAME   $CPX3039                             MAIN ENTRY POINT  00AC70
         MEMBER NAME   $LIB3039                             MAIN ENTRY POINT  000000
         MEMBER NAME   $MAT3039                             MAIN ENTRY POINT  008FE8
         MEMBER NAME   $MCH3039                             MAIN ENTRY POINT  003AF0
         MEMBER NAME   $NIO3039                             MAIN ENTRY POINT  000000
         MEMBER NAME   $RAN3039                             MAIN ENTRY POINT  000000
         MEMBER NAME   $REA3039                             MAIN ENTRY POINT  009F60
         MEMBER NAME   $ROU3039                             MAIN ENTRY POINT  0069F0
         MEMBER NAME   $XPL3039                             MAIN ENTRY POINT  000000
         MEMBER NAME   A68C3039                             MAIN ENTRY POINT  000048
         MEMBER NAME   Z3703039                             MAIN ENTRY POINT  000038

indicating that the XREF program, used to cross reference Algol68C programs in the old days, is not included with Release 1.3039. It is included with Version 247. Calling XREF with Release 1.3039 indeed causes expected ABEND S806-04 (module not found). Note that A68C is an alias for A68C3039 and Z370 is an alias for Z3703039.

Route A. Conventional approach

Most MVS systems are set up in a way that third-party material is not mixed with IBM material. Hence many SYS1 libraries (IBM material) have SYS2 counterparts that contain third-party material.

A.1 Copying datasets to MVSRES

A straightforward way to install Algol68C is to execute below batch JCL job. It installs required material on MVSRES which is a 3350 on my emulated system:
//A68CCOPY JOB 3,'COPY',CLASS=A,MSGCLASS=A,MSGLEVEL=(1,1)
//IEBCOP2 EXEC PGM=IEBCOPY
//SYSPRINT DD SYSOUT=*
//SYSUT1   DD DISP=OLD,DSN=A68CLIB.MOD,UNIT=3330,VOL=SER=A68C01
//SYSUT2   DD DISP=(MOD,CATLG),DSN=SYS2.A68CLIB.MOD,
//         UNIT=3350,VOL=SER=MVSRES,SPACE=(TRK,(120,120,20))
//SYSIN    DD DUMMY
//*
//IEBCOP3 EXEC PGM=IEBCOPY
//SYSPRINT DD SYSOUT=*
//SYSUT1   DD DISP=OLD,DSN=A68CLIB.SYS,UNIT=3330,VOL=SER=A68C01
//SYSUT2   DD DISP=(MOD,CATLG),DSN=SYS2.A68CLIB.SYS,
//         UNIT=3350,VOL=SER=MVSRES,SPACE=(TRK,(10,10,20))
//SYSIN    DD DUMMY
//*
//UPLOAD EXEC PGM=IEBGENER
//SYSPRINT DD SYSOUT=A
//SYSIN    DD DUMMY
//SYSUT2   DD UNIT=3350,DSN=SYS2.PROCLIB(A68CCL),DISP=OLD,
//            VOL=SER=MVSRES,SPACE=(TRK,(2,2))
//SYSUT1   DD DATA,DLM=$$
//* PROCEDURE TO COMPILE ALGOL68C ON MVS 3.8.
//*
//* 1. COMPILATION
//A68     EXEC PGM=A68C,REGION=768K,PARM=F16K
//STEPLIB  DD DSN=SYS2.A68CLIB.MOD,DISP=SHR
//INIT     DD DSN=SYS2.A68CLIB.SYS(INIT),DISP=SHR
//SYSENV   DD DSN=SYS2.A68CLIB.SYS,DISP=SHR
//CODE     DD UNIT=SYSDA,DISP=(NEW,PASS,DELETE),
//            SPACE=(TRK,(58,8),RLSE)
//SYSPRINT DD SYSOUT=*
//PROGRAM  DD DDNAME=SYSIN
//* 2. Z370 TRANSLATOR
//Z370     EXEC PGM=Z370,REGION=192K,
//  COND=(4,LT,A68),PARM=F16K
//STEPLIB  DD DSN=SYS2.A68CLIB.MOD,DISP=SHR
//ZCODE    DD DSN=*.A68.CODE,DISP=(OLD,DELETE,DELETE)
//SYSPRINT DD SYSOUT=A
//SYSGO    DD UNIT=SYSDA,DISP=(NEW,PASS,DELETE),
//            SPACE=(TRK,(58,8),RLSE),
//            DCB=(RECFM=FB,LRECL=80,BLKSIZE=800)
//* 3. LINK EDITOR
//LKED     EXEC PGM=IEWL,REGION=96K,
//  COND=((4,LT,A68),(4,LT,Z370)),
//  PARM=('SIZE=(1024K,8K),LIST,NOMAP,NOXREF,LET,CALL,DCBS')
//SYSPRINT DD SYSOUT=A
//SYSLIN   DD DSN=*.Z370.SYSGO,DISP=(OLD,DELETE,DELETE)
//         DD DDNAME=SYSIN
//SYSLMOD  DD DSN=&GOSET(GO),UNIT=SYSDA,
//            SPACE=(TRK,(58,8,1)),DISP=(MOD,PASS)
//SYSUT1   DD UNIT=(SYSDA,SEP=(SYSLIN,SYSLMOD)),SPACE=(TRK,(58,8))
//SYSLIB   DD DSN=SYS2.A68CLIB.MOD,DISP=SHR
$$
//*
//UPLOAD EXEC PGM=IEBGENER
//SYSPRINT DD SYSOUT=A
//SYSIN    DD DUMMY
//SYSUT2   DD UNIT=3350,DSN=SYS2.PROCLIB(A68CCLG),DISP=OLD,
//            VOL=SER=MVSRES,SPACE=(TRK,(2,2))
//SYSUT1   DD DATA,DLM=$$
//* PROCEDURE TO RUN ALGOL68C ON MVS 3.8.
//*
//* 1. COMPILATION
//A68     EXEC PGM=A68C,REGION=768K,PARM=F16K
//STEPLIB  DD DSN=SYS2.A68CLIB.MOD,DISP=SHR
//INIT     DD DSN=SYS2.A68CLIB.SYS(INIT),DISP=SHR
//SYSENV   DD DSN=SYS2.A68CLIB.SYS,DISP=SHR
//CODE     DD UNIT=SYSDA,DISP=(NEW,PASS,DELETE),
//            SPACE=(TRK,(58,8),RLSE)
//SYSPRINT DD SYSOUT=*
//PROGRAM  DD DDNAME=SYSIN
//* 2. Z370 TRANSLATOR
//Z370     EXEC PGM=Z370,REGION=192K,
//  COND=(4,LT,A68),PARM=F16K
//STEPLIB  DD DSN=SYS2.A68CLIB.MOD,DISP=SHR
//ZCODE    DD DSN=*.A68.CODE,DISP=(OLD,DELETE,DELETE)
//SYSPRINT DD SYSOUT=A
//SYSGO    DD UNIT=SYSDA,DISP=(NEW,PASS,DELETE),
//            SPACE=(TRK,(58,8),RLSE),
//            DCB=(RECFM=FB,LRECL=80,BLKSIZE=800)
//* 3. LINK EDITOR
//LKED     EXEC PGM=IEWL,REGION=96K,
//  COND=((4,LT,A68),(4,LT,Z370)),
//  PARM=('SIZE=(1024K,8K),LIST,NOMAP,NOXREF,LET,CALL,DCBS')
//SYSPRINT DD SYSOUT=A
//SYSLIN   DD DSN=*.Z370.SYSGO,DISP=(OLD,DELETE,DELETE)
//         DD DDNAME=SYSIN
//SYSLMOD  DD DSN=&GOSET(GO),UNIT=SYSDA,
//            SPACE=(TRK,(58,8,1)),DISP=(MOD,PASS)
//SYSUT1   DD UNIT=(SYSDA,SEP=(SYSLIN,SYSLMOD)),SPACE=(TRK,(58,8))
//SYSLIB   DD DSN=SYS2.A68CLIB.MOD,DISP=SHR
//* 4. GO EXECUTE
//GO       EXEC PGM=*.LKED.SYSLMOD,REGION=256K,
//  COND=((4,LT,A68),(4,LT,Z370),(4,LT,LKED)),PARM=''
//STEPLIB  DD DSN=SYS2.A68CLIB.MOD,DISP=SHR
//SYSPRINT DD SYSOUT=*
$$
//
This installs in SYS2.PROCLIB catalogued procedure A68CCL (Compile and Load) and A68CCLG (Compile, Load and Go) which follows the naming scheme for MVT compiler procedures. You can derive a procedure A68CC (Compile) analogously. Note that I doubled the 'C' to arrive at a consistent MVS naming scheme. The distribution uses in A68CLIB.MISC.JSL a single A68CLG. Note that I presume that the PROC00 field in procedure SYS1.PROCLIB(JES2) searches at least SYS1.PROCLIB and SYS2.PROCLIB, otherwise A68CCLG will not be found by JES2.

Route B. SYSCPK approach

Since MVS comes without compilers, Jay Moseley made available SYSCPK, a disk with available MVT compilers pre-installed. SYSCPK includes A68C Version 247 from 1976. Installation of Release 1.3039 on the existing SYSCPK appeared quite straightforward, and I report my steps here for those interested. Note that the high level qualifier for SYSCPK is SYSC which we will use henceforth.

B.1 Copying datasets to SYSCPK

Some, not all, PDS datasets (libraries) needed to be copied from A68C01 to SYSCPK. There are various ways to accomplish that but a simple way not involving TSO is to use a few small batch jobs. Below batch file performs simple calls to IEBCOPY to copy needed libraries:

//A68CCOPY JOB 4,'COPY',CLASS=A,MSGCLASS=A,MSGLEVEL=(1,1)
//*
//IEBCOP1 EXEC PGM=IEBCOPY
//SYSPRINT DD SYSOUT=*
//SYSUT1   DD DISP=OLD,DSN=A68CLIB.MISC.JCL,UNIT=3330,VOL=SER=A68C01
//SYSUT2   DD DISP=(NEW,CATLG),DSN=SYSC.A68CLIB.MISC.JCL,
//         UNIT=3350,VOL=SER=SYSCPK,SPACE=(TRK,(10,10,20))
//SYSIN    DD DUMMY
//*
//IEBCOP2 EXEC PGM=IEBCOPY
//SYSPRINT DD SYSOUT=*
//SYSUT1   DD DISP=OLD,DSN=A68CLIB.MOD,UNIT=3330,VOL=SER=A68C01
//SYSUT2   DD DISP=(NEW,CATLG),DSN=SYSC.A68CLIB.MOD,
//         UNIT=3350,VOL=SER=SYSCPK,SPACE=(TRK,(120,120,20))
//SYSIN    DD DUMMY
//*
//IEBCOP3 EXEC PGM=IEBCOPY
//SYSPRINT DD SYSOUT=*
//SYSUT1   DD DISP=OLD,DSN=A68CLIB.SYS,UNIT=3330,VOL=SER=A68C01
//SYSUT2   DD DISP=(NEW,CATLG),DSN=SYSC.A68CLIB.SYS,
//         UNIT=3350,VOL=SER=SYSCPK,SPACE=(TRK,(10,10,20))
//SYSIN    DD DUMMY
//
Since SYSCPK has ample free space I did not bother about optimal choice for record length when copying from a 3330 to a 3350. I also copied some documentation from A68C01 to SYSCPK. The MOD and SYS libraries are needed on SYSCPK to run A68C, and I copied MISC.JCL to archive the catalogued procedures.

B.2 Integration of catalogued procedures

The A68C libraries on SYSCPK were catalogued by IEBCOPY, so MVS sees them if you inquire using high-level qualifier SYSC. Now catalogued procedures (call them scripts if you want) to run A68C, needed to be integrated so JES2 will find them when called.

I took advantage of SYSCPK containing SYSC.PROCLIB that was integrated in JES2's search path at SYSCPK's installation. What I needed to do was copy relevant JCL from A68CLIB.MISC.JCL to SYSC.PROCLIB. I will just illustrate copying A68CLG, CLG stands for Compile, Link and Go, to A68CCLG. Note that I doubled the 'C' to arrive at a consistent MVS naming scheme. Also, the 247 compiler already installed a procedure A68CLG. A68CCLG is enough to run (small) Algol68C programs. Procedures A68CCL etcetera can be handled analogously. To install the catalogued procedures in SYSC.PROCLIB I devised two approaches of which one must be chosen:

[A] Execute next batch job by sending it to the reader as described earlier:

//A68CCOPY JOB 5,'COPY',CLASS=A,MSGCLASS=A,MSGLEVEL=(1,1)
//*
//IEBGENER EXEC PGM=IEBGENER
//SYSPRINT DD SYSOUT=*
//SYSUT1   DD DISP=SHR,DSN=SYSC.A68CLIB.MISC.JCL(A68CLG)
//SYSUT2   DD DISP=SHR,DSN=SYSC.PROCLIB(A68CCLG)
//SYSIN    DD DUMMY
//
Next TSO came in handy as I needed to customise A68CCLG for my system. I used RPF and its editor for that. All I did was making sure that parameter A68CLIB got substituted by the right qualifiers:
...
A68CCLG PROC  TRKS='58,8',A68CLIB='SYSC.A68CLIB',
...

[B] Alternatively, upload my personal version of A68CCLG to SYSC.PROCLIB:

//UPLA68 JOB 6,'UPLOAD',CLASS=A,MSGCLASS=A,MSGLEVEL=(1,1)
//*
//UPLOAD EXEC PGM=IEBGENER
//SYSPRINT DD SYSOUT=A
//SYSIN    DD DUMMY
//SYSUT2   DD DSN=SYSC.PROCLIB(A68CCLG),DISP=OLD
//SYSUT1   DD DATA,DLM=$$
//* PROCEDURE TO RUN ALGOL68C ON MVS 3.8.
//*
//* 1. COMPILATION
//A68     EXEC PGM=A68C,REGION=768K,PARM=F16K
//STEPLIB  DD DSN=SYSC.A68CLIB.MOD,DISP=SHR
//INIT     DD DSN=SYSC.A68CLIB.SYS(INIT),DISP=SHR
//SYSENV   DD DSN=SYSC.A68CLIB.SYS,DISP=SHR
//CODE     DD UNIT=SYSDA,DISP=(NEW,PASS,DELETE),
//            SPACE=(TRK,(58,8),RLSE)
//SYSPRINT DD SYSOUT=*
//PROGRAM  DD DDNAME=SYSIN
//* 2. Z370 TRANSLATOR
//Z370     EXEC PGM=Z370,REGION=192K,
//  COND=(4,LT,A68),PARM=F16K
//STEPLIB  DD DSN=SYSC.A68CLIB.MOD,DISP=SHR
//ZCODE    DD DSN=*.A68.CODE,DISP=(OLD,DELETE,DELETE)
//SYSPRINT DD SYSOUT=A
//SYSGO    DD UNIT=SYSDA,DISP=(NEW,PASS,DELETE),
//            SPACE=(TRK,(58,8),RLSE),
//            DCB=(RECFM=FB,LRECL=80,BLKSIZE=800)
//* 3. LINK EDITOR
//LKED     EXEC PGM=IEWL,REGION=96K,
//  COND=((4,LT,A68),(4,LT,Z370)),
//  PARM=('SIZE=(1024K,8K),LIST,NOMAP,NOXREF,LET,CALL,DCBS')
//SYSPRINT DD SYSOUT=A
//SYSLIN   DD DSN=*.Z370.SYSGO,DISP=(OLD,DELETE,DELETE)
//         DD DDNAME=SYSIN
//SYSLMOD  DD DSN=&GOSET(GO),UNIT=SYSDA,
//            SPACE=(TRK,(58,8,1)),DISP=(MOD,PASS)
//SYSUT1   DD UNIT=(SYSDA,SEP=(SYSLIN,SYSLMOD)),SPACE=(TRK,(58,8))
//SYSLIB   DD DSN=SYSC.A68CLIB.MOD,DISP=SHR
//* 4. GO EXECUTE
//GO       EXEC PGM=*.LKED.SYSLMOD,REGION=256K,
//  COND=((4,LT,A68),(4,LT,Z370),(4,LT,LKED)),PARM=''
//STEPLIB  DD DSN=SYSC.A68CLIB.MOD,DISP=SHR
//SYSPRINT DD SYSOUT=*
$$

Copyright © 2013 J.M. van der Veer. Updated October 2013.