The target type of the opaque pointer is declared in the library's corresponding implementation part and it is therefore inaccessible to clients. It is declared using the POINTER TO type constructor.

A blueprint defines constraints and requirements which libraries may be required to meet. A library that is required to meet the constraints and requirements of a blueprint is said to declare conformance to the blueprint. When a library declares conformance to a blueprint, its actual conformance is compiler enforced. Certain language features such as binding procedures and functions to operators and built-in syntax are only available to libraries that declare conformance to certain blueprints.

 DEFINITION MODULE FooBarBaz;

 END FooBarBaz.

 IMPORT FooBarBaz; (* equivalent to: IMPORT Foo, Bar, Baz; *)

Import Aggregation

A library that imports other libraries for the sole purpose of re-exporting them is called an import aggregator. This facility is useful for importing a collection of libraries or a library framework with a single import statement.

 DEFINITION MODULE Foo Bar Baz?;
 IMPORT Foo+, Bar+, Baz+;
 END Foo Bar Baz?.
 MODULE Client;
 IMPORT Foo Bar Baz?; (* equivalent to: IMPORT Foo, Bar, Baz; *)

Unqualified Aliasing

An IMPORT directive for single library may be followed by an ALIAS list. The ALIAS list contains one or more unqualified identifiers of the imported library. Imported identifiers whose unqualified names appear in an ALIAS list may then also be referenced by their unqualified identifiers within the importing module. This is called unqualified aliasing and it may cause name conflicts when aliasing identically named identifiers of different libraries. In the event of a name conflict a compile time error shall occur.

 IMPORT FileIO ALIAS Status;
 VAR status : Status; (* unqualified alias for FileIO.Status *)

A library being imported within a definition part of another library may be re-exported by marking it with a re-export tag. Such a re-export tag is denoted by a plus sign trailing the module identifier in an IMPORT directive.

When a library M3 imports another library M2 that re-exports another library M1, both M1 and M2 will be imported into M3.

Import With Re-Export

By default, an imported library is not re-exported. That is, a library M1 imported in the definition part of a library M2 is only available within the definition and implementation parts of M2, but not within any client module M3 that imports M2.

An imported library may be re-exported by marking it with a re-export tag. Such a re-export tag is denoted by a plus sign trailing the module identifier in an IMPORT directive.

 IMPORT Foo+, Bar+, Baz+; (* import and re-export Foo, Bar and Baz *)

Additionally, library modules may use entities provided by other library modules. In order to use the entities provided by a library module, the use of the library must be explicitly declared. A library whose use is so declared is said to be imported.

Library Blueprints

A library blueprint represents a specification to enforce the consistency and integrity of libraries.

Any entities defined or declared in a library's definition part are automatically visible and available in its implementation part without import. By contrast, entities declared only within the implementation part are not visible outside the implementation part. Such entities are said to be encapsulated.

Program Modules

A program module represents the topmost level of a Modula-2 program.

At minimum it will consist of a body that contains one or more statements that will be executed when the program is run. Additionally, it may define or declare constants, types, variables and procedures and function procedures of its own, or it may use such entities provided by one or more library modules. It does not provide any such entities to other modules.

Library Modules

Library modules represent repositories of constants, types, variables and procedures and function procedures for use by program modules and other library modules. Entities so provided are said to be exported by the library module.

Additionally, library modules may use entities provided by other library modules. In order to use the entities provided by a library module, the use of the library must be explicitly announced. A library whose use is so announced is said to be imported.

The Definition Part of Library Modules

The definition part of a library module represents the public interface of the library module.

Any entities defined or declared in the public interface of a library module are automatically exported.

The Implementation Part of Library Modules

The implementation part of a library module represents the implementation of the entities defined in its public interface.

Any entities defined or declared in a library's definition part are automatically visible and available in its implementation part without import. Entities declared only within the implementation part are not visible outside the implementation part. Such entities are said to be encapsulated.

Blueprints

A blueprint represents a specification to enforce the consistency and integrity of libraries.

A blueprint defines constraints and requirements which libraries may be declared to meet. A library that promises to meet the constraints and requirements of a blueprint is said to declare conformance to the blueprint. When a library declares conformance to a blueprint, its actual conformance is compiler enforced. Certain language features such as binding procedures and functions to operators and built-in syntax are only available to libraries that declare conformance to certain blueprints.

Pragma ENCODING specifies the encoding of the source file in which it appears. The pragma controls whether in addition to the characters that are permitted by the grammar, any further printable characters are permitted within quoted literals and comments. Any source file that is not strictly 7-bit ASCII encoded must contain an ENCODING pragma to specify its encoding. Semantics are given below.

Scenarios where pragma INLINE represents a mandate to inline are procedures with a single statement, such as procedures with a single assignment and functions with a single RETURN statement. This inline guarantee exists to promote the use of data encapsulation. Mutators and accessors tagged with an INLINE pragma shall always be inlined.

Scenarios where pragma INLINE represents a mandate are procedures with a single statement, such as procedures with a single assignment and functions with a single RETURN statement. This inline guarantee exists to promote the use of data encapsulation. Mutators and accessors tagged with an INLINE pragma shall always be inlined.

Scenarios where the pragma represents a mandate are mutators and accessors, also known as setter procedures and getter functions. A mutator is a procedure whose only purpose is to store a value in an encapsulated variable or record field. An accessor is a function whose only purpose is to return the value of an encapsulated variable or record field.

   hiddenFoo := value

   RETURN hiddenFoo

Pragma INLINE represents a suggestion that inlining of a procedure is desirable except for certain scenarios where it is specifically mandated. It shall appear both in the definition and implementation of the procedure. An informational message shall be emitted if the suggestion is not followed.

Scenarios where the pragma represents a mandate are mutators and accessors, also known as setter procedures and getter functions. A mutator is a procedure whose only purpose is to store a value in an encapsulated variable or record field. An accessor is a function whose only purpose is to return the value of an encapsulated variable or record field.

 (* Mutator with Inline Mandate *)
 PROCEDURE setFoo ( value : Foo ) <*INLINE*>;
 BEGIN
   foo := value (* hidden variable *)
 END setFoo;

 (* Accessor with Inline Mandate *)
 PROCEDURE foo : Foo <*INLINE*>;
 BEGIN
   RETURN foo (* hidden variable *)
 END foo;

 <*FORWARD TYPE ListNode*>

 TYPE ListNodePtr = POINTER TO ListNode;
 TYPE ListNode = RECORD data : Foo; nextNode : ListNodePtr END;

Pragma FORWARD shall be the only means of forward declaration in a single-pass compiler. Multi-pass compilers shall silently ignore any occurrences of pragma FORWARD without analysis of its contents. Two kinds of forward declarations may be embedded in the pragma: Type and procedure declarations.

 <*FORWARD TYPE List Node?*>
 TYPE List Node Ptr? = POINTER TO List Node?;
 TYPE List Node? = RECORD data : Foo; nextNode : List Node Ptr? END;

Status: 2015-10-08 (update in progress)

Incorrect Pragma Use and Unrecognised Pragmas

A pragma is incorrectly used if it is malformed, misplaced or any other rule for its use is not met. Any incorrect use of a mandatory pragma or a supported optional pragma shall cause a compile time error. Use of an unsafe pragma that is not supported or has not been enabled shall cause a compile time error.

Use of a safe optional pragma that is not supported shall cause a promotable soft compile time warning. An unsupported or unrecognised encoding specifier in pragma ENCODING shall cause a fatal compile time error. A code point sample list within pragma ENCODING shall be ignored if encoding verification is not supported. If a code point sample list or any excess samples are ignored a soft compile time warning shall be emitted. An unsupported or unrecognised language specifier in pragma FFI shall cause a compile time error.

An unrecognised implementation defined pragma shall be treated as specified by its default clause. An implementation defined pragma without a default clause is malformed and shall cause a compile time error.

A type defined in the definition part of a library with the same name as the library is called a module type. When a library with a module type is imported, an unqualified alias for the module type is automatically defined in the importing module. This facility is useful in the construction of abstract data types as library modules.

Aliasing of a qualified identifier that has already been aliased within the same module scope is permissible. Only the first aliasing is significant. Any subsequent aliasing is redundant. Redundant aliasing has no effect but shall cause a soft compile time warning.

Unqualified aliasing of a qualified identifier that has already been aliased within the same module scope is permissible. Only the first aliasing is significant. Any subsequent aliasing is redundant. Redundant aliasing has no effect but shall cause a soft compile time warning.

Import of an Already Imported Module

Import of a module that has already been imported into the same module scope is permissible. Only the first import is significant. Any subsequent imports are redundant. A redundant import has no effect but shall cause a soft compile time warning.

Unqualified Aliasing of an Already Aliased Identifier

Unqualified aliasing of an identifier that has already been aliased within the same module scope is permissible. Only the first aliasing is significant. Any subsequent aliasing is redundant. Redundant aliasing has no effect but shall cause a soft compile time warning.

Importing Libraries

Qualified Import

Unqualified Aliasing

An IMPORT directive for single library may be followed by an ALIAS list. The ALIAS list contains one or more unqualified identifiers of the imported library. Imported identifiers whose unqualified names appear in an ALIAS list may then also be referenced by their unqualified identifiers within the importing module. This is called unqualified aliasing and it may cause name conflicts when aliasing identically named identifiers of different libraries. In the event of a name conflict a compile time error shall occur.

Identifiers defined in the interface of a library module may be imported by other modules using an IMPORT directive. The import brings all exported identifiers into the scope of the importing module. Imported identifiers must be qualified with the exporting module's identifier when it is referenced in the importing module. This is called qualified import and it avoids name conflicts when importing identically named identifiers from different libraries.

 IMPORT FileIO; (* import of module FileIO *)
 VAR status : FileIO.Status; (* qualified identifier *)

An IMPORT directive for single library may be followed by an ALIAS list. The ALIAS list contains one or more unqualified identifiers of the imported library. Imported identifiers whose unqualified names appear in an ALIAS list may then also be referenced by their unqualified identifiers within the importing module. This is called unqualified aliasing and it may cause name conflicts when aliasing identically named identifiers of different libraries.

 IMPORT FileIO ALIAS Status;
 VAR status : Status; (* unqualified alias for FileIO.Status *)

 <*ENCODING="UTF8" : "é"=0uE9, "©"=0uA9, "€"=0u20AC*>

Pragmas

Mandatory Pragmas

Optional Pragmas

Mandatory Pragmas

Optional Pragmas

Implementation Defined Pragmas

Optional Pragmas

Optional Pragmas

• Optional Pragma ALIGN
• Optional Pragma PADBITS
• Optional Pragma NORETURN
• Optional Pragma PURITY
• Optional Pragma SINGLEASSIGN
• Optional Pragma LOWLATENCY
• Optional Pragma VOLATILE
• Optional Pragma DEPRECATED
• Optional Pragma FORWARD
• Optional Pragma ADDR
• Optional Pragma FFI
• Optional Pragma FFIDENT

• Pragma FORWARD

• Implementation Defined Pragmas

 <*GM2.UnrollLoops=TRUE|WARN*> (* turn loop-unrolling on, ignore but warn if unknown *)

The default clause specifies how the pragma shall be treated by implementations that do not recognise it. Modes INFO and WARN mandate it shall be ignored with an informational or warning message respectively. Modes ERROR and FATAL mandate it shall cause a compile time or fatal compile time error respectively.

Implementation Defined Pragmas

EBNF | Syntax Diagram

Implementation defined pragmas are compiler specific and generally non-portable.

An implementation defined pragma starts with a pragma symbol, which may be followed by a value assignment. The pragma ends with a mandatory default clause. The pragma symbol is an implementation defined name which shall be all-lowercase or mixed case. It may be qualified with an implementation prefix, indicating the name of the compiler. The value assignment follows if and only if the pragma is defined to hold a value. Such a value may be either a boolean value or a whole number.

 <*G M2.Unroll Loops?=TRUE|WARN*> (* turn loop-unrolling on, ignore but warn if unknown *)

