## 2. UPPER stropping

Assuming the extra alphabet of lower-case letters (`"a"` to `"z"`) to have been provided, all words written in upper case are deemed to be bold words in this regime, and so identifiers must be rewritten using the new lower-case facility. Example:

```
BEGIN REF LONG REAL x := LOC LONG REAL :=
    LONG 3.141592654; x MINUSAB long pi;
    print(x)
END
```

Disjunctors are now needed between two adjacent bold words, of course, but no longer between a bold word and an identifier. The shortest way of writing the above example is therefore:

```
BEGIN REF LONG REALx:=LOC LONG REAL:=LONG 3.141592654;
    xMINUSABlongpi;print(x)END
```

You may still introduce bold words with a point, so that in this regime `REAL`, `REAL` and `.real` but not `real`) are all bold words. Also, digits appearing in upper-case words are presumed to be "upper-case digits":

```
MODE ROW23 = [1:23] INT; LOC ROW23 row23;
```

This regime is introduced by the pragmat `pr upper pr` (which will usually appear as `.PR UPPER .PR` since, presumably, `UPPER stropping` was not in force before the pragmat).

## 3. RES stropping

`RES` stands for "reserved word", and in this regime the following 61 words are presumed to be bold whether they are preceded by a point or not (see also the first list in Appendix 1).

at, begin, bits, bool, by, bytes, case, channel, char, co, comment,
compl, do, elif, else, empty, end, esac, exit, false, fi, file, flex, for,
format, from, go, goto, heap, if, in, int, is, isn't, loc, long, mode, nil, od,
of, op, ouse, out, par, pr, pragmat, prio, proc, real, ref, sema, short,
skip, string, struct, then, to, true, union, void, while.

Note that this list includes all the delimiter words and all the standard
mode-indications — but none of the standard-prelude operators which must
still, therefore, be stropped with a point. Since, for example, `LONG` is
automatically a bold word in this regime, we have a problem when
representing the identifier *long*, or even *long pi* if we are not prepared to
represent it as *longpi*. Whereas in the POINT regime we needed the point as
an "emboldening" symbol to turn *long* into *long*, we now need an
"intimidating" symbol to turn *long* into *long*. For this purpose we use the
underscore "_", and it may be placed either after the word to be intimidated,
or between two such words. Thus, although *END*, *OF* and *FILE* are all bold
words in this regime, *END OF FILE* is a single identifier, since all its words are
either preceded or followed by an underscore. For our identifier *long*, then,
we write *LONG_* and for *long pi* either *LONGPI* or *LONG PI*. Our example now
appears as follows:

```
BEGIN REF LONG REAL X := LOC LONG REAL :=
    LONG 3.141592654;X .MINUSAB LONG_PI;
    PRINT(X)
END
```

and the minimum number of disjunctors is shown by

```
BEGIN REF LONG REAL X:=LOC LONG REAL:=LONG 3.141592654
X.MINUSAB LONGPI;PRINT(X)END
```

Of course `POINT` stropping may still be used (`REAL` means the same as `REAL` and of course `.REAL_` is illegal – remember that underscore is not a disjunctor).

This regime is introduced by the pragmat *pr res pr* (usually appearing as `.PR RES .PR`).

## strings

