post

UCSD p_system updated

The UCSD p-System part of the site has been enhanced with all I had in my archive. This descendent of the P2 compiler, initiated by Ken Bowles and his students at UCSD, had a big impact around 1980 as a full operating system and with programming languages (Pascal, Fortran, Basic, Modual-2, Ada) in a well-supported portable way. A forerunner of Java, running on small computers like the Apple ][ and CP/M systems. The simple text based user interface and the p-code interpreter were strong points, but were later a disadvantage when native systems and compilers and GUI’s took over. Around 1985 the commercial impact was gone.

Many books, disk images etcetera.

The MS-DOS hosted p-system Supplement book has been scanned by me, the first time!

1978 KIM-1 Pascal-M

KIM-1 Pascal-M 1978 interpreter

Short userguide

0. You need two cassette recorders under Micro Ade software control, see Micro Ade userguide how to read, one to write.
1. Load Micro-Ade (Pascal-M version)
2. In Micro Ade write a Pascal program (remember V1: only uppercase!) and save to tape, standard Micro Ade actions
Every source line is stored as separate file on tape by Micro Ade.
3. Compile on the KIM-1 after reset.
a. Load binaries:
– load interpreter zero page and interpreter $2000
– load Pascal compiler
– load Pascal compiler procedure buffer (at $0200)
b. Start compilation with $2003 G
The compiler will now load the source from reading cassette (see step 2),
and compile to Pxx object record, saved on the recording cassette.
Any errors are flagged on the console, reading continues until the end of the source.

4.If no errors reported the object file is ready for execution. reset the KIM-1.
– Insert the written cassette in the reader.
– Load interpreter and zero page if the KIM-1 has been switched of.
Start the interpreter with 2000G
5. The object code will be read from tape.
When loading is finished and no checksum errors are reported the interpreter prints: <program name> LOADED
6. Start the program with 2003 G

post

Wirth and more: large update

A large update to my history of Pascal and its standards, where it comes from, the early compilers, sources of first compilers, unique articles and rare books, originally scanned, written by Niklaus Wirth, Per Brinch Hansen, Tony Hoare, Dijkstra, Jim Welsh and many more. Enjoy!

Standard Pascal and Validation

Pascal was originally designed by Professor Niklaus Wirth around 1969, with the first version of the language implemented on the CDC 6000 in 1970. It then went through several standardization committees (including ANSI and ISO) and various drafts until in 1983 a final draft was approved, ISO 7185 (also known as un-extended Pascal.)

In 1977, a working group was formed within the British Standards Institution (BSI) to produce a standard for the programming language Pascal. This group produced several working drafts, the first draft for public comment being widely published early in 1979. In 1978, BSI’s proposal that Pascal be added to ISO’s program of work was accepted, and the ISO Pascal Working Group (then designated ISO/TC97/SC5/WG4) was formed in 1979. The Pascal standard was to be published by BSI on behalf of ISO, and this British Standard referenced by the International Standard. In the USA, in the fall of 1978, application was made to the IEEE Standards Board by the IEEE Computer Society to authorize project 770 (Pascal). After approval, the first meeting was held in January 1979. In December of 1978, X3J9 convened as a result of a SPARC (Standards Planning and Requirements
Committee) resolution to form a US TAG (Technical Advisory Group) for the ISO Pascal standardization effort initiated by the UK. These efforts were performed under X3 project 317.

In agreement with IEEE representatives, in February of 1979, an X3 resolution combined the X3J9 and P770 committees into a single committee called the Joint X3J9/IEEE-P770 Pascal Standards Committee. (Throughout, the term JPC refers to this committee.) The first meeting as JPC was held in April 1979. The resolution to form JPC clarified the dual function of the single joint committee to produce a dpANS and a proposed IEEE Pascal standard, identical in content. ANSI/IEEE770X3.97-1983, American National Standard Pascal Computer Programming Language, was approved by the IEEE Standards Board on September 17, 1981, and by the American National Standards Institute on December 16, 1982. British Standard BS6192, Specification for Computer programming language Pascal, was published in 1982, and International Standard 7185 (incorporating BS6192 by reference) was approved by ISO on December 1, 1983. Differences between the ANSI and ISO standards are detailed in the Foreword of ANSI/IEEE770X3.97-1983. In 1985, the ISO Pascal Working Group (then designated ISO/TC97/SC22/WG2, now ISO/IEC JTC1/SC22/WG2) was reconvened after a long break. An Interpretations Subgroup was formed, to interpret doubtful or ambiguous portions of the Pascal standards. As a result of the work of this subgroup, and also of the work on the Extended Pascal standard being produced by WG2 and JPC, BS6192/ISO7185 was revised and corrected during 1988/89; it is expected that ANSI/IEEE770X3.97-1983 will be replaced by the revised ISO 7185.

The major revisions to BS6192:1982 to produce the new ISO 7185 are:
a) resolution of the differences with ANSI/IEEE770X3.97-1983
b) relaxation of the syntax of real numbers, to allow “digit sequences” rather than “unsigned integers” for the various components;
c) in the handling of “end-of-line characters” in text
d) in the handling of run-time errors.

In 1989 revisions were done to the original ISO 7185 Pascal standard to correct errors and ambiguities. As a result of that work, extensions to the language were introduced and formalized as Pascal ISO 10206 in 1991 (commonly known as extended Pascal). This standard introduced several concepts to the original language, such as:

– Modules (which are similar to Delphi units)
– Value Constructors
– Enhanced string capabilities
– Complex Numbers

After finalizing these extensions, the standardization group in charge of these changes (X3J9) set out to add object oriented support to Pascal. The result of that work was a technical report, which was released in 1993. It was not a formal standard but rather a set of general guidelines for adding OO support to Pascal.

In the real world only ISO 7185 had real impact and was more or less implemented in most compilers. Nowadays, on the current desktop operating systems, only the P5 compiler by Scott Moore and Freepascal (nearly) offer support. Compiler writers went off in different directions with extensions like OS support, modularity and object orientation. Object Pascal is an (informal) standard set by Borland in the later Turbo/Borland Pascal compilers, Delphi and also in Freepascal/Lazarus.

Standards available:

Extended Pascal ISO 10206:1990, PDF format
Extended Pascal ISO 10206:1990, text format

ISO/IEC 7185:1990(E), PDF format
ISO/IEC 7185:1990(E), text format
Object-Oriented Extensions to Pascal, 1993

Books on Standard Pascal

Pascal User_Manual and Report Fourth Edition ISO standard
Standard Pascal User Reference Manual, Doug Cooper
Oh_Pascal by Doug Cooper and Michael Clancy
Programming standard Pascal, R.C. Holt J.N.P. Hume

Pascal processor Validation Suite

The suite of programs may be used to validate a Pascal processor by presenting it with a series of programs which it should, or should not, accept. The suite also contains a number of programs that explore implementation-defined features and the quality of the processor. The tests are based on the ISO Standard for Pascal.
On the other hand, the test series contains a large number of test cases which exercise a Pascal processor fairly thoroughly. Hence passing the tests is a strong indication that the processor is well-designed and unlikely to give trouble in use. The validation suite may therefore be of interest to two main groups: implementors of Pascal, and users of Pascal.
expecting too much. Firstly, consider a fully interpretive Pascal processor. It may pass a test which contains a declaration which it would mis-handle otherwise, simply because the program did not include an access to the object concerned so that it was never interpreted. A second example might be a Pascal processor which employs a transformation of the Pascal syntax rules. Since the pathological cases incorporated into the test programs are based on the original rules, a mistake in transformation may not be detected by the test programs.

Example Pascal Validation Suite reports of actual compilers are in the book and source listings.
Other examples are:
the Amsterdam Compiler Kit Report
Pascal Validation Summary Report Sun WorkShop Pascal 4.2

