From 764b6507e1bd87e9141dd58de039cb91e319c55c Mon Sep 17 00:00:00 2001 From: Jason Self Date: Fri, 15 Apr 2022 20:44:46 -0700 Subject: [PATCH] Fix typos and add rest of document --- md/language.md | 2604 +++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 2571 insertions(+), 33 deletions(-) diff --git a/md/language.md b/md/language.md index fa5b469..3332423 100644 --- a/md/language.md +++ b/md/language.md @@ -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\] $ ![2 3 4!] @@ -3148,7 +3148,7 @@ However, the desired effect could be achieved by ) (C )) ...> -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\] @@ -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 +-------------------- @@ -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 @@ -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." )> ;"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." - ) - >> ;"All other ATOMs are found in the - ROOT." + >> ;"All other ATOMs are found in the ROOT." 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 ("arguments") returns the argument `TUPLE` of *frame*. -16.3.2. FUNCT +### 16.3.2. FUNCT -("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) @@ -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 +----------- @@ -6454,6 +6458,7 @@ dummy variables while still in the error state. For example, ("a string" (5)) 16.5. RETRY +----------- @@ -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: >)>> 16.7. Control-G (\^G) +--------------------- Typing control-G (`^G`, ``) 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`, ``) 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 +-------------- @@ -8193,17 +8202,17 @@ arguments: the locative, the new value, and the `FRAME`. For example: >$ #LOCL 2 - + > 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 +-------- @@ -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 +-------------- @@ -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, `` 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) + (FACTORS) ]>) + +multiplies all arguments together (arithmetic) + + + ("TUPLE" TERMS) + #DECL ((VALUE) + (TERMS) ]>) + +adds all arguments together (arithmetic) + + - ("OPTIONAL" MINUEND "TUPLE" SUBTRAHENDS) + #DECL ((VALUE) + (MINUEND) + (SUBTRAHENDS) ]>) + +subtracts other arguments from first argument (arithmetic) + + / ("OPTIONAL" DIVIDEND "TUPLE" DIVISORS) + #DECL ((VALUE) + (DIVIDEND) + (DIVISORS) ]>) + +divides first argument by other arguments (arithmetic) + + 0? (NUMBER) + #DECL ((VALUE) + (NUMBER) ) + +tells whether a number is zero (predicate) + + 1? (NUMBER) + #DECL ((VALUE) + (NUMBER) ) + +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) + (OBJECT-1 OBJECT-2) ANY) + +tells whether two objects are "exactly" equal (predicate) + + =? (OBJECT-1 OBJECT-2) + #DECL ((VALUE) + (OBJECT-1 OBJECT-2) ANY) + +tells whether two objects are "structurally" equal (predicate) + + ABS (NUMBER) + #DECL ((VALUE) + (NUMBER) ) + +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) ) + +returns the `VECTOR` of all type names + + AND ("ARGS" ARGS) + #DECL ((VALUE) + (ARGS) LIST) + +computes logical "and" of truth-values, evaluated by the Subroutine + + AND? ("TUPLE" TUPLE) + #DECL ((VALUE) + (TUPLE) TUPLE) + +computes logical "and" of truth-values, evaluated at call time + + ANDB ("TUPLE" WORDS) + #DECL ((VALUE) WORD + (WORDS) ]>) + +computes bitwise "and" of machine words + + APPLICABLE? (OBJECT) + #DECL ((VALUE) + (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) + (TYPE) ATOM (HOW) ) + +specifies or returns how a data type is applied + + ARGS (CALL) + #DECL ((VALUE) TUPLE + (CALL) ) + +returns arguments of a given un-returned Subroutine call + + ASCII (CODE-OR-CHARACTER) + #DECL ((VALUE) + (CODE-OR-CHARACTER) ) + +returns `CHARACTER` with given ASCII code or vice versa + + ASSIGNED? (ATOM "OPTIONAL" ENV) + #DECL ((VALUE) + (ATOM) ATOM (ENV) ) + +tells whether an `ATOM` has a local value (predicate) + + ASSOCIATIONS () + #DECL ((VALUE) ) + +returns the first object in the association chain + + AT (STRUCTURED "OPTIONAL" (N 1)) + #DECL ((VALUE) LOCATIVE + (STRUCTURED) STRUCTURED (N) ) + +returns a locative to the Nth element of a structure + + ATAN (NUMBER) + #DECL ((VALUE) FLOAT + (NUMBER) ) + +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) + (N) FIX + (STRUCTURE) + + + >) + +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) ) + +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) + (STATS) ) + +gives garbage-collector and storage statistics + + BLOCK (LOOK-UP) + #DECL ((VALUE LOOK-UP) ]>>) + +`SET`s `OBLIST` for looking up `ATOM`s during `READ`ing and `PARSE`ing + + BOUND? (ATOM "OPTIONAL" ENV) + #DECL ((VALUE) + (ATOM) ATOM (ENV) ) + +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) ) + +creates a byte-string from explicit arguments + + CHANLIST () + #DECL ((VALUE) ) + +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) + (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) ) + +"binds" the free variables of a `FUNCTION` to current values + + COND ("ARGS" CLAUSES) + #DECL ((VALUE) ANY + (CLAUSES) > [REST >]>) + +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) ) + +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) + (SWITCH) ) + +enables or disables type-declaration checking + + DECL? (OBJECT PATTERN) + #DECL ((VALUE) + (OBJECT) ANY (PATTERN) ) + +tells whether an object matches a type declaration (predicate) + + DEFINE ('NAME "ARGS" ARGS) + #DECL ((VALUE) ATOM + (NAME) ANY (ARGS) ) + +sets the global value of an `ATOM` to a `FUNCTION` + + DEFMAC ('NAME "ARGS" ARGS) + #DECL ((VALUE) ATOM + (NAME) ANY (ARGS) ) + +sets the global value of an `ATOM` to a `MACRO` + + DEMSIG (NAME) + #DECL ((VALUE) + (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) + (OBJECT) STRUCTURED) + +tells whether a structure has zero elements (predicate) + + ENABLE (INTERRUPT) + #DECL ((VALUE INTERRUPT) IHEADER) + +enables an interrupt + + ENDBLOCK () + #DECL ((VALUE) ]>>) + +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) ]>) + +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) ) + +evaluates an expression in a given environment + + EVALTYPE (TYPE "OPTIONAL" HOW) + #DECL ((VALUE) + (TYPE) ATOM (HOW) ) + +specifies or returns how a data type is evaluated + + EVENT (NAME "OPTIONAL" PRIORITY WHICH) + #DECL ((VALUE) IHEADER + (NAME) (PRIORITY) FIX (WHICH) ) + +sets up an interrupt + + EXP (NUMBER) + #DECL ((VALUE) FLOAT + (NUMBER) ) + +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) > + (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) ) + +returns integer part of a number (arithmetic) + + FLATSIZE (ANY MAX "OPTIONAL" (RADIX 10)) + #DECL ((VALUE) + (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) ) + +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) ) + +returns a previous Subroutine call + + FREE-RUN (PROCESS) + #DECL ((VALUE) + (PROCESS) PROCESS) + +causes a `PROCESS` to leave single-step mode + + FREEZE (STRUCTURE) + #DECL ((VALUE) + (STRUCTURE) + >) + +makes copy of argument in non-moving garbage-collected space + + FUNCT (FRAME) + #DECL ((VALUE) ATOM + (FRAME) ) + +returns Subroutine name of a given previous Subroutine call + + FUNCTION ("ARGS" ARGS) + #DECL ((VALUE) FUNCTION + (ARGS) ) + +creates a `FUNCTION` + + G=? (NUMBER-1 NUMBER-2) + #DECL ((VALUE) + (NUMBER-1 NUMBER-2) ) + +tells whether first argument is greater than or equal to second +(predicate) + + G? (NUMBER-1 NUMBER-2) + #DECL ((VALUE) + (NUMBER-1 NUMBER-2) ) + +tells whether first argument is greater than second (predicate) + + GASSIGNED? (ATOM) + #DECL ((VALUE) + (ATOM) ATOM) + +tells whether an `ATOM` has a global value (predicate) + + GBOUND? (ATOM) + #DECL ((VALUE) + (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?) ) + +causes a garbage collection and changes garbage-collection parameters + + GC-DUMP (ANY PRINTB) + #DECL ((VALUE) >> + (ANY) ANY (PRINTB) ) + +dumps an object so that it can be reproduced exactly + + GC-MON ("OPTIONAL" SWITCH) + #DECL ((VALUE) + (SWITCH) ) + +turns garbage-collection monitoring off or on + + GC-READ (READB "OPTIONAL" (EOF-ROUTINE ')) + #DECL ((VALUE) ANY + (READB) CHANNEL (EOF-ROUTINE) ANY) + +inputs an object that was previously `GC-DUMP`ed + + GDECL ("ARGS" ARGS) + #DECL ((VALUE) ANY + (ARGS) ]>) + +declares the type/structure of the global value of `ATOM`s + + GET (ITEM INDICATOR "OPTIONAL" (IF-NONE <>)) + #DECL ((VALUE) ANY + (ITEM) (INDICATOR) (IF-NONE) ANY) + +does `NTH` or `GETPROP` + + GET-DECL (ATOM-OR-OFFSET) + #DECL ((VALUE) + (ATOM-OR-OFFSET) ) + +gets the type declaration for an `ATOM`'s value or an `OFFSET` + + GETBITS (FROM FIELD) + #DECL ((VALUE) WORD + (FROM) > (FIELD) BITS) + +returns a bit field of a machine word or `STORAGE` address + + GETL (ITEM INDICATOR "OPTIONAL" (IF-NONE <>)) + #DECL ((VALUE) + (ITEM) (INDICATOR) (IF-NONE) ANY) + +does `AT` or `GETPL` + + GETPL (ITEM INDICATOR "OPTIONAL" (IF-NONE <>)) + #DECL ((VALUE) + (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) ) + +returns a locative to the global-value cell of an `ATOM` + + GO (LABEL) + #DECL ((VALUE) ANY + (LABEL) ) + +goes to a label and continues evaluation from there + + GROW (U/VECTOR END BEG) + #DECL ((VALUE) > + (U/VECTOR) > (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) (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) (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) + (NAME) (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 ) (MY-NAME-2 )) + #DECL ((VALUE) 'T + (BODY) (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 ) (MY-NAME-2 )) + #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) + (NUMBER-1 NUMBER-2) ) + +tells whether first argument is less than or equal to second +(predicate) + + L? (NUMBER-1 NUMBER-2) + #DECL ((VALUE) + (NUMBER-1 NUMBER-2) ) + +tells whether first argument is less than second (predicate) + + LEGAL? (STACK-OBJECT) + #DECL ((VALUE) + (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) + (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) ) + +returns a locative to the local-value cell of an `ATOM` + + LOAD (CHANNEL "OPTIONAL" (LOOK-UP .OBLIST)) + #DECL ((VALUE) '"DONE" + (LOOK-UP) ]>>) + +reads and evaluates all objects via an input `CHANNEL` + + LOCATIVE? (OBJECT) + #DECL ((VALUE) + (OBJECT) ANY) + +tells whether an object is a locative (predicate) + + LOG (NUMBER) + #DECL ((VALUE) FLOAT + (NUMBER) ) + +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) + (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) ]>>) + +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) (AMOUNT) FIX) + +shifts bits in a machine word + + LVAL (ATOM "OPTIONAL" ENV) + #DECL ((VALUE) ANY + (ENV) ) + +returns the local value of an `ATOM` + + MAIN () + #DECL ((VALUE) PROCESS) + +returns `#PROCESS 1` (the main `PROCESS`) + + MANIFEST ("TUPLE" ATOMS) + #DECL ((VALUE) 'T + (ATOMS) ) + +declares the global values of `ATOM`s to be constant + + MANIFEST? (ATOM) + #DECL ((VALUE) + (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) (LOOP-FCN) APPLICABLE + (STRUCTURES) ) + +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) (LOOP-FCN) APPLICABLE + (STRUCTURES) ) + +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) + (NUMBERS) ]>) + +returns the greatest of its arguments (arithmetic) + + ME () + #DECL ((VALUE) PROCESS) + +returns the current `PROCESS` + + MEMBER (OBJECT STRUCTURE) + #DECL ((VALUE) + (OBJECT) ANY (STRUCTURE) STRUCTURED) + +tells whether an object is "structurally" equal to some element of a +structure (predicate) + + MEMQ (OBJECT STRUCTURE) + #DECL ((VALUE) + (OBJECT) ANY (STRUCTURE) STRUCTURED) + +tells whether an object is "exactly" equal to some element of a +structure (predicate) + + MIN ("TUPLE" NUMBERS) + #DECL ((VALUE) + (NUMBERS) ]>) + +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) + (OBJECT) ANY) + +tells whether an object is either unstructured or an empty structure +(predicate) + + N==? (OBJECT-1 OBJECT-2) + #DECL ((VALUE) + (OBJECT-1 OBJECT-2) ANY) + +tells whether two objects are NOT "exactly" equal (predicate) + + N=? (OBJECT-1 OBJECT-2) + #DECL ((VALUE) + (OBJECT-1 OBJECT-2) ANY) + +tells whether two objects are NOT "structurally" equal (predicate) + + NETACC (CHANNEL) + #DECL ((VALUE) + (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) + (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) ) + +defines a new data type + + NEXT (ASSOCIATION) + #DECL ((VALUE) + (ASSOCIATION) ASOC) + +returns the next object in the association chain + + NEXTCHR ("OPTIONAL" (CHANNEL .INCHAN) (EOF-ROUTINE ')) + #DECL ((VALUE) + (CHANNEL) CHANNEL (EOF-ROUTINE) ANY) + +returns the character that will next be read via an input `CHANNEL` + + NOT (OBJECT) + #DECL ((VALUE) + (OBJECT) ) + +computes logical "not" of a truth-value + + NTH (STRUCTURED "OPTIONAL" N) + #DECL ((VALUE) ANY + (N) ) + +fetches the Nth element of a structure + + OBLIST? (ATOM) + #DECL ((VALUE) + (ATOM) ATOM) + +returns an `ATOM`'s `OBLIST` or false if none (predicate) + + OFF (INTERRUPT "OPTIONAL" WHICH) + #DECL ((VALUE) + (INTERRUPT) (WHICH) ) + +removes an interrupt `HANDLER` or destroys an interrupt + + OFFSET (N PATTERN) + #DECL ((VALUE) OFFSET + (N) FIX (PATTERN) ) + +creates an integer with attached type declaration + + ON (NAME APPLICABLE PRIORITY "OPTIONAL" (PROCESS 0) WHICH) + #DECL ((VALUE) HANDLER + (NAME) (APPLICABLE) APPLICABLE (PRIORITY) FIX + (PROCESS) (WHICH) ) + +turns on an interrupt and creates an interrupt `HANDLER` + + OPEN ("OPTIONAL" (MODE "READ") "TUPLE" FILE-NAME) + #DECL ((VALUE) > + (MODE) STRING (FILE-NAME) TUPLE) + +creates and opens an I/O `CHANNEL` + + OPEN-NR ("OPTIONAL" (MODE "READ") "TUPLE" FILE-NAME) + #DECL ((VALUE) > + (MODE) STRING (FILE-NAME) TUPLE) + +creates and opens an I/O `CHANNEL` without changing file's reference +date + + OR ("ARGS" ARGS) + #DECL ((VALUE) + (ARGS) LIST) + +computes logical inclusive "or" of truth-values, evaluated by the +Subroutine + + OR? ("TUPLE" TUPLE) + #DECL ((VALUE) + (TUPLE) TUPLE) + +compares logical inclusive "or" of truth-values, evaluated at call +time + + ORB ("TUPLE" WORDS) + #DECL ((VALUE) WORD + (WORDS) ]>) + +computes bitwise inclusive "or" of machine words + + OVERFLOW ("OPTIONAL" SWITCH) + #DECL ((VALUE) + (SWITCH) ) + +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) ]>>) + +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) < [REST ]> + (CHANNEL) CHANNEL) + +writes binary information via an output `CHANNEL` + + PRINTSTRING (BUFFER "OPTIONAL" (CHANNEL .OUTCHAN) (COUNT )) + #DECL ((VALUE COUNT) FIX + (BUFFER) STRING (CHANNEL) CHANNEL) + +writes contents of a `STRING` via an output `CHANNEL` + + PRINTTYPE (TYPE "OPTIONAL" HOW) + #DECL ((VALUE) + (TYPE) ATOM (HOW) ) + +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) ) + +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) (INDICATOR) (VAL) ANY) + +stores into structure or does `PUTPROP` + + PUT-DECL (IDENTIFIER PATTERN) + #DECL ((VALUE IDENTIFIER) + (PATTERN) ) + +changes the type declaration for an `ATOM`'s value or an `OFFSET` + + PUTBITS (TO FIELD "OPTIONAL" (FROM 0)) + #DECL ((VALUE) + (TO FROM) (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) + (TAIL) ) + +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 ') (LOOK-UP .OBLIST) READ-TABLE) + #DECL ((VALUE) ANY + (CHANNEL) CHANNEL (EOF-ROUTINE) ANY (READ-TABLE) VECTOR + (LOOK-UP) ]>>) + +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 ')) + #DECL ((VALUE) FIX + (BUFFER) < [REST ]> + (CHANNEL) CHANNEL (EOF-ROUTINE) ANY) + +reads binary information via an input `CHANNEL` + + READCHR ("OPTIONAL" (CHANNEL .INCHAN) (EOF-ROUTINE ')) + #DECL ((VALUE) + (CHANNEL) CHANNEL (EOF-ROUTINE) ANY) + +reads one character via an input `CHANNEL` + + READSTRING (BUFFER "OPTIONAL" (CHANNEL .INCHAN) (STOP ) + (EOF-ROUTINE ')) + #DECL ((VALUE) FIX + (BUFFER) STRING (CHANNEL) CHANNEL (STOP) (EOF-ROUTINE) ANY) + +reads into a `STRING` via an input `CHANNEL` + + REALTIMER ("OPTIONAL" INTERVAL) + #DECL ((VALUE) + (INTERVAL) ) + +sets or fetches interval for real-time interrupts (ITS version only) + + REMOVE (PNAME "OPTIONAL" OBLIST) + #DECL ((VALUE) + (PNAME) (OBLIST) OBLIST) + +removes an `ATOM` from an `OBLIST` + + RENAME ("TUPLE" FILE-NAME/S) + #DECL ((VALUE) > + (FILE-NAME/S) >) + +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) ) + +executes sequential expressions repeatedly + + RESET (CHANNEL) + #DECL ((VALUE) > + (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 )) + #DECL ((VALUE) ANY + (VAL) ANY (PROCESS) PROCESS) + +transfers execution to another `PROCESS` + + RESUMER ("OPTIONAL" (PROCESS )) + #DECL ((VALUE) + (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) ) + +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) (AMOUNT) FIX) + +rotates bits in a machine word + + RSUBR (CANDIDATE) + #DECL ((VALUE) RSUBR + (CANDIDATE) ATOM DECL [REST ANY]>) + +creates an `RSUBR` + + RSUBR-ENTRY (CANDIDATE OFFSET) + #DECL ((VALUE) RSUBR-ENTRY + (CANDIDATE) ATOM DECL> (OFFSET) FIX) + +adds an entry point to an `RSUBR` + + RSUBR-LINK ("OPTIONAL" SWITCH) + #DECL ((VALUE) + (SWITCH) ) + +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) + (INTERVAL) ) + +sets or fetches interval for run-time interrupt (ITS version only) + + SAVE ("TUPLE" FILE-NAME-AND-GC?) + #DECL ((VALUE) '"SAVED" + (FILE-NAME-AND-GC?) ]>) + +writes the entire state of MDL to a file + + SEND (OTHER-NAME-1 OTHER-NAME-2 BODY + "OPTIONAL" (TYPE 0) (MY-NAME-1 ) (MY-NAME-2 )) + #DECL ((VALUE) + (OTHER-NAME-1 OTHER-NAME-2 MY-NAME-1 MY-NAME-2) STRING (TYPE) FIX + (BODY) ]>>) + +sends an IPC message (ITS version only) + + SEND-WAIT (OTHER-NAME-1 OTHER-NAME-2 BODY + "OPTIONAL" (TYPE 0) (MY-NAME-1 ) (MY-NAME-2 )) + #DECL ((VALUE) 'T + (OTHER-NAME-1 OTHER-NAME-2 MY-NAME-1 MY-NAME-2) STRING (TYPE) FIX + (BODY) ]>>) + +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) ) + +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) ) + +returns sine of a number (arithmetic) + + SLEEP ( "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) > + (PRED) (RECORD-LENGTH KEY-OFFSET) FIX + (OTHER-STRUCS-AND-RECORD-LENGTHS) + > FIX]>) + +sorts elements of a structure and rearranges other structures + + SPECIAL-CHECK ("OPTIONAL" SWITCH) + #DECL ((VALUE) + (SWITCH) ) + +turns interpreter special-checking on or off + + SPECIAL-MODE ("OPTIONAL" SWITCH) + #DECL ((VALUE) + (SWITCH) ) + +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) ) + +returns square root of a number (arithmetic) + + SQUOTA (SYMBOL) + #DECL ((VALUE) + (SYMBOL) ) + +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) + (STRING-1 STRING-2) ) + +compares two character-strings or two print-names + + STRING ("TUPLE" ELEMENTS) + #DECL ((VALUE) STRING + (ELEMENTS) ]>) + +creates a character-string from explicit arguments + + STRUCTURED? (OBJECT) + #DECL ((VALUE) + (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 <- .REST>) TO) + #DECL ((VALUE TO) + (FROM) + > + (REST AMOUNT) FIX) + +copies (part of) a structure into another + + SUICIDE (VAL "OPTIONAL" (PROCESS )) + #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) + (STRUCTURE) + + >) + +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) ) + +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) ) + +makes a data-type machine word for pure-program use + + TYPE? (OBJECT "TUPLE" TYPES) + #DECL ((VALUE) + (OBJECT) ANY (TYPES) ) + +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) ) + +causes an `ATOM` to have no local value + + UNMANIFEST ("TUPLE" ATOMS) + #DECL ((VALUE) 'T + (ATOMS) ) + +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) ) + +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) + (TYPE) ATOM) + +tells whether an `ATOM` is the name of a type (predicate) + + VALRET (MESSAGE) + #DECL ((VALUE) '#FALSE () + (MESSAGE) ) + +passes a message to the superior operating-system process + + VALUE (ATOM "OPTIONAL" ENV) + #DECL ((VALUE) ANY + (ATOM) ATOM (ENV) ) + +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) ]>) + +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` `$` Second argument to + `NTH` or `REST` too big or small. + + `ATOM-ALREADY-THERE` `>$` + `>$` + + `ATOM-NOT-TYPE-NAME-OR-SPECIAL-SYMBOL` `DECL` problem + + `ATOM-ON-DIFFERENT-OBLIST` `INSERT`, `LINK`, `REMOVE` + + `ATTEMPT-TO-BREAK-OWN-SEQUENCE` `>$` + + `ATTEMPT-TO-CHANGE-MANIFEST-VARIABLE` + + `ATTEMPT-TO-CLOSE-TTY-CHANNEL` `$` + + `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` ` 1 !\T>$` + + `ATTEMPT-TO-MUNG-PURE-STRUCTURE` attempt to write into pure page + + `ATTEMPT-TO-SUICIDE-TO-SELF` `>$` + + `BAD-ARGUMENT-LIST` `$` + + `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` `>` + + `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` `$` + + `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` `$` + + `CAN\'T-PARSE` `$` `$` + + `CHANNEL-CLOSED` `>$` + + `CONTROL-G?` `^G` + + `COUNT-GREATER-THAN-STRING-SIZE` `$` + + `DANGEROUS-INTERRUPT-NOT-HANDLED` (See section 21.8.15.) (ITS version + only) + + `DATA-CANT-GO-IN-UNIFORM-VECTOR` `!["STRING"]$` `![]$` + + `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 `` in `DECL` + + `EMPTY-STRING` `$` + + `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) )` + + `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` ` 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` ` >$` + + `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` `` 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` `` 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` `$` `$` + + `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` `>$` + + `OUT-OF-BOUNDS` `<1 '()>$` `BLOAT` argument too + large + + `OVERFLOW` `$` `<* 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` `$` + `$` + + `STRUCTURE-CONTAINS-UNDUMPABLE-TYPE` ` <>>$` + + `SUBSTITUTE-TYPE-FOR-TYPE` `$` + + `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` `` + + `TOO-MANY-ARGS-TO-SPECIAL-UNSPECIAL-DECL` `` + + `TOO-MANY-ARGUMENTS-SUPPLIED` + + `TOP-LEVEL-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) )` + + `WRONG-DIRECTION-CHANNEL` `$` (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: + + >> + ;"Tenex and Tops-20 versions only" + + > + > + >> + + > + > + )>> + >> + + + + "working-directory"> + > + + >> + + ;"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 -- 2.31.1