P3 Pascal compiler

In the tape dump at https://history.dcs.ed.ac.uk/archive/languages/pascal/ Stefano B. found a Pascal P3 source and also a P4 source, not equal to what is found sofar for Pascal P4.
The originator is L.ZAFFALON, CUI, GENEVE.

Here an archive (with the original files from the link above in folder ‘original’) with the Pascal P3 and P4 compiler and interpreter sources

(**********************************************
  *                                            *
  *                                            *
  *         PORTABLE PASCAL COMPILER           *
  *         ************************           *
  *                                            *
  *                PASCAL P3                   *
  *                                            *
  *                                            *
  *     AUTHORS:                               *
  *              URS AMMANN                    *
  *              KESAV NORI                    *
  *              CHRISTIAN JACOBI              *
  *                                            *
  *     ADDRESS:                               *
  *                                            *
  *          INSTITUT FUER INFORMATIK          *
  *          EIDG. TECHNISCHE HOCHSCHULE       *
  *          CH-8096 ZUERICH                   *
  *                                            *
  *                                            *
  *     LAST CHANGES COMPLETED IN MAY 76       *
  *                                            *
  *                                            *
  **********************************************)

Pascal-VU compiler

Where the Pascal-U compiler (1976) implements a subset of Standard Pascal, Pascal-VU (1979) implements full ISO Standard Pascal.

The Pascal‐VU compiler produces code for an EM1 machine. There does not exist a hardware EM1 machine. Therefore, EM1 programs must be interpreted, or translated into instructions for a target machine. The following implementations exist:

  • an interpreter running on a PDP‐11 (using UNIX‐6). Normally the interpreter performs some tests to detect undefined integers, integer overflow, range errors, etc. However, one of the options of the interpreter is to skip these tests.
  • a translator into PDP‐11 instructions (using UNIX‐6).

Pascal-VU June 1980 si afound on a tape dump https://www.tuhs.org/Archive/Applications/Shoppa_Tapes/usenix_80_delaware.tar.gz in the folder ‘tanenbaum’.

The header of the Pascal-VU compiler source

program pem(input,output,em1);
{This Pascal compiler  produces EM1 code as described in
   - A.S.Tanenbaum, J.W.Stevenson & H. van Staveren,
	"Description of a experimental machine architecture for use of
	 block structured languages" Informatika rapport xx.
  A description of Pascal is given in
   - K.Jensen & N.Wirth, "PASCAL user manual and report", Springer-Verlag.
  Several options may be given in the normal pascal way. Moreover,
  a positive number may be used instead of + and -. The options are:
	a:	interpret assertions (+);
	c:	C-type strings allowed (-);
	i:	controls the number of bits in integer sets (16);
	l:	insert code to keep track of source lines (+);
	o:	optimize (+);
	r:	check subranges (+);
	s:	accept only standard pascal programs (-);
	t:	trace procedure entry and exit (-);
	v:	produce code for 24 bit addresses (-);
}
{===================================================================}

Downloads

Pascal-VU Reference manual, 1979
Pascal-VU Reference manual V2
seems to be a later version
Pascal-VU June 1980 tape archive + text files
Pascal-VU compiler test programs
Source of Pascal-VU compiler
Source of Pascal-VU compiler EM.h
Pascal-VU reference manual
ISO standard compliance reference
Description of EM1
Version of 2 March 1979

Pascal and the Vrije Universiteit

The Computer Science department of the Vrije Universiteit in Amsterdam is where I learned about programming.
In Pascal, as was usual in those years. Here my interest in compiler writing started, since there was a lot of work done on that subject there. Recursive descent down Wirth compilers, magic!

The first VU Pascal compiler was Pascal-U, initiated by van de Riet, based of course on Wirth’s portable Pascal compiler/interpreter.

Once this compiler was operational on a Unix PDP-11/45, a Pascal interpreter system was developed called BASIS, to help students do practical programming work.

Two Pascal compiler sources have been found by Stefano B. on archived tapes, with files sent out by the Computer Science department of the VU to other universities:

  • Pascal-U July 1977 on tape https://www.tuhs.org/Archive/Applications/Usenix_77/ug091377.tar.gz
  • Pascal-VU June 1980 on tape https://www.tuhs.org/Archive/Applications/Shoppa_Tapes/usenix_80_delaware.tar.gz

On the next pages details of these compilers can be found:

My personal story about the VU Pascal compilers and the time spent in the Computer Science department

In 1978 I choose to do Computer Science as part of my Math and Physics MSc study. I had some experience with a PDP-11 (with papertape, Fortran). And bought a KIM-1 SBC and did some assembler programming. But I wanted to be a professional programmer with a solid theoretical base. And that is what I found in the new and emerging CS faculty. I met Professor Reind van de Riet and enrolled in the program. Exams, a lot of practice with good support by the staff and a MSc as result!
Two educators there taught me about programming: Professor R.P. van de Riet, and, the then young and later so famous, Professor Andrew S. Tanenbaum. Jim van Keulen was excellent in judging the practical assignments. Professor van het Riet advised me to buy “Algorithms + Data Structures = Programs” by Niklaus Wirth. I learned so much from that book!


I wrote my first programs with BASIS, running on the PDP-11/60, typing on a DEC LA120 printer terminal. Still have some print out. Ruud Wiggers did most of the programming of the Basis system.

VU100

In March 1980 Professor van de Riet asked me to write an article for the VU100 Computerkrant, a publication for the computer show at the VU during the 100 year celebration of the University. about hobbycomputers, as I was his student and editor of the computer magazine Radio Bulletin.


Pascal-U

The Computer Science department of the Vrije Universiteit in Amsterdam is where I learned to program.
In Pascal as was usual in those years. Here my interest in compiler writing started, since there was a lot of interest in that subject there.
Two educators there taught me about programming: Professor R.P. van de Riet, and, the then young and later so famous, Professor Andrew S. Tanenbaum.

The first VU Pascal compiler was Pascal-U, initiated by van de Riet, based of course on Wirth’s portable Pascal-P2 compiler/interpreter.

Once this compiler was operational on a Unix PDP-11/45, a Pascal interpreter system was developed called BASIS, to help a student do practical programing work.

Pascal-U July 1977 can be found in a folder called ‘vrije’ on the tape dump at https://www.tuhs.org/Archive/Applications/Usenix_77/ug091377.tar.gz

Header of the Pascal compiler

(*version: 004      date: 1-5-77*)
(*--------------------------------------------------------------
|                                                               |
|       P A S C A L   C O M P I L E R                           |
|       -----------------------------                           |
|                                                               |
|   This compiler processes PASCAL-U1, a subset of              |
|   of standard PASCAL and has been written in this subset.     |
|   It is a modified version of the PASCAL-P2 compiler as       |
|   distributed by the ETH at Zuerich.                          |
|                                                               |
|   Authors:                                                    |
|      Urs Amann, Kesav Nori, Christian Jacobi                  |
|                                                               |
|   Authors of modification:                                    |
|      Rudolf van Bottenburg, Johan Stevenson                   |
|       Vakgroep Informatica                                    |
|       Wiskundig Seminarium                                    |
|       Vrije Universiteit                                      |
|       A M S T E R D A M                                       |
|                                                               |
---------------------------------------------------------------*)

Downloads

Source of Pascal-U compiler
User manual of the Pascal-U compiler
Archive of Pascal-U compiler
Source and man pages and binaries for Unix System 6

Note that the archive contains the source of the compiler, but not of the interpreter.

First part of the Pascal-U manual

