The people knowing about the really early Pascal history are a dying breed. So before I pass away (see the posts on my rectum cancer), let me post a few more links here that based on yesterday’s Trip down memory lane: book on p-Code based UCSD Pascal which I ended with:
I learned a few more things from [Wayback/Archive] What do you think about something like Pascal bytecode? (Page 2)
Here we go:
Too bad that by now Gnu Pascal (GPC) has been sort of dead for about 15 years. Free Pascal sort of has taken over, it started in 1997 when Turbo/Borland Pascal was discontinued, and around 2015 also established itself in the Linux community.
Before GNU Pascal, there has been a long history of other Pascal products all in one way or the other originating in the Pascal compilers based on the p-Code versions Pascal-P and Pascal-S.
There is a short section at
The Wikipedia page section Pascal (programming language): The Pascal-P system briefly indicates the various Pascal-P versions P1 through P5 and where (at P2) UCSD Pascal branched off (and on which in turn Apple Pascal is based)
Getting the Pascal-P4 to build on Windows using Free Pascal (version 3 has been out for about 10 years now) is answered in [Wayback/Archive] pascal – How to compile P4 from source code? – Stack Overflow (thanks [Wayback/Archive] fpj, [Wayback/Archive] Marco van de Voort and [Wayback/Archive] Scott Franco):
I quickly tried the referenced P4 compiler version and it seems to stumble on a few spots with “comment this” comments related to switching back and fro from ISO Mode. If I comment those files, pint compiles. (and then you could run the original bytecode if necessary)
pcom then still stumbles on taking the ord() of a pointer, which is obviously not very portable either, but unfortunately with 20+ occurrences that have to be replaced with ord(ptrint()).
pcom still doesn’t compile then, FPC doesn’t like passing union fields to VAR parameters. Working around that with a variable and the source compiles, 15 minutes total.
The fixed sourcecode with extra mode statements is at http://www.stack.nl/~marcov/files/p4fixed.zip but requires (as yet unreleased) FPC 3.0 or newer.
The resulting EXE binary can compile the original pcom source to bootstrap itself to bytecode.
…
I’m not sure why Pascal-P4 would be an interesting target. Pascal-P4 was a subset compiler, meaning an incomplete implementation of Pascal. You will find a complete implementation as Pascal-P5:
http://sourceforge.net/projects/pascalp5/
And I believe it has less portability issues as well.
- [Wayback] http://www.stack.nl/~marcov/files/p4fixed.zip
- [Wayback/Archive] https://www.stack.nl/~marcov/ansiiso.txt “A pragmatic discussion about Pascal standards and dialects” of which I think this is the most important bit on naming:
Q: What are the Pascal Standards?
A1: Official answer: (see above Ansi ISO faq)
0 Object Pascal ANSI technical report (1993) (never made standard)
1 Extended Pascal (ISO/IEC 10206 : 1991)
2 Unextended Pascal standard (ISO 7185 : 1990)
with two levels (0: no schemata; 1: schemata)
A2: de-facto answer (main famlies of Pascal dialects in current use:)
The ones in A1 PLUS
3 Apple dialects (roughly ISO 7185 + Object Pascal + some extensions)
4 Borland Turbo Pascal, specially the last "7" release.
5 Delphi (hybrid between TP and own extensions modeled after,
but not compatible with Object Pascal) _VAST_
For the rest there are several hybrids (Pascal-Java hybrids for early smartphones,
Oxygene is a C# - Pascal hybrid, some Oberon derivatives named Pascal for
marketing reasons, Objective Pascal (from FPC) that pulls in Objective C
constructs needed for OS X/iOS interfaces). Even Borland/Inprise/Devco/Codegear/Embarcadero/Indera now
joins the game with their Mobile offerings that borrow heavily from recent Apple
concepts.
- [Wayback] http://sourceforge.net/projects/pascalp5/
- Note that [Wayback/Archive] Scott Franco is an alias for Scott A. Moore (see below)
Some historic links:
- [Wayback/Archive] The TI-99/4A Tech Pages
These pages are dedicated to the Texas Instruments TI-99/4A home computer.
- [Wayback/Archive] The p-code system quickly gets to the core origins of the p-code system:
From the structure of the p-code language, you can tell it was invented by Pascal programmers: provision is made for procedures that are local to other procedures (i.e. nested into them) and a lot of p-codes are devoted to access these procedures or their variables.
- [Wayback/Archive] The p-code card has extensive information including this great (early 1980’s!) feature:
The TI p-system comes with a sophisticated UCSD-Pascal compiler. For instance, if a compilation error occurs, the compiler gives you the option to continue compilation, to stop it, or to enter the Editor with the cursor positioned at the point where the error occured in the source file (ain’t that nice?).
- [Wayback/Archive] http://www.unige.ch/medecine/nouspikel/ti99/pcode.txt
- GNU Pascal – Wikipedia technically has been dead since 2005, though a revival inquiry was done in 2010:
In July 2010 a developer publicly asked opinion (it vanished from the web between July 2014 and June 2015) on the future of GNU Pascal, due to developer shortage and maintenance issues as a GCC port. There was a lively discussion on the maillist where the developers seemed to lean towards reimplementing in C++ with a C code generating backend. The maillist went to sleep again, and as of December 2016 no further releases or announcements about the future course of the project have been made.
- [Wayback/Archive] Quo vadis, GPC?
…
But even if GPC development becomes easier with the new design, as I seriously hope, it will not be a task for a single person. So again, I need to know if some of you are interested, not only in using, but also helping to develop, a new and improved GPC – especially when the new GPC eventually (see below) will be written in readable Pascal, thus removing two obstacles that the current GPC, being written in almost-unreadable C, has always posed to participation.
…
- [Wayback/Archive] The Gpc July 2010 Archive by thread including some Pascal-P* related messages:
- [Wayback/Archive] GNU Pascal
GNU Pascal
Welcome to the WWW home site of GNU Pascal,the free 32/64-bit Pascal compiler!
Copyright © 1987-2005 Free Software Foundation, Inc.
Classic Pascal compilers are still being maintained in several places, not just for heritage.
A few examples:
- [Wayback/Archive] Oppolzer – Informatik The Stanford Pascal Compiler
I am currently the maintainer of an improved version of the Stanford Pascal compiler.
The Stanford Pascal compiler is an offspring of the original Pascal P4 compiler, which was written in the 1970s at ETH Zürich by a team around Niklaus Wirth.
- [Wayback/Archive] StanfordPascal/Pascal: New Stanford Pascal Compiler
New Stanford Pascal Compiler
This is the new Stanford Pascal Compiler. It runs on Windows, OS/2, Linux, MacOs and probably on every other system that has a C Compiler, because the generated P-Code is interpreted by the P-Code interpreter PCINT.
It also runs on the IBM-Mainframe, on the operating systems MVS and CMS (on Hercules) and on today’s z/OS, too, although limited to AMODE 24, at the moment. The P-Code is translated to 370 machine code, there.
- [Wayback/Archive] New Stanford PASCAL Compiler running on MVS (on physical hardware, or using the [Wayback/Archive] Hercules IBM S/370 and ESA/390 Emulator)
- [Wayback/Archive] Pascal-S download | SourceForge.net
This is the original Pascal-S project from Niklaus Wirth at ETH Zurich. It compiles and interprets in one step a subset of the Pascal language, and does it in only about 2000 lines.
- there is no Pascal-P1 as the source code was never released
- [Wayback/Archive] pascal-p2 download | SourceForge.net (this is what both UCSD-Pascal and Pascal-M evolved from)
This was the 2nd version of the Pascal-P compiler created by Niklaus Wirth’s group at ETH Zurich, termed Pascal-P2.
This was the original portable compiler for Pascal. Niklaus Wirth led an effort to gather and reconcile the different sources for the Pascal-P compiler in existence, which were collectively referred to as Pascal-P1.These were then published as part of a porting kit for the compiler.
Pascal-P2 is a “Running history project”. It is a historical record, but still runs on modern computers.
Pascal-P2 exists mainly for historical reference. It was improved at ETH Zurich to become Pascal-P4, and brought to full ISO 7185 standard status as Pascal-P5.
- there is no Pascal-P3 as the source code was never released
- [Wayback/Archive] pascal-p4 download | SourceForge.net
This was the 4th version of the Pascal-P compiler created by Niklaus Wirth’s group at ETH Zurich, termed Pascal-P4.
Pascal-P4 is a “Running history project”. That is to say, it is a historical record, but still runs on modern computers.
Several other adaptions of Pascal-P4 exist, for example for FPC. You will have to search for the details of that, I was unable to find in in sourceforge.
All of the development and bug fixes for Pascal-P4 went into the Pascal-P5 project,
Pascal-P4 is a subset of full Pascal. It may be appropriate for bootstrapping projects, or class projects.
- [Wayback/Archive] pascal-p5 download | SourceForge.net
This is the 5th version of the Pascal-P compiler from Zurich. This is the Pascal-P4 compiler modified to be ISO 7185 Pascal compilant, both in the the implementation language, and in the language it processes.
Pascal-P was an implementation kit, created between 1972 and 1974, for the original language Pascal. The source for the original compiler was passed around and modified quite a bit, but Niklaus Wirth noted that it was very popular, and represented a good method to popularize the language. He gathered the source into a clean version called Pascal-P2. The Zurich group then created an improved version called Pascal-P4.
- [Wayback/Archive] pascal-p6 download | SourceForge.net
Pascal-P6 Is designed to be a full compiler as well as a porting kit. As a full compiler, it implements extensions to the original ISO 7185 Pascal language.
I use a formalized set of extensions that started in the 1980s called “Pascaline”. This set of extensions were implemented in the compiler IP Pascal.
This project is under development. If you want something to use now, please see the Pascal-P5 project.
All the above SourceForge projects are from [Wayback/Archive] samiam95124 / Profile, which is another alias of Scott A. Moore (more pages from and on him below).
There is one more Pascal-P5 based project on SourceForge based on P5 which emits C code. It is [Wayback/Archive] pascal p5c download | SourceForge.net (but not much activity outside that SF project, see the results from [Wayback/Archive] “p5c” “Pascal” – Google Search):
p5c is a fast portable iso standard pascal compiler.
It is derived from the pascal p5 compiler and creates gnu c code instead of p-code.
This makes it very fast since it uses gcc to generate native code.
p5c is multi platform – it is easy to get up and running since you only need gcc to start.
Using gcc enables extra tools like a static analyser and code coverage analyser
It extends p5 by adding arbitrary set limits and conformant arrays.
The project also contains p5x – pascal with extensions to the standard pascal language (underscores allowed in identifiers, otherwise in case statement, constant expressions, etc)
This is similar to the Pascal-P4C which I mentioned yesterday in Trip down memory lane: book on p-Code based UCSD Pascal:
[Wayback] https://homepages.cwi.nl/~steven/pascal/p4c.tar.gz: a gzip (.gz) compressed tar files of which I saved the individual files to [Wayback/Archive] P4C files by I.J.A.vanGeel@twi.tudelft.nl from https://homepages.cwi.nl/~steven/pascal/p4c.tar.gz (P2C translated C version of the P4 Pascal compiler, originally for UNIX and OS/2; requires GCC)
Pascal-P2 bug
I was hoping to find more information about the P4C author through [Wayback/Archive] “I.J.A.vanGeel@twi.tudelft.nl” – Google Search and [Wayback/Archive] Internet Archive Search: I.J.A.vanGeel@twi.tudelft.nl, but got no relevant results (apart from the [Wayback/Archive] gist with p4c.tar.gz content I created for Trip down memory lane: book on p-Code based UCSD Pascal)
Then I tried [Wayback/Archive] “p4c.tar.gz” – Google Search which lead me to the interesting question at [Wayback/Archive] Was there a bug in Wirth’s original Pascal compiler? – Retrocomputing Stack Exchange (thanks [Wayback/Archive] Leo B. and [Wayback/Archive] User texdr.aft)
Q
It appears that both legacy Pascal compilers I have access to (for the BESM-6) contain a bug: they would happily produce code for
program test(output);(* may have to omit (output) depending on the platform *)
function f: integer; (* entering the function sets R2 as the frame pointer *)
begin f := 7 end; (* assigning 7 to 3(R2) - the value return location *)
begin f := 11 end. (* assigning 11 to 3(R2), where R2 has not been initialized yet *)
Both compilers were derivations from one CDC 6600 version or another, up to the data structures and the order of the subroutines. As the bug is in the machine-independent part, which logic would be transcribed unchanged, I suspect that it would exist in all Pascal implementations derived directly from the same CDC 6600 source by bootstrapping.
Could anyone please verify that on a CDC 6600 emulator, if one exists, or using a Pascal compiler known to be a port of the original?
JFYI:
Newer Pascal compilers written in C using YACC do error out on the test case above.
Free Pascal complains, on line 4, Error: Argument cannot be assigned to (why “Argument”, though?).
UCB Pascal on BSD 2.11 is more lucid, saying function f found where variable required.
One other I could find online, Turbo Pascal, however, fails with some kind of an internal error: Error: can't cast from 70 to 76 ("11", line 4).
C
Compare the source code of the func branch of the selector routine in the [Wayback/Archive] P2 compiler (search for “IMPL. RELAT. ADDR. OF FCT. RESULT” to find the relevant line) and in the [Wayback/Archive] P4 compiler. In the latter there is an error check complaining if a function name is assigned to outside its body. (In adding the check, an odd begin–end pair was left, as noted in Daniels and Pemberton’s [Wayback/Archive] book about P4).
C
The error code displayed by P4 is 177 (“You may only assign to the identifier of a function in the body of that function“, see [Wayback/Archive] homepages.cwi.nl/~steven/pascal/book/…), which was not included in the list of error codes at the end of the Pascal user manual, so I would propose that the answer to your question is yes.
C
I found an explanation for the strange Turbo Pascal error: [Wayback/Archive] news.ycombinator.com/item?id=6573092
A
If the compilers you have were based on the P-series, then I believe that there was indeed a bug.
In the P-series compilers after [Wayback/Archive] P2, the destination of an assignment is determined by a routine named [Wayback/Archive] selector, which branches on the klass field of fcp, a variable that holds information about a relevant identifier. When the klass is func, i.e., when the identifier is the name of a function, P2 does this:
IF PFDECKIND = STANDARD THEN ERROR(150)
ELSE
IF PFLEV = 0 THEN ERROR(150) (*EXTERNAL FCT*)
ELSE
IF PFKIND = FORMAL THEN ERROR(151)
ELSE
BEGIN ACCESS := DRCT; VLEVEL := PFLEV + 1;
DPLMT := 0 (*IMPL. RELAT. ADDR. OF FCT. RESULT*)
END
There is an assumption here that an assignment to a function identifier will happen only within the function’s body, but no explicit check. In [Wayback/Archive] P4, this bit of code was changed to
if pfdeckind = standard then
begin error(150); typtr := nil end
else
begin
if pfkind = formal then error(151)
else
if (pflev+1<>level)or(fprocp<>fcp) then error(177);
begin access := drct; vlevel := pflev + 1;
dplmt := 0 (*impl. relat. addr. of fct. result*)
end
end
Here, pflev is a field of fcp, representing the level of nesting at which fcp was declared; level is a global variable holding the current depth of nesting; fprocp is a parameter of block, which is non-nil if the block is the body of a function or procedure. Thus the newly-added line ensures that we are (1) in the body of a function and (2) allowed to perform the assignment. Error 177 is new to P4, and means
You may only assign to the identifier of a function in the body of that function.
There are other early compilers whose source code [Wayback/Archive] survives, which were the progenitors of the P-series compilers; none of them, except for the 1984 version, seem to include the check for assignment validity.
You might have noticed the strange begin and end in the P4 excerpt. This was also pointed out [Wayback/Archive] by Pemberton and Daniels (the third item in the Notes section below). The effect is that code for the assignment is generated, even though it is erroneous; presumably there is an else missing.
C
[Wayback/Archive] One compiler is most likely based on a P-series compiler or their direct predecessor. After decompilation, some scalar constant names and subroutine names were correlated with a P-series source. The overall code structure matches closely. However, contents of the analog of the “selector” routine (called “parseLval”, line 5030) based on relative location and overall function, diverge substantially.
C
[Wayback/Archive] The other compiler, not yet restored to good readability, looks much different: there are no individual token scalars; there is just one all-encompassing record type “identifier” for all named objects; expression trees are not constructed, instruction chains for subexpressions are merged during recursive descent, etc.
Similar “Turbo Pascal” bug
A similar error is in a JavaScript implementation of the Turbo Pascal compiler emulation, supporting the Borland Graphics Interface (BGI). at [Wayback/Archive] lkesteloot/turbopascal: Web-based Turbo Pascal compiler.
This is a web-based Pascal compiler that runs a subset of Turbo Pascal 5.5 code. See the full write-up or try it now!
To run it locally, run the “GO” script to start a web server and go to http://localhost:8000
Go to http://localhost:8000/unit.html to run the unit tests.
See the LICENSE file for the BSD 2-clause license.
It very much looks like Turbo Pascal 3.0 running in your browser:
“Turbo Pascal” running in your browser
The error is described in [Wayback/Archive] Your project is great, Pascal is really underrated language. I looked at parser … | Hacker News:
The JavaScript Turbo Pascal author [Wayback/Archive] Lawrence Kesteloot and his two PDI/DreamWorks co-workers actually won a kind of “Oscar” Certificate of Tecnical Achievement, see [Wayback/Archive] Oscar and [Wayback/Archive] 2012 Scientific and Technical Awards | Academy of Motion Picture Arts & Sciences (both via [Wayback/Archive] Show HN: My Turbo Pascal compiler in JavaScript | Hacker News, which is an interesting read by itself).
Anyway: the error message is rooted in the part of the code at [Wayback/Archive] turbopascal/Parser.js: Line 487 at master · lkesteloot/turbopascal
486 } else if (token.tokenType === Token.IDENTIFIER) {
487 // This could be an assignment or procedure call. Both start with an identifier.
488 node = this._parseVariable(symbolTable);
489
490 // See if this is an assignment or procedure call.
491 token = this.lexer.peek();
492 if (token.isSymbol(":=")) {
493 // It's an assignment.
494 node = this._parseAssignment(symbolTable, node);
495 } else if (node.nodeType === Node.IDENTIFIER) {
496 // Must be a procedure call.
497 node = this._parseProcedureCall(symbolTable, node);
498 } else {
499 throw new PascalError(token, "invalid statement");
500 }
501 } else {
It is a cool project that compiles a lot of early to late 1980s Turbo Pascal code. Lawrence wrote an introduction page already showing his great feel for computer graphics. I quoted a few bits of that page [Wayback/Archive] Turbo Pascal Compiler:
My friend Fredrik Fatemi and I spent the summer after high school (1989) writing graphics programs in Turbo Pascal on his 286 PC (with EGA!) in his basement while watching The Princess Bride again and again on his VCR. He recently found some 3½” diskettes with our programs on it. I couldn’t find a good way to run them on my Mac, so naturally I wrote a Turbo Pascal compiler….
A few notes:
- It implements the subset of the language and standard library that I needed to run these five programs. That’s most of the language and a useful subset of the graphics module.
- It’s about 6,000 lines of JavaScript code and uses a hand-coded recursive-descent parser.
- It compiles to p-code that’s binary compatible with the 1978 UCSD Pascal Compiler. (The real Turbo Pascal compiled directly to machine language.)
- For kicks I also implemented a web version of the Turbo Pascal 3.0 menu. Only the Dir, Edit, Work File, and Run commands work. The language and libraries are closer to the later versions, though.
The ROSE.PAS program is our crowning achievement. It’s an animated canvas of a centipede moving slowly toward a golf ball under a rose. It’s really a dumping ground for a bunch of visual experiments, including a fractal mountain. It’s the program I most wanted to see run again.
…
There are almost two dozen JavaScript files implementing compiler and user interface, here are various more bits of the code:
The cool thing is that there JavaScript implementations of various core Turbo Pascal units like:
- [Wayback/Archive] turbopascal/crt.js at master · lkesteloot/turbopascal
Crt unit with very minimalistic keyboard support and therefore a good axample showing the core of how to add your own unit usig JavaScript implementations of functionality.
- All code:
1 // The CRT sub-system.
2
3 define(["Node"], function (Node) {
4 var importSymbols = function (symbolTable) {
5 // Keyboard functions.
6 symbolTable.addNativeFunction("KeyPressed", Node.booleanType, [], function (ctl) {
7 return ctl.keyPressed();
8 });
9 symbolTable.addNativeFunction("ReadKey", Node.charType, [], function (ctl) {
10 return ctl.readKey();
11 });
12
13 // Sound functions.
14 symbolTable.addNativeFunction("Sound", Node.voidType, [Node.integerType],
15 function (ctl, hz) {
16 // Not implemented.
17 });
18 symbolTable.addNativeFunction("NoSound", Node.voidType, [], function (ctl) {
19 // Not implemented.
20 });
21 };
22
23 return {
24 importSymbols: importSymbols
25 };
26 });
- [Wayback/Archive] turbopascal/graph.js at master · lkesteloot/turbopascal
Graph unit adding BGI graphics support. Great example on adding your own units and implement methods using JavaScript, see for instance these functions:
Some demo programs that literally caught my eye:
Looking at the demos, it is very clear Lawrence had a keen eye on computer graphics early on.
The Russians used Pascal too!
When discussing the above question [Wayback/Archive] Was there a bug in Wirth’s original Pascal compiler? – Retrocomputing Stack Exchange I skipped elaborating on these comments:
C
[Wayback/Archive] One compiler is most likely based on a P-series compiler or their direct predecessor. After decompilation, some scalar constant names and subroutine names were correlated with a P-series source. The overall code structure matches closely. However, contents of the analog of the “selector” routine (called “parseLval“, line 5030) based on relative location and overall function, diverge substantially.
C
[Wayback/Archive] The other compiler, not yet restored to good readability, looks much different: there are no individual token scalars; there is just one all-encompassing record type “identifier” for all named objects; expression trees are not constructed, instruction chains for subexpressions are merged during recursive descent, etc.
The reason was that back then I was focusing on the bug at hand, but the comments were showing a piece of Pascal history I was only aware of by word of mouth:
Most early Pascal through Pascal-P4 developments had taken place in the 1970s during a sort of relaxation period of the Cold War. Back then, Russian scientists were much deprived of foreign hardware just like now in the Second Cold War. Given the rich cultural, technological and scientific Russian heritage they had plenty of literature and during both the Second World War and Cold War learned to get by with very little resources. Despite that, their early computing efforts resulted in MESM: one of the (if not the first of the) programmable electronic computers in Europe. MESM, built in the late 1940s, was based on vacuum tubes and led to a 1950s-1960s series of BESM computers that at first started with vacuum tubes and diodes, but soon were based on transistors all leading up to the BESM-6 that was designed in 1965 and produced from 1968 until 1987 covering the midst of early Pascal through Pascal-P5 compilers.
So I was not surprised to see the above comments confirm the word of mouth stories I heard when attending university 1980s: Russians had working Pascal implementations on their computers.
So it is cool to see the above two mentioned sources being put on-line and documented since 2017 as part of the project [Wayback/Archive] besm6/pascal-re: Reverse engineering of the Pascal-Monitor compiler
That project is part of the GitHub organisation [Wayback/Archive] besm6 which is documenting and bringing alive some of the software running on BESM-6 (partially through virtualised BESM-6 machines).
Their main (Russian) documentation is in the [Wayback/Archive] besm6/besm6.github.io project and hosted at both [Wayback/Archive] Энциклопедия БЭСМ-6 (besm6.github.io) and [Wayback/Archive] Энциклопедия БЭСМ-6 (www.besm6.org).
This is cool, as these bits of almost forgotten history are important to both preserve and tell.
Late additions: bumped into Hans Otten
When finishing up the last details in this post, I bumped into [Wayback/Archive] Sitemap – Pascal for small machines maintained by [Wayback/Archive] Hans Otten (@HansOtten) at [Wayback/Archive] Pascal for small machines – Wirth languages, Pascal, UCSD, Turbo, Delphi, Freepascal, Oberon.
The [Wayback/Archive] “Pascal-P3” – Google Search made me bump into his page [Wayback/Archive] Px compilers – Pascal for small machines
The Pascal-P compiler was created in 1973, then went through several versions, which so far have not been available. Ch. Jacobi gives an overview of the Pascal-P versions in PUG newsletter
#4:
| Name |
Origination |
Year |
Source |
Description |
| Pascal P1 |
Zurich |
1973 |
No |
Either of the early Pascal-P systems (released in March and July 1973 respectively) |
| Pascal-P2 |
Zurich |
1974 |
Yes |
The Pascal-P system released in May 74 |
| Pascal-P3 |
Zurich |
1976 |
No |
The new Pascal-P system with the same hypothetical machine as the one underlying the Pascal P2 system |
| Pascal-P4 |
Zurich |
1976 |
Yes |
The new Pascal-P system with a slightly modified hypothetical machine (allowing a more efficient implementation) |
The versions of P1 that existed have (so far) not been available. The revised version, P2, is available, and was used as the basis for the UCSD system. P3 was a “step” implementation used to bridge between P2 and P4, and is also not obtainable.
The last major version of Pascal-P was P4.
and the underlying pages
The links in the table are to the pages by Scott A. Moore (who goes by several other names: Sam I Am, Scott Franco and Scott Andrew Franco). Before finding Hans Otten’s site, I had already found out these pages do not function any more, but luckily the below archived links still work:
Scott had many more interesting pages on his site, including these:
Via [Wayback/Archive] “Pascal” “Scott” “Moore” “ISO” – Google Search, I found a Pascal-P5 derived implementation at [Wayback/Archive] retropascal/oldpas: prototype for retro pascal, based on p5 pascal compler but, despite the interesting goals (including to run on the web), has also been stalled.
Another approach Hans took is a series of pages around influential people on the Pascal and programming languages world: [Wayback/Archive] Influencal persons – Pascal for small machines (the typo is his).
Pascal Newsletter and reflections on them
Another site that Scott A. Moore maintained was [Wayback/Archive] ANSI-ISO PASCAL, which included a great page on the [Wayback/Archive] Pascal Users Group Newsletters. It not listed the individual letters (they appeared from 1974 through 1983 and are also listed below), but had great section contemplating on their content and two indexes: a first about articles he thought to be very interesting and a second about program listings that were really useful (formatters and pretty printers, Standard Pascal validation suite, LISP interpreter, compiler, etc).
Hopefully that site someday will be restored so it is indexed by search engines again.
For now the list of Pascal Newsletters PDF files plus one retrospective PDF will have to suffice (all are Wayback Machine archived links):
David T. Craig has given an Outsiders Retrospective of the newsletters.
Hopefully Scott A. Moore is still alive
Finally, Scott A. Moore has an interesting (and long!) biography that luckily too was captures in the archives [Wayback/Archive] ANSI-ISO PASCAL: About the Author. I really hope he is still alive. A reminder to me is this tweet:
[Wayback/Archive] Jeroen Wiert Pluimers @wiert@mastodon.social on Twitter: “Beste @HansOtten , ik zie dat pagina’s als standardpascaline.org/scottmoore.html en moorecad.com/standardpascal/p2.html verdwenen zijn. Sterker: de onderliggende sites van Scott A. Moore lijken niet meer te bestaan. Meest @waybackmachine pagina is web.archive.org/web/20220927075942/http://moorecad.com/standardpascal/p2/pcomp.pas Weet jij hoe het met Scott gaat?”
I got the most recently archived page while searching at web.archive.org/web//http://www.moorecad.com which takes a bit of browsing (as you cannot not directly link to various pages within the search result nor sort the search result by archival dates).
Hopefully Scott still lives and by now his sites are up again.
More to come
This post is already almost 6k words, so I need to stop.
Maybe in the future I will go into more detail on some of the above sites, or more material from the [Wayback/Archive] Newest ‘pascal’ Questions – Retrocomputing Stack Exchange, Pascal compilers mentioned at [Wayback/Archive] Roby’s Links or even [Wayback/Archive] Wirth-Dijkstra-langs: Home of Pascal P6.
--jeroen
The Wiert Corner - irregular stream of stuff 
Your project is great, Pascal is really underrated language.I looked at parser (hand written are best), this part spotted my eyes https://github.com/lkesteloot/turbopascal/blob/master/Parser… – IMHO order of checking whatever node is identifier or not have to be reversed. Now, such simple program:
program Test;procedure foo; begin end;begin foo := 10; end.produces error ‘
Error: can't cast from 70 to 76 ("10", line 8)'– whatever this means. :)