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       *
  *                                            *
  *                                            *
  **********************************************)

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

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:

• Pascal-U
• Pascal-VU compiler
• Amsterdam Compiler Kit

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.

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 COMPUTER PASCAL

• Apple Lisa Pascal sources

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.