A Model Implementation of Standard Pascal

The compiler contained in the book “A Model Implementation of Standard Pascal” Jim Welsh and Atholl Hay is a P-machine that implements a full ISO 7185 Compiler/Interpreter.
The “Model Implementation” is extensively parameterized, commented, and has a high degree of portability. The compiler was heavily based upon Pascal Plus, the ICL 2900 Pascal compiler.

Pascal Validation Suite, Wichman Sale
Pascal Validation Suite source listing
Pascal Compiler Validation, Wichmann Z.J. Chechanowicz
A Model Implementation of Standard Pascal, Jim Welsh, Atholl Hay

Scott Moore’s test suite

As no (legal) source is available except the mediocre photocopies of version 2 in the Pascal newsletter (see above) the Pascal Acceptance Test was developed by Scott Moore. The PAT or Pascal Acceptance Test is a series of tests in one file that go through each feature of ISO 7185 Pascal. If a ISO 7185 Pascal implementation can compile and run this correctly, then it is substantially compliant with ISO 7185 Pascal.

Lilith section updated

I have added the repository by Jos Dreesen on Lilith and the Emulith emulator with a local copy.
Jos maintains a ftp with just the files, I made it available as web pages here with higher availability and easier viewing of images and videos.

Emulith

My sites

Links to the sites on hansotten and sophiechermin domains


www.hansotten.com
Main website, about electronic kits (my former Philips bouwdozen mainly) and my former LP collection and my Radio Bulletin articles 1977-1986.

 

 

 


weblog.hansotten.com
My personal blog. Ramblings about what interests me, not directly related to one of the next websites.

 

 

 

 



retro.hansotten.nl
About SBC computers, mainly 6502 CPU based such as KIM-1 and Elektor/Elektuur.

 

 

 

 


pascal.hansotten.com
The computer language Pascal and other Niklaus Wirth languages history and  on small computers.

 

 

 

 

 


duinorasp.hansotten.com
On Arduino, Raspberry Pi and ESP8266 IOT computing.

 

 

 

 



reizen.hansotten.nl

Photos and videos of our travels from the early years to the last!

 

 

 


ancientworld.hansotten.com
Photo’s and descriptions of all sites we have visited (ruined sites and museums) of antquity (mainly greco-roman, some neolithic, some far east).

 

 

 



weesp.hansotten.nl

About my place of birth and city I lived most of my life.

 

 

 

 


www.sophiechermin.nl
Sophie’s blog about our trips and more

 

 

 

 


Modern Object Pascal guide

Link to Quick Modern Object Pascal for Programmers

Michalis Kamburelis and contributors: Maciej Izak

There are many books and resources about Pascal out there, but too many of them talk about the old Pascal, without classes, units or generics.

So I wrote this quick introduction to what I call modern Object Pascal. Most of the programmers using it don’t really call it “modern Object Pascal”, we just call it “our Pascal”. But when introducing the language, I feel it’s important to emphasize that it’s a modern, object-oriented language. It evolved a lot since the old (Turbo) Pascal that many people learned in schools long time ago. Feature-wise, it’s quite similar to C++ or Java or C#.

  • It has all the modern features you expect — classes, units, interfaces, generics…
  • It’s compiled to a fast, native code,
  • It’s very type safe,
  • High-level but can also be low-level if you need it to be.

It also has excellent, portable and open-source compiler called the Free Pascal Compiler, http://freepascal.org/ . And an accompanying IDE (editor, debugger, a library of visual components, form designer) called Lazarushttp://lazarus.freepascal.org/ . Myself, I’m the creator of Castle Game Engine, http://castle-engine.sourceforge.net/ , which is a cool portable 3D and 2D game engine using this language to create games on many platforms (Windows, Linux, MacOSX, Android, iOS, web plugin).

This introduction is mostly directed at programmers who already have experience in other languages. We will not cover here the meanings of some universal concepts, like “what is a class”, we’ll only show how to do them in Pascal.

See here!