... `CHAR`:2.1
  The a68toc compiler insists on a semicolon between identity declarations for different modes. In the above case, you would have to write `INT ninety nine=99 ; CHAR x = "X"`

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... symbol).2.2
  The a68toc compiler does permit a subsequent declaration to use the value of a previous value, but it is strictly non-standard. You would be wise to restrict your programs to Algol 68 syntax because other Algol 68 compilers will not necessarily be so lax.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... screen.2.3
  When Algol 68 was first implemented there were few monitors around, so `print` literally printed its output onto paper.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... case.3.1
  The standard prelude supplied with the Linux port of the `a68toc` compiler provides a means of specifying what should be done if integer overflow occurs. See section 13.3.13 for the details. Likewise for “floating-point overflow” and “floating-point underflow”, see section 13.6.1.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... declared.4.1
  However, the a68toc Algol 68 compiler limits the number of dimensions to three. If you try to declare rows having more than three dimensions, the translation proceeds without error messages, but the resulting C code will fail to compile.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

...subscript4.2
  From the practice of mathematicians who write x1, x2,...

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... on4.3
  but a68toc will only accept multiples of upto three dimensions.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... write4.4
  Unfortunately, there is a bug in the a68toc compiler which prevents you from using a denotation after `BY`. Nor does `BY (2)` or `BY +2` work. However, `BY -2` or `BY -2` does work. For other ways see chapter 6.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... form5.1
  Some editors insert a different character when you press the key marked `|`. Check that the character produced is accepted by the Algol 68 compiler.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... operand.5.2
  The a68toc compiler generates code which will cause a run-time fault if your program tries to execute an `ELSE` part which has been omitted. You can get around that bug by explicitly writing `ELSE SKIP`.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... printed:5.3
  The a68toc compiler objects to this with a run-time error. Ensure that at least `OUT SKIP` occurs in every case clause.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... `INT`.6.1
  Historically, programmers were more interested in the value referred to than the name (Algol 68 was the first language to distinguish clearly between a name and the value referred to), so the generator is followed by the mode of the value to which the name will refer.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... same.6.2
  Provided that both identifiers appear in the same range.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

...PLUSAB@`PLUSAB`.6.3
  `PLUSAB` stands for “plus-and-becomes”. When Algol 68 was first designed, people were more concerned with the values referred to than the names, so `PLUSAB` was intended to describe what happens to the value referred to. Bearing in mind the principle of value integrity, the value referred to by `a` does not become anything, but is replaced by its value plus 1.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... exercises.6.4
  The a68toc compiler requires that you write semicolons instead of commas to separate these three declarations.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... Then6.5
  But because the two sides of an assignment are elaborated collaterally, the RHS might be elaborated before the LHS or even in parallel.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... declaration6.6
  The Revised Report mentions a “ghost element” in this context (see section 10.11 for details)

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... input.6.7
  Console input is better handled using the `kbd channel` described in section 13.7.2.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... line.6.8
  See section 9.4 for details of string terminators.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... globally7.1
  The phrase “names declared globally” is intended to mean here that the names have been declared in a range which encloses the routine, not that `HEAP` has necessarily been used in the declaration. We use the phrase “a global name” in the latter case.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... `2`.7.2
  In chapter 3, we mentioned a bug in the a68toc Algol 68 compiler connected with the `BY` construct in loop clauses. Using the `B` operator is another way of getting round the bug.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... example:7.3
  A compiler which implements the Algol 68 defined by the Revised Report would not have to resort to this device because the declaration of each procedure would be available everywhere in the enclosing range (but see section 6.3.6).

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... `[1:10]`.8.1
  Unfortunately, there is a bug in the a68toc compiler whereby this selection (and similar selections) are disallowed.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... `[1:100]`.8.2
  But this is disallowed by the a68toc compiler.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... irrelevant.9.1
  Unfortunately, for the a68toc compiler, this is not true.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... declarations.9.2
  But not for the a68toc compiler.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... mode.9.3
  Note that an Algol 68 union is quite different from a C union. The latter is simply a remapping of a piece of memory. In an Algol 68 union, where the underlying value is kept is the business of the compiler and it cannot be remapped by the programmer.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... file.10.1
  In Linux, a file has the mode, more-or-less, `REF BOOK`.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... closed10.2
  Unless you know what you are doing!

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... `BITS` 10.3
  This mode is described in section 11.2

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... `INT`)10.4
  `NUMBER` is defined for more modes than `REAL` and `INT` which you will meet in chapter 11.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... line.10.5
  The start of a book in the QAD transput is zero.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... mistakes11.1
  You should expect to make one mistake every 20 lines. Congratulate yourself if you do better!

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... met.11.2
  Note that a serial clause is not an enclosed clause.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... are11.3
  The a68toc compiler does not provide collateral clauses other than row- and structure-displays.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... parallel.11.4
  The a68toc compiler does not provide parallel clauses.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... fail11.5
  The a68toc compiler will wrongly allow this last assignment both at compile-time and run-time.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... “little-endian”12.1
  These terms come from the book by Jonathan Swift entitled “Gulliver's Travels” and they refer to the habit of some people of eating boiled eggs at the “big” end or the “little” end!

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... upside-down12.2
  The remainder of the intriguing limerick runs as follows:-

  > Who ate sour apples and died.
  > The apples fermented inside the lamented
  > and made cider inside 'er inside.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... order12.3
  but only if the tree is reasonably balanced

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... errors.13.1
  One way of avoiding this sort of error is to use “lexical” highlighting with your favourite editor. A missing quote or sharp will cause large amounts of your program to be displayed as a string denotation or a comment.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... completed.13.2
  Various schemes have been developed for documenting a program as it is written, They are often called “literate programming”.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... C modes13.3
  C people call them `types`.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... declarations13.4
  `typedef`s

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... macro13.5
  A synonym for another piece of text which is expanded by the C preprocessor

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... address)13.6
  The `VECTOR` mode is not limited to `CHAR`. You can use it for any mode. See section 13.5.1 for details

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... prelude14.1
  QAD stands for “quick-and-dirty” and was supposed to represent the provided standard prelude. While it is not entirely standard (as far as Algol 68 is concerned), it was certainly not implemented quickly!

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .

... windows.14.2
  See the file `/usr/share/doc/xtermcontrol/ctlseqs.txt.gz` for the latter.

      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .
      .