Fix typos and add rest of document master
authorJason Self <j@jxself.org>
Sat, 16 Apr 2022 03:44:46 +0000 (20:44 -0700)
committerJason Self <j@jxself.org>
Sat, 16 Apr 2022 03:44:46 +0000 (20:44 -0700)
md/language.md

index fa5b46940dfad634bc5fe342c77b5a295ce44818..333242371b7cee1cdf709ec461a453b76498286a 100644 (file)
@@ -2479,7 +2479,7 @@ The representation of an object of `TYPE` `SEGMENT` is the following:
 
     !< 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`.
@@ -2500,7 +2500,7 @@ the following three exceptions:
 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!]
@@ -3148,7 +3148,7 @@ However, the desired effect could be achieved by
 
     <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
@@ -3719,7 +3719,7 @@ does the following:
     *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>
 
@@ -4099,8 +4099,8 @@ This `SUBR` is especially useful in conjunction with (section 11.2.8)
 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
@@ -4277,6 +4277,10 @@ each element, and an interpretation. The format used is the following:
 
 *element-number: type interpretation*
 
+#### 11.2.8.1. Output CHANNELs
+
+The contents of a CHANNEL used for output are as follows:
+
   -------------------------------------------------------------------------------------
   element-number   type          interpretation
   ---------------- ------------- ------------------------------------------------------
@@ -4442,7 +4446,7 @@ outputs the real thing: that ASCII character whose ASCII 7-bit code is
 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
@@ -4733,8 +4737,8 @@ input is available, `READCHR` returns `-1`, `TYPE` `FIX`. If the
 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>
 
@@ -5576,7 +5580,7 @@ to date several instances of the full `DECL`.
 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
@@ -6036,7 +6040,7 @@ a different element of the `LIST` of `OBLIST`s for new insertions. If
 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
@@ -6172,7 +6176,7 @@ ATOM. If there is no such `ATOM`, `REMOVE` returns `#FALSE ()`. Also,
 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>
 
@@ -6221,7 +6225,7 @@ systematic way to accomplish the same thing and more.
 
     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
@@ -6232,12 +6236,10 @@ systematic way to accomplish the same thing and more.
         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
@@ -6350,6 +6352,7 @@ at least two arguments, including:
     `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)
@@ -6364,22 +6367,22 @@ A `FRAME` is an anomalous `TYPE` in the following ways:
 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>
 
@@ -6390,7 +6393,7 @@ arguments, `FRAME` returns the topmost `FRAME` used in an application
 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,
@@ -6403,6 +6406,7 @@ loop and get things `EVAL`ed. For example,
     the-arguments-to-the-Subroutine-which-called-ERROR:tuple
 
 16.4. ERRET
+-----------
 
     <ERRET any frame>
 
@@ -6454,6 +6458,7 @@ dummy variables while still in the error state. For example,
     ("a string" (5))
 
 16.5. RETRY
+-----------
 
     <RETRY frame>
 
@@ -6468,6 +6473,7 @@ the `EVAL` of a `FORM` that makes an `ACTIVATION`, it will cause
 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
@@ -6489,6 +6495,7 @@ the `FLOAD`. Example:
                 <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
@@ -6498,6 +6505,7 @@ 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
 is happening and return to the `FRAME` `.LERR\ !-INTERRUPTS`,
@@ -6505,6 +6513,7 @@ returning the `ATOM` `T`. (In the Tenex and Tops-20 versions, `^O`
 also has the same effect.)
 
 16.9. OVERFLOW
+--------------
 
     <OVERFLOW false-or-any>
 
@@ -8193,17 +8202,17 @@ arguments: the locative, the new value, and the `FRAME`. For example:
     <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>$
@@ -8236,7 +8245,7 @@ the normal `ERROR`.
 
 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"
 
@@ -8559,8 +8568,8 @@ becomes full, Muddle goes through the following procedure:
     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>
 
@@ -8757,8 +8766,8 @@ 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.
 
-22.9.2 PURIFY
--------------
+22.9.2. PURIFY
+--------------
 
     <PURIFY any-1 ... any-N>
 
@@ -9402,7 +9411,7 @@ 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 Patttern `ANY` is recognized as a
+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
@@ -9884,3 +9893,2532 @@ 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