PASCAL‐U is the name of the dialect of Pascal implemented on the PDP 11/45 under
the UNIX time‐sharing system.  This dialect is based on PASCAL‐P as  distributed
by  the ETH at Zurich.  The implementation of PASCAL‐U has been developed by the
vakgroep informatica of the  Vrije  Universiteit,  Amsterdam,  The  Netherlands.

                                 2.Some history
                                 ‐‐‐‐‐‐‐‐‐‐‐‐‐‐
The  first  plans  to implement Pascal on the PDP 11/45 were developed under the
guidance of prof. R.P.van de Riet. In those days (mid 1975) the operating system
was  DOS,  a  single user system.  The greatest problem has been the limited ad‐
dress space of the machine.  The Pcompiler produces code for a virtual  machine,
called  the  SC  machine.  Macro expansion of SC instructions to PDP‐11 code was
not feasible due to the addressing limit of the PDP‐11.  Therefore  the  SC  in‐
structions were directly encoded and an interpreter was written to execute them.
The following description concerns work carried out by Rob Thomas, Johan Steven‐
son and later on by Rudolf van Bottenburg.  The first bootstrap used a CDC Cyber
73 computer on which Pascal was available.

At the end of 1975 a preliminary version was running under  DOS.   Many  changes
have  been  made to the PASCAL‐P2 compiler, most of them forced by the different
size for variables of the various standard  types  and  the  address  alignment.
(The  Pcompiler foolishly assumed that integers,reals etc. all occupied the same
number of storage units.)  At the same time, however, the UNIX time‐sharing sys‐
tem  was  installed. That required adjusting the Pascal system.  The interpreter
was rewritten in the UNIX assembly language, and the SC assembler  in  the  high
level language C.

To  minimize  the  space  requirements, some changes were made to the first UNIX
version:
a.based upon static counting of SC‐instructions in the compiler itself, some in‐
  structions of 2 or more bytes with a high frequency got a 1‐byte format.  This
  is not done very systematically, however. Further measurements are needed.
b.a lot of optimization is done concerning label references: offsets instead  of
  indices, distinction between forward and backward, long and short offsets.
c.the handling of input and output is improved.
This  resulted in a 25% saving in space for code, while at the same time the in‐
terpretation speed improved.  The 16000 SC‐instructions for the compiler  itself
are  coded in less than 26000 bytes, inclusive constants.  This system is called
the PASCAL‐U1 system.

One of the projects under development in our department, is the BASIS system. It
is  used  in teaching basic programming techniques to students of several disci‐
plines. BASIS is a big program written in Pascal, in size  comparable  with  the
Pcompiler.  One  of  the  reasons to make Pascal available on the PDP 11/45, has
been this BASIS project.

The plans for the near future are:
a.to adopt the improvements of the P4‐compiler with respect to the P2‐compiler.
b.to allow external procedures.
c.to allow the Pascal user to choose between interpretation and execution of ex‐
  panded  SC‐instructions.  For example, one would like to make the scanner of a
  compiler fast by execution of its expanded code and leave the other parts  in‐
  terpreted,  since for most programs 20% of the program is responsible for more
  than 80% of its execution time.
d.to make some local improvements touched upon in the assembler description.
e.to tune the instruction set of the abstract machine.

    

MAN page for the PASCAL-U compiler



PC(I)                       03/05/77                        PC(I)


NAME
       pc ‐ PASCAL‐U compiler

SYNOPSIS
       pc [‐lpc12rx] file.p [arg1 ...]

DESCRIPTION
       pc  is  the  UNIX pascal compiler. It has an optional flag
       argument.
       If  no  flags are given, pc compiles the program on file.p
       and leaves the bsc‐code on file.b. Diagnostics are written
       to  standard  output.   The effect of the flags is as fol‐
       lows:

       ‐l   produces a complete listing of the program with error
          indications and explained error messages.

       ‐p  makes a partial listing. Only the erroneous lines  are
          listed.

       ‐c  suppresses code generation, does a syntax and semantic
          check only.

       ‐1 performs pass1 of the compiler, leaves the intermediate
          (sc) code on file.i .Pass2 is suppressed, unless the ‐2
          flag is given.

       ‐2 executes pass2 of the compiler and leaves interpretable
          bsc‐code  on  file.b.   If given without the ‐1 flag it
          expects its input on file.i rather than file.p.

       ‐r  runs  the  compiled program by calling the interpreter
          with file.b as codefile.  Arguments given after  file.p
          are passed.

       ‐x invokes sc‐code expansion.(not yet implemented)

       After  an error is detected during pass1, the code generation
       is suppressed.

       The main differences from standard PASCAL are:
       1. The  program has no other file than those in  the  pro‐
          gram heading, which have type text.There may be at most
          eight files, including the predeclared files input  and
          output,  which  are  associated with standard input and
          output.

       2. Formal  parameters must not be functions or procedures.

       3. All  records are packed. The procedure  unpack  is  not
          available.

       4. The  maximum length of string constants is 80.

       5. The  ordinal value of a set element  must lie between 0

                              ‐ 1 ‐


PC(I)                       03/05/77                        PC(I)


          and 63 inclusive.

       6. A  goto  may  not lead out of a  procedure  or function
          body.

       7. After  reset a call of  get is  necessary to initialize
          the buffer of a non‐standard inputfile.

       8. The procedure dispose is not available.  Mark  and  re‐
lease             are  added  to  manipulate  the  heap:
mark(anyptr)          puts the top of  heap  address  in  anyptr.
            release(anyptr)     restore  the  top  of  heap  from
anyptr.


FILES
       file.p  source file
       file.i  intermediate sc‐code
       file.b  bsc‐code, interpretable by pi.
       /lib/ppass1 pass1
       /lib/ppass2 pass2
       /lib/pclist error diagnostics
       /usr/bin/pi interpreter

SEE ALSO
       pi (I), PASCAL‐U1 documentation, PASCAL user manual.

DIAGNOSTICS
       The  diagnostics  are  intended  to  be  self‐explanatory.
       "Memory Fault" may be given if space is exhausted.

BUGS
       Reals can only be written  in  E‐format.   Runtime  checks
       are   not  implemented.   Omitting the filename in read or
       write may give problems.  Empty fields in records and empty  
       statements  can give messages.  Writeln and readln require 
       always a parameterlist .

                              ‐ 2 ‐
    

MAN page for the PASCAL-U interpreter

PI(I)                                                    12/22/76


NAME
       pi   ‐   the PASCAL‐U interpreter


SYNOPSIS
       pi    bscfile   userfile1 ....


DESCRIPTION
       The  binary  stack computer code (BSC) is read  from  bsc‐file.  The
       userfiles  are expected to be the actual  file  parameters to  be
       substituted for the formal file names given in the  pascal program
       heading.   Standard  output and standard input are substituted  for
       the formal names output and input.  The order of the arguments is
       assumed to correspond with the order of the remaining formal file
       names.


SEE ALSO
       pc(I), PASCAL‐U1 documentation, Pascal user manual


DIAGNOSTICS


       All error messages are self explanatory.  A  memory  fault 
       can also indicate: no room left

    

Apple Lisa Pascal

APPLE LISA COMPUTER PASCAL


The 68000-based Lisa computer (1979 – 1985) was unique in that the majority of its system and application software was written in a powerful extended version of Pascal called Lisa Pascal. This software included the operating system (90^000 lines), the Workshop development environment (100,000 lines), 7 application programs (each around 50.000 lines [e.g. LisaWrite, LisaCalc]), and an avalanche of development support programs (e.g. mouse-based editor, telecommunications program, and Pascal language utilities).