Pragma PURITY marks a procedure with an intended purity level:

Pragma SINGLEASSIGN marks a variable as a single-assignment variable.

Such a variable should be assigned to only once in every possible runtime scenario. An implementation shall issue a promotable soft compile time warning for any single-assignment violation it may detect.

 VAR foo : INTEGER <*SINGLEASSIGN*>;

Pragma LOWLATENCY marks a local variable as latency-critical.

Marking a variable latency-critical represents a suggestion that mapping the variable to a machine register is desirable. An informational message shall be emitted if the suggestion is not followed.

 VAR foo : INTEGER <*LOWLATENCY*>;

Pragma VOLATILE marks a global variable as volatile.

By marking a variable volatile the author states that its value may change during the life time of a program even if no write access can be deduced from source code analysis. An implementation shall neither eliminate any variable so marked, nor shall it emit any unused variable warning for any variable so marked.

 VAR foo : INTEGER <*VOLATILE*>;

Pragma DEPRECATED marks a constant, variable, type or procedure as deprecated. A promotable soft com- pile time warning shall occur whenever an identifier of a deprecated entity is encountered.

 PROCEDURE foo ( bar : Baz ) <*DEPRECATED*>;

to do

Pragma ADDR maps a procedure or a global variable to a fixed memory address.

 PROCEDURE Reset <*ADDR=0x12*>;
 VAR memoryMappedPort : CARDINAL <*ADDR=0x100*>;

Pragma FFI marks a Modula-2 definition part as the Modula-2 interface to a library implemented in another language. Procedure definitions and type declarations in the definition part shall follow the calling convention of the specified language environment for the current target. Predefined foreign interface specifiers are “C”, “Fortran”, “CLR” and “JVM”. If pragma FFI is provided, at least one foreign interface shall be supported. CLR or JVM support is recommended for implementations that target the CLR or JVM, respectively.

 DEFINITION MODULE stdio <*FFI=“C”*>;
 FROM UNSAFE IMPORT FFI, VARGLIST;
 PROCEDURE printf ( CONST format : ARRAY OF CHAR; arglist : VARGLIST );

Pragma FFIDENT maps a Modula-2 identifier of a foreign procedure or variable definition to its respective identifier in the foreign library. It shall be used when the foreign identifier conflicts with Modula-2 reserved words or reserved identifiers. The pragma may only be used within a foreign function interface module.

 PROCEDURE Length ( s : ARRAY OF CHAR ) : INTEGER <*FFIDENT=”LENGTH”*>;
 VAR rwMode : [0..3] OF CARDINAL <*VOLATILE*> <*FFIDENT=”foobarlib_rw_mode”*>;

Pragma NORETURN marks a regular procedure with a promise never to return in any runtime scenario. A soft compile time warning shall occur if the compiler cannot prove that the promise is kept.

 PROCEDURE Reboot System? <*NORETURN*>;

Pragma PURITY marks a procedure with an intended purity level:
• level 0 : may read and modify global state, may call procedures of any level (Default)
• level 1 : may read but not modify global state, may only call level 1 and level 3 procedures
• level 2 : may not read but modify global state, may only call level 2 and level 3 procedures
• level 3 : pure procedure, may not read nor modify global state, may only call level 3 procedures
An implementation shall emit a promotable soft compile time warning for any purity level violation.

 PROCEDURE Foo ( bar : Bar) : Baz <*PURITY=3*>; (* pure and side-effect free *)

 <*PADBITS=2*>           (* unused 2 bits *)

Pragma PADBITS inserts a specified number of padding bits into a packed record type declaration. The maximum permitted value is 256 bits. The pragma is only permitted where alignment is set to zero.

 TYPE Packed = RECORD <*ALIGN=0*>
   oneBit    : [0..1] OF OCTET; (* 1 bit *)
 <*PADBITS=2*>            (* unused 2 bits *)
   twoBits   : [0..3] OF OCTET; (* 2 bits *)
   threeBits : [0..7] OF OCTET; (* 3 bits *)
 END; (* Packed *)

Symbol + denotes a multi-purpose operator. It is left associative and requires two operands.

When the pragma is placed in a module header, it has module scope and determines the default alignment within the module. Permitted alignment values range from one to 32 octets.

 DEFINITION MODULE Foolib <*ALIGN=TSIZE(CARDINAL)*>; (* module scope *)

When the pragma is placed at the end of an array type declaration, it has array scope and determines the alignment of array components. Permitted alignment values range from one to 32 octets.

 TYPE Array = ARRAY 10 OF OCTET <*ALIGN=4*>; (* array scope *)

When the pragma is placed in the body of a record type declaration, it has field list scope and determines the alignment of record fields following the pragma. Permitted alignment values range from zero to 32 octets.

 TYPE Aligned = RECORD
 <*ALIGN=2*>  foo, bar : INTEGER;  (* 16 bit aligned *)
 <*ALIGN=4*>  baz, bam : INTEGER;  (* 32 bit aligned *)
 <*ALIGN=0*>  bits, bobs : [0..15] OF OCTET  (* packed *)
 END; (* Aligned *)

A value of zero specifies packing. When packing is specified, the allocation size of a field of an anonymous subrange of type OCTET, CARDINAL and LONGCARD is reduced to the smallest bit width required to encode its value range. Fields of any other type are aligned on octet boundaries when packing is specified.

EBNF | Syntax Diagram

EBNF | Syntax Diagram

EBNF | Syntax Diagram

to do

Optional Pragma ALIGN

EBNF | Syntax Diagram

Pragma ALIGN controls memory alignment. Alignment is specified in octets.

EBNF | Syntax Diagram

EBNF | Syntax Diagram

EBNF | Syntax Diagram

EBNF | Syntax Diagram

EBNF | Syntax Diagram

Optional Pragma VOLATILE

EBNF | Syntax Diagram

EBNF | Syntax Diagram

Optional Pragma FORWARD

EBNF | Syntax Diagram

EBNF | Syntax Diagram

EBNF | Syntax Diagram

EBNF | Syntax Diagram

An implementation that supports ASCII only shall recognise encoding specifier "ASCII". It shall ignore any UTF8 BOM but reject any non-ASCII characters in the source file. An implementation that supports UTF8 shall recognise specifiers "ASCII" and "UTF8". Support for other encodings is implementation defined. Only one encoding pragma per source file is permitted.

As an option, pragma ENCODING may provide encoding verification. If supported, a list of arbitrary samples with pairs of quoted characters and their respective code point values may follow the encoding specifier.

If a sample list is specified within the pragma body, a verification is carried out by matching the quoted literals in the sample list against their respective code points. Any mismatching pair in the sample list shall cause a fatal compilation error and compilation to abort immediately. The maximum number of code point samples is implementation defined. A maximum of at least 16 is recommended. Excess samples shall be ignored.

 <*ENCODING="UTF8" : "é"=0uE9, "©"=0uA9, "€"=0u20AC*>

Pragma ENCODING specifies the encoding of the source file in which it appears. The pragma controls whether in addition to the characters that are permitted by the grammar, any further printable characters are permitted within quoted literals and comments. Semantics are given below.

An implementation that supports ASII only shall recognise encoding specifier "ASCII". It shall ignore any UTF8 BOM but reject any non-ASCII characters in the source file. An implementation that supports UTF8 shall recognise specifiers "ASCII" and "UTF8". Support for other encodings is implementation defined. Only one encoding pragma per source file is permitted.

Encoding Verification

As an option, pragma ENCODING may provide encoding verification. If supported, a list of arbitrary samples with pairs of quoted characters and their respective code point values may follow the encoding specifier.

If a sample list is specified within the pragma body, a verification is carried out by matching the quoted liter- als in the sample list against their respective code points. Any mismatching pair in the sample list shall cause a fatal compilation error and compilation to abort immediately. The maximum number of code point samples is implementation defined. A maximum of at least 16 is recommended. Excess samples shall be ignored.

 <*ENCODING=”UTF 8?” : “é”=0uE9, “©”=0uA9, “€”=0u20AC*>

Optional Pragma FORWARD

Pragma OUT marks a formal VAR parameter p in the header of a procedure P with a promise to write. The promise is kept if it can be proven at compile time that p is written to within the body of P in every possible runtime scenario, either by assignment or by passing p to an OUT marked VAR paramter in a procedure call. A promotable soft compile time warning shall occur if the promise is not kept.

Pragma GENERATED encodes the name of the template a library was generated from and the date and time when it was last generated. The pragma is inserted into the source by the Modula-2 template engine. A conforming implementation shall use the information recorded in the pragma to avoid unnecessary regeneration of libraries.

 <*GENERATED FROM AssocArrays, 2014-12-31, 23:59:59+0100*>

Pragma GENERATED encodes the name of the template a library was generated from and the date and time when it was last generated. The pragma is inserted into the source by the Modula-2 template engine. An im- plementation shall use the information recorded in the pragma to avoid unnecessary regeneration of libraries.

 <*GENERATED FROM Assoc Arrays?, 2014-12-31, 23:59:59+0100*>

Pragma BLOCKING marks a procedure as blocking to indicate that it invokes a procedure or API that may cause it to wait for an event or availability of a shared resource or the completion of an IO operation. If a procedure not marked as blocking calls a procedure that is marked as blocking, a promotable compile time warning shall occur.

Pragma BLOCKING marks a procedure as blocking to indicate that it invokes a procedure or API that may cause it to wait for an event or availability of a shared resource. If a procedure not marked as blocking calls a procedure that is marked as blocking, a promotable compile time warning shall occur.

Pragma BLOCKING marks a procedure as blocking to indicate that may invokes a procedure or API that may cause it to be suspended to wait for an event or availability of a shared resource. If a procedure not marked as blocking calls a procedure that is marked as blocking, a promotable compile time warning shall occur.

 PROCEDURE Read ( f : File; VAR ch : CHAR ) <*BLOCKING*>;

EBNF | Syntax Diagram

EBNF | Syntax Diagram

Pragma BLOCKING

EBNF | Syntax Diagram

Pragma BLOCKING marks a procedure as blocking.

Pragma INLINE represents a suggestion that inlining of a procedure is desirable. It shall appear both in the definition and implementation of the procedure. An informational message shall be emitted if the suggestion is not followed.

 PROCEDURE Foo ( bar : Baz ) <*INLINE*>;

Pragma NOINLINE represents a mandate that a procedure shall not be inlined. It shall appear both in the definition and implementation of the procedure. The use of pragmas INLINE and NOINLINE is mutually exclusive.

 PROCEDURE Foo ( bar : Baz ) <*NOINLINE*>;

Pragma OUT marks a formal VAR parameter p in the header of a procedure P with a promise to write. The promise is kept if it can be proven that p is written to within the body of P in every possible runtime scenario, either by assignment or by passing p to an OUT marked VAR paramter in a procedure call other than via a variable of a procedure type. A promotable soft compile time warning shall occur if the promise is not kept.

 PROCEDURE init ( VAR n : OCTET <*OUT*> );

 <*IF (TSIZE(INTEGER)=2)*>
 CONST Model = TypeModel.small;
 <*ELSIF (TSIZE(INTEGER)=4)*>
 CONST Model = TypeModel.medium;
 <*ELSIF (TSIZE(INTEGER)=8)*>
 CONST Model = TypeModel.large;

Pragma IF

Pragma IF denoted the start of the initial branch of a conditional compilation section. The source text within the initial branch is only processed if the condition specified in the pragma is true, otherwise it is ignored.

Pragma ELSIF

Pragma ELSIF denotes the start of an alternative branch in a conditional compilation section. The source text within an alternative branch is only processed if the condition specified in the pragma is true and the conditions specified for the corresponding initial branch and all preceding alternative branches of the same nesting level are false, otherwise it is ignored.

