Identifiers are sequences of letters, digits and underscore. The first character must be a letter or an underscore.

Number literals are integer or real constants. The type of an integer literal is the minimal type to which the constant value belongs (see Basic types). If the literal is specified with the suffix H (or h), the representation is hexadecimal. If the literal is specified with the suffix O (or o), the representation is octal. If the literal is specified with the suffix B (or b), the representation is binary. Otherwise the representation is decimal. Integer literals can be interspersed with underscores for better readability.

A real number always contains a decimal point and at least one digit before the point. Optionally it may also contain a decimal scale factor. The letter E (or e) means times ten to the power of.

Character constants are denoted by the ordinal number of the character in hexadecimal notation followed by the letter X (or x).

A character is encoded as a 8-bit code value using the ISO/IEC 8859-1 Latin-1 encoding scheme.

Strings are sequences of printable characters enclosed in single (') or double (") quote marks. The opening quote must be the same as the closing quote and must not occur within the string. A string must not extend over the end of a line. The number of characters in a string is called its length. A string of length 1 can be used wherever a character constant is allowed and vice versa.

Operators and delimiters are the special characters, or character pairs listed below.

The reserved words consist of either all capital or all lower case letters and cannot be used as identifiers. All words listed below are reserved (only capital letter versions shown).

Comments are arbitrary character sequences opened by the bracket (* and closed by *). Comments may be nested. They do not affect the meaning of a program. Luon also supports line comments; text starting with // up to a line break is considered a comment.

The basic types are denoted by predeclared identifiers. The associated operators are defined in Operators and the predeclared function procedures in Predeclared procedures. Either all capital or all lower case identifiers are supported (only capital versions shown).

The values of the given basic types are the following:

INTEGER, and BYTE are integer types, REAL is a floating point type, and together they are called numeric types. The larger type includes (the values of) the smaller type according to the following relations:

An array is a structure consisting of a number of elements which are all of the same type, called the element type. The number of elements of an array is called its length. The length is a positive integer. The elements of the array are designated by indices, which are integers between 0 and the length minus 1.

Arrays declared without length are called open arrays. They can be created for any size.

A dictionary is a structure consisting of arbitrary key-value pairs. The keys and values are all of the same type, called the key and value types. New values are added to the dictionary by assigning the value to a given key. If the value is the default value of the value type, the key-value pair is removed. Accordingly, if the dictionary is indexed with a non-existing key, the default value of the value type is returned. No particular order of the keys is assumed. The KEYS() predeclared function can be used to iterate over all keys included in the dictionary.

A record type is a structure consisting of a fixed number of elements, called fields, with possibly different types. The record type declaration specifies the name and type of each field. The scope of the field identifiers extends from the point of their declaration to the end of the record type, but they are also visible within designators referring to elements of record variables (see Operands). If a record type is exported, field identifiers that are to be visible outside the declaring module must be marked. They are called public fields; unmarked elements are called private fields.

Record types are extensible, i.e. a record type can be declared as an extension of another record type. In the example

T1 is a (direct) extension of T0 and T0 is the (direct) base type of T1 (see Definition of terms). An extended type T1 consists of the fields of its base type and of the fields which are declared in T1. Fields declared in the extended record shadow equally named fields declared in a base type.

Each record is implicitly an extension of the predeclared record type ANYREC. ANYREC does not contain any fields and cannot be instantiated.

All structured types are dynamically allocated. Variables of structured types are automatically initialized with NIL.

If p is a variable of a structured type, a call of the predeclared procedure NEW(p) (see Predeclared procedures) allocates a variable of type T on the heap. If T is a record type or an array type with fixed length, the allocation has to be done with NEW(p); if T is an open array type the allocation has to be done with NEW(p, e) where T is allocated with length given by the expressions e. In either case a reference to the allocated instance is assigned to p. p is of type P.

Variables of a procedure type T have a procedure (or NIL) as value. If a procedure P is assigned to a variable of type T, the formal parameter lists and result types (see Formal parameters) of P and T must match (see Definition of terms). A procedure P assigned to a variable or a formal parameter must not be a predeclared, nor a type-bound procedure.

An enumeration is a list of identifiers that denote the values which constitute a data type. These identifiers are used as constants in the program. They, and no other values, belong to this type. The values are ordered. and the ordering relation is defined by their sequence in the enumeration. The ordinal number of the first value is O, but can be explicitly set to any integer.

The ordinal number of an enumeration identifier can be obtained using the ORD predeclared function procedure, or by just assigning/passing to an integer type variable or parameter. CAST is the reverse operation. MIN returns the first and MAX the last ident of the enumeration. INC returns the next and DEC the previous ident. If T is an enumeration type then INC(MAX(T)) and DEC(MIN(T)) are undefined and terminate the program.

With the exception of set constructors and literal constants (numbers, character constants, or strings), operands are denoted by designators. A designator consists of an identifier referring to a constant, variable, or procedure. This identifier may possibly be qualified by a module identifier (see Declarations and scope rules and Modules) and may be followed by selectors if the designated object is an element of a structure.

If a designates an array, then a[e] denotes that element of a whose index is the current value of the expression e. The type of e must be an integer type.

If r designates a record, then r.f denotes the field f of r or the procedure f bound to the dynamic type of r (see Type-bound procedures).

If a or r are read-only, then also a[e] and r.f are read-only.

A type guard v(T) asserts that the dynamic type of v is T (or an extension of T), i.e. program execution is aborted, if the dynamic type of v is not T (or an extension of T). Within the designator, v is then regarded as having the static type T. The guard is applicable, if

If the designated object is a constant or a variable, then the designator refers to its current value. If it is a procedure, the designator refers to that procedure unless it is followed by a (possibly empty) parameter list in which case it implies an activation of that procedure and stands for the value resulting from its execution. The actual parameters must correspond to the formal parameters as in proper procedure calls (see Formal parameters).

Four classes of operators with different precedences (binding strengths) are syntactically distinguished in expressions. The operator ~ has the highest precedence, followed by multiplication operators, addition operators, and relations. Operators of the same precedence associate from left to right. For example, x-y-z stands for (x-y)-z.

Statement sequences denote the sequence of actions specified by the component statements which are optionally separated by semicolons.

Assignments replace the current value of a variable by a new value specified by an expression. The expression must be assignment compatible with the variable (see Definition of terms). The assignment operator is written as := and pronounced as becomes.

If an expression e of type T_e is assigned to a variable v of type T_v, the following happens:

A procedure call activates a procedure. It may contain a list of actual parameters which replace the corresponding formal parameter list defined in the procedure declaration (see Procedure declarations). The correspondence is established by the positions of the parameters in the actual and formal parameter lists. There are three kinds of parameters: variable (VAR), CONST and value parameters.

If a formal parameter is a VAR parameter, the corresponding actual parameter must be a designator denoting a variable. If it denotes an element of a structured variable, the component selectors are evaluated when the formal/actual parameter substitution takes place, i.e. before the execution of the procedure. If the formal parameter is CONST, then the designated variable, element or field is read-only within the procedure. If a formal parameter is a value parameter, the corresponding actual parameter must be an expression. This expression is evaluated before the procedure activation, and the resulting value is assigned to the formal parameter (see also Formal parameters).

If statements specify the conditional execution of guarded statement sequences. The boolean expression preceding a statement sequence is called its guard. The guards are evaluated in sequence of occurrence, until one evaluates to TRUE, whereafter its associated statement sequence is executed. If no guard is satisfied, the statement sequence following the symbol ELSE is executed, if there is one.

Case statements specify the selection and execution of a statement sequence according to the value of an expression. First the case expression is evaluated, then that statement sequence is executed whose case label list contains the obtained value. The case expression must either be of an integer type that includes the types of all case labels, or an enumeration type with all case labels being valid members of this type, or both the case expression and the case labels must be of type CHAR. Case labels are constants, and no value must occur more than once. If the value of the expression does not occur as a label of any case, the statement sequence following the symbol ELSE is selected, if there is one, otherwise the program is aborted.

The type T of the case expression (case variable) may also be a variable parameter of record type variable. Then each case consists of exactly one case label which must be an extension of T (see Definition of terms), and in the statements S_i labelled by T_i, the case variable is considered as of type T_i. The evaluation order corresponds to the case label order; the first statement sequence is executed whose case label meets the condition.

While statements specify the repeated execution of a statement sequence while the Boolean expression (its guard) yields TRUE. The guard is checked before every execution of the statement sequence.

A repeat statement specifies the repeated execution of a statement sequence until a condition specified by a Boolean expression is satisfied. The statement sequence is executed at least once.

A for statement specifies the repeated execution of a statement sequence while a progression of values is assigned to a control variable of the for statement. Control variables can be of integer or enumeration types. An explicit BY expression is only supported for integer control variables.

The statement

is equivalent to

temp has the same type as v. For integer control variables, step must be a nonzero constant expression; if step is not specified, it is assumed to be 1. For enumeration control variables, there is no explicit step, but the INC or DEC version of the while loop is used depending on ORD(first) ⇐ ORD(last).

A loop statement specifies the repeated execution of a statement sequence. It is terminated upon execution of an exit statement within that sequence (see Return and exit statements).

Loop statements are useful to express repetitions with several exit points or cases where the exit condition is in the middle of the repeated statement sequence.

A return statement indicates the termination of a procedure. It is denoted by the symbol RETURN, followed by an expression if the procedure is a function procedure. The type of the expression must be assignment compatible (see Definition of terms) with the result type specified in the procedure heading (see Procedure declarations).

Function procedures require the presence of a return statement indicating the result value. In proper procedures, a return statement is implied by the end of the procedure body. Any explicit return statement therefore appears as an additional (probably exceptional) termination point.

An exit statement is denoted by the symbol EXIT. It specifies termination of the enclosing loop statement and continuation with the statement following that loop statement. Exit statements are contextually, although not syntactically associated with the loop statement which contains them.

Exception handling is implemented using the predeclared procedures PCALL and RAISE (see Predeclared proper procedures), without any special syntax. There are no predefined exceptions.

An exception is a record. This record is passed as an actual argument to RAISE. If the argument is nil instead, the program execution aborts. RAISE may be called without an argument in which case the compiler provides an allocated record the exact type of which is not relevant. RAISE never returns, but control is transferred from the place where RAISE is called to the nearest dynamically-enclosing call of PCALL. When calling RAISE without a dynamically-enclosing call of PCALL the program execution is aborted.

PCALL executes a protected call of the procedure or procedure type P. P is passed as the second argument to PCALL. P cannot have a return type. P can be a type-bound procedure type. P can be a nested procedure, even if it accesses local variables or parameters of an outer procedure. If P has formal parameters the corresponding actual parameters are passed to PCALL immediately after P. The actual parameters must be parameter compatible with the formal parameters of P (see Definition of terms). The first parameter R of PCALL is of type ANYREC; if RAISE(E) is called in the course of P, then R is set to E; otherwise R is set to NIL. The state of VAR parameters of P or local variables or parameters of an outer procedure accessed by P is non-deterministic in case RAISE is called in the course of P.

Formal parameters are identifiers declared in the formal parameter list of a procedure. They correspond to actual parameters specified in the procedure call. The correspondence between formal and actual parameters is established when the procedure is called. There are three kinds of parameters, value, variable (VAR) and CONST parameters, indicated in the formal parameter list by the absence or presence of the reserved words VAR and CONST.

Value parameters are local variables to which the value of the corresponding actual parameter is assigned as an initial value. VAR parameters correspond to actual parameters that are variables, and they stand for these variables.

CONST parameters are like value parameters, but they are read-only in the procedure body. If a CONST parameters is of structured type, then also the elements or fields are transitively read-only in the procedure body.

The scope of a formal parameter extends from its declaration to the end of the procedure block in which it is declared. A function procedure without parameters must have an empty parameter list. It must be called by a function designator whose actual parameter list is empty too.

Procedures may be associated with a record type declared in the same scope. The procedures are said to be bound to the record type. The binding is expressed by the type of the receiver in the heading of a procedure declaration. The procedure is bound to the type T and is considered local to it.

If a procedure P is bound to a type T0, it is implicitly also bound to any type T1 which is an extension of T0. However, a procedure P' (with the same name as P) may be explicitly bound to T1 in which case it overrides the binding of P. P' is considered a redefinition of P for T1. The formal parameters of P and P' must match (see Definition of terms). If P and T1 are exported (see Declarations and scope rules), P' must be exported too.

If v is a designator and P is a type-bound procedure, then v.P denotes that procedure P which is bound to the dynamic type of v. Note, that this may be a different procedure than the one bound to the static type of v. v is passed to `P’s receiver according to the parameter passing rules specified in Chapter Formal parameters.

If r is the receiver parameter of P declared with type T, r.P^ denotes the (redefined, sometimes calles super) procedure P bound to a base type of T.

Type-bound procedure declarations may be nested and have access to constants, types and procedures declared in the environment of the type-bound procedure (unless concealed by a local declaration), but they don’t have access to the parameters or local variables of outer procedures.

Variables of a type-bound procedure type T have a type-bound procedure or NIL as value. To assign a type-bound procedure P to a variable of a type-bound procedure type T, the right side of the assignment must be a designator of the form v.P, where v is a record and P is a procedure bound to this record. Note, that the dynamic type of v determines which procedure is assigned; this may be a different procedure than the one bound to the static type of v. The formal parameter lists and result types (see Formal parameters) of P and T must match (see Definition of terms). The same rules apply when passing a type-bound procedure to a formal argument of a type-bound procedure type.

The following table lists the predeclared procedures. Some are generic procedures, i.e. they apply to several types of operands. v stands for a variable, x and n for expressions, and T for a type.

Modules can be made generic by adding formal meta parameters. Meta parameters represent types or constants; the latter include procedures. Meta parameters default to types, but can be explicitly prefixed with the TYPE reserved word; the CONST prefix designates a constant meta parameter. A meta parameter can be constrained with a named type, in which case the actual meta parameter must correspond to this type; the correspondence is established when the generic module is instantiated; the type of the actual meta parameter must be assignment compatible with the constraint type (see Definition of terms).

Generic modules can be instantiated with different sets of meta actuals which enables the design of reusable algorithms and data structures. The instantiation of a generic module occurs when importing it. A generic module can be instantiated more than once in the same module with different actual meta parameters. See also Modules.

Meta parameters can be used within the generic module like normal types or constants. If no type constraint is present, the types and constants can be used wherever no information about the actual type is required; otherwise the type constraint determines the permitted operations. The rules for same types and equal types apply analogously to meta parameters, and subsequently also the corresponding assignment, parameter and array compatibility rules.

See also this example.

Configuration variables can be set or unset in the source code using the following syntax:

Each variable is named by an ident which follows the syntax specified in Identifiers. Variable names have compilation unit scope which is separate from all other scopes of the program. Configuration variable directives can be placed anywhere in the source code. The directive only affects the present compilation unit, starting from its position in the source code.

Conditional compilation directives can be placed anywhere in the source code. The following syntax applies:

An ELSIF or ELSE directive must be preceded by an IF or another ELSIF directive. Each IF directive must be ended by an END directive. The directives form sections of the source code. Only the section the condition of which is TRUE (or the section framed by ELSE and END directive otherwise) is visible to the compiler. Conditions are boolean expressions. Ident refers to a configuration variable. When a configuration variable is not explicitly set it is assumed to be FALSE. Each section can contain nested conditional compilation directives.