## §1 Routines

If you have already dipped into Chapter II and looked at how some simple games and puzzles are designed, you'll have seen that any really interesting item needs to be given instructions on how to behave, and that these instructions are written in a language of their own. Chapter I is about that language, and its examples are mostly short programs to carry out mundane tasks, undistracted by the lure of adventure.

### §1.1 Getting started

Inform turns your description of a game (or other program), called the “source code”, into a “story file” which can be played (or run through) using an “interpreter”. Interpreter programs are available for very many models of computer, and if you can already play Infocom's games or other people's Inform games on your machine then you already have an interpreter. There are several interpreter programs available, in a sort of friendly rivalry. You should be able to use whichever you prefer and even the oldest, most rickety interpreter will probably not give serious trouble. A good sign to look out for is compliance with the exacting Z-Machine Standards Document, agreed by an informal committee of interested parties between 1995 and 1997. At time of writing, the current version is Standard 1.0, dating from June 1997.

Turning source code into a story file is called “compilation”, and Inform itself is the compiler. It's also supplied with a whole slew of ready-made source code called the “library” and giving all the rules for adventure games. The story of what the library does and how to work with it occupies most of this manual, but not this chapter.

It isn't practicable to give installation instructions here, because they vary so much from machine to machine, but before you can go any further you'll need to install Inform: try downloading the software for your own machine from `ftp.gmd.de`, which should either install itself or give instructions. A useful test exercise would be to try to create the “Hello World” source code given below, then to compile it with Inform, and finally “play” it on your interpreter. (You can type up source code with any text editor or even with a word-processor, provided you save its documents as “text only”.)

Inform can run in a number of slightly different ways, controlled by “switches”. The way to set these varies from one installation to another. Note that this chapter assumes that you're running Inform in “Strict mode”, controlled by the `-S` switch, which is normally set and ensures that helpful error messages will be printed if a story file you have compiled does something it shouldn't.

### §1.2 Hello World

Traditionally, all programming language tutorials begin by giving a program which does nothing but print “Hello world” and stop. Here it is in Inform:

    !  "Hello world" example program
    [ Main;
      print "Hello world^";
    ];

The text after the exclamation mark is a “comment”, that is, it is text written in the margin by the author to remind himself of what is going on here. Such text means nothing to Inform, which ignores anything on the same line and to the right of an exclamation mark. In addition, any gaps made up of line and page breaks, tab characters and spaces are treated the same and called “white space”, so the layout of the source code doesn't much matter. Exactly the same story file would be produced by:

       [
          Main   ;
    print
             "Hello world^"        ;
         ]
     ;

or, at the other extreme, by:

    [Main;print"Hello world^";];

Laying out programs legibly is a matter of personal taste.

▲ The exception to the rule about ignoring white space is inside quoted text, where `"Hello world^"` and `"Hello world^"` are genuinely different pieces of text and are treated as such. Inform treats text inside quotation marks with much more care than its ordinary program material: for instance, an exclamation mark inside quotation marks will not cause the rest of its line to be thrown away as a comment.

Inform regards its source code as a list of things to look at, divided up by semicolons `;`. These things are generally objects, of which more later. In this case there is only one, called `Main`, and it's of a special kind called a “routine”.

Every program has to contain a routine called `Main`. When a story file is set running the interpreter follows the first instruction in `Main`, and it carries on line by line from there. This process is called “execution”. Once the `Main` routine is finished, the interpreter stops.

These instructions are called “statements”, a traditional term in computing albeit an ungrammatical one. In this case there is only one statement:

    print "Hello world^";

Printing is the process of writing text onto the computer screen. This statement prints the two words “Hello world” and then skips the rest of the line (or “prints a new-line”), because the `^` character, in quoted text, means “new-line”. For example, the statement

    print "Blue^Red^Green^";

prints up:

Blue
Red
Green

`print` is one of 28 different statements in the Inform language. Only about 20 of these are commonly used, but the full list is as follows:

`box` | `break` | `continue` | `do` | `font` | `for`
`give` | `if` | `inversion` | `jump` | `move` | `new_line`
`objectloop` | `print` | `print_ret` | `quit` | `read` | `remove`
`restore` | `return` | `rfalse` | `rtrue` | `save` | `spaces`
`string` | `style` | `switch` | `while`

### §1.3 Routine calls, errors and warnings

The following source code has three routines, `Main`, `Rosencrantz` and `Hamlet`:

    [ Main;
      print "Hello from Elsinore.^";
      Rosencrantz();
    ];
    [ Rosencrantz;
      print "Greetings from Rosencrantz.^";
    ];
    [ Hamlet;
      print "The rest is silence.^";
    ];

The resulting program prints up

Hello from Elsinore.
Greetings from Rosencrantz.

but the text “The rest is silence.” is never printed. Execution begins at `Main`, and “Hello from Elsinore” is printed; next, the statement `Rosencrantz()` causes the `Rosencrantz` routine to be executed. That continues until it ends with the close-routine marker `]`, whereupon execution goes back to `Main` just after the point where it left off: since there is nothing more to do in `Main`, the interpreter stops. Thus, `Rosencrantz` is executed but `Hamlet` is not.

In fact, when the above source code is compiled, Inform notices that `Hamlet` is never needed and prints out a warning to that effect. The exact text produced by Inform varies from machine to machine, but will be something like this:

    RISC OS Inform 6.20 (10th December 1998)
    line 8: Warning: Routine "Hamlet" declared but not used
    Compiled with 1 warning

Errors are mistakes in the source which cause Inform to refuse to compile it, but this is only a warning. It alerts the programmer that a mistake may have been made (because presumably the programmer has simply forgotten to put in a statement calling `Hamlet`) but it doesn't prevent the compilation from taking place. Note that the opening line of the routine `Hamlet` occurs on the 8th line of the program above.

There are usually mistakes in a newly-written program and one goes through a cycle of running a first draft through Inform, receiving a batch of error messages, correcting the draft according to these messages, and trying again. A typical error message would occur if, on line 3, we had mistyped `Rosncrantz()` for `Rosencrantz().` Inform would then have produced:

    RISC OS Inform 6.20 (10th December 1998)
    line 5: Warning: Routine "Rosencrantz" declared but not used
    line 8: Warning: Routine "Hamlet" declared but not used
    line 3: Error: No such constant as "Rosncrantz"
    Compiled with 1 error and 2 warnings (no output)

The error message means that on line 3 Inform ran into a name which did not correspond to any known quantity: it's not the name of any routine, in particular. A human reader would immediately realise what was intended, but Inform doesn't, so that it goes on to warn that the routine `Rosencrantz` is never used. Warnings (and errors) are quite often produced as knock-on effects of other mistakes, so it is generally a good idea to worry about fixing errors first and warnings afterward.

