In response to a number of requests for information about POP-11 that have
appeared recently, I have made the (compressed Postscript) text of a fairly
complete account of the POP-11 language available via the Internet.
To get the book, one must ftp to
piglet.cs.umass.edu
as anonymous, change to binary mode, cd to pub/misc, get popbook.ps.Z, and
uncompress.
The text dates from the late 1980's, and is largely unrevised. For example,
it does not discuss the remarkable improvement in the efficiency of lazy
(non-strict) evaluation achieved by Peyton-Jones and others in this decade.
It also needs some editing, which it will receive at some future point.
Some of the later chapters are POPLOG-specific.
Chapters:
CHAPTER 1 - Introduction: Desirable features of a Programming Language:
convenience of use, power (versus?) efficiency, support of modularity,
arrays-as-functions.
Features of POP-11 - Lisp Semantics & Algol/Pascal.. syntax; support for
functional paradigm; incremental compilation; garbage collection; mutation
supported by the -updater- attribute of functions. Abstraction.
The "Charter of Rights" for first-class objects.
CHAPTER 2 - Procedures: Procedures implement functions and support mutation
of data. Passing arguments, availability of the explicit mechanism of
argument passing. The procedure as the minimum unit of compilation - the
Virtual Machine.
Procedures which return procedure objects - closures. Infix and prefix
syntax for calling a procedure - their semantic equivalence. User-defined
infix operators. Local variables - dynamic locality versus lexical
locality. Procedures with multiple results. Defining the updater of a
procedure. if-then-elseif-endif, iteration through sequences of numbers,
through lists and other structures. Procedures as data-objects; how to
interrogate the call-context. The catch-throw library.
Macros operate on the token-stream.
CHAPTER 3 Data Objects:
Classes of objects defined as having a common key-object. Primitive types:
numbers, words, strings, procedures, processes. Identity equality. Compound
objects - records, vectors and others (eg procedures). Standard operations
on records, vectors (constructors, subscriptors, selectors recognisers
etc.) Hash-coded properties. Field attributes ("full", "int" etc.). Generic
operations on data-types (explode, datalist, datalength, datasize...).
Machine representation of POP objects - relocation by garbage collector.
Byte-accessible objects. Primitives for creating data-classes - datakey,
conskey etc. The class_apply, class_print, class_recognise, class_spec
procedures.
CHAPTER 4: Debugging and error reporting: How to modify the basic
capabilities - redefining the error handlers.
CHAPTER 5 Variables: An identifier record holds the value of a global
variable; identprops gives the basic declaration information. Changing the
protection status of identifiers. Variables are initialised with an
instance of the undefined record-class.
CHAPTER 6 Numbers: Integers big (arbitrary precision) and little,
rationals, floating point numbers, complex numbers. Comparison with Common
Lisp. Fast integer operations generate inline, unchecked code.
CHAPTER 7 Lists and Pairs. Lists are built out of pairs. Dynamic lists (cf.
streams) represent infinite sequences. Dynamic lists of characters, of
tokens. Predicates and functions defined on lists. Pair-specific operations
- front and back. applist and maplist and others.
CHAPTER 8 Words Words are kept in a dictionary - equal words are identical.
Recognising and creating words. The identifier associated with a word. The
gensym function. The procedures mapdic and appdic provide access to the
word-dictionary.
CHAPTER 9 Strings, characters: Finding characters and substrings. Case
conversions, ordering strings, making strings and accessing with subscrs.
CHAPTER 10 Arrays: Arrays as procedures. Making arrays by applying newarray
to a bounds-list and a function which specifies initial values. newanyarray
for making arrays based on arbitrary vector initialisers and subscriptors.
The arrayvector and boundslist functions for discovering the internal
structure of an array.
CHAPTER 11 Properties and Memo Functions: Properties as arbitrary,
mutatable maps from finite sets of objects to finite sets of objects.
Hashing functions - syshash. Specifying default value/procedure, equality
predicate, hash-table policy etc. Finding out what's in a property with
appproperty.
Memoising functions using properties. Sparse arrays.
CHAPTER 12 Processes: Making a process from a procedure with consproc. The
functions suspend and resume. Interrogating process state.
CHAPTER 13 Sections: Sections construct a "naming tree" similar to a file
system directory structure upon which variables can be placed. [SML
structures and Java Classes have some resemblance]. Importing and exporting
variables into a section. Pathnames. functions for creating and
manipulating sections - section_subsect, section_import, section_export
CHAPTER 14 The Library Mechanism: Defining search paths for the library -
popuseslist and popautolist
CHAPTER 15 The POP-11 Compiler: proglist - the list of input tokens - the
mechanism of macro expansion. Conditional compilation with #_IF...#_ENDIF.
Calling the compiler - compile(file), trycompile(file)... The popval
function for compiling and running a program fragment expressed as a
token-list. The use of pop11_comp_stmt_seq, pop11_comp_expr_seq for
extending the language constructs.
CHAPTER 16 The Virtual Machine: The code planting procedures sysPUSH,
sysPOP, sysCALL etc. Creating code-blocks. Creating variables: local,
global, non-local-non-global, lexical scoping.
CHAPTER 17 POPLOG system facilities: System startup reset and exit;
creating and restoring saved images, layering of saved images. Interrupts.
Store management - sys_lock_heap, sysgarbage popgcratio etc. System
Identification - popversion, pop_processor_type, pophost...
CHAPTER 18 How POP tells the time: sys_real_time, sys_convert_date, CPU
time, setting timer-interrupts, syshibernate.
CHAPTER 19 Reading objects from input: The itemiser (tokeniser) procedure
incharitem. Customising this by defining your own character classes.
incharitem to create an item-repeater.
CHAPTER 20 Character Input and Output: Standard character
repeaters/consumers charin, charout. Raw mode. File repeater-makers discin
and discout.
CHAPTER 21 Printing out Objects: Simple printing with pr, using printf for
formatted printing, controlling style. "Printing" into strings etc.
CHAPTER 22 Communicating with Unix: Getting usernames and environment
variable values, operations on file-names - sysfileok, sysfileparse,
sysfiledir, sysfilename. Matching file names, directory manipulation.
Creating Unix processes with sysfork, sysexecute, syspipe. Running shell
commands - sysobey. Signal handling.
CHAPTER 23 Unix-related I/O. Device records - their attributes. Opening
and closing devices. Reading and writing at the device level. File control
operations - sysseek.
CHAPTER 24 External procedures. Conventions for C, Fortran and Pascal.
External arrays, pointers. External call-by-reference.
CHAPTER 25 The POPLOG implementation of Prolog: (derived from a paper by
Chris Mellish) Continuation passing - Prolog-specific features of the
Virtual Machine.
|