I was not a member of the original group which labored for two years
in the design and initial implementation of Muddle; that group was
-composed principally of Gerald Sussman, Carl Hewit, Chris Reeve, Dave
+composed principally of Gerald Sussman, Carl Hewitt, Chris Reeve, Dave
Cressey, and later Bruce Daniels. I would therefore like to take this
opportunity to thank my Muddle mentors, chiefly Chris Reeve and Bruce
Daniels, for remaining civil through several months of verbal
`ROOT`. A metasyntactic variable -- something to be replaced in actual
use by something else -- appears as *radix:fix*, in an italic font;
often the variable will have both a meaning and a data type (as here),
-but sometimes one of those will be ommitted, for obvious reasons.
+but sometimes one of those will be omitted, for obvious reasons.
An ellipsis (...) indicates that something uninteresting has been
omitted. The character `^` means that the following character is to be
done, the result will be printed and Muddle will wait for more typing.
`ESC` will be represented by the glyph `$` in this document.
-Typing the rubout character (`DEL` in the ITS and Top-20 versions,
+Typing the rubout character (`DEL` in the ITS and Tops-20 versions,
`CTRL`+`A` in the Tenex version) causes the last character in the
buffer -- the one most recently typed -- to be thrown away (deleted).
If you now immediately type another rubout, once again the last
effect (in the absence of errors), and the intention is more apparent.
\[Note: if `.L` is a `LIST`, `<LIST !.L>` makes a copy of `.L` whereas
`(!.L)` doesn't; see section 7.7.\] `STRING`, on the other hand,
-produces effect very different from literal `STRING`s.
+produces effects very different from literal `STRING`s.
Examples:
respect to typing in carriage-return, in that it automatically adds a
line-feed. In order to type in a lone carriage-return, a
carriage-return followed by a rubout must be typed. Also `PRINT`,
-`PRINT1` and `PRINC` do not automatically add a line-feed when a
+`PRIN1` and `PRINC` do not automatically add a line-feed when a
carriage-return is output. This enables overstriking on a terminal
that lacks backspacing capability. It also means that what goes on a
terminal and what goes in a file are more likely to look the same.
produces objects of `TYPE` `LOCR` instead of `LOCD`.
19.5. TYPE-C and TYPE-W
-=======================
+-----------------------
In order to handle user `NEWTYPE`s reasonably, the internal `TYPE`
codes for them have to be able to be different from one Muddle run to
`FIX` which determines which interrupts can really "interrupt" -- that
is, cause the current processing to be suspended while their wants are
satisfied. Normal, non-interrupt programs operate at an interrupt
-level of 0 (zero.) An interrupt is processed at an interrupt level
+level of 0 (zero). An interrupt is processed at an interrupt level
equal to the interrupt's priority.
### 21.7.1. Interrupt Processing
priority than the target priority have been processed.
Setting the `INT-LEVEL` extremely high (for example,
-`<INT-LEVEL <CHTPE <MIN> FIX>>`) effectively disables all interrupts
+`<INT-LEVEL <CHTYPE <MIN> FIX>>`) effectively disables all interrupts
(but occurrences of enabled interrupts will still be queued).
If `LISTEN` or `ERROR` is called when the `INT-LEVEL` is not zero,
then the typeout will be
- LISTENING-AT-LEVEL I PROCESS p INT-LEVEL i
+ LISTENING-AT-LEVEL l PROCESS p INT-LEVEL i
### 21.7.3. DISMISS
interrupt, and the mode of the `CHANNEL` tells what kinds of `"CHAR"`
interrupts occur to be handled through that `IHEADER`.
-1. If the `CHANNEL` is for `INPUT`, "CHAR" occurs every time an
+1. If the `CHANNEL` is for `INPUT`, `"CHAR"` occurs every time an
"interesting" character (see below) is received from the
`CHANNEL`'s real terminal, or any character is received from the
`CHANNEL`'s pseudo-terminal, or a character or word is received
In the ITS version, the "interesting" characters are those "enabled
for interrupts" on a real terminal, namely `^@` through `^G`, `^K`
through `^_`, and `DEL` (that is, ASCII codes 0-7, 13-37, and 177
-octal.)
+octal).
In the Tenex and Tops-20 versions, the operating system can be told
which characters typed on a terminal should cause this interrupt to
friends). An interrupt occurs when a character is available for input.
These interrupts are set up in exactly the same way as real-terminal
interrupts, except that a handler gets applied to only **one**
-argument, the `CHANNEL`. Pseudo-terminal are not available in the
+argument, the `CHANNEL`. Pseudo-terminals are not available in the
Tenex and Tops-20 versions.
For any other flavor of ITS channel interrupt, a handler gets applied
a deferrable garbage collection that is needed because of exhausted
movable garbage-collected storage. Enabling this interrupt is the only
way a program can know that a garbage collection is about to occur. A
-handler takes two arguments: A `FIX` telling the number of machine
+handler takes two arguments: a `FIX` telling the number of machine
words needed and an `ATOM` telling what initiated the garbage
collection (see above). If it wishes, a handler can try to prevent a
garbage collection by calling `BLOAT` with the `FIX` argument. If the
### 21.8.6. "CLOCK"
`"CLOCK"`, when enabled, occurs every half second (the ITS
-"slow-clock" tick.) It is not available in the Tenex or Tops-20
+"slow-clock" tick). It is not available in the Tenex or Tops-20
versions. It wants handlers which take no arguments. Example:
<ON "CLOCK" <FUNCTION () <PRINC "TICK ">> 1>
### 21.8.8. "UNBLOCKED"
`"UNBLOCKED"` occurs whenever a `$` (`ESC`) is typed on a terminal if
-a program was hanging and waiting for input, or when a TYI call (which
-see) is satisfied. A handler takes one argument: the `CHANNEL` via
-which the `$` or character is input.
+a program was hanging and waiting for input, or when a `TYI` call
+(which see) is satisfied. A handler takes one argument: the `CHANNEL`
+via which the `$` or character is input.
### 21.8.9. "READ" and "WRITE"
handler takes one argument: A `FIX` between `0` and `7` inclusive,
telling which inferior process is interrupting.
-### 21.8.14. "RUNT and "REALT"
+### 21.8.14. "RUNT" and "REALT"
These are not available in the Tenex and Tops-20 versions.
`"MPV"` ("memory protection violation") occurs if Muddle tries to
refer to a storage address not in its address space. `"PURE"` occurs
if Muddle tries to alter read-only storage. `"ILOPR"` occurs if Muddle
-executes and illegal instruction ("operator"). `"PARITY"` occurs if
+executes an illegal instruction ("operator"). `"PARITY"` occurs if
the CPU detects a parity error in Muddle's address space. All of these
require a handler that takes one argument: the address (`TYPE` `WORD`)
following the instruction that was being executed at the time.
interrupt goes to the superior operating system process.
- If an `IHEADER` is associated but disabled, the error
`DANGEROUS-INTERRUPT-NOT-HANDLED` occurs (`FILE-SYSTEM-ERROR` for
- \`"IOC").
+ `"IOC"`).
- If an `IHEADER` is associated and enabled, but the `INT-LEVEL` is
too high, the error `ATTEMPT-TO-DEFER-UNDEFERABLE-INTERRUPT`
occurs.
Most storage used explicitly by Muddle programs is obtained from a
pool of free storage managed by a "garbage collector". Storage is
-obtained from this pool by the `SUBR`s which construct objects. When a
-`SUBR` finds that the pool of available storage is exhausted, it
-automatically calls the garbage collector.
+obtained from this pool by the `SUBR`s which construct objects. When
+such a `SUBR` finds that the pool of available storage is exhausted,
+it automatically calls the garbage collector.
The garbage collector has two algorithms available to it: the
"copying" algorithm, which is used by default, and the "mark-sweep"
lose.
Thus, if you just "forget about" an object, that is, lose all possible
-means of referencing it, its storage is automatically reclaimed.
+means of referencing it, its storage area is automatically reclaimed.
"Object" in this context includes that stack-structured storage space
used in `PROCESS`es for functional application.
5. Finally, the "mark-sweep" algorithm sweeps through the storage
space, adding unmarked objects to the internal free lists for
later re-use. The "copying" algorithm maps the inferior process's
- address space into Muddle's own, replacing old garbagey with the
- new compact storage, and the inferior process is destroyed.
+ address space into Muddle's own, replacing old garbagey storage
+ with the new compact storage, and the inferior process is
+ destroyed.
22.5 GC
-------
causes the garbage collector to run and returns the total number of
words of storage reclaimed. All of its arguments are optional: if they
-are not supplied, a call to GC simply causes a "copying" garbage
+are not supplied, a call to `GC` simply causes a "copying" garbage
collection.
If *min* is explicitly supplied as an argument, a garbage-collection
parameter is changed permanently before the garbage collector runs.
*min* is the smallest number of words of "free" (unclaimed, available
for use) movable garbage-collected storage the garbage collector will
-be satisfied with having after it is done. Initially it is 8192 words.
-If the total amount of reclaimed storage is less than *min*, the
-garbage collector will ask the operating system for enough storage (in
-1024 word blocks) to make it up. N.B.: the system may be incivil
-enough not to grant the request; in that case, the garbage collector
-will be content with what it has, **unless** that is not enough to
-satisfy a **pending** request for storage. Then it will inform you
-that it is losing. A large *min* will result in fewer total garbage
-collections, but they will take longer since the total quantity of
-storage to be dealt with will generally be larger. Smaller *min*s
-result in shorter, more frequent garbage collections.
+be satisfied with having after it is done each time. Initially it is
+8192 words. If the total amount of reclaimed storage is less than
+*min*, the garbage collector will ask the operating system for enough
+storage (in 1024-word blocks) to make it up. N.B.: the system may be
+incivil enough not to grant the request; in that case, the garbage
+collector will be content with what it has, **unless** that is not
+enough to satisfy a **pending** request for storage. Then it will
+inform you that it is losing. A large *min* will result in fewer total
+garbage collections, but they will take longer since the total
+quantity of storage to be dealt with will generally be larger. Smaller
+*min*s result in shorter, more frequent garbage collections.
+
+*exh?* tells whether or not this garbage collection should be
+"exhaustive". It is optional, a `FALSE` by default. The difference
+between normal and exhaustive "copying" garbage collections is whether
+certain kinds of storage that require complicated treatment (for
+example, associations) are reclaimed. An exhaustive garbage collection
+occurs every eighth time that the "copying" algorithm is used, or when
+`GC` is called with this argument true, or when a normal garbage
+collection cannot satisfy the storage request.
+
+*ms-freq* gives the number of times the "mark-sweep" algorithm should
+be used hereafter for every time the normal "copying" algorithm is
+used. Giving `0` for *ms-freq* means never to use the "mark-sweep"
+algorithm, and giving `<CHTYPE <MIN> FIX>` means (effectively) always
+to use it. The "mark-sweep" algorithm uses considerably less processor
+time than the "copying" algorithm, but it never shrinks the
+free-storage pool, and in fact the pool can become fragmented. The
+"mark-sweep" algorithm could be useful in a program system (such as
+the compiler) where the size of the pool rarely changes, but objects
+are created and thrown away continuously.
22.6. BLOAT
-----------
`READ`ing large `STRING`s, and calling routines within the
interpreter and compiled programs)
-Arguments on the second line are also `FIX` and optional, but they set
-garbage-collection parameters permanently, as follows:
+Arguments on the second line above are also `FIX` and optional, but
+they set garbage-collection parameters permanently, as follows:
- *min*: as for `GC`
- *plcl*: number of slots for `LVAL`s added when the space for
22.8. GC-MON
------------
- <GC-MOND pred>
+ <GC-MON pred>
("garbage-collector monitor") determines whether or not the
interpreter will hereafter print information on the terminal when a
Two `SUBR`s, described next, use only part of the garbage-collector
algorithm, in order to find all pointers to an object. `GC-DUMP` and
`GC-READ`, as their names imply, also use part in order to translate
-between Muddle objects and binary representation thereof.
+between Muddle objects and binary representations thereof.
### 22.9.1. SUBSTITUTE
the "wrong" one, after `OBLIST`s have been in the wrong state. This is
more or less the way `ATOM`s are impurified. It is also useful for
unlinking `RSUBR`s. `SUBSTITUTE` returns *old* as a favor: unless you
-hang onto *old* at that point, it will be garbage-collected.
+hang onto *old* at that point, it will be garbage.
22.9.2 PURIFY
-------------
("value return") seldom returns. It passes control back up the process
tree to the superior of Muddle, passing its argument as a message to
that superior. If it does return, the value is `#FALSE ()`. If the
-argument is a `STRING`, it is passed to the superior as a command to
+argument is a `STRING`, it is passed to the superior as commands to
be executed, via `.VALUE` in the ITS version and `RSCAN` in the
Tops-20 version. If the argument is a `FIX`, it is passed to the
-superior as the "effective address" of a `.BREAK 16`, instruction in
+superior as the "effective address" of a `.BREAK 16,` instruction in
the ITS version and ignored in other versions.
23.4. Inter-process Communication