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.
("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
projects / mudman.git / commitdiff