Apple’s Lisa Pascal developments began from scratch for Apple when it licensed in 1981 a Motorola 68000 native code Pascal compiler from Silicon Valley Software in California. This compiler was based upon the older P4 compiler from Niklaus Wirth of ETH in Switzerland and consisted of two general passes. Pass 1 produced I-Code, a low-level representation of the high-level Pascal constructs. Pass 2, the code generator, converted the I-Codes to optimized 68000 object code. Apple even considered early in the Lisa’s development using a custom Apple processor which would execute P-Code directly, but the expense of developing such a chip was too much for Apple’s accountants and this project was dropped.

All Lisa development was done with the Lisa Workshop, a command line based development environment similar to Apple’s earlier ][ and /// Pascal systems. The Workshop provided an excellent development environment with its Pascal compiler, mouse-based editor, 68000 assembler, and an extensive collection of utility programs (e.g. Format, XRef, ProcNames). The Workshop supported other languages which included BASIC, COBOL, and C.

Apple produced several versions of Lisa Pascal: 1.0, 2.0, 3.0. Version 3. was the last version and supported the creation of intrinsic units which allowed a single copy of a unit to exist in the system and be used by several programs simultaneously. All versions supported language extensions such as otherwise clause in case statements, longint 32 bit integers, § operator for data addresses, data type coercion, and relaxed ordering of const/type/var sections. A lot of bit-based -functions were also
supported (e. g. BITAND to make bit bashing easier. Inline 68000 assembly code could also be used.

Like the Apple /// Pascal, Lisa Pascal also supported SANE, Apple’s IEEE floating-point implementation. In addition to SANE Apple developed a fairly comprehensive math package called MathLib.
Apple also developed an IEEE floating-point test program which attempted to ring out the bugs in SANE (Jerome Coonen of Apple wrote this test program and its associated test vectors).

Lisa Pascal was a superset of Apple’s older ][ and /// Pascals and, as such, was able to compile ][ and /// Pascal programs which did not make any ][ or /// system calls. Lisa Pascal could also produce a compilation listing complete with the Pascal source code interleaved with the generated 68000 assembly statements.

Apple also developed the Lisa QuickDraw (a. k. a. LisaGraf ) graphics library which formed the heart of what was called Lisa Technology. Though written in 68000 assembly^ Apple provided an extensive Pascal interface to this rather remarkable graphics environment (QuickDraw was later patented by Apple and Bi11 Atkinson. QuickDraw’s creator).

When Apple introduced the Macintosh computer in 1984 all Macintosh programming by Apple and others was done with Lisa Pascal and the Lisa Workshop. For this activity Apple created an extensive set of libraries containing the Macintosh toolbox interfaces. Many important Macintosh programs were written in Lisa Pascal, including MacPaint, MacWrite, MacDraw, and MacTerminal.

The key players behind Lisa Pascal were Ira Rubin and Al Hoffmann.
Apple provided extensive documentation for the Lisa Workshop and Lisa Pascal which included a language manual, an operating system manual, and a Workshop manual. Many internal memos were also released by Apple which described special features of Lisa Pascal.

Lisa Pascal was also used by Apple to develop the Lisa Clascal object-oriented language and the Clascal-based Toolkit class library.

Apple discontinued the Lisa in 1985 in favor of the Macintosh and when Apple’s native Macintosh development environment (MPW) became operational in 1986 Apple dropped support for Lisa Pascal and the Lisa Workshop. Therefore, Lisa Pascal lasted from 1981 to 1986, an eternity in the field of microcomputer languages.

APPLE LISA COMPUTER CLASCAL
Apple’s first foray into the world of object-oriented programming was with the Lisa Clascal (Classes + Pascal) language. Developed from 1983 to 1985 Clascal was an extension of Lisa Pascal which included several new keywords such as methods and subclass. The main concepts behind Clascal were derived from Simula and Smalltalk. Xerox PARC’s experimental object-oriented language.
In addition to Clascal Apple also developed an extensive set of class libraries which were collectively called the Lisa Toolkit. This class library allowed Lisa developers to create Lisa desktop applications (a. k. a. tools) in a fairly short time frame.

Though really used only internally by Apple for its own research efforts Clascal was made available to external developers but without any support by Apple (David Redhed of Seattle Washington created an independent Clascal/Toolkit support group called the Toolkit User’s Group [TUG], but this unfortunately did not last too long). Apple considered enhancing ClascaL but this Clascal-85 effort was extinguished by Apple’s work with Object Pascal for the Macintosh.
Several significant programs were developed with Clascal and the Toolkit including a calendar program, Apple’s Lisa-to-tlacintosh data conversion program, a desktop publishing program, and a fuzzy logic program.
The key player behind Clascal was Larry Tesler, one of the Lisa computer’s designers, and several former Xerox Smalltalk experts.

When Apple dropped all support for Clascal and the Toolkit it provided the Toolkit source code to the public, but the source code to the Clascal compiler was, alas, not made public.

Pascal-M 2k1

Pascal-M 2K1

Pascal-M Compiler Linker Disassembler Loader system
Hans Otten, November 2021 Version 0.9
Applicable license: MIT license. Permission given by Mark Rustad.

Note that this version is still beta quality! Your feedback is appreciated!
Contents

Downloads for Windows, Ubuntu and Raspberry PI OS:
Pascal-M 2K1 programs
Pascal-M 2K1 sources

How the Pascal-M system works

The Pascal-M system will let you write Pascal programs and execute them on the 6502, e.g. the KIM-1 or the console of the PC.
The Pascal dialect is standard Pascal (no reals for example) as described in the second edition of ‘The Pascal User Manual and Report’. It can (could in older versions!) compile itself.

To get a Pascal program running on the KIM-1 the Pascal-M 2K1 system requires the following steps.

  1. Edit Write the text of the Pascal program
  2. Compile Repeat 1 and 2 until no compilation errors
  3. Load Convert the object M-code of the compiler output to binary code
  4. Link Combine the compiled binary and the 6502 interpreter to an executable KIM-1 program
  5. Run Load the Papertape file on the KIM-1 and run it

How to use

Step 1: Write a Pascal program with any text editor on your PC, create ASCII text files.
Save the Pascal source with extension .pas, and keep the editor open. I use Notepad++ on Windows, any editor will do.
Step 2 – 4: Start the PascalM2K1 program, a GUI program, and fill in the name of the Pascal source.
Press Compile and if the Pascal-M compiler sees no errors goto step 3 and press Load else go back to the editor.
Note the load address is needed to tell where the code should go in memory, the default is fine for now.
See the section on ‘Memory layout’.
Step 4 requires to fill in the name of the binary of the 6502 interpreter (default pascalmint2k1.bin, make sure it is found).
Also fill in the name you want for the 6502 program (Binary, a papertape version is produced also).
Fill in the upper memory RAM limit in your KIM-1. the default is for 32K RAM above $2000, max is $9FFF.
Press Link.
Step 5: Take the papertape file via a terminal emulator to the KIM-1 (in TTY mode) and run it from start address $2000

The example file test.pas contains the source:

program ctest ;

begin

  writeln('hello world') ;
  
end.

During the steps of PascalM2k1 many files are produced. If for example you start with helloworld.pas and finally link to runhelloworld.bin the following files will be present:

  • helloworld.pas The Pascal source program you have written
  • helloworld.lst Listing of the source program with compilation results
  • helloworld.obp Px code representation of the Mcode
  • helloworld.err Every step produces a file with the status, error or success.
    Also shown in the status field in PascalM2k1
  • helloworld.bin The Mcode loaded into a binary
  • helloworld.prc The Procedure table binary
  • helloworld.dlst The disassembled Mcode, see the Debug section
  • runhelloworld.bin The runnable program binary
  • runhelloworld.pap The MOS papertape version of he runnable program.

You will only have to keep the helloworld.pas and the resulting program runhelloworld.bin and pap, the others can be made again.

Command Line Utilities

The steps described above for PascalM2k1 can also be done with command line utilities. No argument given will prompt for answers.
Help given with -h. Functionality and steps identical to the PascalM2K1 program. Same files produced.

  • cpascalm2k1.exe Pascal-M compiler V2k1
    Syntax:
    cpascalm2k1 <sourcefile> [V]
    produces sourcefile.err (status) and sourcefile.obp (object) files
    V shows errors on console
  • cpascalmload.exe Loader for Pascal-M 2K1
    Syntax:
    cpascalmload <objectfile>[<loadaddress in hex>]
  • cpascalmlinker.exe Pascal-M linker 2K1
    Syntax:
    cpascalmlinker <binfile from loader> <start adress> <interpreter binary><binary startaddres> <linked program file> <upper memory>
  • cpascalmdis.exeDisassembler for Pascal-M 2K1, see the Debug section
    Syntax:
    cpascalmdis <objectfile> <loadaddress in hex>


Pascal-M limitations

Pascal-M is close to standard Pascal, but there are limits due to the P2 origin (close to the second ‘Pascal User Manual and Report’,
recommended as description for Pascal-M) and the limitations to make a small compiler for an 8 bit target.
When you read the compiler source (pascalmcompiler.inc) you will see it is a real language, and can compile itself
(if you strip all enhancements made by me, see SMPASCAL.PAS on the website for the last version that compiles on the KIM-1!)).

This list sums up the important limitations:

  • Identifiers are unique in the first 8 characters
  • No reals
  • Only text files (7 max)
  • 16 bit integers
  • max store size 32768 bytes
  • set max 63 members
  • max 100 procedures/functions, call depth max 12

Memory layout

A Pascal-M program requires RAM from $2000 and up.
The upper limit is variable and can be maximum $DFFF.
The memory layout of a Pascal-M 2K1 system is:

Interpreter start  $2000 - $2F00 : Pascal-M 6502 interpreter
                   $2F00 - $2FFF : procedure buffer 
Load address       $3000 - + size of M-code
                  .
                  .
          heap growing up
                  .
                  .
          stack growing down
                         - $9FFF = Upper memory 
                           (can be $DFFF for a 48K system) 

The interpreter starts at $2000, point the monitor there and Go. After the Jump the memory layout is found: first location of M-code (default $3000), end of memory (default $9FFF) and end of M-code/start of heap (dependent on the size of the M-code).
The linker fills these addresses.

Console interpreter and debugger

cpascalmint2k1.exe is a command line Mcode interpreter and debugger.
Syntax:
pascalmint2k1 [<name of Mcode object>] [debug]

Without the optional debug parameter the Mcode program is executed:

D:\myfiles\development\PascalM\PascalM2k1\pascal interpreter&amp;amp;gt;pascalmint2k1.exe test.obp
hello world

With the debug parameter a command line drive debugger is started. Use also the Mcode disassembly output to see what is happening in the Mcode machine.

D:\pascalmint2k1.exe test.obp debug
Program ctest    Loaded

PC    = 7CFC
M-Debug &gt;?

Available debug commands :

  B = Breakpoint commands
  C = Show stack contents
  D = Display store
  E = Show stack contents
  G = Continue without debugger
  H = Show heappointer
  I = Insert in store
  M = Show markpointer
  N = Next instruction executed
  P = Show programcounter
  S = Show stackpointer
  T = Show procedure table
  X = Exit interpreter

PC    = 7CFC
M-Debug &gt;
Break subcommand &gt;?

Available Break commands :

  C = Clear all breakpoints
  D = Show  all breakpoints
  S = Set breakpoint


Compiling and building the programs from source

Prerequisites

  • A modern PC and operating system. Windows 10 is where the software has been developed, Raspberry OS /Linux have seen limited tested for now. MacOS may work, untested
  • Development (Compile and run everywhere!) with Freepascal and Lazarus IDE (2.x) see https://www.lazarus-ide.org/
    Any version above 2.0 will be OK, No OS dependent functions are used a.f.a.i.k.
  • The archives with the KIM-1 Simulator sources PascalM2k1sources.zip (or higher version).
  • Unpack in a folder, avoid blanks in folder and filenames
  • Start the IDE by clicking on the relevant .lpi file.
  • Build with Run – Build

The system is made up of main programs that ‘include’ the actual functionality. This way the command line utilities and the GUI pascalM2k1 share the code.
If a change is made to an .inc file both vcalling programs may need attention and tests.
No extra components are used, standard Lazarus will do.
Note that the ‘mode’ of the units is important, the compiler needs mode $delphi.

The 6502 interpreter is living in the folder 6502interpreter.
No special assembler syntax is used, TASM 32 bit for Windows command line is included.

tasm -65 pascalmint2k1.asm -b pascalmint2k1.bin
TASM 6502 Assembler.      Version 3.2 September, 2001.
 Copyright (C) 2001 Squak Valley Software
tasm: pass 1 complete.
tasm: pass 2 complete.
tasm: Number of errors = 0

will produce the pascalmint2k1.bin file required

Port to other systems

The Pascal-M system is easy to port to other systems. Another 6502 system is quite easy, adaptations on the assembler source will be:

  • Character I/O, replace the KIM TTY in/out (note the ‘echo’ adaptation, so no hardware echo on the KIM-1!) with the relevant character I/O routines of the new target
  • Take look at the memory layout of the new target, adapt lower and upper memory address in use. It is possible to let the interpreter be independent in memory from the M-code.
    The Pascal-m2K1 does not support this, you will have to manage the binary files and memory management in the interpreter yourself

Another platform is a bit more work. Use an assembler or compiler, the interpreter needs to be written for the new target. Take the Pascal interpreter as example, it is well documented.

Introduction and history

How I spent 40 years on getting so far ….
Pascal-M is the name of the Pascal compiler written by Mark Rustad, around 1977.
It was based (and mostly identical) to the portable P2 Pascal compiler, from the ETH Zurich group led by Niklaus Wirth.
The Px Pascal compilers are portable compiler-interpreters, quality compilers and easy to adapt interpreter to new hosts.

The adaptations by Mark Rustad were in the code production, the M-code is byte oriented and more efficient in memory demands.
File I/O was stripped as was floating point. Only chars, integers 16 bit and booleans. Uppercase only. Input/output was for a teletype, so input was either the keyboard or a HSR (High Speed Reader), output a printer or a HSP( High Speed Punch) via a software
switch.
Mark Rustad told me he ported the compiler to 6800 and 6809. G.J. van der Grinten did work on the interpreter part for the KIM-1 and wrote a 6502 interpreter.
The Micro Ade editor was adapted to produce Pascal text files.

In 1978 I received from the KIM Club in the Netherlands a version of this Pascal-M system, consisting of a KIM-1 tape with the compiler and interpreter and Micro Ade,
listings of the compiler (in Pascal), preliminary M-code description, the interpreter (in 6502 assembler) and the Micro Ade patches.
It was never made into a product for the KIM club, it was a nightmare to use. From entering text to running a program, all from audio cassette files, it took around an hour.
The old days of papertape and cards were gone already. But the time of cross-compiling or floppy drives connected to the KIM-1 was not there yet.
I got no further than a ‘Hello world’ program once and gave up.

In 1983 I started typing in the source on a PDP-11 with RSX-11M Pascal. And moved on to VAX/VMS with the excellent VMS Pascal. After some years I had the compiler, an interpreter
written in Pascal with debugger and the original 6502 interpreter on tape. This system produced for the second time, in 1986, a running ‘Hello world’ on the KIM-1.
I started expanding the compiler, bringing back P2 functionality like file handling, text files are now supported. Lowercase also. Bugs fixed.

But then I bought a CP/M system and the KIM-1 was put aside. Pascal-M forgotten for several years, Pascal compiler technology not.

I came back in MS-DOS times to the Pascal-M system with the compiler running as a Turbo Pascal (1994, 2003). Then Delphi arrived and the Pascal-M system was brought to live again as Delphi console applications.
In 2020 this was compiled in Freepascal, the compiler was cleaned up (and the original source restored also).

And now in 2021 a Lazarus shell around the steps required to produce a working program was programmed. The 6502 interpreter was finally assembled from source again.
Pressing a couple of buttons is now all it takes to produce a program running on the KIM-1 (and as console on the PC).
The command line utilities are refreshed also. So a ‘Hello World’ takes a a couple of minutes from source editing to running on the KIM-1 (Simulator).
The motivation for the KIM-1 Simulator was mostly for being able to test the Pascal-M system!

Error messages from the compiler

     2 Syntax: identifier expected             
     3 Syntax: Program expected                
     4 Syntax: &quot;)&quot; expected                    
     5 Syntax: &quot;:&quot; exepected                   
     6 Syntax: illegal symbol                  
     7 Syntax: actual parameter list           
     8 Syntax: OF expected                     
     9 Syntax: &quot;(&quot; expected                    
    10 Syntax: type specfication expected      
    11 Syntax: &quot;[&quot; expected                    
    12 Syntax: &quot;&quot; expected                    
    13 Syntax: end expected                    
    14 Syntax: &quot;;&quot; expected                    
    15 Syntax: integer expected                
    16 Syntax: &quot;-&quot; expected                    
    17 Syntax: begin expected                  
    18 Syntax: error in declaration part       
    19 Syntax: error in field list             
    20 Syntax: &quot;,&quot; expected                    
    21 Syntax: &quot;*&quot; expected                    
    50 Syntax: &quot;error in constant              
    51 Syntax: &quot;:=&quot; expected                   
    52 Syntax: then expected                   
    53 Syntax: until expected                  
    54 Syntax: do expected                     
    55 Syntax: to/downto expected              
    56 Syntax: if expected                     
    58 Syntax: ill-formed expression           
    59 Syntax: error in variable               
   101 Identifier declared twice               
   102 Low bound exceeds high-bound            
   103 Identifier is not a type identifier     
   104 Identifier not declared                 
   105 Sign not allowed                        
   106 Number expected                         
   107 Incompatible subrange types             
   110 Tag type must be an ordinal type        
   111 Incompatible with tag type              
   113 Index type must be an ordinal type      
   115 Base type must be scalar or subrange    
   116 Error in type of procedure parameter    
   117 Unsatisfied forward reference           
   118 Forward reference type identifier       
   119 Forward declared : repetition par. list 
   120 Function result: scalar,subrange,pointer
   122 Forward declared: repetition result type
   123 Missing result type in function declar. 
   125 Error in type of standard function par. 
   126 Number of parameters disagrees with decl
   129 Incompatible operands                   
   130 Expression is not of SET type           
   131 Test on equality allowed only           
   132 Inclusion not allowed in set comparisons
   134 Illegal type of operands                
   135 Boolean operands required               
   136 Set element must be scalar or subrange  
   137 Set element types not compatible        
   138 Type must be array                      
   139 Index type is not compatible with decl. 
   140 Type must be record                     
   141 Type must be pointer                    
   142 Illegal parameter substitution          
   143 Illegal type of loop control variable   
   144 Illegal type of expression              
   145 Type conflict                           
   147 Case label and case expression not comp.
   148 Subrange bounds must be scalar          
   149 Index type must not be an integer       
   150 Assignment to standard function illegal 
   152 No such field in this record            
   154 Actual parameter must be a variable     
   155 Control variable declared interm. level 
   156 Value already as a label in CASE        
   157 Too many cases in CASE statement        
   160 Previous declaration was not forward    
   161 Again forward declared                  
   169 SET element not in range 0 .. 63        
   170 String constant must not exceed one line
   171 Integer constant exceeds range(32767) 
   172 Too many nested scopes of identifiers   
   173 Too many nested procedures/functions    
   174 Index expression out of bounds          
   175 Internal compiler error : standard funct
   176 Illegal character found                 
   177 Error in type                           
   178 Illegal reference to variable           
   179 Internal error : wrong size variable    
   180 Maximum number of files exceeded        

50 years of Pascal

By Niklaus Wirth
Communications of the ACM, March 2021, Vol. 64 No. 3, Pages 39-41

In the early 1960s, the languages Fortran (John Backus, IBM) for scientific, and Cobol (Jean Sammet, IBM, and DoD) for commercial applications dominated. Programs were written on paper, then punched on cards, and one waited a day for the results. Programming languages were recognized as essential aids and accelerators of the programming process.

In 1960, an international committee published the language Algol 60.1 It was the first time a language was defined by concisely formulated constructs and by a precise, formal syntax. Two years later, it was recognized that a few corrections and improvements were needed. Mainly, however, the range of applications should be widened, because Algol 60 was intended for scientific calculations (numerical mathematics) only. Under the auspices of IFIP a Working Group (WG 2.1) was established to tackle this project.

The group consisted of about 40 members with almost the same number of opinions and views about what a successor of Algol should look like. There ensued many discussions, and on occasions the debates ended even bitterly. Early in 1964 I became a member, and soon was requested to prepare a concrete proposal. Two factions had developed in the committee. One of them aimed at a second, after Algol 60, milestone, a language with radically new, untested concepts and pervasive flexibility. It later became known as Algol 68. The other faction remained more modest and focused on realistic improvements of known concepts. After all, time was pressing: PL/1 of IBM was about to appear. However, my proposal, although technically realistic, succumbed to the small majority that favored a milestone.

uf1.jpg
Figure. A poster of Pascal's syntax diagrams strongly identified with Pascal.

It is never sufficient to merely postulate a language on paper. A solid compiler also had to be built, which usually was a highly complex program. In this respect, large industrial firms had an advantage over our Working Group, which had to rely on enthusiasts at universities. I left the Group in 1966 and devoted myself together with a few doctoral students at Stanford University to the construction of a compiler for my proposal. The result was the language Algol W,2 which after 1967 came into use at many locations on large IBM computers. It became quite successful. The milestone Algol 68 did appear and then sank quickly into obscurity under its own weight, although a few of its concepts did survive into subsequent languages.

But in my opinion Algol W was not perfectly satisfactory. It still contained too many compromises, having emerged from a committee. After my return to Switzerland, I designed a language after my own preferences: Pascal. Together with a few assistants, we wrote a user manual and constructed a compiler. In the course of it, we had a dire experience. We intended to describe the compiler in Pascal itself, then translate it manually to Fortran, and finally compile the former with the latter. This resulted in a great failure, because of the lack of data structures (records) in Fortran, which made the translation very cumbersome. After this unfortunate, expensive lesson, a second try succeeded, where in place of Fortran the local language Scallop (M. Engeli) was used.

Pascal

Like its precursor Algol 60, Pascal2 featured a precise definition and a few lucid, basic elements. Its structure, the syntax, was formally defined in Extended BNF.3 Statements described assignments of values to variables, and conditional and repeated execution. Additionally, there were procedures, and they were recursive. A significant extension were data types and structures: Its elementary data types were integers and real numbers, Boolean values, characters, and enumerations (of constants). The structures were arrays, records, files (sequences), and pointers. Procedures featured two kinds of parameters, value-and variable-parameters. Procedures could be used recursively. Most essential was the pervasive concept of data type: Every constant, variable, or function was of a fixed, static type. Thereby programs included much redundancy that a compiler could use for checking type consistency. This contributed to the detection of errors, and this before the program's execution.

Just as important as addition of features were deletions (with respect to Algol). As C.A.R. Hoare once remarked: A language is characterized not only by what it permits programmers to specify, but even more so by what it does not allow. In this vein, Algol's name parameter was omitted. It was rarely used, and caused considerable complications for a compiler. Also, Algol's own concept was deleted, which allowed local variables to be global, to "survive" the activation of the procedure to which it was declared local. Algol's for statement was drastically simplified, eliminating complex and hard to understand constructs. But the while and repeat statements were added for simple and transparent situations of repetition. Nevertheless, the controversial goto statement remained. I considered it too early for the programming community to swallow its absense. It would have been too detrimental for a general acceptance of Pascal.

Pascal was easy to teach, and it covered a wide spectrum of applications, which was a significant advantage over Algol, Fortran, and Cobol. The Pascal System was efficient, compact, and easy to use. The language was strongly influenced by the new discipline of structured programming, advocated primarily by E.W. Dijkstra to avert the threatening software crisis (1968).


Rapidly computers became faster, and therefore demands on applications grew, as well as those on programmers.


Pascal was published in 1970 and for the first time used in large courses at ETH Zurich on a grand scale. We had even defined a subset Pascal-S and built a smaller compiler, in order to save computing time and memory space on our large CDC computer, and to reduce the turnaround time for students. Back then, computing time and memory space were still scarce.

Pascal's Spread and Distribution

Soon Pascal became noticed at several universities, and interest rose for its use in classes. We received requests for possible help in implementing compilers for other large computers. It was my idea to postulate a hypothetical computer, which would be simple to realize on various other mainframes, and for which we would build a Pascal compiler at ETH. The hypothetical computer would be quickly implementable with relatively little effort using readily available tools (assemblers). Thus emerged the architecture Pascal-P (P for portable), and this technique proved to be extremely successful. The first clients came from Belfast (C.A.R. Hoare). Two assistants brought two heavy cartons of punched cards to Zurich, the compiler they had designed for their ICL computer. At the border, they were scrutinized, for there was the suspicion that the holes might contain secrets subject to custom fees. All this occurred without international project organizations, without bureaucracy and research budgets. It would be impossible today.

An interesting consequence of these developments was the emergence of user groups, mostly of young enthusiasts who wanted to promote and distribute Pascal. Their core resided under Andy Mickel in Minneapolis, where they regularly published a Pascal Newsletter. This movement contributed significantly to the rapid spread of Pascal.

Several years later the first microcomputers appeared on the market. These were small computers with a processor integrated on a single chip and with 8-bit data paths, affordable by private persons. It was recognized that Pascal was suitable for these processors, due to its compact compiler that would fit into the small memory (64K). A group under Ken Bowles at the University of San Diego, and Philippe Kahn at Borland Inc. in Santa Cruz surrounded our compiler with a simple operating system, a text editor, and routines for error discovery and diagnostics. They sold this package for $50 on floppy disks (Turbo Pascal). Thereby Pascal spread immediately, particularly in schools, and it became the entry point for many to programming and computer science. Our Pascal manual became a best-seller.

This spreading did not remain restricted to America and Europe. Russia and China welcomed Pascal with enthusiasm. This I became aware of only later, during my first travels to China (1982) and Russia (1990), when I was presented with a copy of our manual written in (for me) illegible characters and symbols.

Pascal's Successors

But time did not stand still. Rapidly computers became faster, and therefore demands on applications grew, as well as those on programmers. No longer were programs developed by single persons. Now they were being built by teams. Constructs had to be offered by languages that supported teamwork. A single person could design a part of a system, called a module, and do this relatively independently of other modules. Modules would later be linked and loaded automatically. Already Fortran had offered this facility, but now a linker would have to verify the consistency of data types also across module boundaries. This was not a simple matter!

Modules with type consistency checking across boundaries were indeed the primary extension of Pascal's first successor Modula-24 (for modular language, 1979). It evolved from Pascal, but also from Mesa, a language developed at Xerox PARC for system programming, which itself originated from Pascal. Mesa, however, had grown too wildly and needed "taming." Modula-2 also included elements for system programming, which admitted constructs that depended on specific properties of a computer, as they were necessary for interfaces to peripheral devices or networks. This entailed sacrificing the essence of higher languages, namely machine-independent programming. Fortunately, however, such parts could now be localized in specific "low-level" modules, and thereby be properly isolated.


No reference to any computer or mechanism should be necessary to understand it.


Apart from this, Modula contained constructs for programming concurrent processes (or quasiparallel threads). "Parallel programming" was the dominant theme of the 1970s. Overall, Modula-2 grew rather complex and became too complicated for my taste, and for teaching programming. An improvement and simplification appeared desirable.

From such deliberations emerged the language Oberon,5 again after a sabbatical at Xerox PARC. No longer were mainframe computers in use, but powerful workstations with high-resolution displays and interactive usage. For this purpose, the language and interactive operating system Cedar had been developed at PARC. Once again, a drastic simplification and consolidation seemed desirable. So, an operating system, a compiler, and a text editor were programmed at ETH for Oberon. This was achieved by only two programmers—Wirth and Gutknecht—in their spare time over six months. Oberon was published in 1988. The language was influenced by the new discipline of object-oriented programming. However, no new features were introduced except type extension. Thereby for the first time a language was created that was not more complex, but rather simpler, yet even more powerful than its ancestor. A highly desirable goal had finally been reached.

Even today Oberon is successfully in use in many places. A breakthrough like Pascal's, however, did not occur. Complex, commercial systems are too widely used and entrenched. But it can be claimed that many of those languages, like Java (Sun Microsystems) and C# (Microsoft) have been strongly influenced by Oberon or Pascal.

Around 1995 electronic components that are dynamically reprogrammable at the gate level appeared on the market. These field programmable gate arrays (FPGA) can be configured into almost any digital circuit. The difference between hardware and software became increasingly diffuse. I developed the language Lola (logic language) with similar elements and the same structure as Oberon for describing digital circuits. Increasingly, circuits became specified by formal texts, replacing graphical circuit diagrams. This facilitates the common design of hardware and software, which has become increasingly important in practice.

Comments and Conclusion

The principal purpose of a higher-level language is to raise the level of abstraction from that of machine instructions. Examples are data structures vs. word arrays in memory, or conditional and repetitive statements vs. jump instructions. A perfect language should be defined in terms of mathematical logic, of axioms and rules of inference. No reference to any computer or mechanism should be necessary to understand it. This is the basis of portability. Algol's designers saw this goal; but it is most difficult to achieve without sacrificing power of expression. Yet, any new language must be measured on the degree to which it comes close to this goal. The sequence Pascal—Modula—Oberon is witness to my attempts to achieve it. Oberon is close to it. Yet, nothing is perfect.

References

1. Naur, P. Revised report on the algorithmic language Algol 60. Commun. ACM 6, (Jan. 1963), 1–17.

2. Wirth, N. and Hoare, C.A.R. A contribution to the development of ALGOL. Commun. ACM 9 (June 1966), 413–432.

3. Wirth, N. The programming langage Pascal. Acta Informatica 1, (1971), 35–63; https://doi.org/10.1007/BF00264291

4. Wirth, N. What can we do about the unnecessary diversity of notation for syntactic definitions? Commun. ACM 20, 11 (Nov. 1977).

5. Wirth, N. Programming in Modula-2. Springer-Verlag 1982.

6. Wirth, N. The Programming Language Oberon. Software–Practice and Experience 18, (Jul. 1988), 671–690; https://doi.org/10.1002/spe.4380180707

post

Edsger Dijkstra

Page on Edsger Dijkstra has seen an update, Books and such on this amazing scientist, who lived in Nuenen long time ago, 10 km from where i live now. Last time I have seen him was in 1980 in Utrecht, where he gave a speech together with Niklaus Wirth and Tony Hoare at the University.

Apple Pascal

These pages on Apple and Pascal are limited to Apple Pascal for the Apple ][ and III, where the UCSD p-System was used.

But there was much more Pascal history at Apple, as is show on the next article.

History of Apple and Pascal (DTC 1992)

SUMMARY

Apple’s involvement with the Pascal language was extensive during the 1980 ‘s. From Apple’s introduction to Pascal on the Apple II computer in 1978, it has advanced to the powerful Macintosh 680×0 series Pascals of 1992.
Since 1988 Apple’s reliance on Pascal has been eclipsed by the emergence of C/C++ as Apple’s preferred system and application development language. Tho Pascal will have the support of a small but vocal minority at Apple, C/C++ will be the dominant development language for Apple and outsiders for the next decade.

A Brief History of Apple Computer’s Work with the Pascal Language
Written by David T. Craig 07 October 1992

TABLE OF CONTENTS
– INTRODUCTION
– APPLE ][ COMPUTER PASCAL
– APPLE /// COMPUTER PASCAL
– APPLE LISA COMPUTER PASCAL
– APPLE LISA COMPUTER CLASCAL
– APPLE MACINTOSH COMPUTER PASCAL
– APPLE MACINTOSH COMPUTER OBJECT PASCAL

INTRODUCTION
This document provides a concise history of the work that Apple Computer has done with the Pascal computer language. This history was written so that this rather interesting bit of computer technology would be recorded for those with an interest in technical histories like this.
The author has never worked for Apple Computer, but has been involved with software development for Apple’s many computers since 1978 and has extensively used all of Apple’s Pascal implementations. As such, the facts contained herein are based upon personal memories and Apple technical documents and may be inaccurate. The author hopes that those in the know about Apple’s Pascal work will correct and extend upon this paper so that the history of Apple’s Pascals will be made complete.

APPLE ][ COMPUTER PASCAL
See the Apple Pascal II page.
Apple first became involved with the Pascal language for its Apple ][ computer series around 1978. At this time Apple’s software development efforts were based upon the BASIC and 6502 assembly languages.
The key players in bringing Pascal to the Apple ][ were Bill Atkinson and Jef Raskin. Atkinson convinced Apple’s management that the Pascal language would be much better for Apple’s own software development activities than either BASIC or 6502 assembly. Atkinson and Raskin licensed the Pascal language and development system from the University of California at San Diego (UCSD) and began an internal Pascal development group.
Apple’s ][ Pascal system included a Pascal compiler, modal editor, 6502 assembler, a powerful filer, and several utility programs (e.g. program segment mapper). The system was controlled via a command line user interface.

The Apple ][ Pascal compiled to P-Code which was based upon byte codes and a stack architecture. This P-Code was interpreted by an interpreter written in 6502 assembly. 6502 assembly language routines could also be linked with P-Code programs. Identifiers in ][ Pascal were recognized only up to 8 characters, a painful limitation which Apple did not remove until its Macintosh MPW Pascal. Pascal’s memory use was restricted to 64k bytes due to the Apple ][ hardware architecture. ][ Pascal supported program modules called UNITs which could be either regular or shared (a. k. a. intrinsic). Units could be segmented so that they would reside in memory only when needed. ][ Pascal also supported a fairly sophisticated graphics unit called Turtle Graphics created by Atkinson.

Technical documentation for ][ Pascal was reasonably good and consisted of a language reference and an operating system manual.
Several major Apple ][ programs were developed in Apple ][ Pascal, including Apple’s Apple Presents the Apple and
PFS File by PFS Inc.
Apple produced several versions of Apple ][ Pascal: 1.0, 1.1, 1.2, 1.3. As of the middle 1980′ s Apple seems to have abandoned Pascal for the Apple ][. Current Apple ][ Pascal work is done via an Apple-developed Macintosh cross-development system called Macintosh Programmer’s Workshop.

APPLE /// COMPUTER PASCAL
See the Apple Pascal III page.
When Apple developed its Apple /// computer (1980 – 1985) it developed most of its software for this machine with Pascal.
Apple used the Apple ][ Pascal system to create the Apple /// Pascal system. As such, /// Pascal generated P-Codes for a stack-based architecture. The ///’s Pascal language syntax was extended (e. g. otherwise clause in case statements) and like Apple ][ Pascal also supported separate program units. Access to the ///’s native 6502-based operating system, SOS (Sophisticated Operating System, or Sara’s OS), also existed via a special Pascal unit called SOSIO. This OS unit also allowed programmers access to the ///’s larger memory, 256k bytes vs. 64k bytes for the ][ computer.
Apple produced several versions of Apple /// Pascal: 1. 0, 1. 1, 1. 2, 2.0. Version 2.0 of /// Pascal was unique in that it came with extensive technical documentation called the /// Pascal Workbench and consisted of around 1,000 pages. Version 2. 0’s Pascal compiler also produced a compilation listing consisting of the generated P-Code interleaved with the Pascal source code lines. /// Pascal also supported via a conditional compilation directive the compilation of Apple ][ Pascal programs and produced Apple ][ format code files.

Documentation for the /// Pascal system was excellent. This included a language manual, an operating system manual, and a very detailed runtime architecture manual which also listed all the P-Codes.
For /// Pascal Apple developed a very sophisticated floating-point implementation called SANE (Standard Apple Numeric Environment). SANE was based upon the IEEE floating-point standard. /// Pascal versions 1.0 and 1.1 supported only 4 byte REAL numbers, version 1.2 supported the higher quality 8 byte EXTENDED numbers. SANE went on to become the floating-point engine for Apple’s Lisa and Macintosh computers.
Most of Apple’s software for the /// was developed with the Pascal system. This included the System Utility Program and Backup ///.
The key players for Apple /// Pascal were Ira Rubin and Al Hoffmann.
Support for /// Pascal ended when Apple discontinued the /// computer in 1985. From this date onwards Apple seems to have ended its involvement with Pascal which generated P-Code, opting instead to deal fully with native code generators.

APPLE LISA COMPUTER PASCAL
See the Apple Lisa Pascal sources page
The 68000-based Lisa computer (1979 – 1985) was unique in that the majority of its system and application software was written in a powerful extended version of Pascal called Lisa Pascal. This software included the operating system (90^000 lines), the Workshop development environment (100,000 lines), 7 application programs (each around 50.000 lines [e.g. LisaWrite, LisaCalc]), and an avalanche of development support programs (e.g. mouse-based editor, telecommunications program, and Pascal language utilities).

Apple’s Lisa Pascal developments began from scratch for Apple when it licensed in 1981 a Motorola 68000 native code Pascal compiler from Silicon Valley Software in California. This compiler was based upon the older P4 compiler from Niklaus Wirth of ETH in Switzerland and consisted of two general passes. Pass 1 produced I-Code, a low-level representation of the high-level Pascal constructs. Pass 2, the code generator, converted the I-Codes to optimized 68000 object code. Apple even considered early in the Lisa’s development using a custom Apple processor which would execute P-Code directly, but the expense of developing such a chip was too much for Apple’s accountants and this project was dropped.

All Lisa development was done with the Lisa Workshop, a command line based development environment similar to Apple’s earlier ][ and /// Pascal systems. The Workshop provided an excellent development environment with its Pascal compiler, mouse-based editor, 68000 assembler, and an extensive collection of utility programs (e.g. Format, XRef, ProcNames). The Workshop supported other languages which included BASIC, COBOL, and C.

Apple produced several versions of Lisa Pascal: 1.0, 2.0, 3.0. Version 3. was the last version and supported the creation of intrinsic units which allowed a single copy of a unit to exist in the system and be used by several programs simultaneously. All versions supported language extensions such as otherwise clause in case statements, longint 32 bit integers, § operator for data addresses, data type coercion, and relaxed ordering of const/type/var sections. A lot of bit-based -functions were also
supported (e. g. BITAND to make bit bashing easier. Inline 68000 assembly code could also be used.

Like the Apple /// Pascal, Lisa Pascal also supported SANE, Apple’s IEEE floating-point implementation. In addition to SANE Apple developed a fairly comprehensive math package called MathLib.
Apple also developed an IEEE floating-point test program which attempted to ring out the bugs in SANE (Jerome Coonen of Apple wrote this test program and its associated test vectors).

Lisa Pascal was a superset of Apple’s older ][ and /// Pascals and, as such, was able to compile ][ and /// Pascal programs which did not make any ][ or /// system calls. Lisa Pascal could also produce a compilation listing complete with the Pascal source code interleaved with the generated 68000 assembly statements.

Apple also developed the Lisa QuickDraw (a. k. a. LisaGraf ) graphics library which formed the heart of what was called Lisa Technology. Though written in 68000 assembly^ Apple provided an extensive Pascal interface to this rather remarkable graphics environment (QuickDraw was later patented by Apple and Bi11 Atkinson. QuickDraw’s creator).

When Apple introduced the Macintosh computer in 1984 all Macintosh programming by Apple and others was done with Lisa Pascal and the Lisa Workshop. For this activity Apple created an extensive set of libraries containing the Macintosh toolbox interfaces. Many important Macintosh programs were written in Lisa Pascal, including MacPaint, MacWrite, MacDraw, and MacTerminal.

The key players behind Lisa Pascal were Ira Rubin and Al Hoffmann.
Apple provided extensive documentation for the Lisa Workshop and Lisa Pascal which included a language manual, an operating system manual, and a Workshop manual. Many internal memos were also released by Apple which described special features of Lisa Pascal.

Lisa Pascal was also used by Apple to develop the Lisa Clascal object-oriented language and the Clascal-based Toolkit class library.

Apple discontinued the Lisa in 1985 in favor of the Macintosh and when Apple’s native Macintosh development environment (MPW) became operational in 1986 Apple dropped support for Lisa Pascal and the Lisa Workshop. Therefore, Lisa Pascal lasted from 1981 to 1986, an eternity in the field of microcomputer languages.

APPLE LISA COMPUTER CLASCAL
Apple’s first foray into the world of object-oriented programming was with the Lisa Clascal (Classes + Pascal) language. Developed from 1983 to 1985 Clascal was an extension of Lisa Pascal which included several new keywords such as methods and subclass. The main concepts behind Clascal were derived from Simula and Smalltalk. Xerox PARC’s experimental object-oriented language.
In addition to Clascal Apple also developed an extensive set of class libraries which were collectively called the Lisa Toolkit. This class library allowed Lisa developers to create Lisa desktop applications (a. k. a. tools) in a fairly short time frame.

Though really used only internally by Apple for its own research efforts Clascal was made available to external developers but without any support by Apple (David Redhed of Seattle Washington created an independent Clascal/Toolkit support group called the Toolkit User’s Group [TUG], but this unfortunately did not last too long). Apple considered enhancing ClascaL but this Clascal-85 effort was extinguished by Apple’s work with Object Pascal for the Macintosh.
Several significant programs were developed with Clascal and the Toolkit including a calendar program, Apple’s Lisa-to-tlacintosh data conversion program, a desktop publishing program, and a fuzzy logic program.
The key player behind Clascal was Larry Tesler, one of the Lisa computer’s designers, and several former Xerox Smalltalk experts.

When Apple dropped all support for Clascal and the Toolkit it provided the Toolkit source code to the public, but the source code to the Clascal compiler was, alas, not made public.

APPLE MACINTOSH COMPUTER PASCAL
Apple’s Pascal for the Macintosh computer (1984 – present) was a port of Apple’s earlier Lisa Pascal compiler. When Apple began development of the Macintosh (1982) Apple used Lisa Pascal and the Lisa Workshop for system software development.
With the introduction by Apple of the Macintosh Programmer’s Workshop (MPW) in 1986 Apple had a very professional development environment which from an extendability perspective surpassed the Lisa Workshop. MPW tools could be written that would be executed by selecting their names in a mouse-based window environment and performing the do-it command by pressing the Enter key on the keyboard (shades of Smalltalk). MPW provided a Pascal compiler 680×0 series assembler, an improved 680×0 linker, and a cornucopia of source code utility programs (e.g. PasMat, PasRef). Many languages were also supported, both from Apple and outsiders (e.g. a FORTRAN, COBOL, Modula-2).
MPW Pascal extended Lisa Pascal by supporting the newer Motorola 68000 processors, the 68020, 68030, and 68040. Also supported were the Motorola floating-point and memory management chips. Conditional compilation directives allowed MPW Pascal to support the direct generation of floating-point chip instructions so that floating-point speed could be as fast as possible. Identifiers in Pascal programs were recognized up to 63 characters, a limitation which existed in all prior Apple Pascals beginning with Apple ][ Pascal.
Several versions of MPW Pascal existed: 1.0, 2. 0, 3. 0, 3. 2. Version 3.2, the current 1992 version, was created to support development of System 7 programs and had several extensions to make this compiler support very large programs and support the calling of C functions with variable number of parameters.
MPW Pascal has improved upon the optimization of object code and includes such features as peep hole optimization and better register allocation of local and global constants.
Extensive documentation exists for MPW and MPW Pascal.
MPW Pascal was enhanced to support object-oriented programming and was renamed to Object Pascal. This extended version was used by Apple to develop the Macintosh class library called MacApp.
Apple also contracted with THINK Technologies who created an interactive Pascal learning environment that was called Macintosh Pascal (this interpreter was later turned into a real compiler).
Around 1988 Apple started to use the C and C++ languages for its own Internal software development. The ascendancy of C/C++ at Apple has initiated a marked descendancy of Pascal at Apple and by outside developers.

APPLE MACINTOSH COMPUTER OBJECT PASCAL
Object Pascal for the Macintosh was developed by Apple starting in 1985 to support more rapid and more standardized development of Macintosh programs. Available for only MPW, Object Pascal is a descendant of the Lisa Clascal compiler.
The key Apple player behind Object Pascal was Larry Tesler who recruited the help of Niklaus Wirth, the creator of Pascal, to clean up the syntax of Clascal.
Object Pascal was used to develop the extensive MacApp class library. This library was fully documented by Apple via several books and the source code for MacApp was provided to developers.
Object Pascal is being eclipsed by C/C++ at Apple and most outside developers are following Apple’s lead. The Object Pascal MacApp class library has been rewritten in C++.

SUMMARY
Apple’s involvement with the Pascal language was extensive during the 1980 ‘s. From Apple’s introduction to Pascal on the Apple ][ computer in 1978, it has advanced to the powerful Macintosh 680×0 series Pascals of 1992.
Since 1988 Apple’s reliance on Pascal has been eclipsed by the emergence of C/C++ as Apple’s preferred system and application development language. Though Pascal will have the support of a small but vocal minority at Apple, C/C++ will be the dominant development language for Apple and outsiders for the next decade.