Notice that Inform normally doesn't produce the final story file if errors occurred during compilation: this prevents it from producing damaged story files.

### §1.4 Numbers and other constants

Inform numbers are normally whole numbers in the range −32,768 to 32,767. (Special programming is needed to represent larger numbers or fractions, as we shall see when parsing phone numbers in Chapter IV.) There are three notations for writing numbers in source code: here is an example of each.

    -4205
    $3f08
    $$1000111010110

The difference is the radix, or number base, in which they are expressed. The first is in decimal (base 10), the second hexadecimal (base 16, where the digits after 9 are written `a` to `f` or `A` to `F`) and the third binary (base 2). Once Inform has read in a number, it forgets which notation was used: for instance, if the source code is altered so that `$$10110` is replaced by `22`, this makes no difference to the story file produced.

A print statement can print numbers as well as text, though it always prints them back in ordinary decimal notation. For example, the program

    [ Main;
      print "Today's number is ", $3f08, ".^";
    ];

prints up

Today's number is 16136.

since 16,136 in base 10 is the same number as 3f08 in hexadecimal.

Literal quantities written down in the source code are called “constants”. Numbers are one kind; strings of text like `"Today's number is "` are another. A third kind are characters, given between single quotation marks. For instance, `'x'` means “the letter lower-case x”. A “character” is a single letter or typewriter-symbol.

▲ Just as `$3f08` is a fancy way of writing the number 16,136, so `'x'` is a fancy way of writing the number 120. The way characters correspond to numeric values is given by a code called ZSCII, itself quite close to the traditional computing standard called ASCII. 120 means “lower-case x” in ASCII, too, but ZSCII does its own thing with non-English characters like “é”. (You can type accented letters directly into source code: see §1.11.) The available characters and their ZSCII values are laid out in Table 2.

Inform also provides a few constants named for convenience, the most commonly used of which are true and false. A condition such as “the jewelled box is unlocked” will always have either the value true or the value false.

▲ Once again these are numbers in disguise. `true` is 1, `false` 0.

▲ Inform is a language designed with adventure games in mind, where a player regularly types in commands like “unlock the box”, using a fairly limited vocabulary. Writing a word like `'box'` in the source code, in single-quotation marks, adds it to the “dictionary” or vocabulary of the story file to be compiled. This is a kind of constant, too: you can use it for writing code like “if the second word typed by the player is `'box'`, then…”.

▲ If you need to lodge a single-letter word (say “h”) into the dictionary, you can't put it in single quotes because then it would look like a character constant (`'h'`). Instead, the best you can write is `'h//'`. (The two slashes are sometimes used to tack a little linguistic information onto the end of a dictionary word, so that in some circumstances, see §29, you might want to write `'pears//p'` to indicate that “pears” must go into the dictionary marked as a plural. In this case the two slashes only serve to clarify that it isn't a character.)

▲ You can put an apostrophe ' into a dictionary word by writing it as ^: for instance `'helen^s'`.

▲▲ In two places where dictionary words often appear, the name slot of an object definition and in grammar laid out with Verb and Extend, you're allowed to use single or double quotes interchangeably, and people sometimes do. For clarity's sake, this book tries to stick to using single quotes around dictionary words at all times. The handling of dictionary words is probably the single worst-designed bit of syntax in Inform, but you're past it now.

### §1.5 Variables

Unlike a literal number, a variable is able to vary. It is referred to by its name and, like the “memory” key on some pocket calculators, remembers the last value placed in it. For instance, if `oil_left` has been declared as a variable (see below), then the statement

    print "There are ", oil_left, " gallons remaining.^";

would cause the interpreter to print “There are 4 gallons remaining.” if `oil_left` happened to be 4, and so on. It's possible for the statement to be executed many times and produce different text at different times.

Inform can only know the named quantity `oil_left` is to be a variable if the source code has “declared” that it is. Each routine can declare its own selection of up to 15 variables on its opening line. For example, in the program

    [ Main alpha b;
      alpha = 2200;
      b = 201;
      print "Alpha is ", alpha, " while b is ", b, "^";
    ];

the `Main` routine has two variables, `alpha` and `b`.

Going back to the `Main` routine above, the `=` sign which occurs twice is an example of an “operator”: a notation usually made up of the symbols on the non-alphabetic keys on a typewriter and which means something is to be done with or calculated from the items it is written next to. Here `=` means “set equal to”. When the statement `alpha = 2200;` is interpreted, the current value of the variable `alpha` is changed to 2,200. It then keeps that value until another such statement changes it. All variables have the value 0 until they are first set.

The variables `alpha` and `b` are called “local variables” because they are local to `Main` and are its private property. The source code

    [ Main alpha;
      alpha = 2200;
      Rival();
    ];

    [ Rival;
      print alpha;
    ];

causes an error on the `print` statement in `Rival`, since `alpha` does not exist there. Indeed, `Rival` could even have defined a variable of its own also called `alpha` and this would have been an entirely separate variable.

· · · · ·

That's now two kinds of name: routines have names and so have variables. Such names, for instance `Rival` and `alpha`, are called “identifiers” and can be up to 32 characters long. They may contain letters of the alphabet, decimal digits or the underscore `_` character (often used to impersonate a space). To prevent them looking too much like numbers, though, they cannot start with a decimal digit. The following are examples of legal identifiers:

    turns_still_to_play     room101     X

Inform ignores any difference between upper and lower case letters in such names, so for instance `room101` is the same name as `Room101`.

### §1.6 Arithmetic, assignment and bitwise operators

The Inform language is rich with operators, as Table 1 shows. This section introduces a first batch of them.

A general mixture of quantities and operators, designed to end up with a single resulting quantity, is called an “expression”. For example: the statement

    seconds = 60*minutes + 3600*hours;

sets the variable `seconds` equal to 60 times the variable `minutes` plus 3600 times the variable `hours`. White space is not needed between operators and “operands” (the quantities they operate on, such as 3600 and hours). The spaces on either side of the `+` sign were written in just for legibility.

The arithmetic operators are the simplest ones. To begin with, there are `+` (plus), `-` (minus), `*` (times) and `/` (divide by). Dividing one whole number by another usually leaves a remainder: for example, 3 goes into 7 twice, with remainder 1. In Inform notation,

`7/3` evaluates to 2 and `7%3` evaluates to 1

the `%` operator meaning “remainder after division”, usually called just “remainder”.

▲ The basic rule is that `a == (a/b)*b + (a%b)`, so that for instance:

    13/5 == 2    13/-5 == -2    -13/5 == -2    -13/-5 == 2
    13%5 == 3    13%-5 == 3     -13%5 == -3    -13%-5 == -3

• WARNING
Dividing by zero, and taking remainder after dividing by zero, are impossible. You must write your program so that it never tries to. It's worth a brief aside here on errors, because dividing by zero offers an example of how and when Inform can help the programmer to spot mistakes. The following source code:

    [ Main; print 73/0; ];

won't compile, because Inform can see that it definitely involves something illegal:

    line 2: Error: Division of constant by zero
    >   print 73/0;

However, Inform fails to notice anything amiss when compiling this:

    [ Main x; x = 0; print 73/x; ];

and this source code compiles correctly. When the resulting story file is interpreted, however, the following will be printed:

    [** Programming error: tried to divide by zero **]

This is only one of about fifty different programming errors which can turn up when a story file is interpreted. As in this case, they arise when the interpreter has accidentally been asked to do something impossible. The moral is that just because Inform compiles source code without errors, it does not follow that the story file does what the programmer intended.

▲ Since an Inform number has to be between −32,768 and 32,767, some arithmetic operations overflow. For instance, multiplying 8 by 5,040 ought to give 40,320, but this is over the top and the answer is instead −25,216. Unlike dividing by zero, causing arithmetic overflows is perfectly legal. Some programmers make deliberate use of overflows, for instance to generate apparently random numbers.

▲▲ Only apparently random, because overflows are perfectly predictable. Inform story files store numbers in sixteen binary digits, so that when a number reaches 216 = 65,536 it clocks back round to zero (much as a car's odometer clocks over from 999999 miles to 000000). Now, since 65,535 is the value that comes before 0, it represents −1, and 65,534 represents −2 and so on. The result is that if you start with zero and keep adding 1 to it, you get 1, 2, 3, …, 32,767 and then −32,768, −32,767, −32,766, …, −1 and at last zero again. Here's how to predict an overflowing multiplication, say: first, multiply the two numbers as they stand, then keep adding or subtracting 65,536 from the result until it lies in the range −32,768 to 32,767. For example, 8 multiplied by 5,040 is 40,320, which is too big, but we only need to subtract 65,536 once to bring it into range, and the result is −25,216.

· · · · ·

In a complicated expression the order in which the operators work may affect the result. As most human readers would, Inform works out both of

    3 + 2 * 6
    2 * 6 + 3

as 15, because the operator `*` has “precedence” over `+` and so is acted on first. Brackets may be used to overcome this:

    (3 + 2) * 6
    2 * (6 + 3)

evaluate to 30 and 18 respectively. Each operator has such a “precedence level”. When two operators have the same precedence level (for example, `+` and `-` are of equal precedence) calculation is (almost always) “left associative”, that is, carried out left to right. So the notation `a-b-c` means `(a-b)-c` and not `a-(b-c)`. The standard way to write formulae in maths is to give `+` and `-` equal precedence, but lower than that of `*` and `/` (which are also equal). Inform agrees and also pegs `%` equal to `*` and `/`.

The last purely arithmetic operator is “unary minus”. This is also written as a minus sign `-` but is not quite the same as subtraction. The expression:

    -credit

means the same thing as `0-credit`. The operator `-` is different from all those mentioned so far because it operates only on one value. It has higher precedence than any of the five other arithmetic operators. For example,

    -credit - 5

means `(-credit) - 5` and not `-(credit - 5)`.

One way to imagine precedence is to think of it as glue attached to the operator. A higher level means stronger glue. Thus, in

    3 + 2 * 6

the glue around the `*` is stronger than that around the `+`, so that 2 and 6 belong bound to the `*`.

▲ Some languages have a “unary plus” too, but Inform hasn't.

· · · · ·

Some operators don't just work out values but actually change the current settings of variables: expressions containing these are called “assignments”. One such is “set equals”:

    alpha = 72

sets the variable `alpha` equal to 72. Like `+` and the others, it also comes up with an answer: which is the value it has set, in this case 72. The other two assignment operators are `++` and `--`, which will be familiar to any C programmer. They are unary operators, and mean “increase (or decrease) the value of this variable by one”. If the `++` or `--` goes before the variable, then the increase (or decrease) happens before the value is read off; if after, then after. For instance, if `variable` currently has the value 12 then:

`variable++` evaluates to 12 and leaves `variable` set to 13;
`++variable` evaluates to 13 and leaves `variable` set to 13;
`variable--` evaluates to 12 and leaves `variable` set to 11;
`--variable` evaluates to 11 and leaves `variable` set to 11.

These operators are provided as convenient shorthand forms, since their effect could usually be achieved in other ways. Note that expressions like

    500++     (4*alpha)--     34 = beta

are quite meaningless: the values of 500 and 34 cannot be altered, and Inform knows no way to adjust `alpha` so as to make `4*alpha` decrease by 1. All three will cause compilation errors.

· · · · ·

The “bitwise operators” are provided for manipulating binary numbers on a digit-by-digit basis, something which is only done in programs which are working with low-level data or data which has to be stored very compactly. Inform provides `&`, bitwise AND, `|`, bitwise OR and `~`, bitwise NOT. For each digit, such an operator works out the value in the answer from the values in the operands. Bitwise NOT acts on a single operand and results in the number whose i-th binary digit is the opposite of that in the operand (a 1 for a 0, a 0 for a 1). Bitwise AND (and OR) acts on two numbers and sets the i-th digit to 1 if both operands have (either operand has) i-th digit set. All Inform numbers are sixteen bits wide. So:

    $$10111100 & $$01010001 == $$0000000000010000
    $$10111100 | $$01010001 == $$0000000011111101
               ~ $$01010001 == $$1111111110101110

### §1.7 Arguments and Return Values

Here is one way to imagine how an Inform routine works: you feed some values into it, it then goes away and works on them, possibly printing some text out or doing other interesting things, and it then returns with a single value which it gives back to you. As far as you're concerned, the transaction consists of turning a group of starting values, called “arguments”, into a single “return value”:

A1, A2, A3, … → Routine → R

The number of arguments needed varies with the routine: some, like `Main` and the other routines in this chapter so far, need none at all. (Others need anything up to seven, which is the maximum number allowed by Inform.) On the other hand, every routine without exception produces a return value. Even when it looks as if there isn't one, there is. For example:

    [ Main;
      Sonnet();
    ];

    [ Sonnet;
      print "When to the sessions of sweet silent thought^";
      print "I summon up remembrance of things past^";
    ];

`Main` and `Sonnet` both take no arguments, but they both return a value: as it happens this value is `true`, in the absence of any instruction to the contrary. (As was mentioned earlier, `true` is the same as the number 1.) The statement `Sonnet();` calls `Sonnet` but does nothing with the return value, which is just thrown away. But if `Main` had instead been written like so:

    [ Main;
      print Sonnet();
    ];

then the output would be

When to the sessions of sweet silent thought
I summon up remembrance of things past
1

because now the return value, 1, is not thrown away: it is printed out.

You can call it a routine with arguments by writing them in a list, separated by commas, in between the round brackets. For instance, here is a call supplying two arguments:

    Weather("hurricane", 12);

When the routine begins, the value `"hurricane"` is written into its first local variable, and the value `12` into its second. For example, suppose:

    [ Weather called force;
      print "I forecast a ", (string) called, " measuring force ",
          force, " on the Beaufort scale.^";
    ];

Leaving the details of the `print` statement aside for the moment, the call to this routine produces the text:

I forecast a hurricane measuring force 12 on the Beaufort scale.

The `Weather` routine finishes when its `]` end-marker is reached, whereupon it returns `true`, but any of the following statements will finish a routine the moment they are reached:

`rfalse;` which returns `false`,
`rtrue;` which returns `true`,
`return;` which also returns true,
`return` ‹value›`;` which returns ‹value›.

For example, here is a routine to print out the cubes of the numbers 1 to 5:

    [ Main;
      print Cube(1), " ";
      print Cube(2), " ";
      print Cube(3), " ";
      print Cube(4), " ";
      print Cube(5), "^";
    ];

    [ Cube x;
      return x*x*x;
    ];

When interpreted, the resulting story file prints up the text:

1 8 27 64 125

▲ Any “missing arguments” in a routine call are set equal to zero, so the call `Cube()` is legal and does the same as `Cube(0)`. What you mustn't do is to give too many arguments: `Cube(1,2)` isn't possible because there is no variable to put the 2 into.

▲ A hazardous, but legal and sometimes useful practice is for a routine to call itself. This is called recursion. The hazard is that the following mistake can be made, probably in some much better disguised way:

    [ Disaster;
      return Disaster();
    ];

Despite the reassuring presence of the word `return`, execution is tied up forever, unable to finish evaluating the return value. The first call to `Disaster` needs to make a second before it can finish, the second needs to make a third, the third… and so on. (Actually, for “forever” read “until the interpreter runs out of stack space and halts”, but that's little comfort.)

### §1.8 Conditions: `if`, `true` and `false`

The facilities described so far make Inform about as powerful as the average small programmable calculator. To make it a proper programming language, it needs much greater flexibility of action. This is provided by special statements which control whether or not, and if so how many times or in what order, other statements are executed. The simplest is if:

`if (`‹condition›`)` ‹statement›

which executes the ‹statement› only if the ‹condition›, when it is tested, turns out to be true. For example, when the statement

    if (alpha == 3) print "Hello";

is executed, the word “Hello” is printed only if the variable `alpha` currently has value 3. It's important not to confuse the `==` (test whether or not equal to) with the `=` operator (set equal to). But because it's easy to write something plausible like

    if (alpha = 3) print "Hello";

by accident, which always prints “Hello” because the condition evaluates to 3 which is considered non-zero and therefore true (see below), Inform will issue a warning if you try to compile something like this. (‘`=`’ used as condition: ‘`==`’ intended?)

· · · · ·

Conditions are always given in brackets. There are 12 different conditions in Inform (see Table 1), six arithmetic and half a dozen to do with objects. Here are the arithmetic ones:

`(a == b)` | `a` equals `b`
`(a ~= b)` | `a` doesn't equal `b`
`(a >= b)` | `a` is greater than or equal to `b`
`(a <= b)` | `a` is less than or equal to `b`
`(a > b)` | `a` is greater than `b`
`(a < b)` | `a` is less than `b`

A useful extension to this set is provided by the special operator `or`, which gives alternative possibilities. For example,

    if (alpha == 3 or 4) print "Scott";
    if (alpha ~= 5 or 7 or 9) print "Amundsen";

where two or more values are given with the word or between. “Scott” is printed if `alpha` has value either 3 or 4, and “Amundsen” if the value of `alpha` is not 5, is not 7 and is not 9. `or` can be used with any condition, and any number of alternatives can be given. For example

    if (player in Forest or Village or Building) ...

often makes code much clearer than writing three separate conditions out. Or you might want to use

    if (x > 100 or y) ...

to test whether `x` is bigger than the minimum of 100 and `y`.

Conditions can also be built up from simpler ones using the three logical operators `&&`, `||` and `~~`, pronounced “and”, “or” and “not”. For example,

    if (alpha == 1 && (beta > 10 || beta < -10)) print "Lewis";
    if (~~(alpha > 6)) print "Clark";

“Lewis” is printed if `alpha` equals 1 and `beta` is outside the range −10 to 10; “Clark” is printed if `alpha` is less than or equal to 6.

▲ `&&` and `||` work left to right and stop evaluating conditions as soon as the final outcome is known. So for instance `if (A && B) ...` will work out `A` first. If this is `false`, there's no need to work out `B`. This is sometimes called short-cut evaluation and can be convenient when working out conditions like

    if (x~=nothing && TreasureDeposited(x)==true) ...

where you don't want `TreasureDeposited` to be called with the argument `nothing`.

· · · · ·

Conditions are expressions like any other, except that their values are always either `true` or `false`. You can write a condition as a value, say by copying it into a variable like so:

    lower_caves_explored = (Y2_Rock_Room has visited);

This kind of variable, storing a logical state, is traditionally called a “flag”. Flags are always either `true` or `false`: they are like the red flag over the beach at Lee-on-Solent in Hampshire, which is either flying, meaning that the army is using the firing range, or not flying, when it is safe to walk along the shore. Flags allow you to write natural-looking code like:

    if (lower_caves_explored) print "You've already been that way.";

The actual test performed by `if (x) ...` is `x~=0`, not that `x==true`, because all non-zero quantities are considered to represent truth whereas only zero represents falsity.

· · · · ·

▲ Now that the `if` statement is available, it's possible to give an example of a recursion that does work:

    [ GreenBottles n;
      print n, " green bottles, standing on a wall.^";
      if (n == 0) print "(And an awful lot of broken glass.)^";
      else {
          print "And if one green bottle should accidentally fall^";
          print "There'd be ", n-1, " green bottles.^";
          return GreenBottles(n-1);
      }
    ];

Try calling `GreenBottles(10)`. It prints the first verse of the song, then before returning it calls `GreenBottles(9)` to print the rest. So it goes on, until `GreenBottles(0)`. At this point `n` is zero, so the text “(And an awful lot of broken glass.)” is printed for the first and only time. `GreenBottles(0)` then returns back to `GreenBottles(1)`, which returns to `GreenBottles(2)`, which… and so on until `GreenBottles(10)` finally returns and the song is completed.

▲▲ Thus execution reached “ten routines deep” before starting to return back up, and each of these copies of `GreenBottles` had its own private copy of the variable `n`. The limit to how deep you are allowed to go varies from one player's machine to another, but here is a rule of thumb, erring on the low side for safety's sake. (On a standard interpreter it will certainly be safe.) Total up 4 plus the number of its variables for each routine that needs to be running at the same time, and keep the total beneath 1,000. Ten green bottles amounts only to a total of 10 × 5 = 50, and as it seems unlikely that anyone will wish to read the lyrics to “two hundred and one green bottles” the above recursion is safe.

### §1.9 Code blocks, `else` and `switch`

A feature of all statements choosing what to do next is that instead of just giving a single ‹statement›, one can give a list of statements grouped together into a unit called a “code block”. Such a group begins with an open brace `{` and ends with a close brace `}`. For example,

    if (alpha > 5) {
        v = alpha*alpha;
        print "The square of alpha is ", v, ".^";
    }

If `alpha` is 3, nothing is printed; if `alpha` is 9,

The square of alpha is 81.

is printed. (The indentation used in the source code, like all points of source code layout, is a matter of personal taste.†) In some ways, code blocks are like routines, and at first it may seem inconsistent to write routines between `[` and `]` brackets and code blocks between braces `{` and `}`. However, code blocks cannot have private variables of their own and do not return values; and it is possible for execution to break out of code blocks again, or to jump from block to block, which cannot happen with routines.

† Almost everybody indents each code block as shown, but the position of the open brace is a point of schism. This book adopts the “One True Brace Style”, as handed down in such sacred texts as the original Unix source code and Kernighan and Ritchie's textbook of C. Other conventions place the open brace vertically above its matching closure, perhaps on its own otherwise blank line of source code.

· · · · ·

An `if` statement can optionally have the form

`if (` ‹condition› `)` ‹statement1› `else` ‹statement2›

whereupon ‹statement1› is executed if the condition is true, and ‹statement2› if it is false. For example,

    if (alpha == 5) print "Five."; else print "Not five.";

Note that the condition is only checked once, so that the statement

    if (alpha == 5) {
        print "Five.";
        alpha = 10;
    }
    else
        print "Not five.";

cannot ever print both “Five” and then “Not five”.

▲ The `else` clause has a snag attached: the problem of “hanging elses”. In the following, which `if` statement does the `else` attach to?

    if (alpha == 1) if (beta == 2)
        print "Clearly if alpha=1 and beta=2.^";
    else
        print "Ambiguous.^";

Without clarifying braces, Inform pairs an `else` to the most recent `if`. (Much as the U.S. Supreme Court rigorously interprets muddled laws like “all animals must be licensed, except cats, other than those under six months old” by applying a so-called Last Antecedent Rule to ambiguous qualifications like this “other than…”.) The following version is much better style:

    if (alpha == 1) {
        if (beta == 2)
            print "Clearly if alpha=1 and beta=2.^";
        else
            print "Clearly if alpha=1 but beta not 2.^";
    }

· · · · ·

The `if` … `else` … construction is ideal for switching execution between two possible “tracks”, like railway signals, but it is a nuisance trying to divide between many different outcomes this way. To follow the analogy, the `switch` construction is like a railway turntable.

    print "The train on platform 1 is going to ";
    switch (DestinationOnPlatform(1)) {
        1: print "Dover Priory.";
        2: print "Bristol Parkway.";
        3: print "Edinburgh Waverley.";
        default: print "a siding.";
    }

The `default` clause is optional but must be placed last if at all: it is executed when the original expression matches none of the other values. Otherwise there's no obligation for these clauses to be given in numerical or any other order. Each possible alternative value must be a constant, so

    switch (alpha) {
        beta: print "The variables alpha and beta are equal!";
    }

will produce a compilation error. (But note that in a typical game, the name of an object or a location, such as `First_Court`, is a constant, so there is no problem in quoting this as a switch value.)

Any number of outcomes can be specified, and values can be grouped together in lists separated by commas, or in ranges like 3 to 6. For example:

    print "The mission Apollo ", num, " made ";
    switch (num) {
        7, 9: print "a test-flight in Earth orbit.";
        8, 10: print "a test-flight in lunar orbit.";
        11, 12, 14 to 17: print "a landing on the Moon.";
        13: print "it back safely after a catastrophic explosion.";
    }

Each clause is automatically a code block, so a whole run of statements can be given without the need for any braces `{` and `}` around them.

▲ If you're used to the C language, you might want to note a major difference: Inform doesn't have “case fall-through”, with execution running from one case to the next, so there's no need to use `break` statements.

▲▲ A good default clause for the above example would be a little complicated: Apollo 1 was lost in a ground fire, causing a shuffle so that 2 and 3 never happened, while automatic test-flights of the Saturn rocket were unofficially numbered 4 to 6. Apollo 20 was cancelled to free up a heavy launcher for the Skylab station, and 18 and 19 through budget cuts, though the Apollo/Soyuz Test Project (1975) is sometimes unhistorically called Apollo 18. The three Apollo flights to Skylab were called Skylab 2, 3 and 4. All six Mercury capsules were numbered 7, while at time of writing the Space Shuttle mission STS-88 has just landed and the next to launch, in order, are projected to be 96, 93, 99, 103, 101 and 92. NASA has proud traditions.

### §1.10 `while`, `do`… `until`, `for`, `break`, `continue`

The other four Inform control constructions are all “loops”, that is, ways to repeat the execution of a given statement or code block. Discussion of one of them, called `objectloop`, is deferred until §3.4.

The two basic forms of loop are `while` and `do`…`until`:

`while (`‹condition›`)` ‹statement›
`do` ‹statement›`until (`‹condition›`)`

The first repeatedly tests the condition and, provided it is still true, executes the statement. If the condition is not even true the first time, the statement is never executed even once. For example:

    [ SquareRoot n x;
      while (x*x < n) x = x + 1;
      if (x*x == n) return x;
      return x - 1;
    ];

which is a simple if rather inefficient way to find square roots, rounded down to the nearest whole number. If `SquareRoot(200)` is called, then `x` runs up through the values 0, 1, 2, …, 14, 15, at which point `x*x` is 225: so 14 is returned. If `SquareRoot(0)` is called, the `while` condition never holds at all and so the return value is 0, made by the `if` statement.

The `do` … `until` loop repeats the given statement until the condition is found to be `true`. Even if the condition is already satisfied, like `(true)`, the statement is always executed the first time through.

· · · · ·

One particular kind of `while` loop is needed so often that there is an abbreviation for it, called `for`. This can produce any loop in the form

‹start›
`while (`‹condition›`) {`
`` …
`` ‹update›
`}`

where ‹start› and ‹update› are expressions which actually do something, such as setting a variable. The notation to achieve this is:

`for (`‹start›`:` ‹condition›`:` ‹update›`)` …

Note that if the condition is false the very first time, the loop is never executed. For instance, this prints nothing:

    for (counter=1 : counter<0 : counter++) print "Banana";

Any of the three parts of a `for` statement can be omitted. If the condition is missed out, it is assumed always `true`, so that the loop will continue forever, unless escaped by other means (see below).

For example, here is the `while` version of a common kind of loop:

    counter = 1;
    while (counter <= 10) {
        print counter, " ";
        counter++;
    }

which produces the output “1 2 3 4 5 6 7 8 9 10”. (Recall that `counter++` adds 1 to the variable counter.) The abbreviated version is:

    for (counter=1 : counter<=10 : counter++)
        print counter, " ";

▲ Using commas, several assignments can be joined into one. For instance:

    i++, score=50, j++

is a single expression. This is never useful in ordinary code, where the assignments can be divided up by semicolons in the usual way. But in `for` loops it can be a convenience:

    for (i=1, j=5: i<=5: i++, j--)
        print i, " ", j, ", ";

produces the output “1 5, 2 4, 3 3, 4 2, 5 1,”.

▲▲ Comma `,` is an operator, and moreover is the one with the lowest precedence level. The result of `a,b` is always `b`, but `a` and `b` are both evaluated and in that order.

· · · · ·

On the face of it, the following loops all repeat forever:

`while (true)` ‹statement›
`do` ‹statement›`until (false)`
`for (::)` ‹statement›

But there is always an escape. One way is to return from the current routine. Another is to jump to a label outside the loop (see below), though if one only wants to escape the current loop then this is seldom good style. It's neatest to use the statement `break`, which means “break out of” the current innermost loop or `switch` statement: it can be read as “finish early”. All these ways out are entirely safe, and there is no harm in leaving a loop only half-done.

The other simple statement used inside loops is `continue`. This causes the current iteration to end immediately, but the loop then continues. In particular, inside a `for` loop, `continue` skips the rest of the body of the loop and goes straight to the update part. For example,

    for (i=1: i<=5: i++) {
        if (i==3) continue;
        print i, " ";
    }

will output “1 2 4 5”.

· · · · ·

▲ The following routine is a curious example of a loop which, though apparently simple enough, contains a trap for the unwary.

    [ RunPuzzle n count;
      do {
         print n, " ";
         n = NextNumber(n);
         count++;
      }
      until (n==1);
      print "1^(taking ", count, " steps to reach 1)^";
    ];

    [ NextNumber n;
      if (n%2 == 0) return n/2;     ! If n is even, halve it
      return 3*n + 1;               ! If n is odd, triple and add 1
    ];

The call `RunPuzzle(10)`, for example, results in the output

10 5 16 8 4 2 1
(taking 6 steps to reach 1)

The definition of `RunPuzzle` assumes that, no matter what the initial value of `n`, enough iteration will end up back at 1. If this did not happen, the interpreter would lock up into an infinite loop, printing numbers forever. The routine is apparently very simple, so it would seem reasonable that by thinking carefully enough about it, we ought to be able to decide whether or not it will ever finish. But this is not so easy as it looks. `RunPuzzle(26)` takes ten steps, but there again, `RunPuzzle(27)` takes 111. Can this routine ever lock up into an infinite loop, or not?

▲▲ The answer, which caught the author by surprise, is: yes. Because of Inform's limited number range, eventually the numbers reached overflow 32,767 and Inform interprets them as negative − and quickly homes in on the cycle −1, −2, −1, −2,… This first happens to `RunPuzzle(447)`. Using proper arithmetic, unhindered by a limited number range, the answer is unknown. As a student in Hamburg in the 1930s, Lothar Collatz conjectured that every positive `n` eventually reaches 1. Little progress has been made (though it is known to be true if `n` is less than 240), and even Paul Erdös said of it that “Mathematics is not yet ready for such problems.” See Jeffrey Lagarias's bibliography The 3x + 1 Problem and its Generalisations (1996).

### §1.11 How text is printed

Adventure games take a lot of trouble over printing, so Inform is rich in features to make printing elegant output more easy. During story-file interpretation, your text will automatically be broken properly at line-endings. Inform story files are interpreted on screen displays of all shapes and sizes, but as a programmer you can largely ignore this. Moreover, Inform itself will compile a block of text spilling over several source-code lines into normally-spaced prose, so:

    print "Here in her hairs
           the painter plays the spider, and hath woven
           a golden mesh t'untrap the hearts of men
           faster than gnats in cobwebs";

results in the line divisions being replaced by a single space each. The text printed is: “Here in her hairs the painter plays the spider, and hath woven a golden mesh…” and so on. There is one exception to this: if a line finishes with a `^` (new-line) character, then no space is added.

▲ You shouldn't type double-spaces after full stops or other punctuation, as this can spoil the look of the final text on screen. In particular, if a line break ends up after the first space of a double-space, the next line will begin with the second space. Since many typists habitually double-space, Inform has a switch `-d1` which contracts “. ” to “. ” wherever it occurs, and then a further setting `-d2` which also contracts “! ” to “! ” and “? ” to “? ”. A modest warning, though: this can sometimes make a mess of diagrams. Try examining the 1851 Convention on Telegraphy Morse Code chart in ‘Jigsaw’, for instance, where the present author inadvertently jumbled the spacing because `-d` treated the Morse dots as full stops.

· · · · ·

When a string of text is printed up with `print`, the characters in the string normally appear exactly as given in the source code. However, four characters have special meanings. `^` means “print a new-line”. The tilde character `~`, meaning “print a quotation mark”, is needed since quotation marks otherwise finish strings. Thus,

    print "~Look,~ says Peter. ~Socks can jump.~^Jane agrees.^";

is printed as

“Look,” says Peter. “Socks can jump.”
Jane agrees.

The third remaining special character is `@`, occasionally used for accented characters and other unusual effects, as described below. Finally, `\` is reserved for “folding lines”, and is no longer needed but is retained so that old programs continue to work.

▲ If you want to print an actual `~`, `^`, `@` or `\`, you may need one of the following “escape sequences”. A double `@` sign followed by a decimal number means the character with the given ZSCII value, so in particular

`@@92` | comes out as “`\`” | `@@64` | comes out as “`@`”
`@@94` | comes out as “`^`” | `@@126` | comes out as “`~`”

· · · · ·

A number of Inform games have been written in European languages other than English, and even English-language games need accented letters from time to time. Inform can be told via command-line switches to assume that quoted text in the source code uses any of the ISO 8859-1 to -9 character sets, which include West and Central European forms, Greek, Arabic, Cyrillic and Hebrew. The default is ISO Latin-1, which means that you should be able to type most standard West European letters straight into the source code.

▲ If you can't conveniently type foreign accents on your keyboard, or you want to make a source code file which could be safely taken from a PC to a Macintosh or vice versa, you can instead type accented characters using `@`. (The PC operating system Windows and Mac OS use incompatible character sets, but this incompatibility would only affect your source code. A story file, once compiled, behaves identically on PC and Macintosh regardless of what accented letters it may contain.) Many accented characters can be written as `@`, followed by an accent marker, then the letter on which the accent appears:

`@^` put a circumflex on the next letter: a e i o u A E I O or U
`@'` put an acute on the next letter: a e i o u y A E I O U or Y
`@`` put a grave on the next letter: a e i o u A E I O or U
`@:` put a diaeresis on the next letter: a e i o u A E I O or U
`@c` put a cedilla on the next letter: c or C
`@~` put a tilde on the next letter: a n o A N or O
`@\` put a slash on the next letter: o or O
`@o` put a ring on the next letter: a or A

A few other letter-forms are available: German ß (`@ss`), ligatures (`@oe`, `@ae`, `@OE`, `@AE`), Icelandic “thorn” `@th` and “eth” `@et`, a pounds-sterling sign (`@LL`), Spanish inverted punctuation (`@!!` and `@??`) and continental European quotation marks (`@<<` and `@>>`): see Table 2. For instance,

    print "Les @oeuvres d'@AEsop en fran@ccais, mon @'el@`eve!";
    print "Na@:ive readers of the New Yorker re@:elected Mr Clinton.";
    print "Gau@ss first proved the Fundamental Theorem of Algebra.";

Accented characters can also be referred to as constants, like other characters. Just as `'x'` represents the character lower-case-X, so `'@^A'` represents capital-A-circumflex.

▲▲ It takes a really, really good interpreter with support built in for Unicode and access to the proper fonts to use such a story file, but in principle you can place any Unicode character into text by quoting its Unicode value in hexadecimal. For instance, `@{a9}` produces a copyright sign (Unicode values between `$0000` and `$00ff` are equal to ISO Latin1 values); `@{2657}` is a White bishop chess symbol; `@{274b}` is a “heavy eight teardrop-spoked propeller asterisk”; `@{621}` is the Arabic letter Hamza, and so on for around 30,000 more, including vast sets for Pacific Rim scripts and even for invented ones like Klingon or Tolkien's Elvish. Of course none of these new characters are in the regular ZSCII set, but ZSCII is configurable using Inform's Zcharacter directive. See §36 for more.

· · · · ·

▲ The remaining usage of `@` is hacky but powerful. Suppose you are trying to implement some scenes from Infocom's spoof of 1930s sci-fi, ‘Leather Goddesses of Phobos’, where one of the player's companions has to be called Tiffany if the player is female, and Trent if male. The name turns up in numerous messages and it would be tiresome to keep writing

    if (female_flag) print "Tiffany"; else print "Trent";

Instead you can use one of Inform's 32 “printing-variables” `@00` to `@31`. When the text `@14` is printed, for instance, the contents of string 14 are substituted in. The contents of string 14 can be set using the `string` statement, so:

    if (female_flag) string 14 "Tiffany"; else string 14 "Trent";
    ...
    print "You offer the untangling cream to @14, who whistles.^";

The value specified by a `string` statement has to be a literal, constant bit of text. There are really hacky ways to get around this, but if you needed to then you'd probably be better off with a different solution anyway.

### §1.12 The `print` and `print_ret` statements

The `print` and `print_ret` statements are almost identical. The difference is that the second prints out a final and extra new-line character, and then causes a return from the current routine with the value `true`. Thus, `print_ret` should be read as “print this, print a new-line and then return `true`”, and so

    print_ret "That's enough of that.";

is equivalent to

    print "That's enough of that.^"; rtrue;

As an abbreviation, it can even be shortened to:

    "That's enough of that.";

Although Inform newcomers are often confused by the fact that this innocently free-standing bit of text actually causes a return from the current routine, it's an abbreviation which pays dividends in adventure-writing situations:

    if (fuse_is_lit) { deadflag = true; "The bomb explodes!"; }
    "Nothing happens.";

Note that if the source code:

    [ Main;
      "Hello, and now for a number...";
      print 21*764;
    ];

is compiled, Inform will produce the warning message:

    line 3: Warning: This statement can never be reached.
    >   print 21*764;

because the bare string on line 2 is printed using `print_ret`: so the text is printed, then a new-line is printed, and then a return takes place immediately. As the warning message indicates, there is no way the statement on line 3 can ever be executed.

So what can be printed? The answer is a list of terms, separated by commas. For example,

    print "The value is ", value, ".";

contains three terms. A term can take the following forms:

‹a value› | printed as a (signed, decimal) number
‹text in double-quotes› | printed as text
`(`‹rule›`)` ‹value› | printed according to some special rule

Inform provides a stock of special printing rules built-in, and also allows the programmer to create new ones. The most important rules are:

`(char)` | print out the character which this is the ZSCII code for
`(string)` | print out this string
`(address)` | print out the text of this dictionary word
`(name)` | print out the name of this object (see §3)

Games compiled with the Inform library have several other printing rules built-in (like `print (The)` …), but as these aren't part of the Inform language as such they will be left until §26.

▲ `print (string)` … requires a little explanation. Of the following lines, the first two print out “Hello!” but the third prints only a mysterious number:

    print (string) "Hello!";
    x = "Hello!"; print (string) x;
    x = "Hello!"; print x;

This is because strings are internally represented by mysterious numbers. `print (string)` means “interpret this value as the mysterious number of a string, and print out that string”: it is liable to give an error, or in some cases print gibberish, if applied to a value which isn't the mysterious number of any string.

· · · · ·

Any Inform program can define its own printing rules simply by providing a routine whose name is the same as that of the rule. For example, the following pair of routines provides for printing out a value as a four-digit, unsigned hexadecimal number:

    [ hex x y;
      y = (x & $7f00) / $100;
      if (x<0) y = y + $80;
      x = x & $ff;
      print (hexdigit) y/$10, (hexdigit) y,
            (hexdigit) x/$10, (hexdigit) x;
    ];

    [ hexdigit x;
      x = x % $10;
      switch (x) {
          0 to 9: print x;
          10: print "a";  11: print "b";  12: print "c";
          13: print "d";  14: print "e";  15: print "f";
      }
    ];

You can paste these two routines into any Inform source code to make these new printing rules `hex` and `hexdigit` available to that code. For example, `print (hex) 16339;` will then print up “3fd3”, and `print (hex) -2;` will print “fffe”. Something to look out for is that if you inadvertently write

    print hex(16339);

then the text printed will be “3fd31”, with a spurious 1 on the end: because you've printed out the return value of the routine `hex`, which was `true`, or in other words 1.

### §1.13 Other printing statements

Besides `print` and `print_ret`, several other statements can also be used for printing.

    new_line

prints a new-line, otherwise known as a carriage return (named for the carriage which used to move paper across a typewriter). This is equivalent to

    print "^"

but is a convenient abbreviation. Similarly,

`spaces` ‹number›

prints a sequence of the given number of spaces.

`box` ‹string1› … ‹stringn›

displays a reverse-video panel in the centre of the screen, containing each string on its own line. For example, the statement

    box "Passio domini nostri" "Jesu Christi Secundum" "Joannem";

displays the opening line of the libretto to Arvo Pärt's ‘St John Passion’:

Passio domini nostri Jesu Christi Secundum Joannem

· · · · ·

Text is normally displayed in an unembellished but legible type intended to make reading paragraphs comfortable. Its actual appearance will vary from machine to machine running the story file. On most machines, it will be displayed using a “font” which is variably-pitched, so that for example a “w” will be wider on-screen than an “i”. Such text is much easier to read, but makes it difficult to print out diagrams. The statement

    print "+------------+
          ^+   Hello    +
          ^+------------+^";

will print something irregular if the letters in “Hello” and the characters “-”, “+” and “ ” (space) do not all have the same width on-screen:

+------------+
+ Hello +
+------------+

Because one sometimes does want to print such a diagram, to represent a sketch-map, say, or to print out a table, the statement `font` is provided:

    font on
    font off

`font off` switches into a fixed-pitch display style. It is now guaranteed that the interpreter will print all characters at the same width. `font on` restores the usual state of affairs.

In addition, you can choose the type style from a small set of possibilities: roman (the default), boldface, underlined or otherwise emphasized (some interpreters will use italic for this), reverse-colour:

    style roman
    style bold
    style underline
    style reverse

“Reverse colour” would mean, for instance, yellow on blue if the normal text appearance happened to be blue on yellow. An attempt will be made to approximate these effects whatever kind of machine is running the story file.

▲ Changes of foreground and background colours, so memorably used in games like Adam Cadre's ‘Photopia’, can be achieved with care using Z-machine assembly language. See §42.

### §1.14 Generating random numbers

Inform provides a small stock of functions ready-defined, but which are used much as other routines are. As most of these concern objects, only one will be given here: `random`, which has two forms:

    random(N)

returns a random number in the range 1, 2, …, `N`, each of these outcomes being (in theory) equally likely. `N` should be a positive number, between 1 and 32,767, for this to work properly.

`random(`‹two or more constant quantities, separated by commas›`)`

returns a random choice from the given selection of constant values. Thus,

    print (string) random("red", "blue", "green", "violet");

prints the name of one of these four colours at random. Likewise,

    print random(13, 17);

has a 50% chance of printing “13”, and a 50% chance of printing “17”.

▲ Random numbers are produced inside the interpreter by a “generator” which is not truly random in its behaviour. Instead, the sequence of numbers it produces depend on a value inside the generator called the “seed”. Setting this value is called “seeding the random-number generator”. Whenever it has the same seed value, the same sequence of random values will be harvested. This is called “pseudo-randomness”. An interpreter normally goes to some effort to start up with a seed value which is unpredictable: say, the current time of day in milliseconds. Because you just might want to make it predictable, though, you can change the seed value within the story file by calling `random(N)` for a negative number `N` of your own choosing. (This returns zero.) Seeding is sometimes useful to test a game which contains random events or delays. For example if you have release 29 of Infocom's game ‘Enchanter’, you may be surprised to know that you can type “#random 14” into it, after which its random events will be repeatable and predictable. Internally, ‘Enchanter’ does this by calling `random(-14)`.

### §1.15 Deprecated ways to jump around

There are four statements left which control the flow of execution, but one should try to avoid using any of them if, for instance, a `while` loop would do the job more tidily. Please stop reading this section now.

▲ Oh very well. ‘Deprecated’ is too strong a word, anyway, as there are circumstances where jumping is justified and even elegant: to break out of several loops at once, for instance, or to construct a finite state machine. It's the gratuitous use of jumping which is unfortunate, as this rapidly decreases the legibility of the source code.

▲ The `jump` statement transfers execution to some named place in the same routine. (Some programming languages call this `goto`.) To use `jump` a notation is needed to mark particular places in the source code. Such markers are called “labels”. For example, here is a never-ending loop made by hand:

    [ Main i;
      i=1;
      .Marker;
      print "I have now printed this ", i++, " times.^";
      jump Marker;
    ];

This routine has one label, `Marker`. A statement consisting only of a full stop and then an identifier means “put a label here and call it this”. Like local variables, labels belong to the routines defining them and cannot be used by other routines.

▲ The `quit` statement ends interpretation of the story file immediately, as if a return had taken place from the `Main` routine. This is a drastic measure, best reserved for error conditions so awful that there is no point carrying on.

▲▲ An Inform story file has the ability to save a snapshot of its entire state and to restore back to that previous state. This snapshot includes values of variables, the point where code is currently being executed, and so on. Just as we cannot know if the universe is only six thousand years old, as creationists claim, having been endowed by God with a carefully faked fossil record, so an Inform story file cannot know if it has been executing all along or if it was only recently restarted. The statements required are `save` and `restore`:

`save` ‹label›
`restore` ‹label›

This is a rare example of an Inform feature which may depend on the host machine's state of health: for example, if all disc storage is full, then `save` will fail. It should always be assumed that these statements may well fail. A `jump` to the label provided occurs if the operation has been a success. This is irrelevant in the case of a `restore` since, if all has gone well, execution is now resuming from the successful branch of the `save` statement: because that is where execution was when the state was saved.

▲▲ If you don't mind using assembly language (see §42), you can imitate exceptions, in the sense of programming languages like Java. The opcodes you would need are `@throw` and `@catch`.

• REFERENCES
If you need to calculate with integers of any size then the restriction of Inform numbers to the range −32,768 to 32,767 is a nuisance. The function library `"longint.h"`, by Chris Hall and Francis Irving, provides routines to calculate with signed and unsigned 4-byte integers, increasing the range to about ±2,147,000,000. •L. Ross Raszewski's function library `"ictype.h"` is an Inform version of the ANSI C routines `"ctype.h"`, which means that it contains routines to test whether a given character is lower or upper case, or is a punctuation symbol, and so forth. (See also the same author's `"istring.h"`.)