Pragma ELSE

Pragma ELSE denotes the start of a default branch within a conditional compilation section. The source text within the default branch is only processed if the conditions specified for the initial branch and all preceding alternative branches of the same nesting level are false, otherwise it is ignored.

Pragma END

Pragma END denotes the end of a conditional compilation section.

 <*IF (TSIZE(INTEGER)=2)*> CONST Model = TypeModel.small;
 <*ELSIF (TSIZE(INTEGER)=4)*> CONST Model = TypeModel.medium;
 <*ELSIF (TSIZE(INTEGER)=8)*> CONST Model = TypeModel.large;

 UNSAFE.HALT(Errors.UnsupportedTypeModel);

Conditional compilation sections may be nested up to a maximum nesting level of ten including the outermost conditional compilation section. A fatal compile time error shall occur if this value is exceeded. Pragma IF increments the current nesting level, Pragmas ELSIF and ELSE leave it unchanged and Pragma END decrements it.

EBNF | Syntax Diagram

Conditional compilation pragmas are used to denote conditional compilation sections. A conditional compilation section is an arbitrary portion of source text that is either compiled or ignored, depending on whether or not a given condition in form of a boolean compile time expression within the pragma is met.

A conditional compilation section consists of an initial conditional compilation branch denoted by pragma IF, followed by zero or more alternative branches denoted by pragma ELSIF, followed by an optional default branch denoted by pragma ELSE, followed by closing pragma END.

 <*IF (TSIZE(INTEGER)=2)*> CONST Model = Type Model?.small;
 <*ELSIF (TSIZE(INTEGER)=4)*> CONST Model = Type Model?.medium;
 <*ELSIF (TSIZE(INTEGER)=8)*> CONST Model = Type Model?.large;
 <*ELSE*> <*MSG=FATAL : "unsupported type model."*>
 UNSAFE.HALT(Errors.Unsupported Type Model?);
 <*END*>

Conditional compilation sections may be nested up to a maximum nesting level of ten including the outermost conditional compilation section. A fatal compile time error shall occur if this value is exceeded. Pragma IF increments the current nesting level, ELSIF and ELSE leave it unchanged and END decrements it.

 <*MSG=INFO : "Library documentation is available at http://foolib.com"*>

 <*MSG=INFO : "Library documentation is available at `http://foolib.com"*>

Message Mode INFO

Message mode selector INFO is used to emit user defined information during comilation. Emitting an informational message does not change the warning or error count of the current compilation run and it does not cause comilation to fail or abort. A compiler switch may be provided to silence informational messages.

 <*MSG=INFO : "Library documentation is available at http://foolib.com"*>

Message Mode WARN

Message mode selector WARN is used to emit user defined warnings during compilation. Emitting a warning message increments the warning count of the current compilation run but it does not cause compilation to fail or abort. Warnings emitted via pragma MSG are always hard compile time warnings.

 <*MSG=WARN : "foo exceeds maximum value. A default of 100 will be used."*>

Message Mode ERROR

Message mode selector ERROR is used to emit user defined error messages during compilation. Emitting an error message increments the error count of the current compilation run and will ultimately cause compilation to fail but it does not cause an immediate abort. User defined error messages may not be silenced.

 <*MSG=ERROR : "Value of foo is outside of its legal range of [1..100]."*>

Message Mode FATAL

Message mode selector FATAL is used to emit user defined fatal error messages during compilation. Emitting a fatal error message increments the error count of the current compilation run and causes compilation to fail and abort immediately. User defined fatal error messages may not be silenced. Abort may not be avoided.

 <*MSG=ABORT : "Unsupported target architecture."*>

Pragmas For Conditional Compilation

Pragma INLINE

Pragma NOINLINE

Pragma OUT

Pragma GENERATED

Pragma ENCODING

Pragma FORWARD

Optional Pragma PADBITS

Optional Pragma NORETURN

Optional Pragma PURITY

Optional Pragma SINGLEASSIGN

Optional Pragma LOWLATENCY

Optional Pragma DEPRECATED

Optional Pragma ADDR

Optional Pragma FFI

Optional Pragma FFIDENT

Pragmas

• Pragma MSG
• Pragma IF
• Pragma ELSIF
• Pragma ELSE
• Pragma END
• Pragma INLINE
• Pragma NOINLINE
• Pragma OUT
• Pragma GENERATED
• Pragma ENCODING
• Pragma FORWARD
• Pragma ALIGN
• Pragma PADBITS
• Pragma NORETURN
• Pragma PURITY
• Pragma SINGLEASSIGN
• Pragma LOWLATENCY
• Pragma VOLATILE
• Pragma DEPRECATED
• Pragma ADDR
• Pragma FFI
• Pragma FFIDENT

Pragma Safety

A pragma is safe if it provides a safe facility. It is unsafe if it provides an unsafe facility. The use of an unsafe pragma must be enabled by unqualified import of its identically named enabler. Pragma enablers of supported unsafe pragmas shall be provided by pseudo-module UNSAFE.

Language Defined Pragmas In Detail

Pragma MSG

EBNF | Syntax Diagram

Pragma MSG emits four different types of user definable console messages during compilation: informational messages, compilation warnings, compilation error messages and fatal compilation error messages. The type of a message is determined by a message mode selector. Console messages consist of a quoted string literal, the value of a compile time constant or pragma or a comma separated list of these components.

The value of a pragma that represents a compile time setting is denoted by the pragma symbol prefixed with a question mark. Language defined pragmas that represent compile settings are ALIGN and ENCODING.

 <*MSG=INFO : "The current alignment is: ", ?ALIGN*> (* emits alignment value *)
 <*MSG=INFO : "The current encoding is: ", ?ENCODING*> (* emits encoding name *)

Only pragmas that represent compile time settings may be queried in this way.

Pragma Scope And Positioning

The position where a pragma may appear in the source text depends on its scope.

Pragmas are directives to the compiler, used to control or influence the compilation process, but they do not change the meaning of a program. Language defined pragmas and their properties are listed below:

The Record Field Selector

• The COPY Statement

• The IF Statement
• The CASE Statement
• The WHILE Statement

A definition module represents the definition part of a library, that is, its public interface. Any identifier defined in the definition part is available for use without import in the corresponding implementation part of the library and it is automatically exported, that is, it is available for import by other modules.

 PROCEDURE LetterCount ( str : ARRAY OF CHAR ) : CARDINAL;
 PROCEDURE DigitCount ( str : ARRAY OF CHAR ) : CARDINAL;

A definition module represents the definition part of a library, that is, its public interface. Any identifier defined in the definition part is available for use without export in the corresponding implementation part of the library and it is automatically exported, that is, it is available for import by other modules.

 DEFINITION MODULE Counting;
 PROCEDURE Letter Count? ( str : ARRAY OF CHAR ) : CARDINAL;
 PROCEDURE Digit Count? ( str : ARRAY OF CHAR ) : CARDINAL;
 END Counting.

Evaluation Time

An expression is a computational formula that evaluates to a value. An expression may consist of one of more sub-expressions. Sub-expressions consists of operands, operators and optional punctuation.

 IMPORT FileIO; (* qualified import of module FileIO *)
 VAR status : FileIO.Status; (* qualified identifier for Status *)

Qualified import of a module that has already been imported by qualified import into the same module scope is permissible. Only the first import is significant. Any subsequent imports are redundant. A redundant import has no effect but shall cause a soft compile time warning.

Unqualified import of an identifier that has already been imported unqualified from the same origin into the same module scope is permissible. Only the first import is significant. Any subsequent imports are redundant. A redundant import has no effect but shall cause a soft compile time warning.

Unqualified import of an identifier that is also imported qualified into the same module scope is permissible. The imported entity may then be referenced both qualified and unqualified. No compile time warning shall be emitted.

Unqualified import of the type identifier of an ADT whole library module is also imported qualified into the same module scope results in a name conflict and shall cause a compile time error. However, unqualified import of any other identifier from an already imported ADT library module is permissible.

Identifiers defined in the interface of a library module may be imported by other modules using an import directive. There are two kinds.

• qualified import
• unqualified import

Qualified Import

When an identifier is imported by qualified import, it must be qualified with the exporting module's module identifier when it is referenced in the importing module. This avoids name conflicts when importing identically named identifiers from different modules.

 IMPORT File IO; (* qualified import of module File IO *)
 VAR status : File IO.Status; (* qualified identifier for Status *)

Import Aggregation

Importing Modules as Types

If the interface of a module defines a type that has the same name as the module then the type is referenced unqualified. This facility is useful in the construction of abstract data types as library modules.

 DEFINITION MODULE Colour;
 TYPE Colour = ( red, green, blue );
 (* public interface *)
 END Colour.
 IMPORT Colour; (* import module Colour *)
 VAR colour : Colour; (* type referenced as Colour instead of Colour.Colour *)

Unqualified Import

When an identifier is imported by unqualified import, it is made available in the importing module as is. This facility is intended predominantly for import from pseudo-modules and in cases where its use will reduce clutter and improve readability. If two identically named identifiers from different modules are imported unqualified, a name conflict occurs and a compile time error shall be emitted.

example to paste

Wildcard Import

to do

Repeat Import

Qualified Import of an Already Imported Module

Unqualified Import of an Already Imported Identifier

Qualified and Unqualified Import of an Identifier

Unqualified Import from an Already Imported ADT Library Module

• a program module

• a library blueprint

A compilation unit is a sequence of source code that can be independently compiled. There are four kinds.

• the definition part of a library module
• the implementation part of a library module
• a program module
• a blueprint

Any Modula-2 program consists of exactly one program module and zero or more library modules and blueprints.

A variable declared in the top level of a library module's definition part is always exported immutable. It may be assigned to within the library module's implementation part but it may not be assigned to within modules that import it. A pointer variable declared in the top level of a definition part shall cause a promotable compile time warning unless it is of an opaque type or a POINTER TO CONST type.

Global Variables

A variable declared in the top level of a module has a global life span. It exists throughout the runtime of the program. However, it does not have global scope. It is only visible within the module where it is declared, and it it is exported, within modules that import it.

A variable declared in the top level of a library module's definition part is always exported immutable. It may be assigned to within the library module's implementation part but it may not be assigned to within modules that import it. A pointer variable declared in the top level of a definition part shall cause a promotable compile time warning unless it is of an opaque type or a POINTER TO CONST type.

Local Variables

A variable declared within a procedure has local life span and local scope. It only exists during the lifetime of the procedure and it is only visible within the procedure where it is declared and procedures local to the procedure where it is declared.

A variable is a container for a mutable value. A variable is always associated with a type and it can only hold values of its type. Its type is specified in its definition. Its definition is immutable. The value of a variable is undetermined when it is allocated. A value may be assigned at runtime. However, variables of pointer types are automatically intialised to hold the invalid pointer value NIL.

A variable is a container for a value determined at runtime. A variable is always associated with a type and it can only hold values of its type. Its type is specified in its definition. Its definition is immutable. The value of a variable is undetermined when it is allocated. However, variables of pointer types are automatically intialised to hold the invalid pointer value NIL.

A variable is a container for a value determined at runtime. A variable is always associated with a type and it can only hold values of its type. Its type is set at compile time and cannot be changed. The value of a variable is undetermined when it is allocated. However, variables of pointer types are automatically intialised to hold the invalid pointer value NIL.

A constant is an immutable value determined at compile time. Its value is specified by a constant expression in its definition. A constant may not be defined as an alias of a module, a variable, a type or a procedure.

 CONST zero = 0; maxInt = TMAX(INTEGER); buffSize = 100 * TSIZE(INTEGER) + 42; 