Within a character- or string-denotation the worthy characters may be used
freely to represent themselves with the exception of quote ("") and
apostrophe ('). These must appear in pairs. Thus """"" is a character-
denotation for a single quote-symbol (as already explained in 5.1.1.1) and
"'" is similarly a character-denotation for a single apostrophe-symbol. This is
a new feature, and its purpose is to enable a single apostrophe to be used, in
some implementations, to escape into some other notation (e.g., in some
implementation, 'BS' might represent the otherwise unrepresentable
character "backspace" (a character not recognized by the Report) and might
appear in string-denotations such as "='BS' /".

If the additional alphabet of lower-case letters is provided then, within
character- and string-denotations they are distinct from the upper-case letters
(remember that outside such denotations they are not distinguished, except
in UPPER stropping). If some non-worthy characters are available in your
implementation (e.g. ~, {, }, etc.), they may be used in character- and
string-denotations, but whether such programs could be transferred to
another implementation is another matter.

An extra feature, entitled the "string break", is provided to reduce
confusions arising when string-denotations occupy more than one line.
Remember that two quotes ("") together stand for one quote-symbol. If,
however, they are separated by a space, or a change to a new line, then they
are ignored altogether:

```
PRINT("This is a very long string-denotation which "
"occupies more than one line of our program "
"text, even though we want it to appear as one "
"line in our output")
```

Possible confusion

Since a point can sometimes mean a point, and sometimes the start of a
bold word, is there any situation in which you cannot tell which is meant? It
turns out that there is only one situation in legal ALGOL 68 where a genuine
point-symbol can be followed by a bold word, and that is in the following
format-text:

```
$ 2zd. comment format for 3 digit real number with decimal point but
       no decimal digits comment $
```

Suppose we are in UPPER stropping and we write:

```
$ 2zd. COMMENT FORMAT FOR . . . COMMENT $
```

COMMENT could be a representation of **comment** and so could. COMMENT
(POINT stropping is valid in all regimes), so is the point a point or not? The
answer is that it is not, because of the general rule [R 9.4.2.2.b] that, in any
case of doubt, any sequence of marks is to be regarded as a single symbol
wherever such an interpretation is possible. Thus, COMMENT always means
**comment**, whether in UPPER or not. Clearly, the format-text in question
should have been written as

```
$ 2zd. COMMENT FORMAT FOR . . . COMMENT $
```

(which is much clearer to the human reader anyway).
# APPENDIX 6. Syntax Charts

The following charts show exactly which sequences of symbols from a legal ALGOL 68 particular-program and which do not. To see what you may legally write, start where it says "particular-program" in the first chart below, and follow the line. Where the line diverges, you have a choice. You may either write an "ENCLOSED-clause", or you may write a "label" followed by a ":". If you write a label, then you get back where you started so, following the same lines again, you may now write an "ENCLOSED-clause" or you may go for another label. Eventually, you must write an ENCLOSED-clause in order to reach the outgoing arrow on the right, which signifies that your particular-program is complete.

In order to write any construct enclosed in a rectangle (such as an "ENCLOSED-clause"), you must find the start of that construct (usually on another chart) and follow the line from there, writing such constructs as you meet on the way, until you escape via an outgoing arrow. Then you have completed the construct in question and may continue following lines in the original chart. If you encounter a circle (or an oval), simply write the symbol inside it. So, to write an ENCLOSED-clause, find the start on the ENCLOSED-clauses chart. Immediately you are faced with a choice. Suppose you follow the route marked "closed-clause". Now you must write either "begin" or "(". and after that a "serial-clause" (which is on yet another chart). When your serial-clause is complete, you write "end" or ")", whereupon you reach the outgoing arrow and your ENCLOSED-clause is complete. Although the chart does not show it (it would have been just too complicated), if you write "begin" (rather than "(" before the serial-clause, then you must write "end" (rather than ")") after it, and vice-versa.

Every construct written inside a rectangle will thus be found as an entry point somewhere in one of the charts. The only exceptions are some very simple ones such as "label", "defining-identifier", "field-selector", "mode-indication", "operator", "character" and "digit". The first three of these are the same as "applied-identifier" (on the units chart). For mode-indications and operators see 1.3.2 and 4.3.

Above some of the rectangles there appears an indication of the mode that the construct inside is expected to yield, and the strength of its context (5.1.0.2) or whether it may be balanced (5.2.0.1). The mode written underneath an outgoing arrow tells you the mode of the construct you have just written. "MOID" stands for any mode including *void*, and "MODE" for any
PARTICULAR-PROGRAM

<figure><img src="image_87.png" /></figure>

mode other than void. On any one pass through a particular chart, the MODEs etc. encountered must, however, always stand for the same mode.

Generally speaking in ALGOL 68, comments and pragmats (1.3.2) may appear in between any two symbols, but there are some exceptions — notably in identifiers, denotations and format-texts. In these charts, you may insert a comment or a pragmat anywhere where you are following a continuous line, but if your route between two symbols is entirely over dotted lines, then you may not write comments or pragmats although blanks and newlines are still permitted (but see 5.5.1.1 for the dangers of doing this in string-denotations and see Appendix 5 for a commonly used solution to the problem).

In "collection-lists" in the format-texts chart, an indication is given of the modes in the data list of *getf* and *putf* which are compatible with the various patterns. For example, the chart shows that for a real-pattern the mode in the data list on output may be *int* or *real*, but than on input it may only be *ref real*. See 7.6.1.3 for further details on this point.
<figure><img src="image_88.png" /><figcaption>ENCLOSED-CLAUSES</figcaption></figure>
## SERIAL-CLAUSES

<figure><img src="image_89.png" /></figure>

## DECLARATIONS

<figure><img src="image_90.png" /></figure>
DECLARES

<figure><img src="image_91.png" /></figure>
UNITS

<figure><img src="image_92.png" /></figure>
<figure><img src="image_93.png" /></figure>
FORMAT-TEXTS

<figure><img src="image_94.png" /></figure>
<figure><img src="image_95.png" /></figure>

<figure><img src="image_96.png" /></figure>

<figure><img src="image_97.png" /></figure>
INDEX

a, 277
abs, 211, 237, 248
Acceptable, 123, 342
Action, 64, 341
Actual declarer - see declarer, actual
Actual parameter - see parameter, actual
ALGOL 60, 152, 157, 159, 173, 182
ALGOL 68S, 344
Alignment, 273, 274, 275
amode, 84
and, 240, 331
And also symbol, 69, 337
Applied identifier, 158, 198, 209, 213
Applied occurrence, 73, 188, 198, 346
arccos, 242, 247
arcsin, 242, 247
arctan, 242, 247
arg, 211, 237
Array, 101
Ascribe, to, 64, 65, 66, 70, 74, 132, 133, 341
Assign, to, 341
Assignation, 67, 74, 172, 194, 195, 201, 337
Assignation (example - names), 207
Assignation (of multiples), 142, 219, 223
Assignation (scope restriction), 157, 185
Assignation (to unions), 126
Assignation (value yielded), 69
associate, 259, 312
at, 116, 215, 330
b, 277
Backspace, 351
backspace, 251, 253, 261, 276, 347
Balancing, 162, 163, 194, 203, 204, 233, 346,
begin, 69, 150, 154, 160, 166, 167, 172, 330
bin, 237
bin possible, 255, 257, 258, 285
Binary, 226
Binary transput - see transput, binary
bits, 131, 148, 225, 226, 330

bits (input), 254
bits (output), 252
bits lengths, 246
bits shorths, 246
bits width, 225, 241, 246
bitspack, 242, 247
blank, 241
Blank space, 91
Block, 157
Bold word, 93, 137, 165, 185, 186, 339, 349
Book, 255, 259, 263, 343
bool, 131, 330
bool (input), 253
bool (output), 252
Boundpair, 115, 219, 335, 337
Bounds, 151, 215, 337
Bounds (after rowing), 212
Bounds (binary transput), 284
Bounds (in assignations), 219, 220
Bounds (in unions), 223
Bounds (interrogations), 218
Bounds (of row display), 167
Bounds (of string denotation), 213
by, 168, 330
bytes, 131, 148, 225, 330
bytes (input), 254
bytes (output), 252
bytes lengths, 246
bytes shorths, 246
bytes width, 226, 241, 246
bytespack, 242, 247
c, 94
Call, 70, 172, 177, 182, 194, 195, 205, 206, 339
Call by name, 182
Call by reference, 87, 182
Call by value, 86, 182
Call, to, 341
case, 154, 163, 170, 330
Case clause - see clause, case
Cast, 81, 182, 194, 197, 198, 218, 338
Cast (example), 187, 226
Cast (on LHS of assignation), 201, 208
Chaining, 108
chan, 258

channel, 255, 263, 330, 334, 343

char, 131, 330

char (input), 254

char (output), 252

char in string, 271, 347

char in string (example), 324

char number, 260

Character, 265

Character transput — see transput, character

Check, 185

Choice, 279, 283

Choice clause — see clause, choice

Clause, 337

Clause, case, 160, 163, 204, 205, 337

Clause, choice, 156, 160

Clause, closed, 69, 156, 160, 200, 337

Clause, collateral, 160, 172, 337, 345

Clause, conditional, 160, 161, 204, 205, 337

Clause, conformity, 126, 160, 170, 205, 222, 223, 337, 345

Clause, conformity (example), 320

Clause, ENCLOSED, 150, 160, 166, 167, 193, 198, 203, 207, 217, 280, 337

Clause, enquiry, 161, 163, 168, 195, 227, 337

Clause, loop, 156, 160, 168, 337

Clause, parallel, 160, 172, 174, 337, 345

Clause, serial, 68, 150, 204, 227, 337

Clause, serial (coercion of), 203

Clause, serial (in closed clause), 160

Clause, serial (in conditional clause), 161

Clause, serial (in loop clause), 168

Clause, serial (range), 156

Clause, serial (value of), 152

Clause, serial (where used), 154

Clause, unitary — see unit

close, 259, 261

Close, to, 343

Closed clause — see clause, closed

co, 330

Code conversion, 263, 265

Coercend, 193, 337

Coercion, 73, 183, 188, 194, 203, 209, 212, 222, 225, 341

Coercion chart, 196

Collateral clause — see clause, collateral

Collateral declaration — see declaration, collateral

Collateral elaboration, 68, 69, 71, 166, 167, 169, 172, 182, 232, 341

Collection, 280

Column, 167, 215

Comma, 69

Comment, 94, 213, 339

comment, 330

Common sub-expressions, 174

Comorf, 196

compl, 140, 209, 211, 261, 330

compl (input), 253

compl (output), 251

Complete, to, 154, 172, 204, 341

Completer, 153, 337

Completer (example), 320

compressible, 258, 260

Computer word, 148

Concatenation, 239, 244

Conditional clause — see clause, conditional

Conform, to, 126, 170, 340

Conformity clause — see clause, conformity

conj, 211, 237

Constant, 65, 74, 75, 134, 198, 335, 339

Constants (standard prelude), 241

Construct, 64, 335

Context, 194, 342

Contraction, 69, 135, 137, 138, 180, 181, 186, 187, 340

Conversion procedures, 270

Copying, 190, 301

cos, 242, 247

create, 259, 265, 347

Cube root, 151

Current position, 256, 260, 263, 343

Cyclic permutation, 220

d, 276

Data list, 250, 253, 282, 343

Declaration, 66, 68, 150, 157, 336, 346

Declaration, collateral, 132, 135, 172, 186, 336
Declaration, collateral (contraction),
135, 137

Declaration, heap, 149

Declaration, identifier, 66, 133

Declaration, identifier (and multiples),
118, 121

Declaration, identifier (and structures),
102

Declaration, identifier (and unions), 123,
146

Declaration, identity, 74, 75, 133, 194,
336

Declaration, identity (and multiples),
142

Declaration, identity (formal/actual
correspondence), 182

Declaration, mode, 95, 108, 137, 138,
143, 165, 186, 336

Declaration, operation, 97, 165, 186,
188, 336, 346

Declaration, operation (example), 291,
320

Declaration, priority, 99, 185, 186, 188,
227, 336, 346

Declaration, procedure, 85, 179,

Declaration, routine identity, 181, 336

Declaration, routine variable, 181, 336

Declaration, row, 141

Declaration, sample, 132

Declaration, struct, 139

Declaration, union, 146

Declaration, variable, 66, 74, 79, 131,
134, 336, 345

Declaration, variable (and multiples),
141, 143

Declaration, variable (initialized), 135,
194

Declarer, 336

Declarer, actual, 77, 114, 135, 137, 143,
144, 227, 345, 346

Declarer, formal, 75, 133, 144, 146,
179, 180, 198, 223, 333

Declarer, proc, 85, 144, 179

Declarer, row, 141

Declarer, struct, 138

Declarer, union, 146

Defining identifier, 158, 170

Defining occurrence, 73, 188, 346

Delimiters, 154

Denotation, 198, 338

Denotation, bits, 226

Denotation, character, 213

Denotation, long, 226

Denotation, short, 226

Denotation, string, 212, 217, 275

Denotation, void, 223

Deproceduring, 183, 196, 205, 206, 225

Dereferencing, 196, 197, 203, 210, 216

Descriptor, 114, 141, 213, 335, 336

Destination, 68, 201, 338

Develop, to, 96, 340

Dijkstra, E.W., 176

Dimension, 101

Disc, 284

Disjunctor, 349

Display, row, 160, 167, 172, 212, 250,
253, 337, 346

Display, structure, 160, 166, 172, 337,
346

divab, 243, 331

do, 154, 168, 330

down, 175, 238, 331, 345

Drum, 284

Dummy statement, 202

Dyadic operator - see operator, dyadic

Dynamic replicator, 279

e, 276

elaboration, 64, 340

Elaboration, collateral - see collateral
elaboration

elem, 238, 248, 331

Element, 101, 114, 141, 167, 212, 335

elif, 154, 162, 330

else, 154, 161, 330

empty, 223, 330, 345

empty (example), 323

ENCLOSED clause - see clause,
ENCLOSED

end, 69, 150, 154, 160, 166, 167, 172,
330

Enquiry clause - see clause, enquiry

entier, 237, 331

Environment enquiry, 129, 241, 246,
258, 265, 272, 294, 343, 347

eq, 240, 331

Equivalence, 76
error character, 272

esac, 154, 163, 170, 330

estab possible, 258

establish, 259, 265

Event routine, 191, 263, 266, 283

exit, 153, 204, 330

exit (example), 320

exp, 242, 247

exp width, 246, 272

Expect, to, 275, 276, 279, 283

Expression, 150, 160, 194, 339

External object, 64, 335

f, 277

false, 131, 330

fi, 154, 161, 330

Field, 101, 138, 166, 209, 261, 335

Field selector, 101, 138, 209, 338

file, 256, 261, 263, 282, 330, 334

Firm context, 195, 196, 200, 222, 250, 252

Firmly related modes, 188, 340, 346

fixed, 271

Fixed name, 142, 190, 216, 334

Flat descriptor, 115, 143, 342

flex, 142, 143, 144, 190, 212, 217, 330, 345

Flexible name, 120, 142, 190, 216, 219, 334

Flexible name (transput), 280

flip, 272

float, 271

flop, 272

for, 168, 330

Formal declarer - see declarer, formal

Formal parameter - see parameter, formal

format, 281, 282, 330, 334, 347

format, (transput), 250, 253

format pointer, 263, 282

Format text, 273, 274, 281, 338

Formatless transput - see transput, formatless

Formatted transput - see transput, formatted

Formula, 70, 177, 187, 188, 195, 199, 211, 338

FORTRAN, 159

Frame, 273, 274, 276

from, 168, 330

g, 277

Garbage collection, 230, 327, 342

ge, 240, 331

Generator, 227, 338

Generator, heap, 149, 229, 345

Generator, heap, (example), 319

Generator, loc, 77, 89, 135, 227, 346

get, 257, 260, 285

get bin, 285

get possible, 255, 257, 258

getf, 282

Go on symbol, 68, 132, 150, 337

go to, 330

go to statement, 151

go to statement - see also jump

goto, 191, 330

gt, 239, 331

Halt, to, 175, 341

Hardware representation, 348

Heap, 230, 325, 342

heap, 149, 227, 229, 231, 330

heap (example), 320

heap declaration - see declaration, heap

heap generator - see generator, heap

i 211, 237, 331, 332

i, 276

Identification, 158, 346

Identification (of books), 256, 259

Identification (of modes), 165

Identification (of operators), 188

Identifier, 66, 133, 158, 168, 185, 336, 338

Identifier declaration - see declaration, identifier

Identifier, applied - see applied identifier

Identifier, defining - see defining identifier

Identify, to, 73, 158, 340

Identity declaration - see declaration, identity

Identity relation, 129, 172, 194, 195, 205, 232, 338

Identity relation (example), 313, 321, 326

if, 154, 161, 330

im, 211, 237
Implied bracketing, 202, 243
Implies, 239
in, 154, 163, 170, 330
Indexer, 116, 120, 214
Indication, mode - see mode indication
Indicator, 64, 65, 339
Indirect addressing, 81
Initialization, 80, 135
Initialized declaration - see declaration, initialized
Input, formatless, 252
Insertion, 274
Instance, 64, 65, 202, 333, 340
int, 131, 330
int (input), 253
int (output), 251
int lengths, 246
int shorths, 246
int width, 246, 272
Internal object, 64, 133, 333
Interrogations, 121, 218, 245
Intimidation, 351
is, 129, 330
isnt, 129, 330
Jensen's device, 183
Jump, 191, 345, 346
Jump - see also go to statement
k, 276
l, 276
Label, 151, 153, 159, 191, 337
last random, 242, 247
Layout routines, 260
le, 239, 331
leng, 248
level, 175, 248
LHS, 67, 339
Library prelude, 64, 200, 258, 265, 292, 300, 336
line number, 260
Lisp, 230
List, 108
List processing, 230, 234, 319
Literal, 198, 273, 274, 275, 279
In, 242, 247
loc, 77, 79, 157, 227, 330, 345
Local generator - see generator, loc
Local range - see range, local
lock, 259, 261, 347

Logical book, 256
Logical end of file, 256, 259, 263, 283, 286, 343
long, 84, 196, 226, 246, 248, 330, 334
long modes, 128, 148, 345
long modes (example), 297
long operators, 247
long, 246, 247
Loop cause - see clause, loop
lt, 239, 331
lwb, 122, 219, 224, 245, 331
Machineword, 128
Magnetic tape, 258, 284, 286
make conv, 264, 265, 347
make term, 254, 264, 347
Matrices, 300
max abs char, 241
max int, 241, 246, 269, 272
max real, 187, 241, 246, 272
maze, 184
Meek context, 143, 195, 196, 206, 215
Meekly related modes, 346
Metanotion, 75, 83
min, 186, 188
minusab, 244, 331
mod, 238, 331
modab, 243, 331
Mode, 64, 83, 333
mode, 330
Mode declaration - see declaration, mode
Mode indication, 137, 143, 185, 336
Monadic operator - see operator, monadic
Mood, 122
Morf, 196
Multilength arithmetic, 128
Multiple, 335
Multiple selection, 218
Multiple value, 100, 114, 141, 151, 167, 218, 335, 345
Multiple value (as parameter), 190
Multiple value (assignation of), 219
Multiple value (binary transput), 284
Multiple value (in unions), 223
Multiple value (rowing), 212
Multiple value (slicing), 214
Multiple value (transput), 270
n, 279

Name, 65, 80, 134, 201, 207, 227, 229, 232, 334

Name (assignation of), 207

Name (dereferencing), 197

Name (scope of), 157

Name (transput), 250, 253

Names of fields of structures, 105, 210

Names of slices, 121, 216

ncos, 332

ne, 240, 331

New line, 91

newline, 251, 253, 260, 261, 276

newpage, 251, 253, 260, 261, 276

next random, 242, 247

nil, 110, 207, 208, 233, 330

nonproc, 196

not, 236, 331

Notion, 83

nsin, 332

null character, 241, 248

Occurrence, 340

Octal, 226

od, 154, 168, 330

odd, 237

of, 209, 330

on char error, 254, 264, 269, 275, 283, 347

on char error (example), 323

on format end, 264, 268, 282, 283, 347

on line end, 254, 264, 268, 283, 284

on logical file end, 264, 267, 283, 286

on page end, 264, 267, 283, 284

on physical file end, 264, 268, 283

on value error, 264, 268, 279, 283, 347

op, 186, 330

open, 259, 265

Open, to, 256, 259, 343

Operand, 71, 187, 195, 199, 232, 338

Operation declaration - see declaration, operation

Operator, 70, 97, 177, 186, 188, 199, 218, 338

Operator, dyadic, 99, 172, 187

Operator, monadic, 100, 175, 187

Operators (assigning), 243

Operators (complex), 211

Operators (standard prelude), 236, 247

Operators, dyadic (standard prelude), 237, 245

Operators, monadic (standard prelude), 236, 245

or, 240, 331

Order of elaboration, 232

ouse, 154, 164, 171, 330

out, 154, 163, 170, 205, 330

Output, formatless, 250

over, 238, 331

overab, 243, 331

p, 276

page number, 260

Paper tape, 274, 284

par, 174, 330

Parallel clause - see clause, parallel

Parameter, 337

Parameter, actual, 75, 85, 86, 133, 172, 182, 186, 194, 206

Parameter, formal, 70, 75, 85, 133, 180

Parameter, formal (formal/actual correspondence), 182, 187

Parametrize, to, 86, 341

Paranotion, 335

Parity error, 269

Particular program, 64, 150, 151, 335

Phrase, 68, 336

Physical book, 256, 283, 284

Physical end of file, 343

pi, 241, 246

Picture, 268, 273, 274, 280

pie, 160

plusab, 244, 331

plusto, 244, 331

Position enquiries, 260

Power, 199

pr, 330

Pragmat, 94, 339, 349

pragmat, 330

Precision, 148

Primary, 160, 193, 195, 197, 205, 206, 212, 214, 223, 226, 338

Primitive modes, 83, 131, 148, 334

Primitive value, 334

print, 250, 257, 260, 272

printf, 274

prio, 186, 330

Priority, 161, 186, 199
Priority declaration - see declaration, priority
proc, 84, 179, 330, 334
proc declarer - see declarer, proc
proc modes, 84
Procedure, 177, 179, 205, 339
Procedure declaration - see declaration, procedure
Procedured jump, 191, 345
Procedures (standard prelude), 241, 247, 259, 260, 270, 281, 284
Program, 64, 335
Pseudo comment, 94
Punched cards, 274, 284
put, 257, 260, 272, 285
put bin, 285
put possible, 255, 257, 258
putf, 282
q, 276
Quaternary, 181, 193, 201, 207, 219, 232, 337
Queue, 108
Quote symbol, 213
r, 277
Radix, 277
Random access, 258
random, 242, 247
Range, 69, 133, 135, 137, 156, 157, 158, 185, 228, 337
Range, local, 227, 228
Rationals, 297
re, 211, 237
Reach, 156, 158, 169, 186, 337, 340
read, 252, 257, 260
read bin, 285
readf, 273
real, 131, 330
real (input), 253
real (output), 251
real lengths, 246
real shorths, 246
real width, 246, 272
Real time, 174
Record, 101
Recursion, 183
Recursion (example), 316, 323
ref, 65, 84, 144, 330, 334
Refer, to, 65, 340

reidf, 258, 259, 347
reidf possible, 256, 258, 259
Related - see firmly related nodes & meekly related modes
Replication, 238, 243
Replicator, 275, 279
repr, 237, 248
Representation, 91, 330, 348
Reserved bold words, 330
Reserved word, 350
reset, 260, 261, 284, 286
reset possible, 255, 257, 258, 260, 284, 286
Resume, to, 175, 341
Revised lower bound, 116, 215
Rewind, 258
RHS, 67, 339
round, 237
Routine, 70, 84, 177, 179, 180, 335
Routine (and operators), 186
Routine (calling), 205
Routine (recursion), 183
Routine (scope), 185
Routine (transput), 250, 253
Routine identity declaration - see declaration, routine identity
Routine text, 70, 84, 156, 177, 180, 186, 194, 227, 338
Routine variable declaration - see declaration, routine variable
Row declaration - see declaration, row
Row declarer - see declarer, row
Row display - see display, row
'Row of', 334
Rowed, 334
Rowing, 196, 212, 213, 216, 217, 347
s, 276, 277
Sample declaration - see declaration, sample
Scope, 69, 149, 157, 158, 202, 227, 229, 266, 340
Scope (of formats), 281
Scope (of routines), 185, 323
scratch, 259, 261, 347
Secondary, 193, 195, 209, 218, 227, 338
Select, to, 340
Selection, 195, 209, 218, 338
Selector, field - see field selector
sema, 175, 330, 334, 345
Semaphore, 175
Semicolon, 63
Serial clause - see clause, serial
set, 260, 284
set char number, 260, 276, 347
set possible, 255, 257, 258, 260, 284, 285
Shield, to, 108, 139
Shift, 238
shl, 238, 331
short, 84, 196, 226, 330, 334
short modes, 128, 148, 345
short operators, 247
shorten, 248
shr, 238, 331
Side effect, 68, 172
sign, 237
sin, 242, 247
skip, 89, 202, 330
Slice, 120, 195, 214, 220, 223, 229, 339, 347
Slices, overlapping, 220
small real, 151, 160, 241, 246, 272
Soft context, 195, 196, 201, 233
Source, 68, 201, 338
Space, 91
Space character, 213
space, 251, 253, 261, 274, 276
Specification, 170, 337
Specify, to, 101, 340
sqrt, 242, 247
Stack, 228, 230, 342
stand back, 256
stand back channel, 256, 258
stand conv, 265, 347
stand in, 253, 256, 257
stand in channel, 256, 258
stand out, 251, 256, 257
stand out channel, 256, 258
Standard postlude, 64, 236, 256, 336
Standard prelude, 64, 140, 145, 177, 186, 200, 236, 256, 261, 292, 336
Statement, 150, 151, 160, 194, 202, 225, 339
stop, 236
STOWED, 342

STOWED value, 100
Straighten, to, 343
Straightening, 252, 255, 273, 282, 284
Straightening (example), 280
Straightening (of multiple values), 270
Straightening (of structures), 261
string, 145, 212, 270, 330, 334, 347
string (input), 254
string (output), 252
string (straightening), 270
String denotation - see denotation, string
Strong context, 133, 194, 196, 202, 203, 204, 207, 212, 225, 233, 346
Strop, to, 340
Stropping, 93, 349
struct, 84, 330, 334, 335
struct declaration - see declaration, struct
struct declarer - see declarer, struct
Structure, 138, 166, 209, 335, 345
Structure (binary transput), 284
Structure (transput), 261
Structure display - see display, structure
Structured value, 100, 101, 335
Sublanguage, 209, 340, 344
Subname, 105, 109, 121, 210, 216, 334
Subscript, 114, 116, 214, 335
Subvalue, 116, 215, 216, 335
Superlanguage, 340, 344
Supersede, to, 67, 341
switch, 192
Symbol, 91, 92, 330, 339
Synchronisation, 174
Syntax, 204
tan, 242, 247
Terminate, to, 154, 159, 172, 236, 341
Tertiary, 193, 200, 201, 207, 211, 218, 232, 233, 338
Textual order, 345
then, 154, 161, 330
timesab, 243, 248, 331
to, 168, 330
Transient name, 217, 218, 334
Transput, 195, 198, 343
Transput procedures, binary, 284
Transput procedures, formatted, 281
Transput, binary, 255, 258, 284
Transput, character, 255
Transput, formatless, 250
Transput, formatted, 273
Transput, formatted (example), 311
Tree, 108
triangle, 228
Trimmer, 116, 214
Trimscript, 116, 195, 214
true, 131, 330
Truncation, 238, 248
Typographical display feature, 91
Undefined, 68, 162, 163, 172, 179, 202, 224, 248, 254, 266, 268, 269, 286, 342
union, 84, 122, 144, 146, 222, 330, 334, 345
union (example), 319
union (of multiples), 223
union (transput), 253
union declaration - see declaration, union
union declarer - see declarer, union
Unit, 68, 181, 193, 203, 215, 337
Unit (in case clause), 163
Unit (in identity declaration), 133
Unit (in loop clause), 168
Unit (in serial clause), 150, 152
Unit (in structure display), 166, 167
Unitary clause - see unit
United modes, 122
Uniting, 196, 222, 223
Uniting (example), 323
up, 175, 238, 331, 345

upb, 122, 219, 224, 245, 331
Vacuum, 167, 337, 345
Value, 64, 69, 84, 333
Value (of serial clause), 69
Variable, 65, 74, 80, 131, 132, 134, 335, 339
Variable declaration - see declaration, variable
vec, 332
Vectors, 300
Vectors (example), 293
void, 69, 179, 181, 194, 330
void (example), 323
Void denotation - see denotation, void
Voiding, 196, 225
Weak context, 195, 196, 210, 214, 216
Well formed, 97, 113, 139
while, 154, 168, 330
whole, 271
Widening, 194, 196, 197, 200, 204, 209, 222, 225
Word, computer - see computer word
Worthy character, 348
write, 252
write bin, 285
writef, 282
x, 276
x or y, 332
y, 276
Yang, 139
Yield, 64, 152
Yield, to, 340
Yin, 139
z, 276