Abstract
========
-The Muddle programming language began existence in late 1970 as a
-successor to Lisp (Moon, 1974), a candidate vehicle for the Dynamic
-Modeling System, and a possible base for implementation of Planner
-(Hewitt, 1969). The original design goals included an interactive
-integrated environment for programming, debugging, loading, and
-editing: ease in learning and use; facilities for structured, modular,
-shared programs; extensibility of syntax, data types and operators:
-data-type checking for debugging and optional data-type declarations
-for compiled efficiency; associative storage, coroutining, and
-graphics. Along the way to reaching those goals, it developed flexible
-input/output (including the ARPA Network), and flexible interrupt and
-signal handling. It now serves as a base for software prototyping,
-research, development, education, and implementation of the majority
-of programs at MIT-DMS: a library of sharable modules, a coherent user
-interface, special research projects, autonomous daemons, etc.
+The Muddle programming language began existence in late 1970 as a
+successor to Lisp (Moon, 1974), a candidate vehicle for the Dynamic
+Modeling System, and a possible base for implementation of Planner
+(Hewitt, 1969). The original design goals included an interactive
+integrated environment for programming, debugging, loading, and
+editing: ease in learning and use; facilities for structured,
+modular, shared programs; extensibility of syntax, data types and
+operators: data-type checking for debugging and optional data-type
+declarations for compiled efficiency; associative storage,
+coroutining, and graphics. Along the way to reaching those goals, it
+developed flexible input/output (including the ARPA Network), and
+flexible interrupt and signal handling. It now serves as a base for
+software prototyping, research, development, education, and
+implementation of the majority of programs at MIT-DMS: a library of
+sharable modules, a coherent user interface, special research
+projects, autonomous daemons, etc.
This document was originally intended to be a simple low-level
introduction to Muddle. It has, however, acquired a case of
I was not a member of the original group which labored for two years
in the design and initial implementation of Muddle; that group was
-composed principally of Gerald Sussman, Carl Hewit, Chris Reeve, Dave
+composed principally of Gerald Sussman, Carl Hewitt, Chris Reeve, Dave
Cressey, and later Bruce Daniels. I would therefore like to take this
opportunity to thank my Muddle mentors, chiefly Chris Reeve and Bruce
Daniels, for remaining civil through several months of verbal
misconceptions, I would like to thank Chris Reeve, Bruce Daniels, and
especially Gerald Sussman, one of whose good ideas I finally did use.
-*Greg Pfister\
-December 15, 1972*
+Greg Pfister\
+December 15, 1972
Since Greg left the fold, I have taken up the banner and updated his
document. The main sources for small revisions have been the on-line
("the oracle") for the patience to answer questions and resolve
doubts, as he no doubt as done innumerable times before.
-*S. W. Galley\
-May 23, 1979*
+S. W. Galley\
+May 23, 1979
This work was supported by the Advanced Research Projects Agency of
the Department of Defense and was monitored by the Office of Naval
There are no "practice problems"; you are assumed to be learning
Muddle for some purpose, and your work in achieving that purpose will
-be more useful and motivated than artificial problems. In several
+be more useful and motivating than artificial problems. In several
cases, the examples contain illustrations of important points which
-are not covered in the text. Ignore examples as your peril.
+are not covered in the text. Ignore examples at your peril.
This document does not assume knowledge of any specific programming
-language on the \[sic\] your part. However, "computational literacy"
-is assumed: you should have written at least one program before. Also
-very little familiarity is assumed with the interactive time-sharing
-operating systems under which Muddle runs -- ITS, Tenex, and Tops-20
--- namely just file and user naming conventions.
+language on your part. However, "computational literacy" is assumed:
+you should have written at least one program before. Also very little
+familiarity is assumed with the interactive time-sharing operating
+systems under which Muddle runs -- ITS, Tenex, and Tops-20 -- namely
+just file and user naming conventions.
### Notation
Most specifically indicated examples herein are composed of pairs of
lines. The first line of a pair, the input, always ends in `$` (which
-is how the ASCII character ESC is represented, and which always
+is how the ASCII character `ESC` is represented, and which always
represents it). The second line is the result of Muddle's groveling
over the first. If you were to type all the first lines at Muddle, it
would respond with all the second lines. (More exactly, the "first
`ROOT`. A metasyntactic variable -- something to be replaced in actual
use by something else -- appears as *radix:fix*, in an italic font;
often the variable will have both a meaning and a data type (as here),
-but sometimes one of those will be ommitted, for obvious reasons.
+but sometimes one of those will be omitted, for obvious reasons.
An ellipsis (...) indicates that something uninteresting has been
omitted. The character `^` means that the following character is to be
-"controllified": it is usually typed by holding down a terminal's CTRL
-key and striking the other key.
+"controllified": it is usually typed by holding down a terminal's
+`CTRL` key and striking the other key.
Chapter 1. Basic Introduction
=============================
-------------------------
First, catch your rabbit. Somehow get the interpreter running -- the
-program in the file `SYS:TS.Muddle` in the ITS version or
-`SYS:Muddle.SAV` in the Tenex version or `SYS:Muddle.EXE` in the
+program in the file `SYS:TS MDL` in the ITS version or
+`SYS:MDL.SAV` in the Tenex version or `SYS:MDL.EXE` in the
Tops-20 version. The interpreter will first type out some news
relating to Muddle, if any, then type
echoed (printed on your terminal) and remembered in a buffer. The only
characters for which this is normally not true act as follows:
-Typing `$` (ESC) causes Muddle to echo dollar-sign and causes the
+Typing `$` (`ESC`) causes Muddle to echo dollar-sign and causes the
contents of the buffer (the characters which you've typed) to be
interpreted as an expression(s) in Muddle. When this interpretation is
done, the result will be printed and Muddle will wait for more typing.
-ESC will be represented by the glyph `$` in this document.
-
-Typing the rubout character (DEL in the ITS and Top-20 versions,
-CTRL+A in the Tenex version) causes the last character in the buffer
--- the one most recently typed -- to be thrown away (deleted). If you
-now immediately type another rubout, once again the last character is
-deleted -- namely the second most recently typed. Etc. The character
-deleted is echoed, so you can see what you're doing. On some "display"
-terminals, rubout will "echo" by causing the deleted character to
-disappear. If no characters are in the buffer, rubout echoes as a
-carriage-return line-feed.
-
-Typing \^@ (CTRL+@) deletes everything you have typed since the last
-`$`, and prints a carriage-return line-feed.
-
-Typing \^D (CTRL+D) causes the current input buffer to be typed back
-out at you. This allows you to see what you really have, without the
-confusing re-echoed characters produced by rubout.
-
-Typing \^L (CTRL+L) produces the same effect as typing \^D, except
-that, if your terminal is a "display" terminal (for example, IMLAC,
-ARDS, Datapoint), it firsts clears the screen.
-
-Typing \^G (CTRL+G) causes Muddle to stop whatever it is doing and act
-as if an error had occurred ([section
-1.4](#14-errors-simple-considerations-1)). \^G is generally most
-useful for temporary interruptions to check the progress of a
-computation. \^G is "reversible" -- that is, it does not destroy any
-of the "state" of the computation it interrupts. To "undo" a \^G, type
-the characters
+`ESC` will be represented by the glyph `$` in this document.
+
+Typing the rubout character (`DEL` in the ITS and Tops-20 versions,
+`CTRL`+`A` in the Tenex version) causes the last character in the
+buffer -- the one most recently typed -- to be thrown away (deleted).
+If you now immediately type another rubout, once again the last
+character is deleted -- namely the second most recently typed. Etc.
+The character deleted is echoed, so you can see what you're doing. On
+some "display" terminals, rubout will "echo" by causing the deleted
+character to disappear. If no characters are in the buffer, rubout
+echoes as a carriage-return line-feed.
+
+Typing `^@` (`CTRL`+`@`) deletes everything you have typed since the
+last `$`, and prints a carriage-return line-feed.
+
+Typing `^D` (`CTRL`+`D`) causes the current input buffer to be typed
+back out at you. This allows you to see what you really have, without
+the confusing re-echoed characters produced by rubout.
+
+Typing `^L` (`CTRL`+`L`) produces the same effect as typing `^D`,
+except that, if your terminal is a "display" terminal (for example,
+IMLAC, ARDS, Datapoint), it firsts clears the screen.
+
+Typing `^G` (`CTRL`+`G`) causes Muddle to stop whatever it is doing
+and act as if an error had occurred (section 1.4). `^G` is generally
+most useful for temporary interruptions to check the progress of a
+computation. `^G` is "reversible" -- that is, it does not destroy any
+of the "state" of the computation it interrupts. To "undo" a `^G`,
+type the characters
<ERRET T>$
(This is discussed more fully far below, in section 16.4.)
-Typing \^S (CTRL+S) causes Muddle to **throw away** what it is
-currently doing and return a normal "listening" state. (In the Tenex
-and Tops-20 versions, \^O also should have the same effect.) \^S is
-generally most useful for aborting infinite loops and similar terrible
-things. \^S **destroys** whatever is going on, and so it is **not**
-reversible.
+Typing `^S` (`CTRL`+`S`) causes Muddle to **throw away** what it is
+currently doing and return to a normal "listening" state. (In the
+Tenex and Tops-20 versions, `^O` also should have the same effect.)
+`^S` is generally most useful for aborting infinite loops and similar
+terrible things. `^S` **destroys** whatever is going on, and so it is
+**not** reversible.
Most expressions in Muddle include "brackets" (generically meant) that
must be correctly paired and nested. If you end your typing with the
-pair of characters `!$` (!+ESC), all currently unpaired brackets (but
-not double-quotes, which bracket strings of characters) will
-automatically be paired and interpretation will start. Without the !,
-Muddle will just sit there waiting for you to pair them. If you have
-improperly nested parentheses, brackets, etc., within the expression
-you typed, an error will occur, and Muddle will tell you what is
-wrong.
+pair of characters `!$` (`!`+`ESC`), all currently unpaired brackets
+(but not double-quotes, which bracket strings of characters) will
+automatically be paired and interpretation will start. Without the
+`!`, Muddle will just sit there waiting for you to pair them. If you
+have improperly nested parentheses, brackets, etc., within the
+expression you typed, an error will occur, and Muddle will tell you
+what is wrong.
Once the brackets are properly paired, Muddle will immediately echo
carriage-return and line-feed, and the next thing it prints will be
you have some expression unclosed. In that case, if you have not typed
any characters beyond the `$`, you can usually rub out the `$` and
other characters back to the beginning of the unclosed expression.
-Otherwise, what you have typed is beyond the help of rubout and \^@;
-if you want to abort it, use \^S.
+Otherwise, what you have typed is beyond the help of rubout and `^@`;
+if you want to abort it, use `^S`.
Muddle accepts and distinguishes between upper and lower case. All
"built-in functions" must be referenced in upper case.
met. Instead, the right-hand column will be used to state just what
`READ` thought the input in the left-hand column really was.
- --------------------------------------------------------------------------------
+ ------------------------------------------------------------------------------------
Input Explanation
- --------------------------- ----------------------------------------------------
+ --------------------------- --------------------------------------------------------
`ABC$` an `ATOM` of `PNAME` `ABC`
`abc$` an `ATOM` of `PNAME` `abc`
something else (The something else will contain an
`ATOM` of `PNAME` beginning `cd.`)
- `12345A34$` an `ATOM` of `PNAME` `12345A35` (If the A had been
- an E, the object would have been a `FLOAT`.)
- --------------------------------------------------------------------------------
+ `12345A34$` an `ATOM` of `PNAME` `12345A35` (If the A had been an E,
+ the object would have been a `FLOAT`.)
+ ------------------------------------------------------------------------------------
#### 2.6.3.3. (Backslash) in ATOMs
error, but because commenting is needed: `PRINT` doesn't do it full
justice.
- ---------------------------------------------------------------------------
+ -------------------------------------------------------------------------------
Input Explanation
- ------------------------ --------------------------------------------------
+ ------------------------ ------------------------------------------------------
`a\ one\ and\ a\ two$` one `ATOM`, whose `PNAME` has four spaces in it
- `1234\56789$` an `ATOM` of `PNAME` `123456789`, which `PRINT`s
- as `\1233456789`
+ `1234\56789$` an `ATOM` of `PNAME` `123456789`, which `PRINT`s as
+ `\1233456789`
`123\ $` an `ATOM` of `PNAME` `123space`, which `PRINT`s as
`\123\`, with a space on the end
`\\$` an `ATOM` whose `PNAME` is a single backslash
- ---------------------------------------------------------------------------
+ -------------------------------------------------------------------------------
Chapter 3. Built-in Functions
=============================
One way to "name" a `FUNCTION` is
<SETG SQUARE #FUNCTION ((X) <* .X .X>)>$
- #FUNCTION ((X) <* .X .X>
+ #FUNCTION ((X) <* .X .X>)
So that
Another way, which is somewhat cleaner in its typing:
<SETG SQUARE <FUNCTION (X) <* .X .X>>>$
- #FUNCTION ((X) <* .X .X>
+ #FUNCTION ((X) <* .X .X>)
`FUNCTION` is an `FSUBR` which simply makes a `FUNCTION` out of its
arguments and returns the created `FUNCTION`.
effect (in the absence of errors), and the intention is more apparent.
\[Note: if `.L` is a `LIST`, `<LIST !.L>` makes a copy of `.L` whereas
`(!.L)` doesn't; see section 7.7.\] `STRING`, on the other hand,
-produces effect very different from literal `STRING`s.
+produces effects very different from literal `STRING`s.
Examples:
!< func arg-1 arg-2 ... arg-N !>
-where the second `!` (exclamation-point) is optional, and *fun* and
+where the second `!` (exclamation-point) is optional, and *func* and
*arg-1* through *arg-N* are any legal constituents of a `FORM` (that
is, anything). The pointed brackets can be implicit, as in the period
and comma notation for `LVAL` and `GVAL`.
3. What actually gets inserted into the structure being built are the
elements of the structure returned by the `FORM`-like evaluation.
-### 7.7.3 Examples \[1\]
+### 7.7.3. Examples \[1\]
<SET ZOP '![2 3 4]>$
![2 3 4!]
<DEFINE OK (A B "AUX" (D <TUPLE !.A>) (C <REST .D>)) ...>
-9.3 "AUX" \[1\]
+9.3. "AUX" \[1\]
---------------
`"AUX"` (or `"EXTRA"` -- they're totally equivalent) are `STRING`s
*finalf* is applied to **no** arguments; if *finalf* is a `FALSE`,
`MAPF` returns `#FALSE ()`.
-### 10.2.2 MAPR \[1\]
+### 10.2.2. MAPR \[1\]
<MAPR finalf loopf s1 s2 ... sN>
found in chapter 13.
Example: the following `FUNCTION` reads characters from the current
-input channel until an `$` (ESC) is read, and then returns what was
+input channel until an `$` (`ESC`) is read, and then returns what was
read as one `STRING`. (The `SUBR` `READCHR` reads one character from
the input channel and returns it. `NEXTCHR` returns the next
`CHARACTER` which `READCHR` will return -- chapter 11.)
### 11.1.1. Input
All of the following input Subroutines, when directed at a terminal,
-hang until `$` (ESC) is typed and allow normal use of rubout, \^D, \^L
-and \^@.
+hang until `$` (`ESC`) is typed and allow normal use of `rubout`,
+`^D`, `^L` and `^@`.
#### 11.1.1.1. READ
those elements of a `CHANNEL` which specify the number of characters
per output line and the current position on an input line.
-CHANNEL (the TYPE)
-------------------
+11.2. CHANNEL (the TYPE)
+------------------------
I/O channels are dynamically assigned in Muddle, and are represented
by an object of `TYPE` `CHANNEL`, which is of `PRIMTYPE` `VECTOR`. The
The following table tells which `SUBR`s can be used with which modes,
where `OK` indicates an allowed use:
- -------------------------------------------------------------------------------------------------------------------------------------------
- "READ" "PRINT" "READB" "PRINTB", "PRINTO" mode / SUBRs
- -------------------- -------------------- -------------------- ------------------------------------------ ---------------------------------
- OK OK `READ` `READCHR` `NEXTCHR`
- `READSTRING` `FILECOPY`
- `FILE-LENGTH LOAD`
+ -------------------------------------------------------------------------
+ "READ" "PRINT" "READB" "PRINTB", "PRINTO" mode / SUBRs
+ ------ ------- ------- ------------------ ------------
+ OK OK `READ` `READCHR` `NEXTCHR`
+ `READSTRING` `FILECOPY`
+ `FILE-LENGTH LOAD`
- OK OK\* `PRINT` `PRIN1` `PRINC` `IMAGE`
- `CRLF` `TERPRI` `FILECOPY`
- `PRINTSTRING` `BUFOUT` `NETS`
- `RENAME`
+ OK OK\* `PRINT` `PRIN1` `PRINC` `IMAGE`
+ `CRLF` `TERPRI` `FILECOPY`
+ `PRINTSTRING` `BUFOUT` `NETS`
+ `RENAME`
- OK `READB` `GC-READ`
+ OK `READB` `GC-READ`
- OK `PRINTB` `GC-DUMP`
+ OK `PRINTB` `GC-DUMP`
- OK OK OK `ACCESS`
+ OK OK OK `ACCESS`
- OK OK OK OK `RESET`
+ OK OK OK OK `RESET`
- OK OK `ECHOPAIR`
+ OK OK `ECHOPAIR`
- OK `TTYECHO` `TYI`
- -------------------------------------------------------------------------------------------------------------------------------------------
+ OK `TTYECHO` `TYI`
+ -------------------------------------------------------------------------
`*` PRINTing (or `PRIN1`ing) an `RSUBR` (chapter 19) on a `"PRINTB"`
or `"PRINTO"` `CHANNEL` has special effects.
*element-number: type interpretation*
- ------------------------------------------------------------------------------------------------
- element-number type interpretation
- ------------------------- ------------------ ---------------------------------------------------
- -1 `LIST` transcript channel(s) (see below)
+#### 11.2.8.1. Output CHANNELs
- \* 0 varies device-dependent information
+The contents of a CHANNEL used for output are as follows:
- \* 1 `FIX` channel number (ITS) or JFN (Tenex and Tops-20),
- `0` for internal or closed
+ -------------------------------------------------------------------------------------
+ element-number type interpretation
+ ---------------- ------------- ------------------------------------------------------
+ -1 `LIST` transcript channel(s) (see below)
- \* 2 `STRING` mode
+ \* 0 varies device-dependent information
- \* 3 `STRING` first file name argument
+ \* 1 `FIX` channel number (ITS) or JFN (Tenex and Tops-20), `0`
+ for internal or closed
- \* 4 `STRING` second file name argument
+ \* 2 `STRING` mode
- \* 5 `STRING` device name argument
+ \* 3 `STRING` first file name argument
- \* 6 `STRING` directory name argument
+ \* 4 `STRING` second file name argument
- \* 7 `STRING` real first file name
+ \* 5 `STRING` device name argument
- \* 8 `STRING` real second file name
+ \* 6 `STRING` directory name argument
- \* 9 `STRING` real device name
+ \* 7 `STRING` real first file name
- \* 10 `STRING` real directory name
+ \* 8 `STRING` real second file name
- \* 11 `FIX` various status bits
+ \* 9 `STRING` real device name
- \* 12 `FIX` PDP-10 instruction used to do one I/O operation
+ \* 10 `STRING` real directory name
- 13 `FIX` number of characters per line of output
+ \* 11 `FIX` various status bits
- 14 `FIX` current character position on a line
+ \* 12 `FIX` PDP-10 instruction used to do one I/O operation
- 15 `FIX` number of lines per page
+ 13 `FIX` number of characters per line of output
- 16 `FIX` current line number on a page
+ 14 `FIX` current character position on a line
- 17 `FIX` access pointer for file-oriented devices
+ 15 `FIX` number of lines per page
- 18 `FIX` radix for `FIX` conversion
+ 16 `FIX` current line number on a page
- 19 `FIX` sink for an internal `CHANNEL`
- ------------------------------------------------------------------------------------------------
+ 17 `FIX` access pointer for file-oriented devices
+
+ 18 `FIX` radix for `FIX` conversion
+
+ 19 `FIX` sink for an internal `CHANNEL`
+ -------------------------------------------------------------------------------------
N.B.: The elements of a `CHANNEL` below number 1 are usually invisible
but are obtainable via `<NTH <TOP channel> fix>`, for some appropriate
current character position (number 14) and current line number (16)
are not updated. `IMAGE` returns *fix*.
-11.5 Dumped I/O
+11.5. Dumped I/O
---------------
### 11.5.1. Output: GC-DUMP
eventually returns `"DONE"`. First, however, it `READ`s and `EVAL`s
every Muddle object in the file pointed to by *input*, and then
-`CLOSE`s *input*. Any occurrences of rubout, ^@, ^D, \^L, etc., in the
-file are given no special meaning; they are simply `ATOM`
+`CLOSE`s *input*. Any occurrences of `rubout`, `^@`, `^D`, `^L`, etc.,
+in the file are given no special meaning; they are simply `ATOM`
constituents.
*look-up* is optional, used to specify a `LIST` of `OBLIST`s for the
respect to typing in carriage-return, in that it automatically adds a
line-feed. In order to type in a lone carriage-return, a
carriage-return followed by a rubout must be typed. Also `PRINT`,
-`PRINT1` and `PRINC` do not automatically add a line-feed when a
+`PRIN1` and `PRINC` do not automatically add a line-feed when a
carriage-return is output. This enables overstriking on a terminal
that lacks backspacing capability. It also means that what goes on a
terminal and what goes in a file are more likely to look the same.
pseudo-terminal, reading also stops if and when no more characters are
available, that is, when `READCHR` would return `-1`.
-11.8.1. ECHOPAIR
-----------------
+### 11.8.1. ECHOPAIR
+--------------------
<ECHOPAIR terminal-in:channel terminal-out:channel>
returns its first argument, after making the two `CHANNEL`s "know
-about each other" so that rubout, ^@, ^D and \^L on *terminal-in* will
-cause the appropriate output on *terminal-out*.
+about each other" so that `rubout`, `^@`, `^D` and `^L` on
+*terminal-in* will cause the appropriate output on *terminal-out*.
### 11.8.2. TTYECHO
<TYI terminal-input:channel>
returns one `CHARACTER` from *channel* (optional, `.INCHAN` by
-default) when it is typed, rather than after `$` (ESC) is typed, as is
-the case with `READCHR`. The following example echos input characters
-as their ASCII values, until a carriage-return is typed:
+default) when it is typed, rather than after `$` (`ESC`) is typed, as
+is the case with `READCHR`. The following example echos input
+characters as their ASCII values, until a carriage-return is typed:
<REPEAT ((FOO <TTYECHO .INCHAN <>>))
<AND <==? 13 <PRINC <ASCII <TYI .INCHAN>>>>
should use to do so. This is particularly true with respect to
locatives to `LVAL`s; the fact that they are independent of changes in
binding can save a lot of fooling around with `EVAL` and
-`ENVIRONMENT`s. \# Chapter 13. Association (Properties)
+`ENVIRONMENT`s.
+
+Chapter 13. Association (Properties)
+====================================
There is an "associative" data storage and retrieval system embedded
in Muddle which allows the construction of data structures with
14.5. Global DECLs
------------------
-### 15.4.1. GDECL and MANIFEST
+### 14.5.1. GDECL and MANIFEST
There are two ways to declare `GVAL`s for the `DECL`-checking
mechanism. These are through the `FSUBR` `GDECL` ("global
the `ATOM` `DEFAULT` is in that `LIST`, the `OBLIST` following that
`ATOM` will be used.)
-15.4. PRIN1 and OBLISTs
+15.4. PRINT and OBLISTs
-----------------------
When `PRINT` is given an `ATOM` to output, it outputs as little of the
removes *atom* from its `OBLIST`, if it is on one. It returns *atom*
if it was on an `OBLIST`; otherwise it returns `#FALSE ()`.
-### 15.7.6 INSERT
+### 15.7.6. INSERT
<INSERT string-or-atom oblist>
INC!-INCO
;"Put your external symbols into that OBLIST.
- If you have many, just write them successively."
+ If you have many, just write them successively."
<BLOCK (<MOBLIST INCI!-INCO 1> <GET INCO OBLIST> <ROOT>)>
;"Create a local OBLIST, naming it INCI!-INCO, and set up
trailer notation of !-INCO will not work within the current
BLOCK-ENDBLOCK pair."
- <DEFINE INC ;"INC is found in the INCO OBLIST."
- (A) ;"A is not found and is therefore put into INCI by
- READ."
+<DEFINE INC ;"INC is found in the INCO OBLIST."
+ (A) ;"A is not found and is therefore put into INCI by READ."
#DECL ((VALUE A) <OR FIX FLOAT>)
- <SET .A <+ ..A 1>>> ;"All other ATOMs are found in the
- ROOT."
+ <SET .A <+ ..A 1>>> ;"All other ATOMs are found in the ROOT."
<ENDBLOCK>
This example is rather trivial, but it contains all of the issues, of
inputs (what `READ` returns) in it, most recent first. Similarly, if
the `ATOM` `L-OUTS` has a local value that is a `LIST`, `LISTEN` will
keep recent outputs (what `EVAL` returns) in it, most recent first.
-The keeping is done before the `PRINT`ing, so that \^S does not defeat
-its purpose. The user can decide how much to keep around by setting
-the length of each `LIST`. Even if `L-OUTS` is not used, the atom
-`LAST-OUT` is always `SET` to the last object returned by `EVAL` in
-the standard `LISTEN` loop. Example:
+The keeping is done before the `PRINT`ing, so that `^S` does not
+defeat its purpose. The user can decide how much to keep around by
+setting the length of each `LIST`. Even if `L-OUTS` is not used, the
+atom `LAST-OUT` is always `SET` to the last object returned by `EVAL`
+in the standard `LISTEN` loop. Example:
<SET L-INS (NEWEST NEWER NEW)>$
(NEWEST NEWER NEW)
`ERROR` argument).
16.3. FRAME (the TYPE)
+----------------------
A `FRAME` is the object placed on a `PROCESS`'s control stack (chapter
20) whenever a `SUBR`, `FSUBR`, `RSUBR`, or `RSUBR-ENTRY` (chapter 19)
1. It cannot be typed in. It can be generated only by applying a
Subroutine.
2. It does not type out in any standard format, but rather as
- `#FRAME` followed by the `PNAME`of the Subroutine applied.
+ `#FRAME` followed by the `PNAME` of the Subroutine applied.
-16.3.1. ARGS
+### 16.3.1. ARGS
<ARGS frame>
("arguments") returns the argument `TUPLE` of *frame*.
-16.3.2. FUNCT
+### 16.3.2. FUNCT
<FUNCT frame>
-("function"} returns the `ATOM` whose `G/LVAL` is being applied in
+("function"} returns the `ATOM` whose G/LVAL is being applied in
*frame*.
-16.3.3. FRAME (the SUBR)
+### 16.3.3. FRAME (the SUBR)
<FRAME frame>
of `ERROR` or `LISTEN`, which was bound by the interpreter to the
`ATOM` `LERR\ I-INTERRUPTS` ("last error").
-16.3.4. Examples
+### 16.3.4. Examples
Say you have gotten an error. You can now type at `ERROR`'s `LISTEN`
loop and get things `EVAL`ed. For example,
the-arguments-to-the-Subroutine-which-called-ERROR:tuple
16.4. ERRET
+-----------
<ERRET any frame>
("a string" (5))
16.5. RETRY
+-----------
<RETRY frame>
rebinding in the argument `LIST`, thus duplicating side effects.
16.6. UNWIND
+------------
`UNWIND` is an `FSUBR` that takes two arguments, usually `FORM`s. It
`EVAL`s the first one, and, if the `EVAL` returns normally, the value
<CLOSE .C>>)>>
16.7. Control-G (\^G)
+---------------------
-Typing control-G (\^G, `<ASCII 7>`) at Muddle causes it to act just as
-if an error had occurred in whatever was currently being done. You can
-then examine the values of variables as above, continue by applying
-`ERRET` to one argument (which is ignored), `RETRY` a `FRAME` lower on
-the control stack, or flush everything by applying `ERRET` to no
-arguments.
+Typing control-G (`^G`, `<ASCII 7>`) at Muddle causes it to act just
+as if an error had occurred in whatever was currently being done. You
+can then examine the values of variables as above, continue by
+applying `ERRET` to one argument (which is ignored), `RETRY` a `FRAME`
+lower on the control stack, or flush everything by applying `ERRET` to
+no arguments.
16.8. Control-S (\^S)
+---------------------
-Typing control-S (
\^S, `<ASCII 19>`) at Muddle causes it to stop what
+Typing control-S (
`^S`, `<ASCII 19>`) at Muddle causes it to stop what
is happening and return to the `FRAME` `.LERR\ !-INTERRUPTS`,
-returning the `ATOM` `T`. (In the Tenex and Tops-20 versions, \^O also
-has the same effect.)
+returning the `ATOM` `T`. (In the Tenex and Tops-20 versions, `^O`
+also has the same effect.)
16.9. OVERFLOW
+--------------
<OVERFLOW false-or-any>
produces objects of `TYPE` `LOCR` instead of `LOCD`.
19.5. TYPE-C and TYPE-W
-=======================
+-----------------------
In order to handle user `NEWTYPE`s reasonably, the internal `TYPE`
codes for them have to be able to be different from one Muddle run to
<DEFINE SUM3 (A)
<REPEAT ((S .A))
#DECL ((A S0 <OR FIX FLOAT>)
- <SET S <RESUME <+ .S <RESUME "GOT 1"> <RESUME "GOT
- 2">>>>>>
+ <SET S <RESUME <+ .S <RESUME "GOT 1"> <RESUME "GOT 2">>>>>>
20.7. Other Coroutining Features
--------------------------------
`FIX` which determines which interrupts can really "interrupt" -- that
is, cause the current processing to be suspended while their wants are
satisfied. Normal, non-interrupt programs operate at an interrupt
-level of 0 (zero.) An interrupt is processed at an interrupt level
+level of 0 (zero). An interrupt is processed at an interrupt level
equal to the interrupt's priority.
### 21.7.1. Interrupt Processing
priority than the target priority have been processed.
Setting the `INT-LEVEL` extremely high (for example,
-`<INT-LEVEL <CHTPE <MIN> FIX>>`) effectively disables all interrupts
+`<INT-LEVEL <CHTYPE <MIN> FIX>>`) effectively disables all interrupts
(but occurrences of enabled interrupts will still be queued).
If `LISTEN` or `ERROR` is called when the `INT-LEVEL` is not zero,
then the typeout will be
- LISTENING-AT-LEVEL I PROCESS p INT-LEVEL i
+ LISTENING-AT-LEVEL l PROCESS p INT-LEVEL i
### 21.7.3. DISMISS
interrupt, and the mode of the `CHANNEL` tells what kinds of `"CHAR"`
interrupts occur to be handled through that `IHEADER`.
-1. If the `CHANNEL` is for `INPUT`, "CHAR" occurs every time an
+1. If the `CHANNEL` is for `INPUT`, `"CHAR"` occurs every time an
"interesting" character (see below) is received from the
`CHANNEL`'s real terminal, or any character is received from the
`CHANNEL`'s pseudo-terminal, or a character or word is received
which it was typed.
In the ITS version, the "interesting" characters are those "enabled
-for interrupts" on a real terminal, namely <kbd>\^@</kbd> through
-<kbd>\^G</kbd>, <kbd>\^K</kbd> through <kbd>\^\_</kbd>, and
-<kbd>DEL</kbd> (that is, ASCII codes 0-7, 13-37, and 177 octal.)
+for interrupts" on a real terminal, namely `^@` through `^G`, `^K`
+through `^_`, and `DEL` (that is, ASCII codes 0-7, 13-37, and 177
+octal).
In the Tenex and Tops-20 versions, the operating system can be told
which characters typed on a terminal should cause this interrupt to
containing those characters (no more than six, all with ASCII codes
less than 33 octal). If called with no argument, `ACTIVATE-CHARS`
returns a `STRING` containing the characters that currently interrupt.
-Initially, only <kbd>\^G</kbd>, <kbd>\^S</kbd>, and <kbd>\^O</kbd>
-interrupt.
+Initially, only `^G`, `^S`, and `^O` interrupt.
An initial Muddle already has `"CHAR"` enabled on `,INCHAN` with a
priority 8 (eight), the `SUBR` `QUITTER` for a handler to run in
-`#PROCESS 0` (the running `PROCESS`); this is how <kbd>`^G`</kbd> and
-<kbd>`^S`</kbd> are processed. In addition, every time a new `CHANNEL`
-is `OPEN`ed in `"READ"` mode to a terminal, a similar `IHEADER` and
-`HANDLER` are associated with that new `CHANNEL` automatically. These
+`#PROCESS 0` (the running `PROCESS`); this is how `^G` and `^S` are
+processed. In addition, every time a new `CHANNEL` is `OPEN`ed in
+`"READ"` mode to a terminal, a similar `IHEADER` and `HANDLER` are
+associated with that new `CHANNEL` automatically. These
automatically-generated `IHEADER`s and `HANDLER`s use the standard
machinery, and they can be `DISABLE`d or `OFF`ed at will. **However**,
the `IHEADER` for `,INCHAN` should not be `OFF`ed: Muddle knows that
`$` is typed only by an interrupt!
Example: the following causes the given message to be printed out
-whenever a <kbd>`^Y`</kbd> is typed on `.INCHAN`:
+whenever a `^Y` is typed on `.INCHAN`:
<SET H <HANDLER <GET .INCHAN INTERRUPT>
#FUNCTION ((CHAR CHAN)
friends). An interrupt occurs when a character is available for input.
These interrupts are set up in exactly the same way as real-terminal
interrupts, except that a handler gets applied to only **one**
-argument, the `CHANNEL`. Pseudo-terminal are not available in the
+argument, the `CHANNEL`. Pseudo-terminals are not available in the
Tenex and Tops-20 versions.
For any other flavor of ITS channel interrupt, a handler gets applied
a deferrable garbage collection that is needed because of exhausted
movable garbage-collected storage. Enabling this interrupt is the only
way a program can know that a garbage collection is about to occur. A
-handler takes two arguments: A `FIX` telling the number of machine
+handler takes two arguments: a `FIX` telling the number of machine
words needed and an `ATOM` telling what initiated the garbage
collection (see above). If it wishes, a handler can try to prevent a
garbage collection by calling `BLOAT` with the `FIX` argument. If the
### 21.8.6. "CLOCK"
`"CLOCK"`, when enabled, occurs every half second (the ITS
-"slow-clock" tick.) It is not available in the Tenex or Tops-20
+"slow-clock" tick). It is not available in the Tenex or Tops-20
versions. It wants handlers which take no arguments. Example:
<ON "CLOCK" <FUNCTION () <PRINC "TICK ">> 1>
### 21.8.8. "UNBLOCKED"
-`"UNBLOCKED"` occurs whenever a `$` (<kbd>`ESC`</kbd>) is typed on a
-terminal if a program was hanging and waiting for input, or when a TYI
-call (which see) is satisfied. A handler takes one argument: the
-`CHANNEL` via which the `$` or character is input.
+`"UNBLOCKED"` occurs whenever a `$` (`ESC`) is typed on a terminal if
+a program was hanging and waiting for input, or when a `TYI` call
+(which see) is satisfied. A handler takes one argument: the `CHANNEL`
+via which the `$` or character is input.
### 21.8.9. "READ" and "WRITE"
<SET B <AT .A 2>>$
#LOCL 2
<ON "WRITE" <FUNCTION (OBJ VAL FRM)
- #DECL ((VALUE VAL ANY (OBJ) LOCATIVE (FRM) FRAME)
+ #DECL ((VALUE VAL) ANY (OBJ) LOCATIVE (FRM) FRAME)
<CRLF>
<PRINC "Program changed ">
<PRIN1 .OBJ>
<PRINC " to ">
<PRIN1 .VAL>
<PRINC " via ">
- <PRINC .FRM>
+ <PRINT .FRM>
<CRLF>>
4 0 .B>$
- #HANDLER FUNCTION (...)
+ #HANDLER #FUNCTION (...)
<1 .A 10>$
(10 2 3)
<2 .A 20>$
If an error occurs at an `INT-LEVEL` greater than or equal to that of
the `"ERROR"` interrupt, real `ERROR` will be called, because
-`"ERROR"`interrupts cannot be queued.
+`"ERROR"` interrupts cannot be queued.
### 21.8.12. "IPC"
handler takes one argument: A `FIX` between `0` and `7` inclusive,
telling which inferior process is interrupting.
-### 21.8.14. "RUNT and "REALT"
+### 21.8.14. "RUNT" and "REALT"
These are not available in the Tenex and Tops-20 versions.
`"MPV"` ("memory protection violation") occurs if Muddle tries to
refer to a storage address not in its address space. `"PURE"` occurs
if Muddle tries to alter read-only storage. `"ILOPR"` occurs if Muddle
-executes and illegal instruction ("operator"). `"PARITY"` occurs if
+executes an illegal instruction ("operator"). `"PARITY"` occurs if
the CPU detects a parity error in Muddle's address space. All of these
require a handler that takes one argument: the address (`TYPE` `WORD`)
following the instruction that was being executed at the time.
interrupt goes to the superior operating system process.
- If an `IHEADER` is associated but disabled, the error
`DANGEROUS-INTERRUPT-NOT-HANDLED` occurs (`FILE-SYSTEM-ERROR` for
- \`"IOC").
+ `"IOC"`).
- If an `IHEADER` is associated and enabled, but the `INT-LEVEL` is
too high, the error `ATTEMPT-TO-DEFER-UNDEFERABLE-INTERRUPT`
occurs.
Most storage used explicitly by Muddle programs is obtained from a
pool of free storage managed by a "garbage collector". Storage is
-obtained from this pool by the `SUBR`s which construct objects. When a
-`SUBR` finds that the pool of available storage is exhausted, it
-automatically calls the garbage collector.
+obtained from this pool by the `SUBR`s which construct objects. When
+such a `SUBR` finds that the pool of available storage is exhausted,
+it automatically calls the garbage collector.
The garbage collector has two algorithms available to it: the
"copying" algorithm, which is used by default, and the "mark-sweep"
lose.
Thus, if you just "forget about" an object, that is, lose all possible
-means of referencing it, its storage is automatically reclaimed.
+means of referencing it, its storage area is automatically reclaimed.
"Object" in this context includes that stack-structured storage space
used in `PROCESS`es for functional application.
5. Finally, the "mark-sweep" algorithm sweeps through the storage
space, adding unmarked objects to the internal free lists for
later re-use. The "copying" algorithm maps the inferior process's
- address space into Muddle's own, replacing old garbagey with the
- new compact storage, and the inferior process is destroyed.
+ address space into Muddle's own, replacing old garbagey storage
+ with the new compact storage, and the inferior process is
+ destroyed.
-22.5 GC
--------
+22.5. GC
+--------
<GC min:fix exh?:false-or-any ms-freq:fix>
causes the garbage collector to run and returns the total number of
words of storage reclaimed. All of its arguments are optional: if they
-are not supplied, a call to GC simply causes a "copying" garbage
+are not supplied, a call to `GC` simply causes a "copying" garbage
collection.
If *min* is explicitly supplied as an argument, a garbage-collection
parameter is changed permanently before the garbage collector runs.
*min* is the smallest number of words of "free" (unclaimed, available
for use) movable garbage-collected storage the garbage collector will
-be satisfied with having after it is done. Initially it is 8192 words.
-If the total amount of reclaimed storage is less than *min*, the
-garbage collector will ask the operating system for enough storage (in
-1024 word blocks) to make it up. N.B.: the system may be incivil
-enough not to grant the request; in that case, the garbage collector
-will be content with what it has, **unless** that is not enough to
-satisfy a **pending** request for storage. Then it will inform you
-that it is losing. A large *min* will result in fewer total garbage
-collections, but they will take longer since the total quantity of
-storage to be dealt with will generally be larger. Smaller *min*s
-result in shorter, more frequent garbage collections.
+be satisfied with having after it is done each time. Initially it is
+8192 words. If the total amount of reclaimed storage is less than
+*min*, the garbage collector will ask the operating system for enough
+storage (in 1024-word blocks) to make it up. N.B.: the system may be
+incivil enough not to grant the request; in that case, the garbage
+collector will be content with what it has, **unless** that is not
+enough to satisfy a **pending** request for storage. Then it will
+inform you that it is losing. A large *min* will result in fewer total
+garbage collections, but they will take longer since the total
+quantity of storage to be dealt with will generally be larger. Smaller
+*min*s result in shorter, more frequent garbage collections.
+
+*exh?* tells whether or not this garbage collection should be
+"exhaustive". It is optional, a `FALSE` by default. The difference
+between normal and exhaustive "copying" garbage collections is whether
+certain kinds of storage that require complicated treatment (for
+example, associations) are reclaimed. An exhaustive garbage collection
+occurs every eighth time that the "copying" algorithm is used, or when
+`GC` is called with this argument true, or when a normal garbage
+collection cannot satisfy the storage request.
+
+*ms-freq* gives the number of times the "mark-sweep" algorithm should
+be used hereafter for every time the normal "copying" algorithm is
+used. Giving `0` for *ms-freq* means never to use the "mark-sweep"
+algorithm, and giving `<CHTYPE <MIN> FIX>` means (effectively) always
+to use it. The "mark-sweep" algorithm uses considerably less processor
+time than the "copying" algorithm, but it never shrinks the
+free-storage pool, and in fact the pool can become fragmented. The
+"mark-sweep" algorithm could be useful in a program system (such as
+the compiler) where the size of the pool rarely changes, but objects
+are created and thrown away continuously.
22.6. BLOAT
-----------
`READ`ing large `STRING`s, and calling routines within the
interpreter and compiled programs)
-Arguments on the second line are also `FIX` and optional, but they set
-garbage-collection parameters permanently, as follows:
+Arguments on the second line above are also `FIX` and optional, but
+they set garbage-collection parameters permanently, as follows:
- *min*: as for `GC`
- *plcl*: number of slots for `LVAL`s added when the space for
22.8. GC-MON
------------
- <GC-MOND pred>
+ <GC-MON pred>
("garbage-collector monitor") determines whether or not the
interpreter will hereafter print information on the terminal when a
Two `SUBR`s, described next, use only part of the garbage-collector
algorithm, in order to find all pointers to an object. `GC-DUMP` and
`GC-READ`, as their names imply, also use part in order to translate
-between Muddle objects and binary representation thereof.
+between Muddle objects and binary representations thereof.
### 22.9.1. SUBSTITUTE
the "wrong" one, after `OBLIST`s have been in the wrong state. This is
more or less the way `ATOM`s are impurified. It is also useful for
unlinking `RSUBR`s. `SUBSTITUTE` returns *old* as a favor: unless you
-hang onto *old* at that point, it will be garbage-collected.
+hang onto *old* at that point, it will be garbage.
-22.9.2 PURIFY
--------------
+22.9.2. PURIFY
+--------------
<PURIFY any-1 ... any-N>
("value return") seldom returns. It passes control back up the process
tree to the superior of Muddle, passing its argument as a message to
that superior. If it does return, the value is `#FALSE ()`. If the
-argument is a `STRING`, it is passed to the superior as a command to
+argument is a `STRING`, it is passed to the superior as commands to
be executed, via `.VALUE` in the ITS version and `RSCAN` in the
Tops-20 version. If the argument is a `FIX`, it is passed to the
-superior as the "effective address" of a `.BREAK 16`, instruction in
+superior as the "effective address" of a `.BREAK 16,` instruction in
the ITS version and ignored in other versions.
23.4. Inter-process Communication
if an *unmanifest* is referenced more than twice. Example:
<DEFINE MAP-LOOKUP (THINGS "AUX" (DB ,DATA-BASE))
- #DECL ((VALUE) VECTOR (THINGS DB) <UNSPECIAL <PRIMTYPE
- LIST>>)
+ #DECL ((VALUE) VECTOR (THINGS DB) <UNSPECIAL <PRIMTYPE LIST>>)
<MAPF ,VECTOR <FUNCTION (T) <MEMQ .T .DB>> .THINGS>>
24.4. Global and Local Values
You can see the nature of the choices. Nesting is still and all better
than `GO`.
+
+Appendix 1. A Look Inside
+=========================
+
+This appendix tells about the mapping between Muddle objects and
+PDP-10 storage -- in other words, the way things look "on the inside".
+None of this information is essential to knowing how to program in
+Muddle, but it does give some reasons for capabilities and
+restrictions that otherwise you have to memorize. The notation and
+terminology get a little awkward in this discussion, because we are in
+a twilight zone between the worlds of Muddle objects and of bit
+patterns. In general the words and phrases appearing in diagrams refer
+to bit patterns not Muddle objects. A lower-case word (like "tuple")
+refers to the storage occupied by an object of the corresponding
+`PRIMTYPE` (like `TUPLE`).
+
+First some terminology needs discussion. The sine qua non of any
+Muddle object is a **pair** of 36-bit computer words. In general,
+lists consist of pairs chained together by pointers (addresses), and
+vectors consist of contiguous blocks of pairs. `==?` essentially tests
+two pairs to see whether they contain the same bit patterns.
+
+The first (lower-addressed) word of a pair is called the **`TYPE`
+word**, because it contains a numeric **`TYPE` code** that represents
+the object's `TYPE`. The second (higher-addressed) word of a pair is
+called the **value word**, because it contains (part of or the
+beginning of) the "data part" of the object. The `TYPE` word (and
+sometimes the value word) is considered to be made of a left half and
+a right half. We will picture a pair like this:
+
+ ---------------------------------
+ | TYPE | |
+ | - - - - - - - - - - - - - - - |
+ | value |
+ ---------------------------------
+
+where a vertical bar in the middle of a word means the word's halves
+are used independently. You can see that the `TYPE` code is confined
+to the left half of the `TYPE` word. (Half-)words are sometimes
+subdivided into **fields** appropriate for the context; fields are
+also pictured as separated by vertical bars. The right half of the
+`TYPE` word is used for different purposes depending on the `TYPE` of
+the object and actual location of the value.
+
+Actually the 18-bit `TYPE` field is further decoded. The high-order
+(leftmost) bit is the mark bit, used exclusively by the garbage
+collector when it runs. The next two bits are monitor bits, used to
+cause `"READ"` and `"WRITE"` interrupts on read and write references
+to the pair. The next bit is used to differentiate between list
+elements and vector dope words. The next bit is unused but could be
+used in the future for an "execute" monitor. The remaining 13 bits
+specify the actual `TYPE` code. What `CHTYPE` does is to copy the pair
+and put a new `TYPE` code into the new pair.
+
+Each data `TYPE` (predefined and `NEWTYPE`s) must belong to one of
+about 25 "storage allocation classes" (roughly corresponding to Muddle
+`PRIMTYPE`s). These classes are characterized primarily by the manner
+in which the garbage collector treats them. Some of these classes will
+now be described.
+
+"One Word"
+
+This class includes all data that are not pointers to some kind of
+structure. All external (program-available) `TYPE`s in this class are
+of `PRIMTYPE` `WORD`. Example:
+
+ ---------------------------------
+ | FIX | 0 |
+ | - - - - - - - - - - - - - - - |
+ | 105 |
+ ---------------------------------
+
+"Two Word"
+
+The members of this class are all 18-bit pointers to list elements.
+All external `TYPE`s in this class are of `PRIMTYPE` `LIST`. Example:
+
+ ---------------------------------
+ | LIST | 0 |
+ | - - - - - - - - - - - - - - - |
+ | 0 | pointer |
+ ---------------------------------
+
+where `pointer` is a pointer to the first list element. If there are
+no elements, `pointer` is zero; thus empty objects of `PRIMTYPE`
+`LIST` are `==?` if their `TYPE`s are the same.
+
+"Two N Word"
+
+Members of this class are all "counting pointers" to blocks of
+two-word pairs. The right half of a counting pointer is an address,
+and the left half is the negative of the number of 36-bit words in the
+block. (This format is tailored to the PDP-10 `AOBJN` instruction.)
+The number of pairs in the block (`LENGTH`) is half that number, since
+each pair is two words. All external `TYPE`s in this class are of
+`PRIMTYPE` `VECTOR`. Example:
+
+ ---------------------------------
+ | VECTOR | 0 |
+ | - - - - - - - - - - - - - - - |
+ | -2*length | pointer |
+ ---------------------------------
+
+where `length` is the `LENGTH` of the `VECTOR` and `pointer` is the
+location of the start (the element selected by an `NTH` argument of 1)
+of the `VECTOR`.
+
+"N word"
+
+This class is the same as the previous one, except that the block
+contains objects all of the same `TYPE` without individual `TYPE`
+words. The `TYPE` code for all the elements is in vector dope words,
+which are at addresses just larger than the block itself. Thus, any
+object that carries information in its `TYPE` word cannot go into the
+block: `PRIMTYPE`s `STRING`, `BYTES`, `TUPLE` (and the corresponding
+locatives `LOCS`, `LOCB`, `LOCA`), `FRAME`, and `LOCD`. All external
+`TYPE`s in this class are of `PRIMTYPE` `UVECTOR`. Example:
+
+ ---------------------------------
+ | UVECTOR | 0 |
+ | - - - - - - - - - - - - - - - |
+ | -length | pointer |
+ ---------------------------------
+
+where `length` is the `LENGTH` of the `UVECTOR` and `pointer` points
+to the beginning of the `UVECTOR`.
+
+"Byte String" and "Character String"
+
+These two classes are almost identical. Byte strings are byte pointers
+to strings of arbitrary-size bytes. `PRIMTYPE` `BYTES` is the only
+member of this class. Character strings are byte pointers to strings
+of ASCII characters. `PRIMTYPE` `STRING` is the only member of this
+class. Both of these classes consist of a length and a PDP-10 byte
+pointer. In the case of character strings, the byte-size field in the
+byte pointer is always seven bits per byte (hence five bytes per
+word). Example:
+
+ ---------------------------------
+ | STRING | length |
+ | - - - - - - - - - - - - - - - |
+ | byte-pointer |
+ ---------------------------------
+
+where `length` is the `LENGTH` of the `STRING` (in bytes) and
+`byte-pointer` points to a byte just before the beginning of the
+string (an `ILDB` instruction is needed to get the first byte). A
+newly-created `STRING` always has `*010700*` in the left half of
+`byte-pointer`. Unless the string was created by `SPNAME`,
+`byte-pointer` points to a uvector, where the elements (characters) of
+the `STRING` are stored, packed together five to a word.
+
+"Frame"
+
+This class gives the user program a handle on its control and
+variable-reference structures. All external `TYPE`s in this class are
+of `PRIMTYPE` `FRAME`. Three numbers are needed to designate a frame:
+a unique 18-bit identifying number, a pointer to the frame's storage
+on a control stack, and a pointer to the `PROCESS` associated with the
+frame. Example:
+
+ ---------------------------------
+ | FRAME |PROCESS-pointer|
+ | - - - - - - - - - - - - - - - |
+ | unique-id | frame-pointer |
+ ---------------------------------
+
+where `PROCESS-pointer` points to the dope words of a `PROCESS`
+vector, and `unique-id` is used for validating (testing `LEGAL?`) the
+`frame-pointer`, which points to a frame for some Subroutine call on
+the control stack.
+
+"Tuple"
+
+A tuple pointer is a counting pointer to a vector on the control
+stack. It may be a pointer to the arguments to a Subroutine or a
+pointer generated by the `"TUPLE"` declaration in a `FUNCTION`. Like
+objects in the previous class, these objects contain a unique
+identifying number used for validation. `PRIMTYPE` `TUPLE` is the only
+member of this class. Example:
+
+ ---------------------------------
+ | TUPLE | unique-id |
+ | - - - - - - - - - - - - - - - |
+ | -2*length | pointer |
+ ---------------------------------
+
+Other Storage Classes
+
+The rest of the storage classes include strictly internal `TYPE`s and
+pointers to special kinds of lists and vectors like locatives, `ATOM`s
+and `ASOC`s. A pair for any `LOCATIVE` except a `LOCD` looks like a
+pair for the corresponding structure, except of course that the `TYPE`
+is different. A `LOCD` pair looks like a tuple pair and needs a word
+and a half for its value; the `unique-id` refers to a binding on the
+control stack or to the "global stack" if zero. Thus `LOCD`s are in a
+sense "stack objects" and are more restricted than other locatives.
+
+An `OFFSET` is stored with the `INDEX` in the right half of the value
+word and the Pattern in the left half. Since the Pattern can be either
+an `ATOM` or a `FORM`, the left half actually points to a pair, which
+points to the actual Pattern. The Pattern `ANY` is recognized as a
+special case: the left-half pointer is zero, and no pair is used.
+Thus, if you're making the production version of your program and want
+to save some storage, can do something like
+`<SETG FOO <PUT-DECL ,FOO ANY>>` for all `OFFSET`s.
+
+Basic Data Structures
+---------------------
+
+Lists
+
+List elements are pairs linked together by the right halves of their
+first words. The list is terminated by a zero in the right half of the
+last pair. For example the `LIST` `(1 2 3)` would look like this:
+
+ -------------
+ | LIST | 0 |
+ | - - - - - | ----------- ----------- -----------
+ | 0 | ------>| FIX | ------->| FIX | ------->| FIX | 0 |
+ ------------- | - - - - | | - - - - | | - - - - |
+ | 1 | | 2 | | 3 |
+ ----------- ----------- -----------
+
+The use of pointers to tie together elements explains why new elements
+can be added easily to a list, how sharing and circularity work, etc.
+The links go in only one direction through the list, which is why a
+list cannot be `BACK`ed or `TOP`ped: there's no way to find the
+`REST`ed elements.
+
+Since some Muddle values require a word and a half for the value in
+the pair, they do not fit directly into list elements. This problem is
+solved by having "deferred pointers". Instead of putting the datum
+directly into the list element, a pointer to another pair is used as
+the value with the special internal `TYPE` `DEFER`, and the real datum
+is put in the deferred pair. For example the `LIST` `(1 "hello" 3)`
+would look like this:
+
+ -------------
+ | LIST | 0 |
+ | - - - - - | ----------- ----------- -----------
+ | 0 | ------>| FIX | ------->|DEFER| ------->| FIX | 0 |
+ ------------- | - - - - | | - - - - | | - - - - |
+ | 1 | | ----- | 3 |
+ ----------- ----------- | -----------
+ |
+ ----------- |
+ |STRING| 5|<-
+ | - - - - |
+ |byte-pntr|
+ -----------
+
+Vectors
+
+A vector is a block of contiguous words. More than one pair can point
+to the block, possibly at different places in the block; this is how
+sharing occurs among vectors. Pointers that are different arise from
+`REST` or `GROW`/`BACK` operations. The block is followed by two "dope
+words", at addresses just larger than the largest address in the
+block. Dope words have the following format:
+
+ / /
+ | |
+ | |
+ ---------------------------------
+ | type | grow |
+ | - - - - - - - - - - - - - - - |
+ | length | gc |
+ ---------------------------------
+
+The various fields have the following meanings:
+
+`type` -- The fourth bit from the left (the "vector bit", `40000`
+octal) is always one, to distinguish these vector dope words from a
+`TYPE`/value pair.
+
+If the high-order bit is zero, then the vector is a `UVECTOR`, and the
+remaining bits specify the uniform `TYPE` of the elements. `CHUTYPE`
+just puts a new `TYPE` code in this field. Each element is limited to
+a one-word value: clearly `PRIMTYPE` `STRING`s and `BYTES`es and stack
+objects can't go in uniform vectors.
+
+If the high-order bit is one and the `TYPE` bits are zero, then this
+is a regular `VECTOR`.
+
+If the high-order bit is one and the `TYPE` bits are not all zero,
+then this is either an `ATOM`, a `PROCESS`, an `ASOC`, or a
+`TEMPLATE`. The special internal format of these objects will be
+described a little later in this appendix.
+
+`length` -- The high-order bit is the mark bit, used by the garbage
+collector. The rest of this field specifies the number of words in the
+block, including the dope words. This differs from the length given in
+pairs pointing to this vector, since such pairs may be the result of
+`REST` operations.
+
+`grow` -- This is actually two nine-bit fields, specifying either
+growth or shrinkage at both the high and low ends of the vector. The
+fields are usually set only when a stack must be grown or shrunk.
+
+`gc` -- This is used by the garbage collector to specify where this
+vector is moving during compaction.
+
+Examples (numbers in octal): the `VECTOR` `[1 "bye" 3]` looks like:
+
+ ---------------
+ | VECTOR | 0 |
+ | - - - - - - | -----------------
+ | -6 | ----------->| FIX | |
+ --------------- | - - - - - - - |
+ | 1 |
+ -----------------
+ | STRING | 3 |
+ | - - - - - - - |
+ | byte pointer |
+ -----------------
+ | FIX | |
+ | - - - - - - - |
+ | 3 |
+ -----------------
+ | 440000 | 0 |
+ | - - - - - - - |
+ | 10 | |
+ -----------------
+
+The `UVECTOR` `![-1 7 -4!]` looks like:
+
+ ---------------
+ | UVECTOR | 0 |
+ | - - - - - - | -----------------
+ | -3 | ----------->| -1 |
+ --------------- -----------------
+ | 7 |
+ -----------------
+ | -4 |
+ -----------------
+ | 40000+FIX | 0 |
+ | - - - - - - - |
+ | 5 | |
+ -----------------
+
+Atoms
+
+Internally, atoms are special vector-like objects. An atom contains a
+value cell (the first two words of the block, filled in whenever the
+global or local value of the `ATOM` is referenced and is not already
+there), an `OBLIST` pointer, and a print name (`PNAME`), in the
+following format:
+
+ ---------------------------------
+ | type | bindid |
+ ---------------------------------
+ | pointer-to-value |
+ ---------------------------------
+ | pointer-to-oblist |
+ ---------------------------------
+ | print-name |
+ / /
+ / /
+ |(ASCII with NUL padding on end)|
+ ---------------------------------
+ | ATOM | valid-type |
+ | - - - - - - - - - - - - - - - |
+ | length | gc |
+ ---------------------------------
+
+If the type field corresponds to `TYPE` `UNBOUND`, then the `ATOM` is
+locally and globally unbound. (This is different from a pair, where
+the same `TYPE` `UNBOUND` is used to mean unassigned.) If it
+corresponds to `TYPE` `LOCI` (an internal `TYPE`), then the value cell
+points either to the global stack, if `bindid` is zero, or to a local
+control stack, if `bindid` is non-zero. The `bindid` field is used to
+verify whether the local value pointed to by the value cell is valid
+in the current environment. The `pointer-to-OBLIST` is either a
+counting pointer to an oblist (uvector). a positive offset into the
+"transfer vector" (for pure `ATOM`s), or zero, meaning that this
+`ATOM` is not on an `OBLIST`. The `valid-type` field tells whether or
+not the `ATOM` represents a `TYPE` and if so the code for that `TYPE`:
+`grow` values are never needed for atoms.
+
+Associations
+
+Associations are also special vector-like objects. The first six words
+of the block contain `TYPE`/value pairs for the `ITEM`, `INDICATOR`
+and `AVALUE` of the `ASOC`. The next word contains forward and
+backward pointers in the chain for that bucket of the association hash
+table. The last word contains forward and backward pointers in the
+chain of all the associations.
+
+ ---------------------------------
+ | ITEM |
+ | - - - - - - - - - - - - - - - |
+ | pair |
+ ---------------------------------
+ | INDICATOR |
+ | - - - - - - - - - - - - - - - |
+ | pair |
+ ---------------------------------
+ | AVALUE |
+ | - - - - - - - - - - - - - - - |
+ | pair |
+ ---------------------------------
+ | bucket-chain-pointers |
+ ---------------------------------
+ | association-chain-pointers |
+ ---------------------------------
+ | ASOC | 0 |
+ | - - - - - - - - - - - - - - - |
+ | 12 octal | gc |
+ ---------------------------------
+
+`PROCESS`es
+
+A `PROCESS` vector looks exactly like a vector of `TYPE`/value pairs.
+It is different only in that the garbage collector treats it
+differently from a normal vector, and it contains extremely volatile
+information when the `PROCESS` is `RUNNING`.
+
+Templates
+
+In a template, the number in the type field (left half or first dope
+word) identifies to which "storage allocation class" this `TEMPLATE`
+belongs, and it is used to find PDP-10 instructions in internal tables
+(frozen uvectors) for performing `LENGTH`, `NTH`, and `PUT` operations
+on any object of this `TYPE`. The programs to build these tables are
+not part of the interpreter, but the interpreter does know how to use
+them properly. The compiler can put these instructions directly in
+compiled programs if a `TEMPLATE` is never `REST`ed; otherwise it must
+let the interpreter discover the appropriate instruction. The value
+word of a template pair contains, not a counting pointer, but the
+number of elements that have been `REST`ed off in the left half and a
+pointer to the first dope word in the right half.
+
+The Control Stack
+-----------------
+
+Accumulators with symbolic names `AB`, `TB`, and `TP` are all pointers
+into the `RUNNING` `PROCESS`'s control stack. `AB` ("argument base")
+is a pointer to the arguments to the Subroutine now being run. It is
+set up by the Subroutine-call mediator, and its old value is always
+restored after a mediated Subroutine call returns. `TB` ("temporaries
+base") points to the frame for the running Subroutine and also serves
+as a stack base pointer. The `TB` pointer is really all that is
+necessary to return from a Subroutine -- given a value to return, for
+example by `ERRET` -- since the frame specifies the entire state of
+the calling routine. `TP` ("temporaries pointer") is the actual stack
+pointer and always points to the current top of the control stack.
+
+While we're on the subject of accumulators, we might as well be
+complete. Each accumulator contains the value word of a pair, the
+corresponding `TYPE` words residing in the `RUNNING` `PROCESS` vector.
+When a `PROCESS` is not `RUNNING` (or when the garbage collector is
+running), the accumulator contents are stored in the vector, so that
+the Objects they point to look like elements of the `PROCESS` and thus
+are not garbage-collectible.
+
+Accumulators `A`, `B`, `C`, `D`, `E` and `O` are used almost entirely
+as scratch accumulators, and they are not saved or restored across
+Subroutine calls. Of course the interrupt machinery always saves these
+and all other accumulators. `A` and `B` are used to return a pair as
+the value of a Subroutine call. Other than that special feature, they
+are just like the other scratch accumulators.
+
+`M` and `R` are used in running `RSUBR`s. `M` is always set up to
+point to the start of the `RSUBR`'s code, which is actually just a
+uniform vector of instructions. All jumps and other references to the
+code use `M` as an index register. This makes the code
+location-insensitive, which is necessary because the code uvector will
+move around. `R` is set up to point to the vector of objects needed by
+the `RSUBR`. This accumulator is necessary because objects in
+garbage-collected space can move around, but the pointers to them in
+the reference vector are always at the same place relative to its
+beginning.
+
+`FRM` is the internal frame pointer, used in compiled code to keep
+track of pending Subroutine calls when the control stack is heavily
+used. `P` is the internal-stack pointer, used primarily for internal
+calls in the interpreter.
+
+One of the nicest features of the Muddle environment is the uniformity
+of the calling and returning sequence. All Subroutines -- both
+built-in F/SUBRs and compiled `RSUBR(-ENTRY)`s -- are called in
+exactly the same way and return the same way. Arguments are always
+passed on the control stack and results always end up in the same
+accumulators. For efficiency reasons, a lot of internal calls within
+the interpreter circumvent the calling sequence. However, all calls
+made by the interpreter when running user programs go through the
+standard calling sequence.
+
+A Subroutine call is initiated by one of three UUOs (PDP-10
+instructions executed by software rather than hardware). `MCALL`
+("Muddle call") is used when the number of arguments is known at
+assemble or compile time, and this number is less than 16. `QCALL`
+("quick call") may be used if, in addition, an `RSUBR(-ENTRY)` is
+being called that can be called "quickly" by virtue of its having
+special information in its reference vector. `ACALL` ("accumulator
+call") is used otherwise. The general method of calling a Subroutine
+is to `PUSH` (a PDP-10 instruction) pairs representing the arguments
+onto the control stack via `TP` and then either (1) `MCALL` or `QCALL`
+or (2) put the number of arguments into an accumulator and `ACALL`.
+Upon return the object returned by the Subroutine will be in
+accumulators `A` and `B`, and the arguments will have been `POP`ped
+off the control stack.
+
+The call mediator stores the contents of `P` and `TP` and the address
+of the calling instruction in the current frame (pointed to by `TB`).
+It also stores Muddle's "binding pointer" to the topmost binding in
+the control stack. (The bindings are linked together through the
+control stack so that searching through them is more efficient than
+looking at every object on the stack.) This frame now specifies the
+entire state of the caller when the call occurred. The mediator then
+builds a new frame on the control stack and stores a pointer back to
+the caller's frame (the current contents of `TB`), a pointer to the
+Subroutine being called, and the new contents of `AB`, which is a
+counting pointer to the arguments and is computed from the information
+in the `MCALL` or `QCALL` instruction or the `ACALL` accumulator. `TB`
+is then set up to point to the new frame, and its left half is
+incremented by one, making a new `unique-id`. The mediator then
+transfers control to the Subroutine.
+
+A control stack frame has seven words as shown:
+
+ ---------------------------------
+ | ENTRY | called-addr |
+ ---------------------------------
+ | unique-id | prev frame |
+ ---------------------------------
+ | argument pointer |
+ ---------------------------------
+ | saved binding pointer |
+ ---------------------------------
+ | saved P |
+ ---------------------------------
+ | saved TP |
+ ---------------------------------
+ | saved calling address |
+ ---------------------------------
+
+The first three words are set up during the call to the Subroutine.
+The rest are filled in when this routine calls another Subroutine. The
+left half of `TB` is incremented every time a Subroutine call occurs
+and is used as the `unique-id` for the frame, stored in frame and
+tuple pairs as mentioned before. Obviously this `id` is not strictly
+unique, since each 256K calls it wraps around to zero. The right half
+of `TB` is always left pointing one word past the
+saved-calling-address word in the frame. `TP` is also left pointing at
+that word, since that is the top of the control stack at Subroutine
+entry. The arguments to the called Subroutine are below the frame on
+the control stack (at lower storage addresses), and the temporaries
+for the called Subroutine are above the frame (at higher storage
+addresses). These arguments and temporaries are just pairs stored on
+the control stack while needed: they are all that remain of
+`UNSPECIAL` values in compiled programs.
+
+The following figure shows what the control stack might look like
+after several Subroutine calls.
+
+ / /
+ | |
+ -----------------
+ | |
+ | args for S1 |
+ | |
+ -----------------
+ | frame for S1 |
+ ----------------- <--
+ | | |
+ | temps for S1 | |
+ | | |
+ ----------------- |
+ | | |
+ | args for S2 | |
+ | | |
+ ----------------- |
+ | frame for S2 | ---
+ ----------------- <------
+ | | |
+ | temps for S2 | |
+ | | |
+ ----------------- |
+ | args for S3 | |
+ ----------------- |
+ | frame for S3 | -------
+ -----------------
+ | |
+ | temps for S3 |
+ | |
+ | |
+ -----------------
+ (top)
+
+The above figure shows the frames all linked together through the
+control stack (the "execution path"), so that it is easy to return to
+the caller of a given Subroutine (`ERRET` or `RETRY`).
+
+Subroutine exit is accomplished simply by the call mediator, which
+loads the right half of `TB` from the previous frame pointer, restores
+the "binding pointer", `P`, and `TP`, and transfers control back to
+the instruction following the saved calling address.
+
+Variable Bindings
+-----------------
+
+All local `ATOM` values are kept on the control stack of the `PROCESS`
+to which they are local. As described before, the atom contains a word
+that points to the value on the control stack. The pointer is actually
+to a six-word "binding block" on the control stack. Binding blocks
+have the following format:
+
+ ---------------------------------
+ | BIND or UBIND | prev |
+ ---------------------------------
+ | pointer to ATOM |
+ ---------------------------------
+ | value |
+ | - - - - - - - - - - - - - - - |
+ | pair |
+ ---------------------------------
+ | decl | unique-id |
+ ---------------------------------
+ | previous-binding |
+ ---------------------------------
+
+where:
+
+- `BIND` means this is a binding for a `SPECIAL` `ATOM` (the only
+ kind used by compiled programs), and `UBIND` means this is a
+ binding for an `UNSPECIAL` `ATOM` -- for `SPECIAL` checking by the
+ interpreter;
+- `prev` points to the closest previous binding block for any `ATOM`
+ (the "access path" -- `UNWIND` objects are also linked in this
+ chain);
+- `decl` points to a `DECL` associated with this value, for
+ `SET(LOC)` to check;
+- `unique-id` is used for validation of this block; and
+- `previous-binding` points to the closest previous binding for this
+ `ATOM` (used in unbinding).
+
+Bindings are generated by an internal subroutine called `SPECBIND`
+(name comes from `SPECIAL`). The caller to `SPECBIND` `PUSH`es
+consecutive six-word blocks onto the control stack via `TP` before
+calling `SPECBIND`. The first word of each block contains the `TYPE`
+code for `ATOM` in its left half and all ones in its right half.
+`SPECBIND` uses this bit pattern to identify the binding blocks.
+`SPECBIND`'s caller also fills in the next three words and leaves the
+last two words empty. `SPECBIND` fills in the rest and leaves the
+"binding pointer" pointing at the topmost binding on the control
+stack. `SPECBIND` also stores a pointer to the current binding in the
+value cell of the atom.
+
+Unbinding is accomplished during Subroutine return. When the previous
+frame is being restored, the call mediator checks to see if the saved
+"binding pointer" and the current one are different; if they are,
+`SPECSTORE` is called. `SPECSTORE` runs through the binding blocks,
+restoring old value pointers in atoms until the "binding pointer" is
+equal to the one saved in the frame.
+
+Obviously variable binding is more complicated than this, because
+`ATOM`s can have both local and global values and even different local
+values in different `PROCESS`es. The solution to all of these
+additional problems lies in the `bindid` field of the atom. Each
+`PROCESS` vector also contains a current `bindid`. Whenever an ATOM's
+local value is desired, the `RUNNING` `PROCESS`'s `bindid` is checked
+against that of the atom: if they are the same, the atom points to the
+current value; if not, the current `PROCESS`'s control stack must be
+searched to find a binding block for this `ATOM`. This binding scheme
+might be called "shallow binding". The searching is facilitated by
+having all binding blocks linked together. Accessing global variables
+is accomplished in a similar way, using a `VECTOR` that is referred to
+as the "global stack". The global stack has only an `ATOM` and a value
+slot for each variable, since global values never get rebound.
+
+`EVAL` with respect to a different environment causes some additional
+problems. Whenever this kind of `EVAL` is done, a brand new `bindid`
+is generated, forcing all current local value cells of atoms to appear
+invalid. Local values must now be obtained by searching the control
+stack, which is inefficient compared to just pulling them out of the
+atoms. (The greatest inefficiency occurs when an `ATOM`'s `LVAL` is
+never accessed twice in a row in the same environment.) A special
+block is built on the control stack and linked into the binding-block
+chain. This block is called a "skip block" or "environment splice",
+and it diverts the "access path" to the new environment, causing
+searches to become relative to this new environment.
+
+Appendix 2. Predefined Subroutines
+==================================
+
+The following is a very brief description of all the primitives
+(F/SUBRs) currently available in MDL. These descriptions are in no way
+to be considered a definition of the effects or values produced by the
+primitives. They just try to be as complete and as accurate as is
+possible in a single-statement description. However, because of the
+complexity of most primitives, many important assumptions and
+restrictions have been omitted. Even though all primitives return a
+value, some descriptions mention only the side effects produced by a
+primitive, because these primitives are most often used for this
+effect rather than the value.
+
+A description is given in this format:
+
+*name* (*arguments*)\
+*decl*\
+English description
+
+This format is intended to look like a `FUNCTION` definition, omitting
+the call to `DEFINE` and all internal variable and code. The *name* is
+just the ATOM that is used to refer to the primitive. The names of the
+*arguments* are intended to be mnemonic or suggestive of their
+meanings. The *decl* is a `FUNCTION`-style `DECL` (chapter 14) for the
+primitive. In some cases the `DECL` may look unusual, because it is
+intended to convey information to a person about the uses of
+arguments, not to convey information to the MDL interpreter or
+compiler. For example, `<OR FALSE ANY>` is functionally equivalent to
+`ANY`, but it indicates that only the "truth" of the argument is
+significant. Indeed, the `[OPT ...]` construction is often used
+illegally, with other elements following it: be warned that MDL would
+not accept it. An argument is included in the same `LIST` with `VALUE`
+(the value of the primitive) only if the argument is actually returned
+by the primitive as a value. In other words,
+`#DECL ((VALUE ARG) ...)` implies `<==? .VALUE .ARG>`.
+
+ * ("TUPLE" FACTORS)
+ #DECL ((VALUE) <OR FIX FLOAT>
+ (FACTORS) <TUPLE [REST <OR FIX FLOAT>]>)
+
+multiplies all arguments together (arithmetic)
+
+ + ("TUPLE" TERMS)
+ #DECL ((VALUE) <OR FIX FLOAT>
+ (TERMS) <TUPLE [REST <OR FIX FLOAT>]>)
+
+adds all arguments together (arithmetic)
+
+ - ("OPTIONAL" MINUEND "TUPLE" SUBTRAHENDS)
+ #DECL ((VALUE) <OR FIX FLOAT>
+ (MINUEND) <OR FIX FLOAT>
+ (SUBTRAHENDS) <TUPLE [REST <OR FIX FLOAT>]>)
+
+subtracts other arguments from first argument (arithmetic)
+
+ / ("OPTIONAL" DIVIDEND "TUPLE" DIVISORS)
+ #DECL ((VALUE) <OR FIX FLOAT>
+ (DIVIDEND) <OR FIX FLOAT>
+ (DIVISORS) <TUPLE [REST <OR FIX FLOAT>]>)
+
+divides first argument by other arguments (arithmetic)
+
+ 0? (NUMBER)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (NUMBER) <OR FIX FLOAT>)
+
+tells whether a number is zero (predicate)
+
+ 1? (NUMBER)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (NUMBER) <OR FIX FLOAT>)
+
+tells whether a number is one (predicate)
+
+ 1STEP (PROCESS)
+ #DECL ((VALUE PROCESS) PROCESS)
+
+causes a `PROCESS` to enter single-step mode
+
+ ==? (OBJECT-1 OBJECT-2)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (OBJECT-1 OBJECT-2) ANY)
+
+tells whether two objects are "exactly" equal (predicate)
+
+ =? (OBJECT-1 OBJECT-2)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (OBJECT-1 OBJECT-2) ANY)
+
+tells whether two objects are "structurally" equal (predicate)
+
+ ABS (NUMBER)
+ #DECL ((VALUE) <OR FIX FLOAT>
+ (NUMBER) <OR FIX FLOAT>)
+
+returns absolute value of a number (arithmetic)
+
+ ACCESS (CHANNEL ACCESS-POINTER)
+ #DECL ((VALUE CHANNEL) CHANNEL
+ (ACCESS-POINTER) FIX)
+
+sets access pointer for next I/O transfer via a `CHANNEL`
+
+ ACTIVATE-CHARS ("OPTIONAL" STRING)
+ #DECL ((VALUE STRING) STRING)
+
+sets or returns interrupt characters for terminal typing (Tenex and
+Tops-20 versions only)
+
+ AGAIN ("OPTIONAL" (ACTIVATION .LPROG\ !-INTERRUPTS))
+ #DECL ((VALUE) ANY
+ (ACTIVATION) ACTIVATION)
+
+resumes execution at the given `ACTIVATION`
+
+ ALLTYPES ()
+ #DECL ((VALUE) <VECTOR [REST ATOM]>)
+
+returns the `VECTOR` of all type names
+
+ AND ("ARGS" ARGS)
+ #DECL ((VALUE) <OR FALSE ANY>
+ (ARGS) LIST)
+
+computes logical "and" of truth-values, evaluated by the Subroutine
+
+ AND? ("TUPLE" TUPLE)
+ #DECL ((VALUE) <OR FALSE ANY>
+ (TUPLE) TUPLE)
+
+computes logical "and" of truth-values, evaluated at call time
+
+ ANDB ("TUPLE" WORDS)
+ #DECL ((VALUE) WORD
+ (WORDS) <TUPLE [REST <PRIMTYPE WORD>]>)
+
+computes bitwise "and" of machine words
+
+ APPLICABLE? (OBJECT)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (OBJECT) ANY)
+
+tells whether argument is applicable (predicate)
+
+ APPLY (APPLICABLE "TUPLE" ARGUMENTS)
+ #DECL ((VALUE) ANY
+ (APPLICABLE) APPLICABLE (ARGUMENTS) TUPLE)
+
+applies first argument to the other arguments
+
+ APPLYTYPE (TYPE "OPTIONAL" HOW)
+ #DECL ((VALUE) <OR ATOM APPLICABLE '#FALSE ()>
+ (TYPE) ATOM (HOW) <OR ATOM APPLICABLE>)
+
+specifies or returns how a data type is applied
+
+ ARGS (CALL)
+ #DECL ((VALUE) TUPLE
+ (CALL) <OR FRAME ENVIRONMENT ACTIVATION PROCESS>)
+
+returns arguments of a given un-returned Subroutine call
+
+ ASCII (CODE-OR-CHARACTER)
+ #DECL ((VALUE) <OR CHARACTER FIX>
+ (CODE-OR-CHARACTER) <OR FIX CHARACTER>)
+
+returns `CHARACTER` with given ASCII code or vice versa
+
+ ASSIGNED? (ATOM "OPTIONAL" ENV)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (ATOM) ATOM (ENV) <OR FRAME ENVIRONMENT ACTIVATION PROCESS>)
+
+tells whether an `ATOM` has a local value (predicate)
+
+ ASSOCIATIONS ()
+ #DECL ((VALUE) <OR ASOC '#FALSE ()>)
+
+returns the first object in the association chain
+
+ AT (STRUCTURED "OPTIONAL" (N 1))
+ #DECL ((VALUE) LOCATIVE
+ (STRUCTURED) STRUCTURED (N) <OR FIX OFFSET>)
+
+returns a locative to the Nth element of a structure
+
+ ATAN (NUMBER)
+ #DECL ((VALUE) FLOAT
+ (NUMBER) <OR FIX FLOAT>)
+
+returns arc tangent of a number (arithmetic)
+
+ ATOM (PNAME)
+ #DECL ((VALUE) ATOM
+ (PNAME) STRING)
+
+creates an `ATOM` with a given name
+
+ AVALUE (ASSOCIATION)
+ #DECL ((VALUE) ANY
+ (ASSOCIATION) ASOC)
+
+returns the "value" field of an association
+
+ BACK (STRUCTURE "OPTIONAL" N)
+ #DECL ((VALUE) <OR VECTOR TUPLE UVECTOR STORAGE STRING BYTES TEMPLATE>
+ (N) FIX
+ (STRUCTURE) <OR <PRIMTYPE VECTOR> <PRIMTYPE TUPLE>
+ <PRIMTYPE UVECTOR> <PRIMTYPE STORAGE>
+ <PRIMTYPE STRING> <PRIMTYPE BYTES>
+ <PRIMTYPE TEMPLATE>>)
+
+replaces some elements removed from a non-list structure by `REST`ing
+and changes to primitive data type
+
+ BIND ("ARGS" ARGS)
+ #DECL ((VALUE) ANY
+ (ARGS) <LIST [OPT ATOM] LIST [OPT DECL] ANY>)
+
+executes sequential expressions without providing a bound `ACTIVATION`
+
+ BITS (WIDTH "OPTIONAL" (RIGHT-EDGE 0))
+ #DECL ((VALUE) BITS
+ (WIDTH RIGHT-EDGE) FIX)
+
+creates a bit mask for `PUTBITS` and `GETBITS`
+
+ BLOAT ("OPTIONAL"
+ (FREE 0) (STACK 0) (LOCALS 0) (GLOBALS 0) (TYPES 0) (STORAGE 0) (P-STACK 0)
+ MIN GROW-LOCAL GROW-GLOBAL GROW-TYPE GROW-STORAGE PURE P-STACK-SIZE STACK-SIZE)
+ #DECL ((VALUE) FIX
+ (FREE STACK LOCALS GLOBALS TYPES STORAGE P-STACK MIN GROW-LOCAL GROW-GLOBAL
+ GROW-TYPE GROW-STORAGE PURE P-STACK-SIZE STACK-SIZE) FIX)
+
+allocates extra storage temporarily
+
+ BLOAT-STAT ("OPTIONAL" STATS)
+ #DECL ((VALUE) <UVECTOR [27 FIX]>
+ (STATS) <UVECTOR [27 ANY]>)
+
+gives garbage-collector and storage statistics
+
+ BLOCK (LOOK-UP)
+ #DECL ((VALUE LOOK-UP) <OR OBLIST <LIST [REST <OR OBLIST 'DEFAULT>]>>)
+
+`SET`s `OBLIST` for looking up `ATOM`s during `READ`ing and `PARSE`ing
+
+ BOUND? (ATOM "OPTIONAL" ENV)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (ATOM) ATOM (ENV) <OR FRAME ENVIRONMENT ACTIVATION PROCESS>)
+
+tells whether an `ATOM` is locally bound (predicate)
+
+ BREAK-SEQ (OBJECT PROCESS)
+ #DECL ((VALUE PROCESS) PROCESS
+ (OBJECT) ANY)
+
+modifies execution sequence of another `PROCESS`
+
+ BUFOUT ("OPTIONAL" (CHANNEL .OUTCHAN))
+ #DECL ((VALUE CHANNEL) CHANNEL)
+
+writes out all internal MDL buffers for an output `CHANNEL`
+
+ BYTE-SIZE (BYTES)
+ #DECL ((VALUE) FIX
+ (BYTES) BYTES)
+
+returns size of bytes in a byte-string
+
+ BYTES (SIZE "TUPLE" ELEMENTS)
+ #DECL ((VALUE) BYTES
+ (SIZE) FIX (ELEMENTS) <TUPLE [REST FIX]>)
+
+creates a byte-string from explicit arguments
+
+ CHANLIST ()
+ #DECL ((VALUE) <LIST [REST CHANNEL]>)
+
+returns a `LIST` of currently open I/O `CHANNEL`s
+
+ CHANNEL ("OPTIONAL" (MODE "READ") "TUPLE" FILE-NAME)
+ #DECL ((VALUE) CHANNEL
+ (MODE) STRING (FILE-NAME) TUPLE)
+
+creates an unopened I/O `CHANNEL`
+
+ CHTYPE (OBJECT TYPE)
+ #DECL ((VALUE) ANY
+ (OBJECT) ANY (TYPE) ATOM)
+
+makes a new pair with a given data type from an old one
+
+ CHUTYPE (UVECTOR TYPE)
+ #DECL ((VALUE UVECTOR) <PRIMTYPE UVECTOR>
+ (TYPE) ATOM)
+
+changes the data type of the elements of a uniform vector
+
+ CLOSE (CHANNEL)
+ #DECL ((VALUE CHANNEL) CHANNEL)
+
+closes an I/O `CHANNEL`
+
+ CLOSURE (FUNCTION "TUPLE" VARIABLES)
+ #DECL ((VALUE) CLOSURE
+ (FUNCTION) FUNCTION (VARIABLES) <TUPLE [REST ATOM]>)
+
+"binds" the free variables of a `FUNCTION` to current values
+
+ COND ("ARGS" CLAUSES)
+ #DECL ((VALUE) ANY
+ (CLAUSES) <LIST <LIST <OR FALSE ANY>> [REST <LIST <OR FALSE ANY>>]>)
+
+evaluates conditions and selected expression
+
+ CONS (NEW-ELEMENT LIST)
+ #DECL ((VALUE) LIST
+ (NEW-ELEMENT) ANY (LIST) LIST)
+
+adds an element to the front of a `LIST`
+
+ COS (NUMBER)
+ #DECL ((VALUE) FLOAT
+ (NUMBER) <OR FIX FLOAT>)
+
+returns cosine of a number (arithmetic)
+
+ CRLF ("OPTIONAL" (CHANNEL .OUTCHAN))
+ #DECL ((VALUE) 'T
+ (CHANNEL) CHANNEL)
+
+prints a carriage-return and line-feed via an output `CHANNEL`
+
+ DECL-CHECK ("OPTIONAL" SWITCH)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (SWITCH) <OR FALSE ANY>)
+
+enables or disables type-declaration checking
+
+ DECL? (OBJECT PATTERN)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (OBJECT) ANY (PATTERN) <OR ATOM FORM>)
+
+tells whether an object matches a type declaration (predicate)
+
+ DEFINE ('NAME "ARGS" ARGS)
+ #DECL ((VALUE) ATOM
+ (NAME) ANY (ARGS) <LIST [OPT ATOM] LIST [OPT DECL] ANY>)
+
+sets the global value of an `ATOM` to a `FUNCTION`
+
+ DEFMAC ('NAME "ARGS" ARGS)
+ #DECL ((VALUE) ATOM
+ (NAME) ANY (ARGS) <LIST [OPT ATOM] LIST [OPT DECL] ANY>)
+
+sets the global value of an `ATOM` to a `MACRO`
+
+ DEMSIG (NAME)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (NAME) STRING)
+
+signals an ITS daemon
+
+ DISABLE (INTERRUPT)
+ #DECL ((VALUE INTERRUPT) IHEADER)
+
+disables an interrupt
+
+ DISMISS (VAL "OPTIONAL" ACTIVATION INT-LEVEL)
+ #DECL ((VALUE VAL) ANY
+ (ACTIVATION) ACTIVATION (INT-LEVEL) FIX)
+
+dismisses an interrupt occurrence
+
+ ECHOPAIR (IN OUT)
+ #DECL ((VALUE IN) CHANNEL
+ (OUT) CHANNEL)
+
+coordinates I/O `CHANNEL`s for echoing characters on rubout
+
+ EMPTY? (OBJECT)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (OBJECT) STRUCTURED)
+
+tells whether a structure has zero elements (predicate)
+
+ ENABLE (INTERRUPT)
+ #DECL ((VALUE INTERRUPT) IHEADER)
+
+enables an interrupt
+
+ ENDBLOCK ()
+ #DECL ((VALUE) <OR OBLIST <LIST [REST <OR OBLIST 'DEFAULT>]>>)
+
+restores the .OBLIST that existed before corresponding call to `BLOCK`
+
+ ENTRY-LOC (ENTRY)
+ #DECL ((VALUE) FIX
+ (ENTRY) RSUBR-ENTRY)
+
+returns the offset in the code vector of an `RSUBR-ENTRY`
+
+ EQVB ("TUPLE" WORDS)
+ #DECL ((VALUE) WORD
+ (WORDS) <TUPLE [REST <PRIMTYPE WORD>]>)
+
+computes bitwise "equivalence" of machine words
+
+ ERRET ("OPTIONAL" VAL (FRAME .LERR\ !-INTERRUPTS))
+ #DECL ((VALUE) ANY
+ (VAL) ANY (FRAME) FRAME)
+
+continues evaluation from the last `ERROR` or `LISTEN` or from a given
+`FRAME`
+
+ ERROR ("TUPLE" INFO)
+ #DECL ((VALUE) ANY
+ (INFO) TUPLE)
+
+stops and informs user of an error
+
+ ERRORS ()
+ #DECL ((VALUE) OBLIST)
+
+returns the `OBLIST` where error messages are located
+
+ EVAL (ANY "OPTIONAL" ENV)
+ #DECL ((VALUE) ANY
+ (ENV) <OR FRAME ENVIRONMENT ACTIVATION PROCESS>)
+
+evaluates an expression in a given environment
+
+ EVALTYPE (TYPE "OPTIONAL" HOW)
+ #DECL ((VALUE) <OR ATOM APPLICABLE '#FALSE ()>
+ (TYPE) ATOM (HOW) <OR ATOM APPLICABLE>)
+
+specifies or returns how a data type is evaluated
+
+ EVENT (NAME "OPTIONAL" PRIORITY WHICH)
+ #DECL ((VALUE) IHEADER
+ (NAME) <OR STRING ATOM IHEADER> (PRIORITY) FIX (WHICH) <OR CHANNEL LOCATIVE>)
+
+sets up an interrupt
+
+ EXP (NUMBER)
+ #DECL ((VALUE) FLOAT
+ (NUMBER) <OR FIX FLOAT>)
+
+returns "e" to the power of a number (arithmetic)
+
+ EXPAND (ANY)
+ #DECL ((VALUE) ANY
+ (ANY) ANY)
+
+evaluates its argument (only once if a `MACRO` is involved) in the
+top-level environment
+
+ FILE-EXISTS? ("TUPLE" FILE-NAME)
+ #DECL ((VALUE) <OR 'T <FALSE STRING FIX>>
+ (FILE-NAME) TUPLE)
+
+tests for existence of a file (predicate)
+
+ FILE-LENGTH (INCH)
+ #DECL ((VALUE) FIX
+ (INCH) CHANNEL)
+
+returns the system-provided length of a file open on an input
+`CHANNEL`
+
+ FILECOPY ("OPTIONAL" (INCH .INCHAN) (OUCH .OUTCHAN))
+ #DECL ((VALUE) FIX
+ (INCH OUCH) CHANNEL)
+
+copies characters from one `CHANNEL` to another until end-of-file on
+the input `CHANNEL`
+
+ FIX (NUMBER)
+ #DECL ((VALUE) FIX
+ (NUMBER) <OR FLOAT FIX>)
+
+returns integer part of a number (arithmetic)
+
+ FLATSIZE (ANY MAX "OPTIONAL" (RADIX 10))
+ #DECL ((VALUE) <OR FIX '#FALSE ()>
+ (ANY) ANY (MAX RADIX) FIX)
+
+returns number of characters needed to `PRIN1` an object, if not
+greater than given maximum
+
+ FLOAD ("TUPLE" FILE-NAME-AND-LOOK-UP)
+ #DECL ((VALUE) '"DONE"
+ (FILE-NAME-AND-LOOK-UP) TUPLE)
+
+reads and evaluates all objects in a file
+
+ FLOAT (NUMBER)
+ #DECL ((VALUE) FLOAT
+ (NUMBER) <OR FIX FLOAT>)
+
+returns floating-point value of a number (arithmetic)
+
+ FORM ("TUPLE" ELEMENTS)
+ #DECL ((VALUE) FORM
+ (ELEMENTS) TUPLE)
+
+creates a `FORM` from explicit arguments
+
+ FRAME ("OPTIONAL" (FRAME .LERR\ !-INTERRUPTS))
+ #DECL ((VALUE) FRAME
+ (FRAME) <OR FRAME ENVIRONMENT ACTIVATION PROCESS>)
+
+returns a previous Subroutine call
+
+ FREE-RUN (PROCESS)
+ #DECL ((VALUE) <OR PROCESS '#FALSE ()>
+ (PROCESS) PROCESS)
+
+causes a `PROCESS` to leave single-step mode
+
+ FREEZE (STRUCTURE)
+ #DECL ((VALUE) <OR VECTOR UVECTOR STRING BYTES>
+ (STRUCTURE) <OR <PRIMTYPE VECTOR> <PRIMTYPE TUPLE> <PRIMTYPE UVECTOR>
+ <PRIMTYPE STRING> <PRIMTYPE BYTES>>)
+
+makes copy of argument in non-moving garbage-collected space
+
+ FUNCT (FRAME)
+ #DECL ((VALUE) ATOM
+ (FRAME) <OR FRAME ENVIRONMENT ACTIVATION PROCESS>)
+
+returns Subroutine name of a given previous Subroutine call
+
+ FUNCTION ("ARGS" ARGS)
+ #DECL ((VALUE) FUNCTION
+ (ARGS) <LIST [OPT ATOM] LIST [OPT DECL] ANY>)
+
+creates a `FUNCTION`
+
+ G=? (NUMBER-1 NUMBER-2)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (NUMBER-1 NUMBER-2) <OR FIX FLOAT>)
+
+tells whether first argument is greater than or equal to second
+(predicate)
+
+ G? (NUMBER-1 NUMBER-2)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (NUMBER-1 NUMBER-2) <OR FIX FLOAT>)
+
+tells whether first argument is greater than second (predicate)
+
+ GASSIGNED? (ATOM)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (ATOM) ATOM)
+
+tells whether an `ATOM` has a global value (predicate)
+
+ GBOUND? (ATOM)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (ATOM) ATOM)
+
+tells whether an `ATOM` ever had a global value (predicate)
+
+ GC ("OPTIONAL" MIN (EXHAUSTIVE? <>) MS-FREQ)
+ #DECL ((VALUE) FIX
+ (MIN MS-FREQ) FIX (EXHAUSTIVE?) <OR FALSE ANY>)
+
+causes a garbage collection and changes garbage-collection parameters
+
+ GC-DUMP (ANY PRINTB)
+ #DECL ((VALUE) <OR ANY <UVECTOR <PRIMTYPE WORD>>>
+ (ANY) ANY (PRINTB) <OR CHANNEL FALSE>)
+
+dumps an object so that it can be reproduced exactly
+
+ GC-MON ("OPTIONAL" SWITCH)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (SWITCH) <OR FALSE ANY>)
+
+turns garbage-collection monitoring off or on
+
+ GC-READ (READB "OPTIONAL" (EOF-ROUTINE '<ERROR ...>))
+ #DECL ((VALUE) ANY
+ (READB) CHANNEL (EOF-ROUTINE) ANY)
+
+inputs an object that was previously `GC-DUMP`ed
+
+ GDECL ("ARGS" ARGS)
+ #DECL ((VALUE) ANY
+ (ARGS) <LIST [REST <LIST [REST ATOM]> <OR ATOM FORM>]>)
+
+declares the type/structure of the global value of `ATOM`s
+
+ GET (ITEM INDICATOR "OPTIONAL" (IF-NONE <>))
+ #DECL ((VALUE) ANY
+ (ITEM) <OR STRUCTURED ANY> (INDICATOR) <OR FIX OFFSET ANY> (IF-NONE) ANY)
+
+does `NTH` or `GETPROP`
+
+ GET-DECL (ATOM-OR-OFFSET)
+ #DECL ((VALUE) <OR ATOM FORM '#FALSE ()>
+ (ATOM-OR-OFFSET) <OR LOCD OFFSET>)
+
+gets the type declaration for an `ATOM`'s value or an `OFFSET`
+
+ GETBITS (FROM FIELD)
+ #DECL ((VALUE) WORD
+ (FROM) <OR <PRIMTYPE WORD> <PRIMTYPE STORAGE>> (FIELD) BITS)
+
+returns a bit field of a machine word or `STORAGE` address
+
+ GETL (ITEM INDICATOR "OPTIONAL" (IF-NONE <>))
+ #DECL ((VALUE) <OR LOCATIVE LOCAS ANY>
+ (ITEM) <OR STRUCTURED ANY> (INDICATOR) <OR FIX OFFSET ANY> (IF-NONE) ANY)
+
+does `AT` or `GETPL`
+
+ GETPL (ITEM INDICATOR "OPTIONAL" (IF-NONE <>))
+ #DECL ((VALUE) <OR LOCAS ANY>
+ (ITEM INDICATOR IF-NONE) ANY)
+
+returns a locative to an association
+
+ GETPROP (ITEM INDICATOR "OPTIONAL" (IF-NONE <>))
+ #DECL ((VALUE) ANY
+ (ITEM INDICATOR IF-NONE) ANY)
+
+returns the value associated with an item under an indicator
+
+ GLOC (ATOM "OPTIONAL" (MAKE-SLOT <>))
+ #DECL ((VALUE) LOCD
+ (ATOM) ATOM (MAKE-SLOT) <OR FALSE ANY>)
+
+returns a locative to the global-value cell of an `ATOM`
+
+ GO (LABEL)
+ #DECL ((VALUE) ANY
+ (LABEL) <OR ATOM TAG>)
+
+goes to a label and continues evaluation from there
+
+ GROW (U/VECTOR END BEG)
+ #DECL ((VALUE) <OR <PRIMTYPE VECTOR> <PRIMTYPE UVECTOR>>
+ (U/VECTOR) <OR <PRIMTYPE VECTOR> <PRIMTYPE UVECTOR>> (END BEG) FIX)
+
+increases the size of a vector or uniform vector
+
+ GUNASSIGN (ATOM)
+ #DECL ((VALUE ATOM) ATOM)
+
+causes an `ATOM` to have no global value
+
+ GVAL (ATOM)
+ #DECL ((VALUE) ANY
+ (ATOM) ATOM)
+
+returns the global value of an `ATOM`
+
+ HANDLER (IHEADER HANDLER "OPTIONAL" (PROCESS #PROCESS 0))
+ #DECL ((VALUE) HANDLER
+ (IHEADER) IHEADER (HANDLER) <OR HANDLER APPLICABLE> (PROCESS) PROCESS)
+
+creates an interrupt `HANDLER`
+
+ HANG ("OPTIONAL" (UNHANG <>))
+ #DECL ((VALUE) ANY
+ (UNHANG) ANY)
+
+does nothing, interruptibly, potentially forever
+
+ IBYTES (SIZE LENGTH "OPTIONAL" (ELEMENT 0))
+ #DECL ((VALUE) BYTES
+ (SIZE LENGTH) FIX (ELEMENT) ANY)
+
+creates a byte-string from implicit arguments
+
+ IFORM (LENGTH "OPTIONAL" (ELEMENT #LOSE 0))
+ #DECL ((VALUE) FORM
+ (LENGTH) FIX (ELEMENT) ANY)
+
+creates a `FORM` from implicit arguments
+
+ ILIST (LENGTH "OPTIONAL" (ELEMENT #LOSE 0))
+ #DECL ((VALUE) LIST
+ (LENGTH) FIX (ELEMENT) ANY)
+
+creates a `LIST` from implicit arguments
+
+ IMAGE (CODE "OPTIONAL" (CHANNEL .OUTCHAN))
+ #DECL ((VALUE CODE) FIX
+ (CHANNEL) CHANNEL)
+
+sends an image-mode character via an output `CHANNEL`
+
+ IN (POINTER)
+ #DECL ((VALUE) ANY
+ (POINTER) LOCATIVE)
+
+returns the object pointed to by a locative
+
+ INDEX (OFFSET)
+ #DECL ((VALUE) FIX
+ (OFFSET) OFFSET)
+
+fetches the integral part of an `OFFSET`
+
+ INDICATOR (ASSOCIATION)
+ #DECL ((VALUE) ANY
+ (ASSOCIATION) ASOC)
+
+returns the "indicator" field of an association
+
+ INSERT (PNAME OBLIST)
+ #DECL ((VALUE) ATOM
+ (PNAME) <OR ATOM STRING> (OBLIST) OBLIST)
+
+adds an `ATOM` to an `OBLIST`
+
+ INT-LEVEL ("OPTIONAL" NEW-INT-LEVEL)
+ #DECL ((VALUE) FIX
+ (NEW-INT-LEVEL) FIX)
+
+returns and/or sets current interrupt level
+
+ INTERRUPT (NAME "TUPLE" HANDLER-ARGS)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (NAME) <OR STRING ATOM IHEADER> (HANDLER-ARGS) TUPLE)
+
+causes an interrupt to occur
+
+ INTERRUPTS ()
+ #DECL ((VALUE) OBLIST)
+
+returns the `OBLIST` on which interrupt names are kept
+
+ IPC-HANDLER (BODY TYPE OTHER-NAME-1 OTHER-NAME-2
+ "OPTIONAL" (MY-NAME-1 <UNAME>) (MY-NAME-2 <JNAME>))
+ #DECL ((VALUE) 'T
+ (BODY) <OR STRING UVECTOR> (TYPE) FIX
+ (OTHER-NAME-1 OTHER-NAME-2 MY-NAME-1 MY-NAME-2) STRING)
+
+is the built-in handler for "IPC" (ITS version only)
+
+ IPC-OFF ()
+ #DECL ((VALUE) 'T)
+
+stops all listening on the IPC device (ITS version only)
+
+ IPC-ON ("OPTIONAL" (MY-NAME-1 <UNAME>) (MY-NAME-2 <JNAME>))
+ #DECL ((VALUE) 'T
+ (MY-NAME-1 MY-NAME-2) STRING)
+
+listens on the IPC device (ITS version only)
+
+ ISTORAGE (LENGTH "OPTIONAL" (ELEMENT #LOSE 0))
+ #DECL ((VALUE) STORAGE
+ (LENGTH) FIX (ELEMENT) ANY)
+
+creates a non-garbage-collected `STORAGE` from implicit arguments
+(archaic)
+
+ ISTRING (LENGTH "OPTIONAL" (ELEMENT !\^@))
+ #DECL ((VALUE) STRING
+ (LENGTH) FIX (ELEMENT) ANY)
+
+creates a character-string from implicit arguments
+
+ ITEM (ASSOCIATION)
+ #DECL ((VALUE) ANY
+ (ASSOCIATION) ASOC)
+
+returns the "item" field of an association
+
+ ITUPLE (LENGTH "OPTIONAL" (ELEMENT #LOSE 0))
+ #DECL ((VALUE) TUPLE
+ (LENGTH) FIX (ELEMENT) ANY)
+
+creates a `TUPLE` from implicit arguments
+
+ IUVECTOR (LENGTH "OPTIONAL" (ELEMENT #LOSE 0))
+ #DECL ((VALUE) UVECTOR
+ (LENGTH) FIX (ELEMENT) ANY)
+
+creates a `UVECTOR` from implicit arguments
+
+ IVECTOR (LENGTH "OPTIONAL" (ELEMENT #LOSE 0))
+ #DECL ((VALUE) VECTOR
+ (LENGTH) FIX (ELEMENT) ANY)
+
+creates a `VECTOR` from implicit arguments
+
+ JNAME ()
+ #DECL ((VALUE) STRING)
+
+returns the "job name" of MDL's process
+
+ L=? (NUMBER-1 NUMBER-2)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (NUMBER-1 NUMBER-2) <OR FIX FLOAT>)
+
+tells whether first argument is less than or equal to second
+(predicate)
+
+ L? (NUMBER-1 NUMBER-2)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (NUMBER-1 NUMBER-2) <OR FIX FLOAT>)
+
+tells whether first argument is less than second (predicate)
+
+ LEGAL? (STACK-OBJECT)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (STACK-OBJECT) ANY)
+
+tells whether argument (which might live on the control stack) is
+still legal (predicate)
+
+ LENGTH (OBJECT)
+ #DECL ((VALUE) FIX
+ (OBJECT) STRUCTURED)
+
+returns the number of elements in a structure
+
+ LENGTH? (OBJECT MAX)
+ #DECL ((VALUE) <OR FIX '#FALSE ()>
+ (OBJECT) STRUCTURED (MAX) FIX)
+
+tells whether length of structure is less than or equal to an integer
+(predicate)
+
+ LINK (EXPR PNAME "OPTIONAL" (OBLIST <1 .OBLIST>))
+ #DECL ((VALUE EXPR) ANY
+ (PNAME) STRING (OBLIST) OBLIST)
+
+creates a symbolic `LINK` to any expression for `READ`ing
+
+ LIST ("TUPLE" ELEMENTS)
+ #DECL ((VALUE) LIST
+ (ELEMENTS) TUPLE)
+
+creates a `LIST` from explicit arguments
+
+ LISTEN ("TUPLE" INFO)
+ #DECL ((VALUE) ANY
+ (INFO) TUPLE)
+
+stops and informs user that MDL is listening
+
+ LLOC (ATOM "OPTIONAL" ENV)
+ #DECL ((VALUE) LOCD
+ (ENV) <OR FRAME ENVIRONMENT ACTIVATION PROCESS>)
+
+returns a locative to the local-value cell of an `ATOM`
+
+ LOAD (CHANNEL "OPTIONAL" (LOOK-UP .OBLIST))
+ #DECL ((VALUE) '"DONE"
+ (LOOK-UP) <OR OBLIST <LIST [REST <OR OBLIST 'DEFAULT>]>>)
+
+reads and evaluates all objects via an input `CHANNEL`
+
+ LOCATIVE? (OBJECT)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (OBJECT) ANY)
+
+tells whether an object is a locative (predicate)
+
+ LOG (NUMBER)
+ #DECL ((VALUE) FLOAT
+ (NUMBER) <OR FIX FLOAT>)
+
+returns natural logarithm of a number (arithmetic)
+
+ LOGOUT ()
+ #DECL ((VALUE) '#FALSE ())
+
+logs out of the operating system (useful for background processes)
+
+ LOOKUP (PNAME OBLIST)
+ #DECL ((VALUE) <OR ATOM '#FALSE ()>
+ (PNAME) STRING (OBLIST) OBLIST)
+
+returns an `ATOM` found on a given `OBLIST`
+
+ LPARSE ("OPTIONAL"
+ (STRING .PARSE-STRING) (RADIX 10) (LOOK-UP .OBLIST) PARSE-TABLE LOOK-AHEAD)
+ #DECL ((VALUE) LIST
+ (STRING) STRING (RADIX) FIX (PARSE-TABLE) VECTOR (LOOK-AHEAD) CHARACTER
+ (LOOK-UP) <OR OBLIST <LIST [REST <OR OBLIST 'DEFAULT>]>>)
+
+returns a `LIST` of the objects parsed from a `STRING` (sections
+7.6.6.3, 15.7.2, 17.1.3)
+
+ LSH (WORD AMOUNT)
+ #DECL ((VALUE) WORD
+ (WORD) <PRIMTYPE WORD> (AMOUNT) FIX)
+
+shifts bits in a machine word
+
+ LVAL (ATOM "OPTIONAL" ENV)
+ #DECL ((VALUE) ANY
+ (ENV) <OR FRAME ENVIRONMENT ACTIVATION PROCESS>)
+
+returns the local value of an `ATOM`
+
+ MAIN ()
+ #DECL ((VALUE) PROCESS)
+
+returns `#PROCESS 1` (the main `PROCESS`)
+
+ MANIFEST ("TUPLE" ATOMS)
+ #DECL ((VALUE) 'T
+ (ATOMS) <TUPLE [REST ATOM]>)
+
+declares the global values of `ATOM`s to be constant
+
+ MANIFEST? (ATOM)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (ATOM) ATOM)
+
+tells whether the global value of an `ATOM` is constant (predicate)
+
+ MAPF (FINAL-FCN LOOP-FCN "TUPLE" STRUCTURES)
+ #DECL ((VALUE) ANY
+ (FINAL-FCN) <OR APPLICABLE FALSE> (LOOP-FCN) APPLICABLE
+ (STRUCTURES) <TUPLE [REST STRUCTURED]>)
+
+maps function onto elements of structures
+
+ MAPLEAVE ("OPTIONAL" (VAL T))
+ #DECL (
+ (VAL) ANY)
+
+leaves the most recent `MAPF/R` with a value
+
+ MAPR (FINAL-FCN LOOP-FCN "TUPLE" STRUCTURES)
+ #DECL ((VALUE) ANY
+ (FINAL-FCN) <OR APPLICABLE FALSE> (LOOP-FCN) APPLICABLE
+ (STRUCTURES) <TUPLE [REST STRUCTURED]>)
+
+maps function onto `REST`s of structures
+
+ MAPRET ("TUPLE" ELEMENTS)
+ #DECL (
+ (ELEMENTS) TUPLE)
+
+returns a variable number of objects to the current `MAPF/R`
+
+ MAPSTOP ("TUPLE" ELEMENTS)
+ #DECL (
+ (ELEMENTS) TUPLE)
+
+`MAPRET`s, then stops looping of `MAPF/R` and causes application
+
+ MAX ("TUPLE" NUMBERS)
+ #DECL ((VALUE) <OR FIX FLOAT>
+ (NUMBERS) <TUPLE [REST <OR FIX FLOAT>]>)
+
+returns the greatest of its arguments (arithmetic)
+
+ ME ()
+ #DECL ((VALUE) PROCESS)
+
+returns the current `PROCESS`
+
+ MEMBER (OBJECT STRUCTURE)
+ #DECL ((VALUE) <OR STRUCTURED '#FALSE ()>
+ (OBJECT) ANY (STRUCTURE) STRUCTURED)
+
+tells whether an object is "structurally" equal to some element of a
+structure (predicate)
+
+ MEMQ (OBJECT STRUCTURE)
+ #DECL ((VALUE) <OR STRUCTURED '#FALSE ()>
+ (OBJECT) ANY (STRUCTURE) STRUCTURED)
+
+tells whether an object is "exactly" equal to some element of a
+structure (predicate)
+
+ MIN ("TUPLE" NUMBERS)
+ #DECL ((VALUE) <OR FIX FLOAT>
+ (NUMBERS) <TUPLE [REST <OR FIX FLOAT>]>)
+
+returns the least of its arguments (arithmetic)
+
+ MOBLIST (NAME "OPTIONAL" (LENGTH 13))
+ #DECL ((VALUE) OBLIST
+ (NAME) ATOM (LENGTH) FIX)
+
+creates or gets an `OBLIST`
+
+ MOD (NUMBER MODULUS)
+ #DECL ((VALUE) FIX
+ (NUMBER MODULUS) FIX)
+
+returns number-theoretic remainder (fixed-point residue) (arithmetic)
+
+ MONAD? (OBJECT)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (OBJECT) ANY)
+
+tells whether an object is either unstructured or an empty structure
+(predicate)
+
+ N==? (OBJECT-1 OBJECT-2)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (OBJECT-1 OBJECT-2) ANY)
+
+tells whether two objects are NOT "exactly" equal (predicate)
+
+ N=? (OBJECT-1 OBJECT-2)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (OBJECT-1 OBJECT-2) ANY)
+
+tells whether two objects are NOT "structurally" equal (predicate)
+
+ NETACC (CHANNEL)
+ #DECL ((VALUE) <OR CHANNEL '#FALSE ()>
+ (CHANNEL) CHANNEL)
+
+accepts a network connection
+
+ NETS (CHANNEL)
+ #DECL ((VALUE CHANNEL) CHANNEL)
+
+forces operating-system network-`CHANNEL` buffer to be sent
+
+ NETSTATE (CHANNEL)
+ #DECL ((VALUE) <UVECTOR FIX FIX FIX>
+ (CHANNEL) CHANNEL)
+
+returns state information for a network `CHANNEL`
+
+ NEWTYPE (NEW-TYPE OLD-TYPE "OPTIONAL" PATTERN)
+ #DECL ((VALUE NEW-TYPE) ATOM
+ (OLD-TYPE) ATOM (PATTERN) <OR ATOM FORM>)
+
+defines a new data type
+
+ NEXT (ASSOCIATION)
+ #DECL ((VALUE) <OR ASOC '#FALSE ()>
+ (ASSOCIATION) ASOC)
+
+returns the next object in the association chain
+
+ NEXTCHR ("OPTIONAL" (CHANNEL .INCHAN) (EOF-ROUTINE '<ERROR ...>))
+ #DECL ((VALUE) <OR CHARACTER FIX>
+ (CHANNEL) CHANNEL (EOF-ROUTINE) ANY)
+
+returns the character that will next be read via an input `CHANNEL`
+
+ NOT (OBJECT)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (OBJECT) <OR FALSE ANY>)
+
+computes logical "not" of a truth-value
+
+ NTH (STRUCTURED "OPTIONAL" N)
+ #DECL ((VALUE) ANY
+ (N) <OR FIX OFFSET>)
+
+fetches the Nth element of a structure
+
+ OBLIST? (ATOM)
+ #DECL ((VALUE) <OR OBLIST '#FALSE ()>
+ (ATOM) ATOM)
+
+returns an `ATOM`'s `OBLIST` or false if none (predicate)
+
+ OFF (INTERRUPT "OPTIONAL" WHICH)
+ #DECL ((VALUE) <OR HANDLER IHEADER '#FALSE ()>
+ (INTERRUPT) <OR HANDLER IHEADER STRING ATOM> (WHICH) <OR CHANNEL LOCATIVE>)
+
+removes an interrupt `HANDLER` or destroys an interrupt
+
+ OFFSET (N PATTERN)
+ #DECL ((VALUE) OFFSET
+ (N) FIX (PATTERN) <OR ATOM FORM>)
+
+creates an integer with attached type declaration
+
+ ON (NAME APPLICABLE PRIORITY "OPTIONAL" (PROCESS 0) WHICH)
+ #DECL ((VALUE) HANDLER
+ (NAME) <OR STRING ATOM> (APPLICABLE) APPLICABLE (PRIORITY) FIX
+ (PROCESS) <OR FIX PROCESS> (WHICH) <OR CHANNEL LOCATIVE>)
+
+turns on an interrupt and creates an interrupt `HANDLER`
+
+ OPEN ("OPTIONAL" (MODE "READ") "TUPLE" FILE-NAME)
+ #DECL ((VALUE) <OR CHANNEL <FALSE STRING STRING FIX>>
+ (MODE) STRING (FILE-NAME) TUPLE)
+
+creates and opens an I/O `CHANNEL`
+
+ OPEN-NR ("OPTIONAL" (MODE "READ") "TUPLE" FILE-NAME)
+ #DECL ((VALUE) <OR CHANNEL <FALSE STRING STRING FIX>>
+ (MODE) STRING (FILE-NAME) TUPLE)
+
+creates and opens an I/O `CHANNEL` without changing file's reference
+date
+
+ OR ("ARGS" ARGS)
+ #DECL ((VALUE) <OR FALSE ANY>
+ (ARGS) LIST)
+
+computes logical inclusive "or" of truth-values, evaluated by the
+Subroutine
+
+ OR? ("TUPLE" TUPLE)
+ #DECL ((VALUE) <OR FALSE ANY>
+ (TUPLE) TUPLE)
+
+compares logical inclusive "or" of truth-values, evaluated at call
+time
+
+ ORB ("TUPLE" WORDS)
+ #DECL ((VALUE) WORD
+ (WORDS) <TUPLE [REST <PRIMTYPE WORD>]>)
+
+computes bitwise inclusive "or" of machine words
+
+ OVERFLOW ("OPTIONAL" SWITCH)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (SWITCH) <OR ANY FALSE>)
+
+enables or disables overflow error (arithmetic)
+
+ PARSE ("OPTIONAL"
+ (STRING .PARSE-STRING) (RADIX 10) (LOOK-UP .OBLIST) PARSE-TABLE LOOK-AHEAD)
+ #DECL ((VALUE) ANY
+ (STRING) STRING (RADIX) FIX (PARSE-TABLE) VECTOR (LOOK-AHEAD) CHARACTER
+ (LOOK-UP) <OR OBLIST <LIST [REST <OR OBLIST 'DEFAULT>]>>)
+
+parses a `STRING` into an object (sections 7.6.6.2, 15.7.2, 17.1.3)
+
+ PCODE (NAME OFFSET)
+ #DECL ((VALUE) PCODE
+ (NAME) STRING (OFFSET) FIX)
+
+creates pointer to pure `RSUBR` code
+
+ PNAME (ATOM)
+ #DECL ((VALUE) STRING
+ (ATOM) ATOM)
+
+returns the print-name of an `ATOM` as a distinct copy
+
+ PRIMTYPE (OBJECT)
+ #DECL ((VALUE) ATOM
+ (OBJECT) ANY)
+
+returns the primitive data type of an object
+
+ PRIMTYPE-C (TYPE)
+ #DECL ((VALUE) PRIMTYPE-C
+ (TYPE) ATOM)
+
+gets a "storage allocation code" for a data type
+
+ PRIN1 (OBJECT "OPTIONAL" (CHANNEL .OUTCHAN))
+ #DECL ((VALUE OBJECT) ANY
+ (CHANNEL) CHANNEL)
+
+prints an object via an output `CHANNEL`
+
+ PRINC (OBJECT "OPTIONAL" (CHANNEL .OUTCHAN))
+ #DECL ((VALUE OBJECT) ANY
+ (CHANNEL) CHANNEL)
+
+prints an object via an output `CHANNEL` without `STRING` or
+`CHARACTER` brackets or `ATOM` trailers
+
+ PRINT (OBJECT "OPTIONAL" (CHANNEL .OUTCHAN))
+ #DECL ((VALUE OBJECT) ANY
+ (CHANNEL) CHANNEL)
+
+prints an object via an output `CHANNEL` between new-line and space
+
+ PRINTB (BUFFER CHANNEL)
+ #DECL ((VALUE BUFFER) <<OR UVECTOR STORAGE> [REST <PRIMTYPE WORD>]>
+ (CHANNEL) CHANNEL)
+
+writes binary information via an output `CHANNEL`
+
+ PRINTSTRING (BUFFER "OPTIONAL" (CHANNEL .OUTCHAN) (COUNT <LENGTH .BUFFER>))
+ #DECL ((VALUE COUNT) FIX
+ (BUFFER) STRING (CHANNEL) CHANNEL)
+
+writes contents of a `STRING` via an output `CHANNEL`
+
+ PRINTTYPE (TYPE "OPTIONAL" HOW)
+ #DECL ((VALUE) <OR ATOM APPLICABLE '#FALSE ()>
+ (TYPE) ATOM (HOW) <OR ATOM APPLICABLE>)
+
+specifies or returns how a data type is printed
+
+ PROCESS (STARTUP)
+ #DECL ((VALUE) PROCESS
+ (STARTUP) APPLICABLE)
+
+creates a new `PROCESS` with given startup function
+
+ PROG ("ARGS" ARGS)
+ #DECL ((VALUE) ANY
+ (ARGS) <LIST [OPT ATOM] LIST [OPT DECL] ANY>)
+
+executes sequential expressions
+
+ PURIFY ("TUPLE" TUPLE)
+ #DECL ((VALUE) ANY
+ (TUPLE) TUPLE)
+
+purifies objects for sharing by different operating-system processes
+
+ PUT (ITEM INDICATOR "OPTIONAL" VAL)
+ #DECL ((VALUE) ANY
+ (ITEM) <OR STRUCTURED ANY> (INDICATOR) <OR FIX OFFSET ANY> (VAL) ANY)
+
+stores into structure or does `PUTPROP`
+
+ PUT-DECL (IDENTIFIER PATTERN)
+ #DECL ((VALUE IDENTIFIER) <OR LOCD OFFSET>
+ (PATTERN) <OR ATOM FORM>)
+
+changes the type declaration for an `ATOM`'s value or an `OFFSET`
+
+ PUTBITS (TO FIELD "OPTIONAL" (FROM 0))
+ #DECL ((VALUE) <PRIMTYPE WORD>
+ (TO FROM) <PRIMTYPE WORD> (FIELD) BITS)
+
+sets a bit field in a machine word
+
+ PUTPROP (ITEM INDICATOR "OPTIONAL" VAL)
+ #DECL ((VALUE) ANY
+ (ITEM INDICATOR VAL) ANY)
+
+(dis)associates a value with an item under an indicator
+
+ PUTREST (HEAD TAIL)
+ #DECL ((VALUE HEAD) <PRIMTYPE LIST>
+ (TAIL) <PRIMTYPE LIST>)
+
+replaces the rest of a list
+
+ QUIT ()
+ #DECL ((VALUE) '#FALSE ())
+
+exits from MDL gracefully
+
+ QUITTER (WAS-TYPED CHANNEL)
+ #DECL ((VALUE WAS-TYPED) CHARACTER
+ (CHANNEL) CHANNEL)
+
+is the interrupt handler for \^G and \^S quit features
+
+ QUOTE ("ARGS" ARGS)
+ #DECL ((VALUE) ANY
+ (ARGS) LIST)
+
+returns the first argument unevaluated
+
+ RANDOM ("OPTIONAL" SEED-1 SEED-2)
+ #DECL ((VALUE) FIX
+ (SEED-1 SEED-2) FIX)
+
+generates a uniform pseudo-random integer (arithmetic)
+
+ READ ("OPTIONAL"
+ (CHANNEL .INCHAN) (EOF-ROUTINE '<ERROR ...>) (LOOK-UP .OBLIST) READ-TABLE)
+ #DECL ((VALUE) ANY
+ (CHANNEL) CHANNEL (EOF-ROUTINE) ANY (READ-TABLE) VECTOR
+ (LOOK-UP) <OR OBLIST <LIST [REST <OR OBLIST 'DEFAULT>]>>)
+
+reads one object via an input `CHANNEL` (sections 11.1.1.1, 11.3,
+15.7.1, 17.1.3)
+
+ READB (BUFFER CHANNEL "OPTIONAL" (EOF-ROUTINE '<ERROR ...>))
+ #DECL ((VALUE) FIX
+ (BUFFER) <<OR UVECTOR STORAGE> [REST <PRIMTYPE WORD>]>
+ (CHANNEL) CHANNEL (EOF-ROUTINE) ANY)
+
+reads binary information via an input `CHANNEL`
+
+ READCHR ("OPTIONAL" (CHANNEL .INCHAN) (EOF-ROUTINE '<ERROR ...>))
+ #DECL ((VALUE) <OR CHARACTER FIX>
+ (CHANNEL) CHANNEL (EOF-ROUTINE) ANY)
+
+reads one character via an input `CHANNEL`
+
+ READSTRING (BUFFER "OPTIONAL" (CHANNEL .INCHAN) (STOP <LENGTH .BUFFER>)
+ (EOF-ROUTINE '<ERROR ...>))
+ #DECL ((VALUE) FIX
+ (BUFFER) STRING (CHANNEL) CHANNEL (STOP) <OR FIX STRING> (EOF-ROUTINE) ANY)
+
+reads into a `STRING` via an input `CHANNEL`
+
+ REALTIMER ("OPTIONAL" INTERVAL)
+ #DECL ((VALUE) <OR FIX FLOAT '#FALSE ()>
+ (INTERVAL) <OR FIX FLOAT>)
+
+sets or fetches interval for real-time interrupts (ITS version only)
+
+ REMOVE (PNAME "OPTIONAL" OBLIST)
+ #DECL ((VALUE) <OR ATOM '#FALSE ()>
+ (PNAME) <OR ATOM STRING> (OBLIST) OBLIST)
+
+removes an `ATOM` from an `OBLIST`
+
+ RENAME ("TUPLE" FILE-NAME/S)
+ #DECL ((VALUE) <OR 'T <FALSE STRING FIX>>
+ (FILE-NAME/S) <TUPLE <OR STRING CHANNEL>>)
+
+renames or deletes a disk file
+
+ REP ()
+ #DECL ((VALUE) ANY)
+
+is the built-in function for `READ-EVAL-PRINT` loop
+
+ REPEAT ("ARGS" ARGS)
+ #DECL ((VALUE) ANY
+ (ARGS) <LIST [OPT ATOM] LIST [OPT DECL] ANY>)
+
+executes sequential expressions repeatedly
+
+ RESET (CHANNEL)
+ #DECL ((VALUE) <OR CHANNEL <FALSE STRING STRING FIX>>
+ (CHANNEL) CHANNEL)
+
+reopens an I/O `CHANNEL` at its beginning
+
+ REST (STRUCTURED "OPTIONAL" (N 1))
+ #DECL ((VALUE) STRUCTURED
+ (N) FIX)
+
+removes the first `N` elements from a structure and changes to
+primitive data type
+
+ RESTORE ("OPTIONAL" NAME-1 NAME-2 NAME-3 NAME-4)
+ #DECL ((VALUE) '"RESTORED"
+ (NAME-1 NAME-2 NAME-3 NAME-4) STRING)
+
+restores MDL's state from a file
+
+ RESUME (VAL "OPTIONAL" (PROCESS <RESUMER>))
+ #DECL ((VALUE) ANY
+ (VAL) ANY (PROCESS) PROCESS)
+
+transfers execution to another `PROCESS`
+
+ RESUMER ("OPTIONAL" (PROCESS <ME>))
+ #DECL ((VALUE) <OR PROCESS '#FALSE ()>
+ (PROCESS) PROCESS)
+
+returns the `PROCESS` that last resumed the given `PROCESS`
+
+ RETRY ("OPTIONAL" FRAME)
+ #DECL (
+ (FRAME) FRAME)
+
+retries a previous Subroutine call, usually from the error level
+
+ RETURN ("OPTIONAL" (VAL T) (ACTIVATION .LPROG\ !-INTERRUPTS))
+ #DECL ((VALUE) ANY
+ (VAL) ANY (ACTIVATION) ACTIVATION)
+
+leaves a `PROG`/`REPEAT` with a value
+
+ RGLOC (ATOM "OPTIONAL" (MAKE-SLOT <>))
+ #DECL ((VALUE) LOCR
+ (ATOM) ATOM (MAKE-SLOT) <OR FALSE ANY>)
+
+returns a locative to the global-value cell of an `ATOM` for
+pure-program use
+
+ ROOT ()
+ #DECL ((VALUE) OBLIST)
+
+returns the `OBLIST` containing names of primitives
+
+ ROT (WORD AMOUNT)
+ #DECL ((VALUE) WORD
+ (WORD) <PRIMTYPE WORD> (AMOUNT) FIX)
+
+rotates bits in a machine word
+
+ RSUBR (CANDIDATE)
+ #DECL ((VALUE) RSUBR
+ (CANDIDATE) <VECTOR <OR CODE PCODE> ATOM DECL [REST ANY]>)
+
+creates an `RSUBR`
+
+ RSUBR-ENTRY (CANDIDATE OFFSET)
+ #DECL ((VALUE) RSUBR-ENTRY
+ (CANDIDATE) <VECTOR <OR ATOM RSUBR> ATOM DECL> (OFFSET) FIX)
+
+adds an entry point to an `RSUBR`
+
+ RSUBR-LINK ("OPTIONAL" SWITCH)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (SWITCH) <OR FALSE ANY>)
+
+enables or disables the automatic `RSUBR` linking feature
+
+ RUNINT ("TUPLE" TUPLE)
+ #DECL ((VALUE) ANY
+ (TUPLE) TUPLE)
+
+applies interrupt handler (for internal use only)
+
+ RUNTIMER ("OPTIONAL" INTERVAL)
+ #DECL ((VALUE) <OR FIX FLOAT '#FALSE ()>
+ (INTERVAL) <OR FIX FLOAT>)
+
+sets or fetches interval for run-time interrupt (ITS version only)
+
+ SAVE ("TUPLE" FILE-NAME-AND-GC?)
+ #DECL ((VALUE) '"SAVED"
+ (FILE-NAME-AND-GC?) <TUPLE [OPT STRING] [OPT STRING]
+ [OPT STRING] [OPT STRING] [OPT <OR FALSE ANY>]>)
+
+writes the entire state of MDL to a file
+
+ SEND (OTHER-NAME-1 OTHER-NAME-2 BODY
+ "OPTIONAL" (TYPE 0) (MY-NAME-1 <UNAME>) (MY-NAME-2 <JNAME>))
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (OTHER-NAME-1 OTHER-NAME-2 MY-NAME-1 MY-NAME-2) STRING (TYPE) FIX
+ (BODY) <OR STRING STORAGE <UVECTOR [REST <PRIMTYPE WORD>]>>)
+
+sends an IPC message (ITS version only)
+
+ SEND-WAIT (OTHER-NAME-1 OTHER-NAME-2 BODY
+ "OPTIONAL" (TYPE 0) (MY-NAME-1 <UNAME>) (MY-NAME-2 <JNAME>))
+ #DECL ((VALUE) 'T
+ (OTHER-NAME-1 OTHER-NAME-2 MY-NAME-1 MY-NAME-2) STRING (TYPE) FIX
+ (BODY) <OR STRING STORAGE <UVECTOR [REST <PRIMTYPE WORD>]>>)
+
+sends an IPC message and waits for it to be received (ITS version
+only)
+
+ SET (ATOM LVAL "OPTIONAL" ENV)
+ #DECL ((VALUE LVAL) ANY
+ (ATOM) ATOM (ENV) <OR FRAME ENVIRONMENT ACTIVATION PROCESS>)
+
+changes the local value of an `ATOM`
+
+ SETG (ATOM GVAL)
+ #DECL ((VALUE GVAL) ANY
+ (ATOM) ATOM)
+
+changes (the global value of an `ATOM`
+
+ SETLOC (POINTER OBJECT)
+ #DECL ((VALUE OBJECT) ANY
+ (POINTER) LOCATIVE)
+
+changes the contents pointed to by a locative
+
+ SIN (NUMBER)
+ #DECL ((VALUE) FLOAT
+ (NUMBER) <OR FIX FLOAT>)
+
+returns sine of a number (arithmetic)
+
+ SLEEP (<OR FIX FLOAT> "OPTIONAL" (UNHANG <>))
+ #DECL ((VALUE) ANY
+ (UNHANG) ANY)
+
+does nothing, interruptibly, the given number of seconds
+
+ SNAME ("OPTIONAL" DIRECTORY)
+ #DECL ((VALUE DIRECTORY) STRING)
+
+sets or returns the directory name used by default for new I/O
+`CHANNEL`s
+
+ SORT (PRED KEY-STRUC "OPTIONAL" (RECORD-LENGTH 1) (KEY-OFFSET 0)
+ "TUPLE" OTHER-STRUCS-AND-RECORD-LENGTHS)
+ #DECL ((VALUE KEY-STRUC) <OR <PRIMTYPE VECTOR> <PRIMTYPE TUPLE> <PRIMTYPE UVECTOR>>
+ (PRED) <OR FALSE APPLICABLE> (RECORD-LENGTH KEY-OFFSET) FIX
+ (OTHER-STRUCS-AND-RECORD-LENGTHS)
+ <TUPLE [REST <OR <PRIMTYPE VECTOR> <PRIMTYPE TUPLE> <PRIMTYPE UVECTOR>> FIX]>)
+
+sorts elements of a structure and rearranges other structures
+
+ SPECIAL-CHECK ("OPTIONAL" SWITCH)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (SWITCH) <OR ANY FALSE>)
+
+turns interpreter special-checking on or off
+
+ SPECIAL-MODE ("OPTIONAL" SWITCH)
+ #DECL ((VALUE) <OR 'SPECIAL 'UNSPECIAL>
+ (SWITCH) <OR 'SPECIAL 'UNSPECIAL>)
+
+sets specialty declaration used by default
+
+ SPNAME (ATOM)
+ #DECL ((VALUE) STRING
+ (ATOM) ATOM)
+
+returns the print-name of an `ATOM` by sharing it
+
+ SQRT (NUMBER)
+ #DECL ((VALUE) FLOAT
+ (NUMBER) <OR FIX FLOAT>)
+
+returns square root of a number (arithmetic)
+
+ SQUOTA (SYMBOL)
+ #DECL ((VALUE) <OR FIX '#FALSE ()>
+ (SYMBOL) <PRIMTYPE WORD>)
+
+gets the address of an internal interpreter symbol (for internal use
+only)
+
+ STACKFORM ("ARGS" ARGS)
+ #DECL ((VALUE) ANY
+ (ARGS) LIST)
+
+applies a function to stacked arguments (archaic)
+
+ STATE (PROCESS)
+ #DECL ((VALUE) ATOM
+ (PROCESS) PROCESS)
+
+returns a `PROCESS`'s current state
+
+ STRCOMP (STRING-1 STRING-2)
+ #DECL ((VALUE) <OR '1 '0 '-1>
+ (STRING-1 STRING-2) <OR ATOM STRING>)
+
+compares two character-strings or two print-names
+
+ STRING ("TUPLE" ELEMENTS)
+ #DECL ((VALUE) STRING
+ (ELEMENTS) <TUPLE [REST <OR STRING CHARACTER>]>)
+
+creates a character-string from explicit arguments
+
+ STRUCTURED? (OBJECT)
+ #DECL ((VALUE) <OR 'T '#FALSE ()>
+ (OBJECT) ANY)
+
+tells whether an object is structured (predicate)
+
+ SUBSTITUTE (NEW OLD)
+ #DECL ((VALUE OLD) ANY
+ (NEW) ANY)
+
+substitutes one object for another in the entire address space
+
+ SUBSTRUC (FROM "OPTIONAL" (REST 0) (AMOUNT <- <LENGTH .OBJECT> .REST>) TO)
+ #DECL ((VALUE TO) <OR LIST VECTOR UVECTOR STRING BYTES>
+ (FROM) <OR <PRIMTYPE LIST> <PRIMTYPE VECTOR> <PRIMTYPE TUPLE>
+ <PRIMTYPE UVECTOR> <PRIMTYPE STRING> <PRIMTYPE BYTES>>
+ (REST AMOUNT) FIX)
+
+copies (part of) a structure into another
+
+ SUICIDE (VAL "OPTIONAL" (PROCESS <RESUMER>))
+ #DECL ((VALUE) ANY
+ (VAL) ANY (PROCESS) PROCESS)
+
+causes the current `PROCESS` to die and resumes another
+
+ TAG (LABEL)
+ #DECL ((VALUE) TAG
+ (LABEL) ATOM)
+
+creates a `TAG` for use by `GO`
+
+ TERPRI ("OPTIONAL" (CHANNEL .OUTCHAN))
+ #DECL ((VALUE) '#FALSE ()
+ (CHANNEL) CHANNEL)
+
+prints a carriage-return and line-feed via an output `CHANNEL`
+
+ TIME ("TUPLE" IGNORED)
+ #DECL ((VALUE) FLOAT
+ (IGNORED) TUPLE)
+
+returns the elapsed execution time in seconds
+
+ TOP (STRUCTURE)
+ #DECL ((VALUE) <OR VECTOR TUPLE UVECTOR STORAGE STRING BYTES TEMPLATE>
+ (STRUCTURE) <OR <PRIMTYPE VECTOR> <PRIMTYPE TUPLE>
+ <PRIMTYPE UVECTOR> <PRIMTYPE STORAGE>
+ <PRIMTYPE STRING> <PRIMTYPE BYTES> <PRIMTYPE TEMPLATE>>)
+
+replaces all elements removed from a non-list structure by `REST`ing
+and changes to primitive data type
+
+ TTYECHO (CHANNEL SWITCH)
+ #DECL ((VALUE CHANNEL) CHANNEL
+ (SWITCH) <OR FALSE ANY>)
+
+turns echoing (of characters typed on a terminal) on or off
+
+ TUPLE ("TUPLE" ELEMENTS)
+ #DECL ((VALUE) TUPLE
+ (ELEMENTS) TUPLE)
+
+creates a `TUPLE` from explicit arguments
+
+ TYI ("OPTIONAL" CHANNEL)
+ #DECL ((VALUE) CHARACTER
+ (CHANNEL) CHANNEL)
+
+inputs a `CHARACTER` from a terminal immediately
+
+ TYPE (OBJECT)
+ #DECL ((VALUE) ATOM
+ (OBJECT) ANY)
+
+returns the data type of an object
+
+ TYPE-C (TYPE "OPTIONAL" PRIMTYPE)
+ #DECL ((VALUE) TYPE-C
+ (TYPE PRIMTYPE) ATOM)
+
+makes a data type code for pure-program use
+
+ TYPE-W (TYPE "OPTIONAL" PRIMTYPE RIGHT-HALF)
+ #DECL ((VALUE) TYPE-W
+ (TYPE PRIMTYPE) ATOM (RIGHT-HALF) <PRIMTYPE WORD>)
+
+makes a data-type machine word for pure-program use
+
+ TYPE? (OBJECT "TUPLE" TYPES)
+ #DECL ((VALUE) <OR ATOM '#FALSE ()>
+ (OBJECT) ANY (TYPES) <TUPLE ATOM [REST ATOM]>)
+
+tells whether an object's data type is one of the given types
+(predicate)
+
+ TYPEPRIM (TYPE)
+ #DECL ((VALUE) ATOM
+ (TYPE) ATOM)
+
+returns a data type's primitive type
+
+ UNAME ()
+ #DECL ((VALUE) STRING)
+
+returns the "user name" of MDL's process
+
+ UNASSIGN (ATOM "OPTIONAL" ENV)
+ #DECL ((VALUE ATOM) ATOM
+ (ENV) <OR FRAME ENVIRONMENT ACTIVATION PROCESS>)
+
+causes an `ATOM` to have no local value
+
+ UNMANIFEST ("TUPLE" ATOMS)
+ #DECL ((VALUE) 'T
+ (ATOMS) <TUPLE [REST ATOM]>)
+
+declares the global values of `ATOM`s not to be constants
+
+ UNPARSE (OBJECT "OPTIONAL" RADIX)
+ #DECL ((VALUE) STRING
+ (OBJECT) ANY (RADIX) FIX)
+
+creates a `STRING` representation of an object
+
+ UNWIND ('NORMAL 'CLEAN-UP)
+ #DECL ((VALUE) ANY
+ (NORMAL CLEAN-UP) ANY)
+
+specifies cleaning-up during non-local return
+
+ UTYPE (UVECTOR)
+ #DECL ((VALUE) ATOM
+ (UVECTOR) <PRIMTYPE UVECTOR>)
+
+returns the data type of all elements of a uniform vector
+
+ UVECTOR ("TUPLE" ELEMENTS)
+ #DECL ((VALUE) UVECTOR
+ (ELEMENTS) TUPLE)
+
+creates a `UVECTOR` from explicit arguments
+
+ VALID-TYPE? (TYPE)
+ #DECL ((VALUE) <OR TYPE-C '#FALSE ()>
+ (TYPE) ATOM)
+
+tells whether an `ATOM` is the name of a type (predicate)
+
+ VALRET (MESSAGE)
+ #DECL ((VALUE) '#FALSE ()
+ (MESSAGE) <OR STRING FIX>)
+
+passes a message to the superior operating-system process
+
+ VALUE (ATOM "OPTIONAL" ENV)
+ #DECL ((VALUE) ANY
+ (ATOM) ATOM (ENV) <OR FRAME ENVIRONMENT ACTIVATION PROCESS>)
+
+returns the local or else the global value of an `ATOM`
+
+ VECTOR ("TUPLE" ELEMENTS)
+ #DECL ((VALUE) VECTOR
+ (ELEMENTS) TUPLE)
+
+creates a `VECTOR` from explicit arguments
+
+ XJNAME ()
+ #DECL ((VALUE) STRING)
+
+returns the "intended job name" of MDL's process
+
+ XORB ("TUPLE" WORDS)
+ #DECL ((VALUE) WORD
+ (WORDS) <TUPLE [REST <PRIMTYPE WORD>]>)
+
+computes bitwise exclusive "or" of machine word:
+
+ XUNAME ()
+ #DECL ((VALUE) STRING)
+
+returns the "intended user name" of MDL's process
+
+Appendix 3. Predefined Types
+============================
+
+On these two pages is a table showing each of MDL's predefined
+`TYPE`s, its primitive type if different, and various flags: `S` for
+`STRUCTURED`, `E` for `EVALTYPE` not `QUOTE`, and `A` for
+`APPLICABLE`.
+
+`X` means that an object of that `TYPE` cannot be `CHTYPE`d to and
+hence cannot be `READ` in (if attempted, a `CAN'T-CHTYPE-INTO` error
+is usual).
+
+`B` means that an object of that `TYPE` cannot be `READ` in (if
+attempted, a `STORAGE-TYPES-DIFFER` error is usual), that instead it
+is built by the interpreter or `CHTYPE`d to by a program, and that its
+`PRINT`ed representation makes it look as though its `TYPEPRIM` were
+different.
+
+`%` means that an object of that `TYPE` is `PRINT`ed using `%`
+notation and can be `READ` in only that way.
+
+ -------------------------------------------------------------------------------
+ `TYPE` `TYPEPRIM` `S` `E` `A` comments
+ --------------- ------------------ ----- ----- ----- --------- ----------------
+ `ACTIVATION` `FRAME` `X`
+
+ `ASOC` `B` sic: only one
+ `S`
+
+ `ATOM`
+
+ `BITS` `WORD`
+
+ `BYTES` `S`
+
+ `CHANNEL` `VECTOR` `S` `X`
+
+ `CHARACTER` `WORD`
+
+ `CLOSURE` `LIST` `S` `A`
+
+ `CODE` `UVECTOR` `S`
+
+ `DECL` `LIST` `S`
+
+ `DISMISS` `ATOM` can be returned
+ by interrupt
+ handler
+
+ `ENVIRONMENT` `FRAME` `B`
+
+ `FALSE` `LIST` `S`
+
+ `FIX` `WORD` `A`
+
+ `FLOAT` `WORD`
+
+ `FORM` `LIST` `S` `E`
+
+ `FRAME` `B`
+
+ `FSUBR` `WORD` `A` `X`
+
+ `FUNCTION` `LIST` `S` `A`
+
+ `HANDLER` `VECTOR` `S` `X`
+
+ `IHEADER` `VECTOR` `S` `X` "interrupt
+ header"
+
+ `ILLEGAL` `WORD` `X` Garbage
+ collector may
+ put this on
+ non-`LEGAL?`
+ object.
+
+ `INTERNAL` `INTERNAL-TYPE` `X` should not be
+ seen by programs
+
+ `LINK` `ATOM` `X` for terminal
+ shorthand
+
+ `LIST` `S` `E`
+
+ `LOCA` `B` locative to
+ `TUPLE`
+
+ `LOCAS` `B` locative to
+ `ASOC`
+
+ `LOCB` `B` locative to
+ `BYTES`
+
+ `LOCD` `%` locative to
+ G/LVAL
+
+ `LOCL` `B` locative to
+ `LIST`
+
+ `LOCR` `%` locative to
+ `GVAL` in pure
+ program
+
+ `LOCS` `B` locative to
+ `STRING`
+
+ `LOCT` `B` locative to
+ `TEMPLATE`
+
+ `LOCU` `B` locative to
+ `UVECTOR`
+
+ `LOCV` `B` locative to
+ `VECTOR`
+
+ `LOSE` `WORD` a place holder
+
+ `MACRO` `LIST` `S` `A`
+
+ `OBLIST` `UVECTOR` `S` `X`
+
+ `OFFSET` `OFFSET` `A` `%`
+
+ `PCODE` `WORD` `%` "pure code"
+
+ `PRIMTYPE-C` `WORD` `%` "primtype code"
+
+ `PROCESS` `B`
+
+ `QUICK-ENTRY` `VECTOR` `S` `A` `%` an `RSUBR-ENTRY`
+ that has been
+ `QCALL`ed and
+ `RSUBR-LINK`ed
+
+ `QUICK-RSUBR` `VECTOR` `S` `A` `%/B` an `RSUBR` that
+ has been
+ `QCALL`ed and
+ `RSUBR-LINK`ed
+
+ `READA` `FRAME` `X` in eof slot
+ during recursive
+ `READ` via
+ `READ-TABLE`
+
+ `RSUBR` `VECTOR` `S` `A` `%/B` if code vector
+ is pure/impure,
+ respectively
+
+ `RSUBR-ENTRY` `VECTOR` `S` `A` `%`
+
+ `SEGMENT` `LIST` `S` `E`
+
+ `SPLICE` `LIST` `S` for returning
+ many things via
+ `READ-TABLE`
+
+ `STORAGE` `S` If possible, use
+ `FREEZE` `SUBR`
+ instead.
+
+ `STRING` `S`
+
+ `SUBR` `WORD` `A` `X`
+
+ `TAG` `VECTOR` `S` `X` for non-local
+ `GO`s
+
+ `TEMPLATE` `S` `B` The interpreter
+ itself can't
+ build one. See
+ Lebling (1979).
+
+ `TIME` `WORD` used internally
+ to identify
+ `FRAME`s
+
+ `TUPLE` `S` `B` vector on the
+ control stack
+
+ `TYPE-C` `WORD` `%` "type code"
+
+ `TYPE-W` `WORD` `%` "type word"
+
+ `UNBOUND` `WORD` `X` value of
+ unassigned but
+ bound `ATOM`, as
+ seen by
+ locatives
+
+ `UVECTOR` `S` `E` "uniform vector"
+
+ `VECTOR` `S` `E`
+
+ `WORD`
+ -------------------------------------------------------------------------------
+
+Appendix 4. Error Messages
+==========================
+
+This is a list of all error-naming ATOMs initially in the ERRORS
+OBLIST, in the left-hand column, and appropriate examples or
+elucidations, where necessary, in the right-hand column.
+
+ ----------------------------------------------------------- ------------------------------------
+ `ACCESS-FAILURE` `ACCESS`, `RESTORE` (Tenex and
+ Tops-20 versions only)
+
+ `ALREADY-DEFINED-ERRET-NON-FALSE-TO-REDEFINE`
+
+ `APPLY-OR-STACKFORM-OF-FSUBR` First argument to `APPLY`,
+ `STACKFORM`, MAPF/R doesn't `EVAL`
+ all its arguments.
+
+ `ARG-WRONG-TYPE`
+
+ `ARGUMENT-OUT-OF-RANGE` `<ASCII 999>$` Second argument to
+ `NTH` or `REST` too big or small.
+
+ `ATOM-ALREADY-THERE` `<INSERT "T" <ROOT>>$`
+ `<LINK 'T "T" <ROOT>>$`
+
+ `ATOM-NOT-TYPE-NAME-OR-SPECIAL-SYMBOL` `DECL` problem
+
+ `ATOM-ON-DIFFERENT-OBLIST` `INSERT`, `LINK`, `REMOVE`
+
+ `ATTEMPT-TO-BREAK-OWN-SEQUENCE` `<BREAK-SEQ T <ME>>$`
+
+ `ATTEMPT-TO-CHANGE-MANIFEST-VARIABLE`
+
+ `ATTEMPT-TO-CLOSE-TTY-CHANNEL` `<CLOSE ,INCHAN>$`
+
+ `ATTEMPT-TO-DEFER-UNDEFERABLE-INTERRUPT` "Undeferable" interrupt
+ (e.g. `"ERROR"`) while `INT-LEVEL`
+ is too high to handle it
+
+ `ATTEMPT-TO-GROW-VECTOR-TOO-MUCH` `GROW` argument greater than
+ `<* 16 1024>`
+
+ `ATTEMPT-TO-MUNG-ATOMS-PNAME` `<PUT <SPNAME T> 1 !\T>$`
+
+ `ATTEMPT-TO-MUNG-PURE-STRUCTURE` attempt to write into pure page
+
+ `ATTEMPT-TO-SUICIDE-TO-SELF` `<SUICIDE <ME>>$`
+
+ `BAD-ARGUMENT-LIST` `<GDECL ("HI") STRING>$`
+
+ `BAD-ASCII-CHARACTER` A character with wrong byte size or
+ ASCII code more than 177 octal has
+ been read (how?).
+
+ `BAD-BYTES-DECL`
+
+ `BAD-CHANNEL`
+
+ `BAD-CLAUSE` Argument to `COND` is non-`LIST` or
+ empty `LIST`.
+
+ `BAD-DECLARATION-LIST` `DECL` in bad form
+
+ `BAD-DEFAULT-OBLIST-SPECIFICATION` bad use of `DEFAULT` in `LIST` of
+ `OBLIST`s
+
+ `BAD-ENTRY-BLOCK` `RSUBR-ENTRY` does not point to good
+ `RSUBR`.
+
+ `BAD-ENVIRONMENT`
+
+ `BAD-FIXUPS`
+
+ `BAD-FUNARG` `CLOSURE` in bad form
+
+ `BAD-GC-READ-FILE`
+
+ `BAD-INPUT-BUFFER` (for a `CHANNEL`)
+
+ `BAD-LINK` `<GUNASSIGN <CHTYPE link ATOM>>`
+
+ `BAD-MACRO-TABLE` `.READ-TABLE` or `.PARSE-TABLE` is
+ not a vector.
+
+ `BAD-OBLIST-OR-LIST-THEREOF` Alleged look-up list is not of
+ `TYPE` `OBLIST` or `LIST`.
+
+ `BAD-PARSE-STRING` non-`STRING` argument to `PARSE`
+
+ `BAD-PNAME` attempt to output `ATOM` with
+ missing or zero-length `PNAME`
+
+ `BAD-PRIMTYPEC`
+
+ `BAD-TEMPLATE-DATA`
+
+ `BAD-TYPE-CODE`
+
+ `BAD-TYPE-NAME` `ATOM` purports to be a `TYPE` but
+ isn't.
+
+ `BAD-TYPE-SPECIFICATION` `DECL` problem
+
+ `BAD-USE-OF-BYTE-STRING` `#3$`
+
+ `BAD-USE-OF-MACRO`
+
+ `BAD-USE-OF-SQUIGGLY-BRACKETS` `{}$`
+
+ `BAD-VECTOR` Bad argument to `RSUBR-ENTRY`
+
+ `BYTE-SIZE-BAD` `"NET" CHANNEL`
+
+ `CANT-CHTYPE-INTO` `<CHTYPE 1 SUBR>$`
+
+ `CANT-FIND-TEMPLATE` attempt to `GC-READ` a structure
+ containing a `TEMPLATE` whose `TYPE`
+ does not exist
+
+ `CANT-OPEN-OUTPUT-FILE` `SAVE`
+
+ `CANT-RETRY-ENTRY-GONE` attempt to `RETRY` a call to an
+ `RSUBR-ENTRY` whose `RSUBR` cannot
+ be found
+
+ `CANT-SUBSTITUTE-WITH-STRING-OR-TUPLE-AND-OTHER` `<SUBSTITUTE "T" T>$`
+
+ `CAN\'T-PARSE` `<PARSE "">$` `<PARSE ")">$`
+
+ `CHANNEL-CLOSED` `<READ <CLOSE channel>>$`
+
+ `CONTROL-G?` `^G`
+
+ `COUNT-GREATER-THAN-STRING-SIZE` `<PRINTSTRING "" ,OUTCHAN 1>$`
+
+ `DANGEROUS-INTERRUPT-NOT-HANDLED` (See section 21.8.15.) (ITS version
+ only)
+
+ `DATA-CANT-GO-IN-UNIFORM-VECTOR` `!["STRING"]$` `![<FRAME>]$`
+
+ `DATA-CAN\'T-GO-IN-STORAGE` `FREEZE ISTORAGE`
+
+ `DECL-ELEMENT-NOT-FORM-OR-ATOM`
+
+ `DECL-VIOLATION`
+
+ `DEVICE-OR-SNAME-DIFFERS` `RENAME`
+
+ `ELEMENT-TYPE-NOT-ATOM-FORM-OR-VECTOR` `DECL` problem
+
+ `EMPTY-FORM-IN-DECL`
+
+ `EMPTY-OR/PRIMTYPE-FORM` `<OR>` or `<PRIMTYPE>` in `DECL`
+
+ `EMPTY-STRING` `<READSTRING "">$`
+
+ `END-OF-FILE`
+
+ `ERRET-TYPE-NAME-DESIRED`
+
+ `ERROR-IN-COMPILED-CODE`
+
+ `FILE-NOT-FOUND` `RESTORE`
+
+ `FILE-SYSTEM-ERROR`
+
+ `FIRST-ARG-WRONG-TYPE`
+
+ `FIRST-ELEMENT-OF-VECTOR-NOT-CODE` `RSUBR` in bad form.
+
+ `FIRST-VECTOR-ELEMENT-NOT-REST-OR-A-FIX` `#DECL ((X) <LIST [FOO]>)`
+
+ `FRAME-NO-LONGER-EXISTS` (unused)
+
+ `HANDLER-ALREADY-IN-USE`
+
+ `HAS-EMPTY-BODY` `<#FUNCTION ((X)) 1>$`
+
+ `ILLEGAL`
+
+ `ILLEGAL-ARGUMENT-BLOCK` attempt to `PRINT` a `TUPLE` that no
+ longer exists
+
+ `ILLEGAL-FRAME`
+
+ `ILLEGAL-LOCATIVE`
+
+ `ILLEGAL-SEGMENT` Third and later arguments to MAPF/R
+ not `STRUCTURED`.
+
+ `ILLEGAL-TENEX-FILE-NAME` (Tenex and Tops-20 versions only)
+
+ `INT-DEVICE-WRONG-TYPE-EVALUATION-RESULT` function for `"INT"` input `CHANNEL`
+ returned non-`CHARACTER`.
+
+ `INTERNAL-BACK-OR-TOP-OF-A-LIST` in compiled code
+
+ `INTERNAL-INTERRUPT` (unused)
+
+ `INTERRUPT-UNAVAILABLE-ON-TENEX` (Tenex and Tops-20 versions only)
+
+ `ITS-CHANNELS-EXHAUSTED` Interpreter couldn't open an ITS I/O
+ channel.
+
+ `MEANINGLESS-PARAMETER-DECLARATION` bad object in argument `LIST` of
+ Function
+
+ `MESSAGE-TOO-BIG` IPC (ITS version only)
+
+ `MUDDLE-VERSIONS-DIFFER` `RESTORE` (version = release)
+
+ `NEGATIVE-ARGUMENT`
+
+ `NIL-LIST-OF-OBLISTS` `<SET OBLIST '()> T$`
+
+ `NO-FIXUP-FILE` MDL couldn't find fixup file
+ (section 19.9).
+
+ `NO-ITS-CHANNELS-FREE` `IPC-ON` (ITS version only)
+
+ `NO-MORE-PAGES` for pure-code mapping
+
+ `NO-PROCESS-TO-RESUME` `<OR <RESUMER> <RESUME>>$`
+
+ `NO-ROOM-AVAILABLE` MDL couldn't allocate a page to map
+ in pure code.
+
+ `NO-SAV-FILE` MDL couldn't find pure-code file
+ (section 19.9).
+
+ `NO-STORAGE` No free storage available for
+ `GROW`.
+
+ `NON-6-BIT-CHARACTER-IN-FILE-NAME`
+
+ `NON-APPLICABLE-REP` `<VALUE REP>` not `APPLICABLE`
+
+ `NON-APPLICABLE-TYPE`
+
+ `NON-ATOMIC-ARGUMENT`
+
+ `NON-ATOMIC-OBLIST-NAME` `T!-3$`
+
+ `NON-DSK-DEVICE` (unused)
+
+ `NON-EVALUATEABLE-TYPE` (unused)
+
+ `NON-EXISTENT-TAG` (unused)
+
+ `NON-STRUCTURED-ARG-TO-INTERNAL-PUT-REST-NTH-TOP-OR-BACK` in compiled code
+
+ `NON-TYPE-FOR-PRIMTYPE-ARG` `<PRIMTYPE not-type>` in `DECL`
+
+ `NOT-A-TTY-TYPE-CHANNEL`
+
+ `NOT-HANDLED` First argument to `OFF` not `ON`ed.
+
+ `NOT-IN-ARG-LIST` `TUPLE` or `ITUPLE` called outside
+ argument `LIST`.
+
+ `NOT-IN-MAP-FUNCTION` `MAPRET`, `MAPLEAVE`, `MAPSTOP` not
+ within MAPF/R
+
+ `NOT-IN-PROG` `<RETURN>$` `<AGAIN>$`
+
+ `NTH-BY-A-NEGATIVE-NUMBER` in compiled code
+
+ `NTH-REST-PUT-OUT-OF-RANGE` in compiled code
+
+ `NULL-STRING` zero-length `STRING`
+
+ `NUMBER-OUT-OF-RANGE` `2E38$`
+
+ `ON-AN-OBLIST-ALREADY` `<INSERT T <ROOT>>$`
+
+ `OUT-OF-BOUNDS` `<1 '()>$` `BLOAT` argument too
+ large
+
+ `OVERFLOW` `</ 1 0>$` `<* 1E30 1E30>$`
+
+ `PDL-OVERFLOW-BUFFER-EXHAUSTED` Stack overflow while trying to
+ expand stack: use `RETRY`.
+
+ `PROCESS-NOT-RESUMABLE` use of another `PROCESS`'s `FRAME`,
+ etc.
+
+ `PROCESS-NOT-RUNABLE-OR-RESUMABLE`
+
+ `PURE-LOAD-FAILURE` Pure-code file disappeared.
+
+ `READER-SYNTAX-ERROR-ERRET-ANYTHING-TO-GO-ON`
+
+ `RSUBR-ENTRY-UNLINKED` `RSUBR-ENTRY` whose `RSUBR` cannot
+ be found
+
+ `RSUBR-IN-BAD-FORMAT`
+
+ `RSUBR-LACKS-FIXUPS` `KEEP-FIXUPS` should have been true
+ when `RSUBR` was input.
+
+ `SECOND-ARG-WRONG-TYPE`
+
+ `STORAGE-TYPES-DIFFER` `<CHTYPE 1 LIST>$`
+ `<CHUTYPE '![1] LIST>$`
+
+ `STRUCTURE-CONTAINS-UNDUMPABLE-TYPE` `<GC-DUMP <ME> <>>$`
+
+ `SUBSTITUTE-TYPE-FOR-TYPE` `<SUBSTITUTE SUBR FSUBR>$`
+
+ `TEMPLATE-TYPE-NAME-NOT-OF-TYPE-TEMPLATE` attempt to `GC-READ` a structure
+ containing a `TEMPLATE` whose `TYPE`
+ is defined but is not a `TEMPLATE`
+
+ `TEMPLATE-TYPE-VIOLATION`
+
+ `THIRD-ARG-WRONG-TYPE`
+
+ `TOO-FEW-ARGUMENTS-SUPPLIED`
+
+ `TOO-MANY-ARGS-TO-PRIMTYPE-DECL` `<PRIMTYPE any ...>`
+
+ `TOO-MANY-ARGS-TO-SPECIAL-UNSPECIAL-DECL` `<SPECIAL any ...>`
+
+ `TOO-MANY-ARGUMENTS-SUPPLIED`
+
+ `TOP-LEVEL-FRAME` `<ERRET> <FRAME <FRAME <FRAME>>>$`
+
+ `TYPE-ALREADY-EXISTS` `NEWTYPE`
+
+ `TYPE-MISMATCH` attempt to make a value violate its
+ `DECL`
+
+ `TYPE-UNDEFINED`
+
+ `TYPES-DIFFER-IN-STORAGE-OBJECT` `ISTORAGE`
+
+ `TYPES-DIFFER-IN-UNIFORM-VECTOR` `![T <>]$`
+
+ `UNASSIGNED-VARIABLE`
+
+ `UNATTACHED-PATH-NAME-SEPARATOR` `!-$`
+
+ `UNBOUND-VARIABLE`
+
+ `UNMATCHED` `ENDBLOCK` with no matching `BLOCK`
+
+ `UVECTOR-PUT-TYPE-VIOLATION` `PUT`, `SETLOC`, `SUBSTRUC` in
+ compiled code
+
+ `VECTOR-LESS-THAN-2-ELEMENTS` `#DECL ((X) <LIST [REST]>)`
+
+ `WRONG-DIRECTION-CHANNEL` `<OPEN "MYFILE">$` (Mode missing or
+ misspelt.)
+
+ `WRONG-NUMBER-OF-ARGUMENTS`
+ ----------------------------------------------------------- ------------------------------------
+
+Appendix 5. Initial Settings
+============================
+
+The various switches and useful variables in MDL are initially set up
+with the following values:
+
+ <ACTIVATE-CHARS <STRING <ASCII 7> <ASCII 19> <ASCII 15>>>
+ ;"Tenex and Tops-20 versions only"
+ <DECL-CHECK T>
+ <UNASSIGN <GUNASSIGN DEV>>
+ <GC-MON <>>
+ <SET INCHAN <SETG INCHAN <OPEN "READ" "TTY:">>>
+ <UNASSIGN KEEP-FIXUPS>
+ <UNASSIGN <GUNASSIGN NM1>>
+ <UNASSIGN <GUNASSIGN NM2>>
+ <SET OBLIST <SETG OBLIST (<MOBLIST INITIAL 151> <ROOT>)>>
+ <SET OUTCHAN <SETG OUTCHAN <OPEN "PRINT" "TTY:">>>
+ <OVERFLOW T>
+ <UNASSIGN REDEFINE>
+ <RSUBR-LINK T>
+ <SETG <UNASSIGN SNM> "working-directory">
+ <SPECIAL-CHECK <>>
+ <SPECIAL-MODE UNSPECIAL>
+ <SET THIS-PROCESS <SETG THIS-PROCESS <MAIN>>>
+ <ON "CHAR" ,QUITTER 8 0 ,INCHAN>
+ <ON "IPC" ,IPC-HANDLER 1> ;"ITS version only"
+
+References
+==========
+
+Hewitt, Carl, _Planner: A Language for Manipulating Models and Proving Theorems in a Robot_,
+Proc. International Joint Conference on Artificial Intelligence, May 1969.
+
+Lebling, P. David, _The MDL Programming Environment_, Laboratory for Computer Science,
+M.I.T., 1979.
+
+Moon, David A., _MACLISP Reference Manual_, Laboratory for Computer Science, M.I.T., April
+1974.
+
+Topic Index
+===========
+
+Parenthesized words refer to other items in this index.
+
+ ----------------------------------- -----------------------------------
+ arguments `"OPTIONAL"` `"TUPLE"` `"ARGS"`
+ (parameter)
+
+ arithmetic `+` `-` `*` `/` `ABS` `EXP` `LOG`
+ `SIN` `COS` `ATAN` `MIN` `MAX`
+ `RANDOM` `0?` `1?` `==?` `L?` `G?`
+ `L=?` `G=?` `N==?`
+
+ array `VECTOR` `UVECTOR` `TUPLE` `STRING`
+ `BYTES` `TEMPLATE`
+
+ assignment `SET` `SETG` `DEFINE` `DEFMAC`
+ `ENVIRONMENT` (value parameter
+ binding)
+
+ binding `BOUND?` `GBOUND?` `ASSIGNED?`
+ `GASSIGNED?` `LEGAL?` (assignment
+ value parameter)
+
+ bits `WORD` `BITS` `PUTBITS` `GETBITS`
+ `BYTES` `ANDB` `ORB` `XORB` `EQVB`
+ `LSH` `ROT`
+
+ block `BIND` `PROG` `REPEAT` `BLOCK`
+ `ENDBLOCK` `OBLIST` `MOBLIST`
+ `OBLIST?` `!-`
+
+ boolean `FALSE` `COND` `AND` `AND?` `OR`
+ `OR?` `NOT` (comparison)
+
+ bugs (errors)
+
+ call `FORM` `APPLY` `APPLICABLE?` `EVAL`
+ `SEGMENT`
+
+ change `PUT-DECL` `PUTPROP` `SET` `SETG`
+ (side effect)
+
+ character `CHARACTER` `STRING` `ASCII`
+ `PRINC` `READCHR` `NEXTCHR`
+ `FLATSIZE` `LISTEN` `PARSE`
+ `LPARSE` `UNPARSE`
+
+ circular `PUTREST` `PUT` `LENGTH?`
+ `FLATSIZE`
+
+ comma `GVAL` `SETG`
+ ----------------------------------- -----------------------------------
+
+Name Index
+==========
+
+An underscored page number refers to a primary description: an unadorned
+page number refers to a secondary description.
+
+ ----------------------------------- -----------------------------------
+ `!"` [7.6.6]
+
+ `!$` **[1.2]**
+
+ `!,` **[7.7.1]**
+
+ `!-` **[15.3]**
+
+ `!-#FALSE ()` **[15.7.4]**
+
+ `!.` **[7.7.1]** [24.1.1]
+
+ `!<` **[7.7.1]** [24.1.1]
+
+ `!>` **[7.7.1]**
+
+ `![` **[7.2.3]**
+
+ `!\` **[7.6.6]** [11.1.2.3]
+
+ `!]` **[7.2.3]**
+
+ `"` [2.6.3.1] **[7.2.4]** [11.1.2.3]
+
+ `">"` **[11.2.1]**
+
+ `"ACT"` **[9.8]** [9.9]
+
+ `"ARGS"` **[9.5]** [9.9]
+
+ `"AUX"` **[9.3]** [9.9][] [11.2.7] [11.3]
+
+ `"BIND"` **[9.7]** [9.9]
+
+ `"BLOCKED"` [21.7.1] **[21.8.7]**
+
+ `"CALL"` **[9.6]** [9.9]
+
+ `"CHAR"` **[21.8]**
+
+ `"CLOCK"` **[21.8.6]**
+
+ `"DIVERT-AGC"` **[21.8.5]** [22.4]
+
+ `"DSK"` **[11.2.1]** [11.6.1]
+
+ `"ERROR"` **[21.8.11]**
+
+ `"EXTRA"` **[9.3]** [9.9]
+
+ `"GC"` **[21.8.4]**
+
+Official Distribution List
+==========================
+
+ Defense Documentation Center
+ Cameron Station
+ Alexandria, VA 22314
+ 12 copies
+
+ Office of Naval Research
+ Information Systems Program
+ Code 437
+ Arlington, VA 22217
+ 2 copies
+
+ Office of Naval Research
+ Branch Office/Boston
+ Building 114, Section D
+ 666 Summer Street
+ Boston, MA 02210
+ 1 copy
+
+ Office of Naval Research
+ Branch Office/Chicago
+ 536 South Clark Street
+ Chicago, IL 60605
+ 1 copy
+
+ Office of Naval Research
+ Branch Office/Pasadena
+ 1030 East Green Street
+ Pasadena, CA 91106
+ 1 copy
+
+ New York Area
+ 715 Broadway - 5th floor
+ New York, N. Y. 10003
+ 1 copy
+
+ Naval Research Laboratory
+ Technical Information Division
+ Code 2627
+ Washington, D. C. 20375
+ 6 copies
+
+ Assistant Chief for Technology
+ Office of Naval Research
+ Code 200
+ Arlington, VA 22217
+ 1 copy
+
+ Office of Naval Research
+ Code 455
+ Arlington, VA 22217
+ 1 copy
+
+ Dr. A. L. Slafkosky
+ Scientific Advisor
+ Commandant of the Marine Corps
+ (Code RD-1)
+ Washington, D. C. 20380
+ 1 copy
+
+ Office of Naval Research
+ Code 458
+ Arlington, VA 22217
+ 1 copy
+
+ Naval Ocean Systems Center
+ Advanced Software Techonolgy
+ Division - Code 5200
+ San Diego, CA 92152
+ 1 copy
+
+ Mr. E. H. Gleissner
+ Naval Ship Research & Development Center
+ Computation & Math Department
+ Bethesda, MD 20084
+ 1 copy
+
+ Captain Grace M. Hopper (008)
+ Naval Data Automation Command
+ Washington Navy Yard
+ Building 166
+ Washington, D. C. 20374
+ 1 copy
+
+ Mr. Kin B. Thompson
+ Technical Director
+ Information Systems Division
+ (OP-91T)
+ Office of Chief of Naval Operations
+ Washington, D. C. 20350
+ 1 copy
+
+ Captain Richard L. Martin, USN
+ Commanding Officer
+ USS Francis Marion (LPA-249)
+ FPO New York, N. Y. 09501
+ 1 copy
\ No newline at end of file
projects / mudman.git / blobdiff