A variable is an container for a value determined at runtime. A variable is always associated with a type and it can only hold values of its type. Its type is set at compile time and cannot be changed. The value of a variable is undetermined when it is allocated. However, variables of pointer types are automatically intialised to hold the invalid pointer value NIL.

 VAR ch : CHAR; n, m : CARDINAL; i, j : INTEGER; x, y, z : REAL; 

A constant is an immutable value determined at compile time. A constant may be defined as an alias of another constant, but not as an alias of a module, a variable, a type or procedure.

 CONST zero = 0; maxInt = TMAX(INTEGER); buffSize = MAX(fooLen, barLen, bazLen);

Operators are special symbols or reserved words that represent an operation within an expression. An operator may be unary or binary. Unary operators are prefix or postfix, binary operators are always infix. An operator may be either left-associative or non-associative and it has a precedence level between one and six, where six represents the highest level. Arity, associativity and precedence determine the order of evaluation in expressions that consist of multiple sub-expressions and may contain different operators.

Expressions are evaluated at precedence level one. Its sub-expressions are simple expressions. Its operators are the relational operators and the identity operator. Level one has the lowest precedence.

Simple expressions are evaluated at precedence level one. Its sub-expressions are terms. Its operators are the plus and minus operators and the OR operator.

Terms are evaluated at precedence level three. Its sub-expressions are simple terms. Its operators are the asterisk, solidus, DIV, MOD, AND operators and the set difference operator.

Simple terms are evaluated at precedence level four. Its sub-expressions are factors and its operator is the NOT operator.

Factors are evaluated at precedence level five. Its sub-expressions are simple factors and its operator is the type conversion operator.

Simple factors are evaluated at precedence level six. Its sub-expressions are literals, structured values, expressions in parentheses, designators and function calls. Its pseudo-operators are the parentheses of parenthesised expressions and the selectors of designators. Level six has the highest precedence.

EBNF | Syntax Diagram

EBNF | Syntax Diagram

EBNF | Syntax Diagram

EBNF | Syntax Diagram

EBNF | Syntax Diagram

EBNF | Syntax Diagram

Grammar rule expression represents evaluation level one. Its operands are simple expressions. Its operators are the relational operators and the identity operator. Level one has the lowest precedence.

Grammar rule simple expression represents evaluation level two. Its operands are terms. Its operators are the plus and minus operators and the OR operator.

Grammar rule term represents evaluation level three. Its operands are simple terms. Its operators are the asterisk, solidus, DIV, MOD, AND operators and the set difference operator.

Grammar rule simple term represents evaluation level four. Its operand is a factor and its operator is the NOT operator.

Grammar rule factor represents evaluation level five. Its operand is a simple factor and its operator is the type conversion operator.

Grammar rule simple factor represents evaluation level six. It consists of literals, structured values, expressions in parentheses, designators and function calls. Its pseudo-operators are the parentheses of parenthesised expressions and the selectors of designators. Level six has the highest precedence.

• pointer target selector

A selector is a suffix to select one or more components from a value. There are four kinds.

to do

to do

to do

to do

to do

to do

Operands

An operand may be a literal, a designator or a sub-expression. Whether any given operand may legally occur at a given position within an expression is determined by expression compatibility. Expression compatibility of operands is dependent on the operator of an expression or sub-expression as each operator defines what operand types it can accept.

Designators

A designator consists of an identifier that refers to a constant, a variable or a function call, followed by an optional designator tail that consists of one or more selectors. The identifier component of a designator may be a qualified identifier.

Selectors

A selector is a syntactical entity to select one or more components from a value. There are four kinds.

• subscript selector
• array slice selector
• record field selector
• pointer target selecto

The Subscript Selector

to do

The Array Slice Selector

to do

The Array Slice Selector

to do

The Pointer Target Selector

to do

An expression is a computational formula that evaluates to a value. An expression consists of operands, operators and optional punctuation.

Runtime and Compile Time Expressions

Expressions are classified according to their time of evaluation. An expression that may only be evaluated at runtime is called a runtime expression. An expression that is evaluated at compile time is called a compile time expression or constant expression. Constant expressions consist only of operands whose values are known at compile time and only invoke built-in functions or macros that may be evaluated at compile time.

Evaluation Order

The evaluation order of expressions is determined by operator precedence and punctuation. There are five levels of operator precedence. However, sub-expressions enclosed in parentheses, designators and function calls always take precedence over the evaluation order defined by operator precedence. This constitutes an implicit sixth level of expression evaluation.

Evaluation Level 1

Evaluation Level 2

Evaluation Level 3

Evaluation Level 4

Evaluation Level 5

Evaluation Level 6

• The RETURN Statement
• The YIELD Statement

• The REPEAT Statement
• The LOOP Statement

The FOR statement is used to iterate over an iterable entity and execute a statement or statement sequence during each iteration cycle. It consists of a loop header and a loop body. The loop header consists of one or two loop variants, an optional iteration order, and the iterable expression. The loop body consists of a statement or statement sequence.

The Iterable Expression

The iterable expression — or iterable in short – is denoted by a designator if an instance of a collection type or by an identifier of an ordinal type or subrange, an anonymous subrange of an ordinal type. An ordinal type or subrange iterable is always immutable. A collection iterable may be either mutable or immutable.

• Immutable Types

• subrange types

An immutable type is an immutable equivalence type of a mutable type. The type it is an equivalence type of is called its base type. The base type may be any dynamically allocatable ADT provided that it is not an immutable equivalence type itself. An immutable type obtains its properties from its base type, except for its identifier. It is defined using the CONST type constructor.

An immutable type is compatible with its base type. Any value of an immutable type is also a legal value of its base type and vice versa. However, instances of an immutable type are immutable, they may not be L-values except for initialisation in a NEW statement and they may not be passed to a formal VAR parameter.

An ALIAS type is a nominal equivalence type of another type. The type it is an equivalence type of is called its base type. The base type may be any type. An ALIAS type obtains its properties from its base type, except for its identifier. It is defined using the ALIAS OF type constructor.

An immutable type is compatible with its supertype. Any value of an immutable type is also a legal value of its supertype and vice versa. However, instances of an immutable type are immutable, they may not be L-values except for initialisation in a NEW statement and they may not be passed to a formal VAR parameter.

A derived type is a nominal derivative of another type. The type it is derived from is called its base type. The base type may be any type. A derived type obtains its properties from its base type, except for its identifier. It is defined using the = symbol followed by the base type in the type constructor.

An ALIAS type is a nominal sub-type of another type. The type it is a sub-type of is called its base type. The base type may be any type. An ALIAS type obtains its properties from its base type, except for its identifier. It is defined using the ALIAS OF type constructor.

Immutable Types

An immutable type is an immutable subtype of a mutable type. The type it is a subtype of is called its supertype. The supertype may be any dynamically allocatable ADT provided that it is not an immutable subtype itself. An immutable type obtains its properties from its supertype, except for its identifier. It is defined using the CONST type constructor.

Example:

 TYPE ImmutableFooArray = CONST FooArray;

An immutable type is compatible with its supertype, except where such compatibility would violate the subtype's immutability. Any value of an immutable type is also a legal value of its supertype and vice versa. However, instances of an immutable type are immutable, they may not be L-values except for initialisation in a NEW statement and they may not be passed to a formal VAR parameter.

Example:

 VAR array : FooArray; immArray : ImmutableFooArray;
 NEW array; (* initialisation not required *)
 NEW immArray := { foo, bar, baz }; (* initialisation required *)
 COPY array := immArray; (* copying from immutable to mutable *)
 COPY immArray := array; (* compile time error: attempt to modify immutable instance *)

Subrange Types

A subrange type is a subtype of a scalar or ordinal type. The type it is a subtype of is called its supertype. The supertype may be any scalar or ordinal type. A subrange type obtains its properties from its supertype, except for its identifier, and its lower and upper bounds. Both lower and upper bound must be specified in its type definition and they must be legal values of the supertype. A subrange type is defined using a range constructor.

Examples:

 TYPE Radian = [0.0 .. tau] OF REAL;
 TYPE Natural = [1 .. TMAX(CARDINAL)] OF CARDINAL;

A subrange type is upwards compatible with its supertype, but the supertype is not downwards compatible with all of its subrange types. This restriction exists because any value of a subrange type is always a legal value of its supertype, but a value of a supertype is not necessarily a legal value of its subrange type.

Examples:

 VAR natural : Natural; cardinal : CARDINAL;
 natural := cardinal; (* compile time error *)
 cardinal := natural; (* OK *)

The subrange type definition of a scalar type that represents real numbers may specify open bounds. An open lower bound is prefixed by the > symbol. An open upper bound is prefixed by the < symbol. An open bound of a subrange type is not a legal value of the subrange type.

 TYPE PosReal = [>0.0 .. TMAX(REAL)] OF REAL;
 TYPE NegReal = [TMIN(REAL) .. <0.0] OF REAL;

• Predefined Identifiers (formerly Pervasives)

• opaque types

A derived type is a type defined to inherit all its properties from another type, except for its identifier. A derived type is defined using the = symbol followed by the base type in the type constructor.

Semantics

Compilation Units

Import of Identifiers

Definition Modules

Definitions

Constant Definitions

Variable Declarations

Type Definitions

Derived Types

ALIAS Types

Subrange Types

Immutable Types

Enumeration Types

Enumeration Type Extension

Set Types

Array Types

Flexible Array Types

Character Arrays

Record Types

Record Type Extension

Pointer Types

Coroutine Types

Procedure Types

Opaque Types

Opaque Pointer Types

Opaque Record Types

Semi-Opaque Record Types

Implementation and Program Modules

Statements

Memory Management Statements

The NEW Statement

The RETAIN Statement

The RELEASE Statement

Destructive Update Statements

The Assignment Statement

The Increment Statement

The Decrement Statement

The COPY Statement

The Procedure Call Statement

The RETURN Statement

The YIELD Statement

The IF Statement

The CASE Statement

The WHILE Statement

The REPEAT Statement

The LOOP Statement

The FOR Statement

The Iterable Entity

The Loop Variant Section

The Iteration Order

Iterating Over Ordinal Types

Iterating Over The CHAR Type

Iterating Over An Enumeration Type

Iterating Over A Whole Number Type

Iterating Over Collections

Iterating Over A List

Iterating Over An Array

Iterating Over A Set

Iterating Over A Dictionary

The EXIT Statement

Expressions

Operators

The Pointer Dereferencing Operator

The Type Conversion Operator

The NOT Operator

The Asterisk Operator

The Solidus Operator

The DIV Operator

The MOD Operator

The AND Operator

The Set Difference Operator

The Plus Operator

The Minus Operator

The Concatenation Operator

The OR Operator

The Equality Operator

The Inequality Operator

The > Operator

The >= Operator

The < Operator

The <= Operator

The IN Operator

The Identity Operator

Structured Values

Predefined Identifiers

Summary Of Built-in Compile-Time Macros

Constant NIL

Constant EMPTY

Constants TRUE and FALSE

Predefined Types

Type BOOLEAN

Type CHAR

Type UNICHAR

Type OCTET

Type CARDINAL

Type LONGCARD

Type INTEGER

Type LONGINT

Type REAL

Type LONGREAL

Predefined Procedures

Blueprints

Type Classification

Literal Compatibility

Constraints

Requirements

Primitives

Pragmas

Older Wiki content, parts of which may be reused

(To do: transfer missing content from PDF version and update)

• Language Report (PDF) (needs update)

Older Wiki content, parts of which may be reused:

Scope

• Import Aggregators

Types

• Flexible Array Fields in Records

Predefined Identifiers

• Predefined Identifiers (formerly Pervasives)

• Type CHAR
• Type UNICHAR

Type CHAR is an ordinal type for 7-bit character values and its value range is 0u0 .. 0u7F. It is defined as:

Type UNICHAR is a container type for Unicode character values. Its size is always 32-bit but its value range is 0u0 .. 0u10FFFF. Type CHAR is upwards compatible with UNICHAR but the reverse is not the case. This restriction exists because every legal value of type CHAR is also a legal value of type UNICHAR but not every value of type UNICHAR is also a legal value of type CHAR.

Type REAL is a real number type with implementation defined precision and range.

Type LONGREAL is a real number type with a precision and range equal to or higher than that of type REAL.

No predefined type may be an ALIAS type of another, even if the types share the same implementation.

A structured value is a compound value that consists of a comma separated list of value components enclosed in braces. A component value may be a value repetition clause, a value range, a literal, a structured value or an identifier denoting a value or structured value. A value repetition clause is a constant expression followed by BY followed by a repetition factor which shall be a constant expression of a whole number type. A value range is an ordinal constant expression representing the start value followed by .. followed by another ordinal constant expression representing the end value, both ordinal values shall be of the same type.

A structured value is a compound value that consist of a comma separated list of value components enclosed in braces. A component value may be a value repetition clause, a value range, a literal, a structured value or an identifier denoting a value or structured value. A value repetition clause is a constant expression followed by BY followed by a repetition factor which shall be a constant expression of a whole number type. A value range is an ordinal constant expression representing the start value followed by .. followed by another ordinal constant expression representing the end value, both ordinal values shall be of the same type.

 { 0 BY 100 }, { "a" .. "z" }, { 1 .. 31 }
 { 1970, Month.Jan, 1, 0, 0, 0.0, TZ.UTC }
 { "a", "bcd", 123, 456.78, { 9, 10 }, { foo, bar, baz } }

• The RETURN Statement
• The YIELD Statement

The RETURN Statement

The RETURN statement is used within a procedure body to return control to its caller and in the main body of the program to return control to the operating environment that activated the program. A RETURN statement may or may not return a value, depending on the type of the procedure in which it is invoked. When returning from a regular procedure, no value may be returned. When returning from a function procedure a value of the procedure's return type must be returned. Non-compliance shall cause a compile time error.

 PROCEDURE successor ( n : CARDINAL ) : CARDINAL;
 BEGIN
   RETURN n + 1
 END successor;

The YIELD Statement

The YIELD statement is used within a coroutine procedure body to suspend the coroutine and pass control to its caller. A YIELD statement may or may not yield a value, depending on the type of the coroutine procedure in which it is invoked. When yielding from a regular procedure, no value may be yielded. When yielding from a function procedure a value of the procedure's return type must be yielded. The YIELD statement may only occur within the body of coroutine procedures. Non-compliance shall cause a compile time error.

 PROCEDURE [COROUTINE] iterator ( CONST array : ARRAY OF INTEGER ) : INTEGER;
 BEGIN
   FOR value IN array DO
     YIELD value
   END;
   RETURN -1
 END iterator;

The IF Statement

EBNF | Syntax Diagram

An IF statement is a conditional flow-control statement. It evaluates a condition in form of a boolean expression. If the condition is true then program control passes to its THEN block. If the condition is false and an ELSIF branch follows, then program control passes to the ELSIF branch to evaluate that branch's condition. Again, if the condition is true then program control passes to the THEN block of the ELSIF branch. If there are no ELSIF branches, or if the conditions of all ELSIF branches are false, and if an ELSE branch follows, then program control passes to the ELSE block. At most one block in the statement is executed. IF-statements must always be terminated with an END.

 IF i > 0 THEN
   WRITE("Positive")
 ELSIF i = 0 THEN
   WRITE("Zero")
 ELSE
   WRITE("Negative")
 END;

The CASE Statement

EBNF | Syntax Diagram

A CASE statement is a flow-control statement that passes control to one of a number of labeled statements or statement sequences depending on the value of an ordinal expression. Control is passed to the first statement following the case label that matches the ordinal expression. If no label matches, control is passed to the ELSE block.

 CASE colour OF
 | colour.red   : WRITE("Red")
 | colour.green : WRITE("Green")
 | colour.blue  : WRITE("Blue")
 ELSE
   UNSAFE.HALT(1) (* fatal error -- abort *)
 END;

A case label shall be listed at most once. If a case is encountered at runtime that is not listed in the case label list and if there is no ELSE block, no case label statements shall be executed and no error shall result.

The WHILE Statement

EBNF | Syntax Diagram

A WHILE statement is used to repeat a statement or statement sequence depending on a condition in form of a boolean expression. The expression is evaluated each time before the DO block is executed. The DO block is repeated as long as the expression evaluates to TRUE.

 WHILE NOT EOF(file) DO READ(file, ch) END;

The REPEAT Statement

EBNF | Syntax Diagram

A REPEAT statement is used to repeat a statement or statement sequence depending on a condition in form of a boolean expression. The expression is evaluated each time after the REPEAT block has executed. the expression evaluates to TRUE the REPEAT block is executed, otherwise not.

 REPEAT READ(file, ch) UNTIL ch = terminator END;

The LOOP Statement

EBNF | Syntax Diagram

A LOOP statement is used to repeat a statement or statement sequence indefinitely unless explicitly terminated by an EXIT statement.

 LOOP
   READ(file, ch);
   IF ch IN TerminatorSet THEN
     EXIT
   END (* IF *)
 END; (* LOOP *)

An opaque record type is a record type whose identifier is available to client modules that import it but its fields are not. Such a record type is defined with exported restricted fields. An export restricted field is a field that is directly accessible only within the library module in which the type is defined and within any extension library thereof. It is not directly accessible within any other scope. Such a field is declared by prefixing the field declaration with the * symbol.

An opaque record type is a record type with export restricted fields. An export restricted field is a field that is directly accessible only within the library module in which the type is defined and within any extension library thereof. It is not directly accessible within any other scope. Such a field is declared by prefixing the field declaration with the * symbol.

Since all record fields are lexically present within the definition part, the allocation size of an opaque record type can be determined at compile time even when no source code is available for the corresponding implementation part. Instances of opaque record types are therefore statically allocatable.

Any attempt to access a restricted field within a scope where it is not accessible shall cause a compile time error.

Semi-Opaque Record Types

Semit-Opaque Record Types

A record type may contain both public and export restricted fields. Such a record type is called semi-opaque.

Semi-Opaque Record Types

A record type may contain both public and export restricted fields. Such a record is called semi-opaque.

When a structured value is assigned to an instance of a semi-opaque record type, it may only contain values for public fields.

It is safe practise to declare the restricted fields of semi-opaque record types with an initialisation expression.

 len := PascalString.Length(str); (* proper use: access via public interface *)

 TYPE SemiOpaque = RECORD

 VAR triplet : SemiOpaque;

 TYPE SemiOpaque = RECORD
 * i : INTEGER = 0; (* auto-initialising restricted field *)

 * length : OCTET; (* export restricted field *)
 * data : OctetArray255 (* export restricted field *)

Since export restricted fields are not directly accessible outside their defining library, they may only be operated on by clients through facilities provided in the library's public interface.

 VAR str : PascalString; len : OCTET;
 len := str.length; (* compile time error: access of a restricted field *)
 len := Pascal String?.Length(str); (* proper use: access via public interface *)

Export restricted fields may be automatically initialised for every instance of the type by suffixing the field declaration with an initialisation expression. The initialisation expression shall be a compile time expression of the type of the field.

 DEFINITION MODULE PascalString;
 TYPE PascalString = RECORD
 * length : OCTET = 0; (* auto-initialisation to zero *)
 * data : OctetArray255
 END;

A record type may contain both public and export restricted fields. Such a record is called semi-opaque or partially opaque.

 TYPE Semi Opaque? = RECORD
 * i : INTEGER; (* restricted field *)
   j, k : INTEGER (* public fields *)
 END;

When an instance of a semi-opaque record type is assigned a structured value, the structured value may only contain values for public fields.

 VAR triplet : Semi Opaque?;
 triplet := { 0, 0, 0 }; (* compile time error: access of a restricted field *)
 triplet := { 0, 0 }; (* proper use: only public fields are written to *)

Semi-opaque record based AD Ts? should be designed such that restricted fields of instances are auto-initialised.

 TYPE Semi Opaque? = RECORD
 * i : INTEGER = 0; (* restricted field *)
   j, k : INTEGER (* public fields *)
 END;

An instance of a record type holds exactly one value for each field. Fields are addressable by selector using dot notation.

An opaque record type is a record type with export restricted fields, used for the construction of ADTs. An export restricted field is a field that is directly accessible only within the library module in which the type is defined and within any extension library thereof. It is not directly accessible within any other scope. An export restricted field is declared by prefixing its declaration with the * symbol.

   * length : OCTET = 0; (* export restricted field *)

 str.length := 5; (* compile time error: access of a restricted field *)

One or more fields in a record type declaration may be export restricted by prefixing their declaration with the * symbol. An export restricted field is only accessible within the library module in which the record type is defined and any extension library thereof.

 TYPE Point = RECORD
   * typeID : UniqueTypeID; (* export restricted field *)
     x, y : REAL (* publicly accessible fields *)
 END;

Since all record fields are lexically present within the definition part, the allocation size of an opaque record type can be calculated at compile time even when no source code is available for the corresponding implementation part. Instances of opaque record based ADTs are therefore statically allocatable.

Fields that are not export restricted are directly accessible in any scope into which an opaque record type has been imported, but export restricted fields are only accessible within the implementation part and extension modules of the library that defines the opaque record type. Export restricted fields may only be operated on by clients through facilities provided in the library's public interface.

   * length : OCTET; (* export restricted field *)
   * data : ARRAY 255 OF OCTET (* export restricted field *)

 DEFINITION MODULE PascalString;
 TYPE PascalString = RECORD

 END PascalString.

 IMPORT PascalString;
 VAR str : PascalString; (* allocated on the stack *)

 IMPORT PascalString;
 VAR str : PascalString;

 Terminal.WriteOctets(str.data); (* compile time error: access of a restricted field *)
 PascalString.copy(str, "foobar"); (* proper use: operation through public interface *)

An instance of a record type holds exactly one value for each field. Fields are addressable by selector using dot notation.

Opaque Record Types

An opaque record type is a record type with export restricted fields. It is used for the construction of ADTs.

 DEFINITION MODULE Pascal String?;
 TYPE Pascal String? = RECORD
   * length : OCTET;
   * data : ARRAY 255 OF OCTET (* export restricted *)
 END;
 (* public interface *)
 END Pascal String?.

Since all fields are lexically present within the definition part, the allocation size of an opaque record type can be calculated even when no source code is available for the corresponding implementation part. Instances of opaque record based ADTs are therefore statically allocatable.

 IMPORT Pascal String?;
 VAR str : Pascal String?; (* allocated on the stack *)

Fields that are not export restricted are directly accessible in any scope into which an opaque record type has been imported, but export restricted fields are only accessible within the implementation part and extension modules of the library that defines the opaque record type. They may only be operated on by clients through facilities provided in the library's public interface.

Example:

 IMPORT Pascal String?;
 VAR str : Pascal String?;
 str.length := 0; (* compile time error: access of a restricted field *)
 Terminal.Write Octets?(str.data); (* compile time error: access of a restricted field *)
 Pascal String?.copy(str, "foobar"); (* proper use: operation through public interface *)

• Opaque Types

Derived Types

A derived type is a type defined to inherit all its properties from another type, except for its identifier. A derived type is defined using the = symbol followed by the base type in the type constructor.

Examples:

 TYPE Celsius = REAL; Fahrenheit = REAL;

Due to strict name equivalence, derived types and their base types are incompatible because their identifiers are different.

 VAR celsius : Celsius; fahrenheit : Fahrenheit;
 celsius := fahrenheit; (* compile time error: incompatible types *)

To assign values across type boundaries, type conversion is required.

 celsius := (fahrenheit :: Celsius - 32.0) * 100.0/180.0; (* type conversion *)

ALIAS Types

