1 % Inform in four minutes
2 % Roger Firth <roger@firthworks.com>
4 A quick reference to the Inform programming language.
6 Copyright © 2002 Roger Firth <roger@firthworks.com>. Copying and
7 distribution, with or without modification, are permitted in any
8 medium without royalty provided the copyright notice and this notice
11 <http://www.firthworks.com/roger/>
13 Version 1.3 (March 2002)
15 The road to brevity is via imprecision and through solecism.
20 A Z-code **word** literal uses sixteen bits (whereas a Glulx word has
21 thirty-two bits). A **byte** literal is always eight bits.
23 - Decimal: `-32768` to `32767`\
24 Hexadecimal: `$0` to `$FFFF`\
25 Binary: `$$0` to `$$1111111111111111`
28 - Dictionary word: `'aardvark'` (up to nine characters significant);
29 use circumflex "`^`" to denote apostrophe.\
30 Plural word: `'aardvarks//p'`\
31 Single-character word: `"a"` (`name` property only) or `'a//'`
32 - String: `"aardvark's adventure"` (maximum around 4000 characters);
33 can include special values including:
35 ------------- ------------------------------------
42 @`a a with a grave accent "`à`", et al
43 @LL pound sign "£", et al
44 @00 ... @31 low string 0..31
45 ------------- ------------------------------------
50 The identifier of an Inform *constant*, *variable*, *array*, *class*,
51 *object*, *property*, *attribute*, *routine* or *label*. Up to 32
52 characters: alphabetic (case not significant), numeric and underscore,
53 with the first character not a digit.
55 Expressions and Operators
56 -------------------------
58 Use parentheses (...) to control the order of evaluation.
59 Arithmetic/logical expressions support these operators:
61 ---------- ---------------------------------------------
64 *p * q* multiplication
65 *p / q* integer division
67 *p++* increments *p*, evaluates to original value
68 *++p* increments *p*, evaluates to new value
69 *p--* decrements *p*, evaluates to original value
70 *--p* decrements *p*, evaluates to new value
73 *~p* bitwise NOT (inversion)
74 ---------- ---------------------------------------------
76 Conditional expressions return `true` (1) or `false` (0); *q* may be a
77 list of alternatives *q1* `or` *q2* `or` ... *qN*:
79 ---------------- ----------------------------------------
80 *p == q* *p* is equal to *q*
81 *p ~= q* *p* isn't equal to *q*
82 *p* > *q* *p* is greater than *q*
83 *p < q* *p* is less than *q*
84 *p >= q* *p* is greater than or equal to *q*
85 *p <= q* *p* is less than or equal to *q*
86 *p ofclass q* object *p* is of class *q*
87 *p in q* object *p* is a child of object *q*
88 *p notin q* object *p* isn't a child of object *q*
89 *p provides q* object *p* provides property *q*
90 *p has q* object *p* has attribute *q*
91 *p hasnt q* object *p* hasn't attribute *q*
92 ---------------- ----------------------------------------
94 Boolean expressions return `true` (1) or `false` (0):
96 -------- ----------------------------------
97 p && q both p and q are true (non-zero)
98 p || q either p or q is true (non-zero)
100 -------- ----------------------------------
102 To return -1, 0 or 1 based on unsigned comparison:
106 To return `true` if object *q* is a child or grand-child or... of *p*:
108 IndirectlyContains(p,q)
110 To return a random number 1..*N*, or one from a list of constant
114 random(value,value, ... value )
119 Named word values, unchanging at run-time, which are by default
123 Constant constant = expr;
125 Standard constants are `true` (1), `false` (0) and `nothing` (0), also
128 To define a constant (unless it already exists):
130 Default constant expr ;
135 Named word/byte values which can change at run-time and are by default
138 A **global** variable is a single word:
141 Global variable = expr;
143 A **word array** is a set of global words accessed using `array-->0`,
144 `array-->1`, ... `array-->(N-1)`:
147 Array array --> expr1 expr2 ... exprN;
148 Array array --> "string";
150 A **table array** is a set of global words accessed using
151 *array-->1*, *array-->2*, ... *array-->N*, with
152 *array-->0* initialized to *N*:
154 Array array table N ;
155 Array array table expr1 expr2 ... exprN
156 Array array table "string";
158 A **byte array** is a set of global bytes accessed using
159 *array->0*, *array->1*, ... *array->(N-1)*:
162 Array array -> expr1 expr2 ... exprN;
163 Array array -> "string";
165 A **string array** is a set of global bytes accessed using
166 *array->1*, *array->2*, ... *array->N*, with *array->0*
169 Array array string N;
170 Array array string expr1 expr2 ... exprN;
171 Array array string "string";
173 In all these cases, the characters of the initializing *string* are
174 unpacked to the individual word/byte elements of the array. See also
175 Objects (for **property** variables) and Routines (for **local**
181 To declare a *class* - a template for a family of objects -
182 where the optional (*N*) limits instances created at run-time:
185 class class class ... class
186 has attr_def attr_def ... attr_def
191 To declare an *object*; "`Object`" can instead be a *class*, the
192 remaining four header items are all optional, and *arrows*
193 (`->`, `->` `->`, ...) and *parent_object* are incompatible:
195 Object arrows object "ext_name " parent_object
196 class class class ... class
197 has attr_def attr_def ... attr_def
202 The `class`, `has` and `with` (and also the rarely-used `private`)
203 segments are all optional, and can appear in any order.
205 To determine an object's class as one of `Class`, `Object`,
206 `Routine`, `String` (or `nothing`):
210 **has segment**: Each *attr_def* is either of:
215 To change attributes at run-time:
217 give object attr_def attr_def ... attr_def;
219 **with/private segments**: Each *prop_def* declares a variable
220 (or word array) and can take any of these forms (where a
221 *value* is an expression, a string or an embedded routine):
225 property value value ... value
227 A property variable is addressed by *object.property* (or
228 within the object's declaration as *self.property*).
230 Multiple values create a property array; in this case
231 *object.#property* is the number of **bytes** occupied by the
232 array, the entries can be accessed using
233 *object.&property-->0*, *object.&property-->1*, ... , and
234 *object.property* refers to the value of the first entry.
236 A property variable inherited from an object's class is
237 addressed by *object.class::property*; this gives the
238 original value prior to any changes within the object.
240 Manipulating the object tree
241 ----------------------------
243 To change object relationships at run-time:
245 move object to parent_object ;
248 To return the parent of an object (or nothing):
252 To return the first child of an object (or nothing):
256 To return the adjacent child of an object's parent (or nothing):
260 To return the number of child objects directly below an object:
271 class.destroy(object)
272 class.recreate(object)
273 class.copy(to_object,from_object)
277 object.property(a1,a2, ... a7)
281 routine.call(a1,a2, ... a7)
286 string.print_to_array(array)
291 Each *statement* is terminated by a semi-colon ";".
293 A *statement_block* is a single *statement* or a series of
294 *statements* enclosed in braces {...}.
296 An exclamation "!" starts a comment - rest of line ignored.
298 A common statement is the assignment:
302 There are two forms of multiple assignment:
304 variable = variable = ... = expr ;
305 variable = expr, variable = expr, ... ;
310 A routine can have up to 15 local variables: word values which are
311 private to the routine and which by default are set to zero on each
312 call. Recursion is permitted.
314 A **standalone** routine:
316 - has a name, by which it is called using `routine();` can also be
317 called indirectly using
319 indirect(routine,a1,a2, ... a7)
321 - can take arguments, using `routine(a1,a2, ... a7)`, whose values
322 initialise the equivalent local variables
324 - returns true at the final "]"
327 local_var local_var ... local_var ;
334 A routine **embedded** as the value of an object property:
336 - has no name, and is called when the property is invoked; can also
337 be called explicitly using object.property()
339 - accepts arguments only when called explicitly
341 - returns false at the final "]"
344 local_var local_var ... local_var;
351 Routines return a single value, when execution reaches the final "\]"
352 or an explicit return statement:
359 To define a dummy standalone routine with N local variables (unless it
367 To execute statements if *expr* is true; optionally, to execute other
368 statements if *expr* is false:
377 To execute statements depending on the value of *expr*:
380 value: statement; ... statement;
381 value: statement; ... statement;
383 default: statement; ... statement;
386 where each *value* can be given as:
389 lo_constant to hi_constant
390 constant,constant, ... constant
395 To execute statements while *expr* is true:
400 To execute statements until *expr* is true:
406 To execute statements while a variable changes:
408 for (set_var : loop_while_expr : update_var )
411 To execute statements for all defined objects:
413 objectloop (variable)
416 To execute statements for all objects selected by *expr*:
418 objectloop (expr_starting_with_variable)
421 To jump out of the current innermost loop or switch:
425 To immediately start the next iteration of the current loop: