Last changes: 2021-09-06
Update 09.2021: the CMD files for the Windows and OS/2 variant have been improved. The installation steps are now described precisely (see below, Resources paragraph). Enjoy !
Update 05.2021: there have been some errors in the VM/CMS variant of the compiler;
this has been fixed.
Furthermore, the VM distribution now comes in two variants (two AWS tapes);
the first one (File PAS2021B.AWS) contains the whole development minidisk, as it was in prior releases.
The second one (File PAS2021B_COMP.AWS) which may fit better to the needs of the average user,
contains only the compiler and the runtime (and the compiler sources).
If you are not interested in the sources, you can simply delete all files with filetype PASCAL or ASSEMBLE from the minidisk, after loading it from the AWS tape.
The Compiler-only version will soon be part of the new VM community edition of the VM/370 R6 operating system; the files will be placed on the Y disk, there.
The 2020.12 compiler version is available for MVS or z/OS (IBM mainframe or Hercules);
this is virtually the same as the 2020.11 version, with some minor error corrections.
The most significant changes:
static and auto variables can now optionally be initialized with the definition
using the already known structured constant syntax. The initialization of static data
is done at compile time, but the initialization of automatic variables has to be done
at block entry time, of course. You will find more information on these topics on the
Stanford compiler Facebook pages.
BTW: many thanks to
for checking out the MVS version of the compiler
and providing instructions
and download files in TAR format on his Hercules related web site: New Stanford PASCAL Compiler - Hercules Compilers (Jay Moseley)
Compiler release 2021.01 available for VM/CMS - see below (Resources paragraph)
Compiler release 2020.12 available for MVS (TK4-) - see below (Resources paragraph)
Compiler release 2021.03 available for Windows and OS/2 at GitHub - find the link below
The compiler (2020.11 version) compiling itself to 370 machine code on VM/CMS:
I am currently the maintainer of an improved version of the Stanford Pascal compiler.
The Stanford Pascal compiler is an offspring of the original Pascal P4 compiler, which was written in the 1970s at ETH Zürich by a team around Niklaus Wirth.
cited from english Wikipedia:
To propagate the language rapidly, a compiler "porting kit" was created in Zürich
that included a compiler that generated code for a "virtual" stack machine,
i.e., code that lends itself to reasonably efficient interpretation, along with an interpreter for that code - the Pascal-P system.
The P-system compilers were termed Pascal-P1, Pascal-P2, Pascal-P3, and Pascal-P4.
Pascal-P1 was the first version, and Pascal-P4 was the last to come from Zürich.
A compiler based on the Pascal-P4 compiler, which created native binaries,
was released for the IBM System/370 mainframe computer
by the Australian Atomic Energy Commission; it was called the "AAEC Pascal Compiler" after the abbreviation of the name of the Commission.
end of citation
As I learned recently from Mark Waterbury, this is not correct. The AAEC compiler is an independent development and is not based on the P4 compiler. Mark gave me the sources, and I compared them to the original Stanford compiler, which is a P4 variant, and there are many differences. It is very unlikely if not impossible that the AAEC compiler builders had access to the P4 source.
The true story is: starting from the P4 compiler from Zürich, some work has been done in Bombay (India), and then the Stanford compiler was based on that work. The P4 compiler produces P-Code, which is independent of the target machine; to be able to run on the IBM mainframe, the P-Code needs to be translated to 370 machine code. I don't know exactly when the P-Code-to-370 translator was written; the first comment is by S. Hazeghi of Stanford. So maybe the customization of the P4 compiler to the IBM mainframe was done at Stanford; this must have been in the second half of the 1970s. The P4 compiler targetted to the IBM mainframe was then called the Stanford Pascal Compiler and was used heavily during the late 1970s and early 1980s.
Mark also told me that the Stanford compiler probably was used to bootstrap the Pascal/VS compiler from IBM, which is a self-compiling compiler (like Stanford). Pascal/VS internally uses some sort of extended P-Code, which is an extension of the P4 P-Code. BTW: the UCSD Pascal system used an intermediate code called U-Code, which is based on P4's P-Code, too.
Some years later (1982 ca.), the Stanford compiler was transferred to the McGill university in Montreal, Canada and used on their MUSIC/SP mainframe operating system. That's where I found it in 2011. The McGill version of the compiler (still called Stanford Pascal) had several significant extensions, compared to the original Stanford version of 1979.
This page tells the story what happened from 2011 to today (not much
in the years 2011 to 2016),
what I did in the years since 2016, what I am doing now and what I will do in the future.
The Stanford compiler was originally targetted to IBM mainframes only.
Today it runs on VM/370 Rel.6 and on MVS 3.8j on the Hercules emulator.
And it runs on today's z/OS, too (tested first by Rene Jansen in 05.2017, thanks!).
It will sure run on modern zVM, too (at the moment limited to AMODE 24, RMODE 24).
The VM and MVS versions can be downloaded from this site (including source codes), see "Resources" below.
It also runs (tested) on Windows, OS/2, Linux (x86)
and Mac OS, because I ported it there in the end of 2016.
On these platforms the P-Code generated by the first compiler pass is interpreted by a P-Code interpreter written in ANSI-C,
so it will probably run on every platform that has a C compiler. Please contact me, if you want to test it on other platforms.
The Windows (and OS/2) version is available from this site, too; see "Resources" below.
You can follow the development process more closely on this Facebook page:
Stanford Pascal on Facebook
This picture shows the Pascal compiler compiling itself on Windows
(only pass 1 needed, Pascal to P-Code; the P-Code is interpreted by the P-Code interpreter PCINT).
Topics with this icon are not yet completed ... maybe implemented, but documentation is missing.
I will no longer post the sources here explicitly, because they are on GitHub anyway (see link below), and keeping them current here is a lot of work which can be saved.
Furthermore, I would like to add that the versions on GitHub are always the best and newest and the mainframe versions for VM/CMS and MVS can be one or two released behind. I hope you don't mind.
Since 2016 ca., when I first ported the compiler to Windows, the new versions and the enhancements are first implemented and tested on Windows and then (later) on the mainframe.
PAS2021B_COMP.AWS - this tape contains the needed files to run the compiler
PAS2021B.AWS - this is a TAPE DUMP of the complete development disk, including test programs etc.
Usage Notes for the MVS version:
the ZIP file contains an "Installation Guide" PDF, where you can find detailed instructions. You can also find it here.
The non-Mainframe versions of New Stanford Pascal are based on the P-Code interpreter PCINT.
The most recent version is available at GitHub:https://github.com/StanfordPascal/Pascal
Installation steps for the Windows and OS/2 version:
a) Download the Compiler ZIP File from GitHub and unpack it into a directory of your choice b) if you're on Windows, you can use the PCINT.EXE which is in the bin subdirectory. Otherwise (if you are using OS/2 or MacOS or Unix), you will have to compile PCINT using the sources which are in the bin subdir, too. c) Now you should choose a directory, where the executables of the compiler should be stored; this directory should be part of your PATH (for example: C:\bin ... or another directory of your choice). d) Please copy the file COPYBIN.CMD from the script subdir to the install directory (one level up) e) edit the SET command in COPYBIN.CMD (at the beginning) which sets the environment variable PASDIR to the directory for the executables of your choice (see step c)) f) and now start COPYBIN.CMD, so that the needed files are placed into the PASDIR directory
Now the compiler commands should work from everywhere. Just make sure that the environment variable PASDIR always contains the directory where the compiler is (as chosen in step c)), because it is referenced in the compiler script files.
Use PASCAL <program> or
PP <program> to call the Pascal compiler; the program should be stored in a file <program>.PAS
Use PRUN <program> to run the program
set DD_<logical_filename>=<physical_filename_including_path> to assign files
For other (Non-Windows) systems:
PCINT can IMHO be compiled with every standard C compiler; I used IBM's C compiler on OS/2 and the Open Watcom C compiler on Windows (and gcc on Linux, BTW).
The CMD files for Windows (and the installation method described above) will work for OS/2, too. If you are on another system, you will have to adjust the script files; maybe you find some ideas in the subdirectory script_ix. Otherwise, you can contact me directly.
New Stanford Pascal - Special Topics
External Procedures in Stanford Pascal - written in Pascal, FORTRAN or Assembler
New Stanford Pascal Installation Guide for MVS
Reading Textfiles with New Stanford Pascal
Strings in New Stanford Pascal
Troubles with Procedure Parameters
P-Code Description (2019) - work in progress
P-Code Description (2017)
P-Code Description (2016)
P-Code Description (1978)
Old documents on different topics
The Programming Language Pascal (Niklaus Wirth, 1972)
Pascal P-Compiler Implementation Notes (ETH Zürich 3054-01)
On Code Generation in a Pascal Compiler (ETH Zürich 3056-01)
Stanford Pascal/360 Implementation Guide (1974)
The Stanford Pascal compiler (1979)
A Pascal P-Code Interpreter for the Stanford Emmy (1979)
The Implementation of Case Statements in Pascal (1981)
Pascal/VS Language Reference Manual (1981)
The Pascal ISO 7185 Standard (1991)
Wirth: A Pioneer of Computer Science
Description of Algol 60 (Rutishauser 1967)
Algol W Language Description (1972)
A Politico Social History of Algol (Bemer)
The Algol 68 Story (1978)
The Dijkstra-Zonneveld Algol 60 Compiler for the X1 (2003)
The History of the Algol Effort (2006)
Algol Anniversary (Huub de Beer 2010)
Algol in France (Mounier, Kuhn 2011)
MARST - An Algol-to-C translator (Download)
The Advent of the Recursive Procedure (2010)
E. W. Dijkstra: First Years in the Computing Science 1951 - 1968 (Van Den Hove 2009)
The Edsger W. Dijkstra Archive
The PL360 Programming Language (1968)
LE Stack and Heap Implementation (IBM 2005)
Columbia University Computing History
40 Jahre Informatik in München (2007)
Evaluation of Algol 68, Pascal, ... for a Common High Order Programming Language (1976)
DOD Language Evaluation (1977)
A Methodology for Evaluating Languages and their Compilers for Secure Applications (1978)