An ALIAS type is a derived type specifically defined to be compatible with its base type even though their identifiers are different. An ALIAS type is defined using the ALIAS OF type constructor.

 TYPE INT = ALIAS OF INTEGER;

An ALIAS type and its base type are compatible in every aspect. They may therefore be used interchangeably.

Example:

 VAR i : INT; j : INTEGER;
 i := j; (* i and j are compatible *)

Subrange Types

A subrange type is a type defined as a subset of a scalar or ordinal type. A subrange type is upwards compatible with its base type, but the base type is not downwards compatible with any subrange types derived from it. A subrange type inherits all its properties from its base type, except for its lower and upper bound. A subrange type's lower and upper bound must be specified in its type definition. Both lower and upper bound must be compatible with the base type and they must be legal values of the base type.

Examples:

 TYPE Radian = [0.0 .. tau] OF REAL;
 TYPE Natural = [1 .. TMAX(CARDINAL)] OF CARDINAL;

For subrange types of scalar types that represent real numbers, lower and upper bounds may be specified as open bounds. An open lower bound is prefixed by the > symbol. An open upper bound is prefixed by the < symbol. An open bound of a subrange type is not a legal value of the type.

Examples:

 TYPE PosReal = [>0.0 .. TMAX(REAL)] OF REAL;
 TYPE NegReal = [TMIN(REAL) .. <0.0] OF REAL;

Immutable Types

A CONST type is a type defined to be an immutable alias type of a mutable ADT. A CONST type is defined using the CONST type constructor.

 TYPE ImmutableFooArray = CONST FooArray;

A CONST type is compatible with its base type, except where such compatibility would violate the type's immutability.

 VAR array : FooArray; immArray : ImmutableFooArray;
 NEW array; (* initialisation not required *)
 NEW immArray := { foo, bar, baz }; (* initialisation required *)
 COPY array := immArray; (* copying from immutable to mutable *)
 COPY immArray := array; (* compile time error: attempt to modify immutable instance *)

Enumeration Types

EBNF | Syntax Diagram

An enumeration type is an ordinal type whose legal values are defined by a list of identifiers. The identifiers are assigned ordinal values from left to right as they appear in the type definition. The ordinal value assigned to the leftmost identifier is always zero.

Example:

 TYPE Colour = ( red, green, blue ); (* ORD(red) => 0 *)

When referencing an enumerated value, its identifier must be qualified with its type identifier, except within a subrange type constructor. This requirement fixes a flaw in classic Modula-2 where the import of an enumeration type could cause name conflicts.

Example:

 TYPE BaseColour = [red .. green] OF Colour; (* unqualified *)
 VAR colour : Colour;  colour := Colour.green; (* qualified *)

Enumeration Type Extension

An enumeration type may be defined as an extension of another by listing the identifier of the base type as the first item in the enumerated value list prefixed by the + symbol. All enumerated values of the base type become legal values of the new type. The base type is downwards compatible with any extended types derived from it, but extensions are not upwards compatible with their base type. This restriction exists because any value of the base type is always a legal value of any extension type derived from it, but not every value of an extension type is also a legal value of the base type.

 TYPE MoreColour = ( +Colour, orange, magenta, cyan );
 (* equivalent to: MoreColour = ( red, green, blue, orange, magenta, cyan );

The allocation size of an enumeration type is always 16 bit. Its maximum value range is 65536 values.

Set Types

EBNF | Syntax Diagram

A set type is a collection type whose storable values are defined by the legal values of an associated enumeration type of up to 256 values. The values stored in a set are also called elements of the set and the associated enumeration type is called its element type. A set type is defined using the SET OF type constructor.

 TYPE ColourSet = SET OF Colour;

An instance of a set type may hold multiple elements but any given element may be stored at most once. An element stored in a set is said to be a member of the set. A set is represented as an array of boolean membership values, where the element is the accessor and the membership is the value. A membership value may thus be either TRUE or FALSE.

Examples:

 VAR  colours : ColourSet; isMember : BOOLEAN;
 colours := { Colour.red, Colour.green }; (* assignment *)
 isMember := colours[Colour.green]; (* membership retrieval *)
 colours[Colour.blue] := TRUE; (* membership storage *)

Array Types

EBNF | Syntax Diagram

An array type is an indexed collection type whose values are of a single arbitrary type, called the array's value type. The type's capacity is specified by a value count parameter in the type definition. The capacity must be a whole number value and it may not be zero. Array types are defined using the ARRAY OF type constructor.

 TYPE IntArray = ARRAY 10 OF INTEGER;

The values of an array instance are addressable by cardinal index using subscript notation. The lowest index is always zero.

Examples:

 VAR array : IntArray; int : INTEGER;
 array := { 0 BY TLIMIT(IntArray) }; (* initialise all values with zero *)
 int := array[5]; (* value retrieval *)
 array[5] := 42; (* value storage *)

Flexible Array Types

An array type may be defined to hold a variable number of values by prefixing the value count parameter in the type's definition with the < symbol. The type's capacity is one less than the specified value count and it may not be zero.

 TYPE FlexArray = ARRAY < 10 OF INTEGER;

The instance of a rigid array type always holds exactly the number of values that equals the type's capacity. No values may be appended, inserted or removed at runtime. By contrast, the instance of a flexible array type may hold a variable number of values. Within the limits of the type's capacity, values may be appended, inserted and removed at runtime.

 VAR array : FlexArray;
 array := { 42, -5, 0 }; (* initialise with three values *)
 APPEND(array, -35); (* append a value *)
 INSERT(array, 0, 11); (* value insertion *)
 REMOVE(array, 3, 1); (* value removal *)

Instances of flexible arrays may further be sliced and concatenated. Flexible array types and their slices are insertion and concatenation compatible as long as the respective value types are compatible.

 VAR array1, array2, array3 : FlexArray;
 array2 := { 1, 2, 3, 4 }; array3 := { 7, 8, 9 };
 array1 := array2 & array3; (* concatenation : { 1, 2, 3, 4, 7, 8, 9 } *)
 array1[4..5] := { 5, 6 }; (* sliced insert : { 1, 2, 3, 4, 5, 6, 7, 8, 9 } *)

Character Arrays

For security reasons, array types with value types CHAR and UNICHAR may only be defined as flexible array types. Rigid character array types are not supported. An attempt to define a rigid character array type shall cause a compile time error.

Examples:

 TYPE String = ARRAY 100 OF CHAR; (* compile time error: unsupported definition *)
 TYPE String = ARRAY < 100 OF CHAR; (* OK, supported character array type definition *)

The instances of character array types are initialised with a single NUL character and compliant implementations must ensure that they are NUL terminated after every assign, append and concatenation operation.

Record Types

EBNF | Syntax Diagram

A record type is a compound type whose components are of arbitrary types. The components are called fields. The number of fields is arbitrary. Record types are defined using the RECORD type constructor.

Example:

 TYPE Point = RECORD x, y : REAL END;

An instance of a record type holds exactly one value for each field. Fields are addressable by selector.

 VAR  point : Point; r : REAL;
 record := { 0.0, 0.0 }; (* initialise all fields with zero *)
 r := point.x; (* field retrieval *)
 point.y := 0.75; (* field storage *)

Record Type Extension

A record type may be defined as an extension of another by giving the identifier of the base type in parentheses before the field list declaration. All fields of the base type become fields of the new type. The field names of the base type may therefore not be reused in the extension type's own field list declaration. The base type is downwards compatible with any extended types derived from it, but type extensions are not upwards compatible with their base type. This restriction exists because any field of the base type is always a field of any extension type derived from it, but not every field of an extension type is also a field of the base type.

 TYPE ColourPoint = RECORD ( Point ) colour : Colour END;
 VAR  cPoint : ColourPoint;
 cPoint := { 0.0, 0.0, Colour.red }; (* initialise all fields *)
 cPoint.x := 1.5; cPoint.y := 0.75;

Pointer Types

EBNF | Syntax Diagram

A pointer type is a container for a typed reference to an entity at a memory storage location. The type of the referenced entity is called the target type. The entity referenced by an instance of a pointer type is called the pointer's target. Pointer types are defined using the POINTER TO type constructor.

Example:

 TYPE IntPtr = POINTER TO INTEGER;

Typed references are created using predefined procedure PTR. Instances of pointer types are dereferenced using the pointer dereferencing operator ^.

 VAR int : INTEGER; intPtr : IntPtr;
 intPtr := PTR(int, IntPtr); (* obtain a typed reference to int *)
 intPtr^ := 0; (* write to int via dereferenced pointer intPtr *)

A pointer type may be defined to restrict the mutability of its target.

Example:

 TYPE ImmIntPtr = POINTER TO CONST INTEGER;

Although the instance of such a pointer itself is mutable, its target is always treated immutable. A dereferenced instance may not be used as an L-value and it may not be passed to a procedure as a VAR parameter. Pointers to mutable and immutable targets are therefore always incompatible. Any violation shall cause a compile time error.

Example:

 VAR int : INTEGER; intPtr : IntPtr; immPtr : ImmIntPtr;
 intPtr := PTR(int, IntPtr); immPtr := PTR(int, ImmIntPtr);
 intPtr^ := 0; (* OK, modifying a mutable target *)
 immPtr^ := 0; (* compile time error due to attempt to modify an immutable target *)

Coroutine Types

EBNF | Syntax Diagram

A coroutine type is a special purpose pointer type whose target is a coroutine. An associated procedure type is part of the type definition. A coroutine procedure is compatible with a coroutine type when it matches the signature of the type's associated procedure type. Coroutine types are defined using the COROUTINE type constructor.

Examples:

 TYPE Iterator = COROUTINE ( IteratorProc );

Procedure Types

EBNF | Syntax Diagram

A procedure type is a special purpose pointer type whose target is a procedure. The procedure's signature is part of the type definition. A procedure is compatible with a procedure type when their signatures match. Procedure types are defined using the PROCEDURE type constructor.

Examples:

 TYPE WriteStrProc = PROCEDURE ( CONST ARRAY OF CHAR );
 TYPE FSM = PROCEDURE ( CONST ARRAY OF CHAR, FSM );

Opaque Types

An opaque type is a type whose internal composition and structure is not accessible outside of the implementation part of the library in which it is defined. Instances of an opaque type may only be operated on by clients of its exporting library through the operations exported by the public interface of the library. There are two kinds of opaque types:

• opaque pointer types
• opaque record types

Opaque Pointer Types

An opaque pointer type is a special pointer type used for the construction of ADTs. The definition and declaration of such an ADT is divided between the definition and implementation part of its library. The identifier of the opaque type is defined in the library's definition part and it may be imported from there by clients. It is defined using the OPAQUE type constructor.

 DEFINITION MODULE Tree;
 TYPE Tree = OPAQUE; (* opaque pointer *)
 (* public interface *)
 END Tree.

The target type of the opaque pointer is declared in the library's corresponding implementation part and it is therefore inaccessible to clients. It is declared using the PPOINTER TO type constructor.

 IMPLEMENTATION MODULE Tree;
 TYPE Tree = POINTER TO TreeDescriptor; (* target type specification *)
 TYPE TreeDescriptor = RECORD
   left, right : Tree;
   value : ValueType
 END; (* TreeDescriptor *)
 (* implementation *)
 END Tree.

Instances of an opaque pointer based ADT may only be allocated dynamically at runtime.

Example:

 IMPORT Tree;
 VAR tree : Tree;
 NEW tree := { foo, bar, baz };

An opaque pointer type is a special pointer type used for the construction of ADTs. The definition and declaration of such an ADT is divided between the definition and implementation part of its library. The identifier of the opaque type is defined in the library's definition part and it may be imported from there by clients. It is defined using the OPAQUE type constructor.

   value : ValueType

 TYPE Tree = POINTER TO TreeDescriptor; (* target type specification *)
 TYPE TreeDescriptor = RECORD

 END; (* TreeDescriptor *)

• Character Encoding
• Lexical Entities

• Library Generation
• Importing Libraries

• Implicit Export
• Restricted Export

• Constant Definitions
• Variable Declarations
• Type Definitions
• Opaque Types
• Derived Types
• Alias Types
• Subrange Types
• Immutable Types
• Enumeration Types
• Set Types
• Array Types
• Record Types
• Pointer Types
• Coroutine Types
• Procedure Types

• Blocks
• Declarations

• The NEW Statement
• The RETAIN Statement
• The RELEASE Statement
• The Assignment Statement
• The Increment Statement
• The Decrement Statement
• The Procedure Call Statement
• The COPY Statement
• The IF Statement
• The CASE Statement
• The WHILE Statement
• The REPEAT Statement
• The LOOP Statement
• The FOR Statement
• The RETURN Statement
• The YIELD Statement
• The EXIT Statement

• The Pointer Dereferencing Operator
• The Type Conversion Operator
• The NOT Operator
• The Asterisk Operator
• The Solidus Operator
• The DIV Operator
• The MOD Operator
• The AND Operator
• The Set Difference Operator
• The Plus Operator
• The Minus Operator
• The OR Operator
• The Concatenation Operator
• The Equality Operator
• The Inequality Operator
• The > Operator
• The >= Operator
• The < Operator
• The <= Operator
• The IN Operator
• The Identity Operator

• Constant NIL
• Constant EMPTY
• Constant TRUE
• Constant FALSE

• Type BOOLEAN
• Type OCTET
• Type CARDINAL
• Type LONGCARD
• Type INTEGER
• Type LONGINT
• Type REAL
• Type LONGREAL

• Procedure INSERT
• Procedure APPEND
• Procedure REMOVE
• Procedure SORT
• Procedure SORTNEW
• Procedure READ
• Procedure READNEW
• Procedure WRITE
• Procedure WRITEF
• Procedure TODO

• Function ABS
• Function ODD
• Function PRED
• Function SUCC
• Function CHR
• Function ORD
• Function EXISTS
• Function COUNT
• Function LENGTH
• Function PTR
• Function FIRST
• Function LAST
• Function MIN
• Function MAX

• Function TMIN
• Function TMAX
• Function TLIMIT
• Function TSIZE

• Import Aggregators

• Flexible Array Fields in Records

• Predefined Identifiers (formerly Pervasives)

• opaque types

Opaque Types

An opaque type is a type whose internal composition and structure is not accessible outside of the implementation part of the library in which it is defined. Instances of an opaque type may only be operated on by clients of its exporting library through the operations exported by the public interface of the library. There are two kinds of opaque types:

• opaque pointer types
• opaque record types

Opaque Pointer Types

An opaque pointer type is a special pointer type used for the construction of ADTs. The definition and declaration of such an ADT is divided between the definition and implementation part of its library. The identifier of the opaque type is defined in the library's definition part and may be imported from there by clients.

The identifier of an opaque pointer type is available in the library that defines it and in modules that import it. It is defined using the OPAQUE type constructor.

 DEFINITION MODULE Tree;
 TYPE Tree = OPAQUE; (* opaque pointer *)
 (* public interface *)
 END Tree.

The target type of the opaque pointer is declared in the library's corresponding implementation part and it is therefore inaccessible to clients. It is declared using the PPOINTER TO type constructor.

 IMPLEMENTATION MODULE Tree;
 TYPE Tree = POINTER TO Tree Descriptor?; (* target type specification *)
 TYPE Tree Descriptor? = RECORD
   left, right : Tree;
   value : Value Type?
 END; (* Tree Descriptor? *)
 (* implementation *)
 END Tree.

Instances of an opaque pointer based ADT may only be allocated dynamically at runtime.

 IMPORT Tree;
 VAR tree : Tree;
 NEW tree := { foo, bar, baz };

 TYPE ImmutableFooArray = CONST FooArray;

 VAR array : FooArray; immArray : ImmutableFooArray;

A CONST type is a type defined to be an immutable alias type of a mutable ADT. A CONST type is defined using the CONST type constructor.

 TYPE Immutable Foo Array? = CONST Foo Array?;

A CONST type is compatible with its base type, except where such compatibility would violate the type's immutability.

 VAR array : Foo Array?; immArray : Immutable Foo Array?;
 NEW array; (* initialisation not required *)
 NEW immArray := { foo, bar, baz }; (* initialisation required *)
 COPY array := immArray; (* copying from immutable to mutable *)
 COPY immArray := array; (* compile time error: attempt to modify immutable instance *)

An ALIAS type is a derived type specifically defined to be compatible with its base type even though their identifiers are different. An ALIAS type is defined using the ALIAS OF type constructor.

• Derived Types

• derived types
• subrange types
• alias types
• immutable types

Derived Types

A derived type is a type defined to inherit all its properties from another type, except for its identifier. A derived type is defined using the = symbol followed by the base type in the type constructor.

 TYPE Celsius = REAL; Fahrenheit = REAL;

Due to strict name equivalence, derived types and their base types are incompatible because their identifiers are different.

 VAR celsius : Celsius; fahrenheit : Fahrenheit;
 celsius := fahrenheit; (* compile time error: incompatible types *)

To assign values across type boundaries, type conversion is required.

 celsius := (fahrenheit :: Celsius - 32.0) * 100.0/180.0; (* type conversion *)

An ALIAS type is a derived type specifically defined to be compatible with its base type. An ALIAS type is defined using the ALIAS OF type constructor.

 TYPE INT = ALIAS OF INTEGER;

An ALIAS type and its base type are compatible in every aspect. They may therefore be used interchangeably.

 VAR i : INT; j : INTEGER;
 i := j; (* i and j are compatible *)

Primitive SUBSET is a polymorphic primitive to test whether a set is a subset of another. It is called passing the set to be tested as its first operand and the suspected superset as its second operand. Both operands shall be of the same set type. The primitive returns TRUE if the first operand is a subset of the second operand, otherwise FALSE. It has one signature:

To obtain a list element accessor for the n-th value stored in a list, the primitive is called passing the list as its first operand and the index as its second operand. The first operand shall be of a list type and the second operand shall be of type LONGCARD. The primitive returns an accessor for the list element that stores the value or NIL if no element exists at the given index.

To obtain the preceding or succeeding list element accessor of a known accessor in a list, the primitive is called passing the list as its first operand, the known accessor as its second operand and a neighbour selector as its third operand. The first operand shall be of a list type. The second operand shall be of the list's accessor type and the third operand shall be a quoted character literal of type CHAR where "+" selects the succeeding and "-" selects the preceding neighbour. The primitive returns an accessor to the selected neighbour element in the list or NIL if the selected neighbour does not exist.

To retrieve the n-th value stored for a key in a multi-dictionary, the primitive is called passing the dictionary as its first operand, the key as its second operand and the index of the value to be retrieved as its third operand. The first operand shall be of a multi-dictionary type. The second operand shall be of the dictionary's key type and the third operand shall be of type CARDINAL. The primitive returns the value stored at the index for the key in the dictionary.

To retrieve the value stored at a given index in an array, the primitive is called passing the array as its first operand and the index as its second operand. The first operand shall be of an array type and the second operand shall be of the array's index type. The primitive returns the value stored at the index in the array.

To retrieve the value stored at a given list element accessor from a list, the primitive is called passing the list as its firs operand and the element accessor as its second operand. The first operand shall be of a list type and the second operand shall be of the list's accessor type. The primitive returns the value stored at the accessor in the list.

Retrieving An Element Counter From A Set

To retrieve the counter for a given element in a set, the primitive is called passing the set as its first operand and the element as its second operand. The first operand shall be of a set type and the second operand shall be of the set's element type. The primitive returns a value indicating how many times the element is stored in the list.

To retrieve the value stored for a given key in a dictionary, the primitive is called passing the dictionary as its first operand and the key as its second operand. The first operand shall be of a dictionary type and the second operand shall be of the dictionary's key type. The primitive returns the value stored for the key in the dictionary.

To retrieve the n-th value stored for a key in a multi-dictionary, the primitive is called passing the dictionary as its first operand, the key as its second operand and the index of the value to be retrieved as its third operand. The first operand shall be of a dictionary type. The second operand shall be of the dictionary's key type and the third operand shall be of type CARDINAL. The primitive returns the value stored at the index for the key in the dictionary.

To overwrite one or more consecutive values starting at a given index in an array or list with a fill value, the primitive is called passing the array or list as its first operand, the start index as its second operand, the number of values to be overwritten as its third operand and the fill value as its fourth operand. The first operand shall be of an array or list type. The second operand shall be of the array's index type or in case of a list, it shall be of type LONGCARD. The third operand shall be of type LONGCARD and the fourth operand shall be of the value type of the array or list.

An Invocation of TMAX is replaced by the largest legal value of its operand. Its operand shall be the type identifier of a scalar or ordinal type. Its replacement value is of the type denoted by its operand. It has one signature:

To overwrite one or more consecutive values starting at a given index in an array or list, the primitive is called passing the array or list as its first operand, the start index as its second operand and the values to be written as its third operand. The first operand shall be of an array or list type. The second operand shall be of the array's index type or in the case of a list, it shall be of type LONGCARD. The third operand shall be a non-empty variadic list of the value type of the array or list.

To overwrite one or more consecutive values starting at a given index in an array of list with a fill value, the primitive is called passing the array or list as its first operand, the start index as its second operand, the number of values to be overwritten as its third operand and the fill value as its fourth operand. The first operand shall be of an array or list type. The second operand shall be of the array's index type or in case of a list, it shall be of type LONGCARD. The third operand shall be of type LONGCARD and the fourth operand shall be of the value type of the array or list.

To overwrite the element counters of multiple given elements in a set, the primitive is called passing the set as its first operand and a list of element/counter pairs to be written as its second operand. The first operand shall be of a set type. The second operand shall be a non-empty variadic list of element/counter pairs, where the elements are of the set's element type and the counters are of its counter type.

Overwriting Multiple Values For Given Keys In A Dictionary

To overwrite multiple values for given keys in a dictionary, the primitive is called passing the dictionary as its first operand and a list of key/value pairs to be written as its second operand. The first operand shall be of a dictionary type. The second operand shall be a non-empty variadic list of key/value pairs, where the keys are of the dictionary's key type and the values are of its value type.

To overwrite a value at a given index in an array, the primitive is called passing the array as its first operand, the index as its second operand and the value to be written as its third operand. The first operand shall be of an array type. The second operand shall be of the array type's index type. The third operand shall be of the array's value type.

To overwrite a value for a given accessor in a list, the primitive is called passing the list as its first operand, the accessor as its second operand and the value to be written as its third operand. The first operand shall be of a list type. The second operand shall be of the list type's accessor type. The third operand shall be of the list's value type.

To overwrite multiple consecutive values starting at a given index in an array or list, the primitive is called passing the array or list as its first operand, the start index as its second operand and the values to be written as its third operand. The first operand shall be of an array or list type. The second operand shall be of the array's index type or in the case of a list, it shall be of type LONGCARD. The third operand shall be a non-empty variadic list of the value type of the array or list.

To overwrite one of more consecutive values starting at a given index in an array of list with a fill value, the primitive is called passing the array or list as its first operand, the start index as its second operand, the number of values to be overwritten as its third operand and the fill value as its fourth operand. The first operand shall be of an array or list type. The second operand shall be of the array's index type or in case of a list, it shall be of type LONGCARD. The third operand shall be of type LONGCARD and the fourth operand shall be of the value type of the array or list.

To overwrite the element counter of a given element in a set, the primitive is called passing the set as its first operand, the element as its second operand and the counter value to be written as its third operand. The first operand shall be of a set type. The second operand shall be of the set's element type. The third operand shall be of the set's counter type.

To overwrite the element counters of multiple given elements in a set, the primitive is called passing the set as its first operand and the element/counter pairs to be written as its second operand. The first operand shall be of a set type. The second operand shall be a non-empty variadic list of element/counter pairs, where the elements are of the set's element type and the counters are of the set's counter type.

Overwriting A Single Value For A Key In A Dictionary

To overwrite a value for a given key in a dictionary, the primitive is called passing the dictionary as its first operand, the key as its second operand and the value to be written as its third operand. The first operand shall be of a dictionary type. The second operand shall be of the dictionary's key type. The third operand shall be of the dictionary's value type.

To overwrite multiple values for given keys in a dictionary, the primitive is called passing the dictionary as its first operand and the key/value pairs to be written as its second operand. The first operand shall be of a dictionary type. The second operand shall be a non-empty variadic list of key/value pairs, where the keys are of the dictionary's key type and the values are of the dictionary's value type.

Overwriting The N-th Value For A Key In A Multi-Dictionary

To overwrite the n-th value for a given key in a multi-dictionary, the primitive is called passing the dictionary as its first operand, the key as its second operand, the index of the value to be overwritten as its third operand and the value to be written as its fourth operand. The first operand shall be of a multi-dictionary type. The second operand shall be of the dictionary's key type. The third operand shall be of type CARDINAL. The fourth operand shall be of the dictionary's value type.

A CASE statement is a flow-control statement that passes control to one of a number of labeled statements or statement sequences depending on the value of an ordinal expression. Control is passed to the first statement following the case label that matches the ordinal expression. If no label matches, control is passed to the ELSE block.

A case label shall be listed at most once. If a case is encountered at runtime that is not listed in the case label list and if there is no ELSE block, no case label statements shall be executed and no error shall result.

   ( c : <DictionaryType>; entries : ARGLIST >0 OF { key : <KeyType >; value : <ValueType> );

Primitive STORE is a polymorphic primitive to overwrite one or more values in a collection. It has nine signatures:

Overwriting A Single Value In An Array

 PROCEDURE STORE ( c : <ArrayType>; atIndex : <IndexType>; value : <ValueType> );

Overwriting A Single Value In A List

 PROCEDURE STORE ( c : <ListType>; p : <AccessorType>; value : <ValueType> );

Overwriting Multiple Values In An Array Or List

   ( c : <SeqType>; fromIndex : <IndexType>; values : ARGLIST >0 OF <ValueType> );

Overwriting An Array Or List Or Part Thereof With A Fill-Value

 PROCEDURE STORE
   ( c : <SeqType>; fromIndex : <IndexType>; valueCount : LONGCARD; fillValue : <ValueType> );

Overwriting The Element Counter for A Single Element In A Set

 PROCEDURE STORE ( c : <SetType>; element : <ElementType>; counter : <CounterType> );

Overwriting The Element Counters for Multiple Elements In A Set

 PROCEDURE STORE
   ( c : <SetType>; entries : ARGLIST >0 OF { element : <ElementType>; counter : <CounterType> } );

Overwriting A Key/Value Pair In A Dictionary

 PROCEDURE STORE ( c : <DictionaryType>; key : <KeyType>; value : <ValueType> );

Overwriting Multiple Key/Value Pairs In A Dictionary

   ( c : <DictionaryType>; entries : ARGLIST >1 OF { key : <KeyType >; value : <ValueType> );

Overwriting The N-th Key/Value Pair In A Multi-Dictionary

 PROCEDURE STORE
   ( c : <DictionaryType>; key : <KeyType>; index : CARDINAL; value : <ValueType> );

 PROCEDURE VALUE ( VAR c : <ListType>; p : <AccessorType> ) : <ValueType>;

 PROCEDURE SEEK ( c : <ListType>; index : LONGCARD ) : <AccessorType>;

   ( c : <ListType>; current : <AccessorType>; plusOrMinus : <CharLiteral> ) : <AccessorType>;

Primitive SUBSET

Primitive SUBSET is a polymorphic primitive to test whether a set is a subset of another. It has one signature:

 PROCEDURE SUBSET ( subset, superset : <SetType> ) : BOOLEAN;

Primitive SEEK

Primitive SEEK is a polymorphic primitive to obtain accessors to list elements for list traversal. It has two signatures:

Obtaining An Element Accessor By Index

 PROCEDURE SEEK ( c : <ListType>; index : LONGCARD ) : <AccessorType> );

Obtaining An Element Accessor Through Neighbour

 PROCEDURE SEEK
   ( c : <ListType>; current : <AccessorType>; plusOrMinus : <CharLiteral> ) : <AccessorType> );

Primitive STORE is a polymorphic primitive to overwrite one or more values in a collection. It has eight signatures:

Primitive VALUE

Primitive VALUE is a polymorphic primitive to retrieve a value from a collection. It has five signatures:

Retrieving A Value From An Array

 PROCEDURE VALUE ( VAR c : <ArrayType>; atIndex : <IndexType> ) : <ValueType>;

Retrieving A Value From A List

 PROCEDURE VALUE ( VAR c : <ListType>; accessor : <AccessorType> ) : <ValueType>;

Retrieving A Counter From A Set

 PROCEDURE VALUE ( VAR c : <SetType>; element : <ElementType> ) : <CounterType>;

Retrieving A Value From A Dictionary

 PROCEDURE VALUE ( VAR c : <DictionaryType>; key : <KeyType> ) : <ValueType>;

Retrieving The N-th Value For A Key From A Multi-Dictionary

 PROCEDURE VALUE
   ( VAR c : <DictionaryType>; key : <KeyType>; index : CARDINAL ) : <ValueType>;

Overwriting Multiple Key/Value Pairs In A Dictionary

   ( c : <DictionaryType>; entries : ARGLIST >1 OF { key : <KeyType >; value : <ValueType> );

Overwriting The N-th Key/Value Pair In A Multi-Dictionary

   ( c : <DictionaryType>; key : <KeyType>; index : CARDINAL; value : <ValueType> );

Primitive STORE is a polymorphic macro to overwrite one or more values in a collection. It has eight signatures:

Overwriting An Array Or List Or Part Thereof With A Fill-Value

Overwriting A Single Value In An Array Or List

 PROCEDURE STORE ( c : <SeqType>; atIndex : <IndexType>; value : <ValueType> );

Overwriting Multiple Values In An Array Or List

   ( c : <SeqType>; fromIndex : <IndexType>; values : ARGLIST >0 OF <ValueType> );

Overwriting A Slice Or All Of An Array Or List With A Fill-Value

   ( c : <SeqType>; fromIndex : <IndexType>; valueCount : LONGCARD; fillValue : <ValueType> );

Overwriting The Element Counter for A Single Element In A Set

Overwriting The Element Counters for Multiple Elements In A Set

Primitive SXF is a polymorphic primitive to serialise a scalar value given by its first operand to scalar exchange format and pass the serialised value back in its second operand. Its first operand shall be of a scalar type. Its second operand shall be an OCTET array large enough to hold the serialised value. It has one signature:

Primitive VAL is a polymorphic primitive to convert a serialised scalar value given by its first operand to a value of a scalar type and pass the converted value back in its second operand. Its first operand shall be an OCTET array. Its second operand shall be of the scalar target type. It has one signature:

Primitive STORE

Primitive STORE is a polymorphic macro to overwrite one or more values in a collection. It has X signatures:

Overwriting A Single Value In An Array

 PROCEDURE STORE ( c : <ArrayType>; atIndex : <IndexType>; value : <ValueType> );

Overwriting Multiple Values In An Array

 PROCEDURE STORE
   ( c : <ArrayType>; fromIndex : <IndexType>; values : ARGLIST >0 OF <ValueType> );

Overwriting an Array or Array Slice With A Fill-Value

 PROCEDURE STORE
   ( c : <ArrayType>; fromIndex : <IndexType>; valueCount : LONGCARD; fillValue : <ValueType> );

Overwriting The Element Count for A Single Element In A Set

 PROCEDURE STORE ( c : <SetType>; element : <ElementType>; counter : <CounterType> );

Overwriting The Element Counts for Multiple Elements In A Set

 PROCEDURE STORE
   ( c : <SetType>; entries : ARGLIST >0 OF { element : <ElementType>; counter : <CounterType> } );

Overwriting A Key/Value Pair In A Dictionary

 PROCEDURE STORE ( c : <DictionaryType>; key : <KeyType>; value : <ValueType> );

Overwriting The N-th Key/Value Pair In A Multi-Dictionary

 PROCEDURE STORE
   ( c : <DictionaryType>; key : <KeyType>; index : CARDINAL; value : <ValueType> );

Overwriting Multiple Key/Value Pairs In A Dictionary

 PROCEDURE STORE
   ( c : <DictionaryType>; entries : ARGLIST >1 OF { key : <KeyType >; value : <ValueType> );

Primitives are built-in polymorphic macros for internal use by the compiler to synthesise various operations for library defined ADTs. They should not need to be invoked directly by library or program code since their functionality becomes available through built-in syntax. Library implementations of ADTs may be required to provide specific implementations and bind them to their respective primitives.

Primitive SXF

Primitive SXF is a polymorphic macro to serialise a scalar value given by its first operand to scalar exchange format and pass the serialised value back in its second operand. Its first operand shall be of a scalar type. Its second operand shall be an OCTET array large enough to hold the serialised value. It has one signature:

 PROCEDURE SXF ( CONST value : <ScalarType>; VAR sxfValue : ARRAY OF OCTET );

Primitive VAL

Primitive VAL is a polymorphic macro to convert a serialised scalar value given by its first operand to a value of a scalar type and pass the converted value back in its second operand. Its first operand shall be an OCTET array. Its second operand shall be of the scalar target type. It has one signature:

 PROCEDURE VAL ( CONST sxfValue : ARRAY OF OCTET; VAR value : <ScalarType> );

Primitives

• Primitive SXF
• Primitive VAL
• Primitive STORE
• Primitive VALUE
• Primitive SEEK
• Primitive SUBSET

Primitives

Primitives are built-in polymorphic macros for internal use by the compiler to synthesise various operations for library defined AD Ts?. They should not need to be invoked directly by library or program code since their functionality becomes available through built-in syntax. Library implementations of AD Ts? may be required to provide specific implementations and bind them to their respective primitives.

• Primitive SXF
• Primitive VAL
• Primitive STORE
• Primitive VALUE
• Primitive SEEK
• Primitive SUBSET

An Invocation of TMIN is replaced by the smallest legal value of its operand. Its operand shall be the type identifier of a scalar or ordinal type. Its replacement value is of the type denoted by its operand. It has one signature:

An Invocation of TAMX is replaced by the largest legal value of its operand. Its operand shall be the type identifier of a scalar or ordinal type. Its replacement value is of the type denoted by its operand. It has one signature:

An Invocation of TLIMIT is replaced by the capacity limit of its operand. Its operand shall be the type identifier of a collection type. Its replacement value is of type LONGCARD. It has one signature:

Function ABS is a polymorphic function to return the absolute value of its operand. Unlike the mathematical definition of abs(x), the ABS function is strictly limited to scalar operands. Its operand shall be of a scalar type. Its return type is the operand type. It has one signature:

Function ABS is a polymorphic function to return the absolute value of its operand. Unlike the mathematical definition of abs(x), the ABS function is strictly limited to scalar operands. Its operand shall be of a scalar type. Its return type is the operand type. It has one signature:

 PROCEDURE ABS ( value : <ScalarType> ) : <OperandType>;

Function ABS is a polymorphic function to return the absolute value of its operand. It is strictly limited to scalar operands. Its operand shall be of a scalar or ordinal type. Its return type is the operand type. It has one signature:

Function COUNT is a polymorphic function to return the number of characters stored in its operand. Its operand shall be of a CHAR or UNICHAR array type or a string ADT. Its return type is type LONGCARD. It has one signature: