modulAware Data Sheet

1. Language Features

• Identifiers: sequences of letters, digits and the additional character "_". Upper and lower case letters have a distinctive function and all characters are relevant but the identifier length is restricted to 31 (except for module names which have 24 relevant characters in maximum).
• Number literals: integers in decimal and hexadecimal notation; reals in single and double precision with a unique notation; Those standard functions marked by an * in chap. 2 may also be used in constant expressions and are evaluated at compile-time.
• Comments: enclosed in (* ... (*may be nested to as many levels as you like *) ... *).
• Type declarations: BOOLEAN, SHORTINT, INTEGER, LONGINT, REAL, LONGREAL, CHAR, SET (32 elements), LONGSET (64 elements), SYSTEM.BYTE, SYSTEM.PTR, multi-dimensional dynamic and open array types, record types, extended record types, pointer types and procedure types.
• Arithmetic operators: +,-,* for the addition, subtraction, multiplication of mixed operands of type integers and reals. / for real division, DIV for integer division MOD for integer modulus.
• Logical operators: OR, &, ~ for logical conjunction, disjunction and negation.
• Set operators: +,-,*,/ for set union, difference, intersection and symmetric set difference.
• Relational operators: =, #, <, <=, >, >=, IN for equal, unequal, less, less or equal, greater, greater or equal, contained in (set membership). Except for IN, all relational operators are also allowed for operands of type string (ARRAY OF CHAR).
• Variable designators: allow type test, syntactically in the form of design (extendedRecordType). Also SYSTEM.VAL(T,v) can be substituted for a formal variable parameter of type T.
• Statements: assigment, procedure and method call, if statement, case statement while statement, repeat statement, for statement, loop statement, with statement (type guard), return and exit statement.
• Procedure and function procedure declarations with multi-dimensional open array and procedure-type formal parameters. Recursive procedure calls are allowed. Declaration of types and variables before use is required. When needed textually prior to declaration, forward declaration of procedures is needed.
• Type-bound procedures (methods) with a receiver of type pointer to record or variable parameter of type record.
• Modules constitute a collection of declarations and sequences of statements. A module serves as a wall around its local objects whose transparency is strictly under control of the programmer. There are no local or dynamic modules as in Modula-2.
• Compilation units are proper modules. There is no separation between definition and implementation module as in Modula-2. The definition module is produced by a browser tool (AlphaOberon). Objects marked by "*" are exported (consts, types, variables, function-, proper-, and type- bound-procedures (methods)). Variables and record fields marked with a "-" are exported as read-only variables.
• Module initialisation: the body of an implementation module acts as an initialisation facility for its local objects.

2. Standard functions and procedures

• Standard functions procedures are predeclared and directly known by the compiler. Only those qualified with "S." have to be imported from the predeclared module SYSTEM. Those procedures marked with an "*" may be also be used in the declaration section in constant expressions; A2O specific extensions, restrictions and deviations from Hans-Peter M~ossenb~ock's ETH-Report Nr. 160 (revised May-1992) are marked by an "#":
  • ABS (x:T): T absolute value of type T; T of integer or real type. *
  • ASH (x: T; n: INTEGER): T x*2^n; if n>=0 then x shifted arithmetically to the left by n bit otherwise to the right by n bit.
  • S.ADR (x: T): LONGINT gives the storage address of the substituted variable x.
  • S.BIT (a: LONGINT; n: integerType): BOOLEAN bit n of Mem[a] (32 bit word at storage address a).
  • CAP (ch: CHAR): CHAR the corresponding capital letter. # (for 7 bit ASCII only) *
  • CHR (i: anyIntegerType): CHAR the character with ordinal number i. *
  • ENTIER (x: T): LONGINT conversion of any real type T to integer: largest integer not greater than x (floor). *
  • S.ESTABLISH (handle$I: HANDLER): HANDLER; AXP only: OpenVMS exception processing LIB$ESTABLISH; see module VMS$Exceptions
  • S.LENTIER (x: T): S.SIGNED_64 conversion of any real type T to 64 bit integer: largest integer not greater than x (floor). (AXP only) #
  • LEN (a: T): LONGINT equivalent to LEN(a,0)
  • LEN (a: T; n: INTEGER): LONGINT length of an array or open array parameter a of any array type T in dimension n (first dimension = 0, counted from the left); LEN(a,0) = LEN(a); (high index bound +1).
  • S.LENGTH (s: ARRAY OF CHAR): LONGINT number of characters in the string s. # (extension)
  • MAX (T): T maximum value of type T, with T of any basic type. *
  • MIN (T): T minimum value of type T, with T of any basic type. *
  • ODD (i: T): BOOLEAN boolean expression (i MOD 2 # 0), for i of integer type T. *
  • ORD (i: CHAR): INTEGER ordinal number of i in the set of values defined by type CHAR. *
  • LONG (x: T1): T2 conversion from T1 to T2. T2=LONGINT if T1=INTEGER; T2=INTEGER if T1=SHORTINT; T2=LONGREAL if T1=REAL. *
  • S.LONG (x: T1): T2 conversion from T1 to T2. T2=SIGNED_64 if T1=SIGNED_32. * otherwise like LONG.
  • S.REVERT(): HANDLER; AXP only: OpenVMS exception processing LIB$REVERT; see module VMS$Exceptions
  • S.ROT (x: T; n: INTEGER): T x is rotated left by n bit.
  • S.LSH (x: T; n: INTEGER): T if n>=0 then x shifted logical to the left by n bit otherwise to the right by n bit. # (currently implemented as ASH)
  • SIZE (T): integerType number of storage units (BYTEs) required for allocation of a variable of type T. *
  • SHORT (x: T1): T2 conversion from T1 to T2. T2=INTEGER if T1=LONGINT; T2=SHORTINT if T1=INTEGER; T2=REAL if T1=LONGREAL. *
  • S.SHORT (x: T1): T2 conversion from T1 to T2. T2=SIGNED_32 if T1=SIGNED_64. * otherwise like SHORT.
  • S.VAL (T, x): T so-called type transfer function to cast the expression x to type T with SIZE(T). Takes SIZE(T) bytes.
• Standard procedures

  With i variable of integer type, n of integer type, s variable of type SET:

  • ASSERT (b: BOOLEAN; n: integerConst); (A2O only)
  • COPY (x: ARRAY OF CHAR; VAR v: ARRAY OF CHAR); v:=x
  • DEC (i) is equivalent to i:=i-1, INC (i) is i:=i+1
  • DEC (i,n) is i:=i-n, INC (i,n) is i:=i+n
  • EXCL (s,n) is s:=s-{n}, INCL (s,n) is s:=s+{n}
  • HALT (n: integerConst) terminate program execution, with halt-message x.
  • S.GET (a: LONGINT; VAR v: T); v:=Mem[a]; T of any basic type, pointer or procedure type.
  • S.GETREG (n: integerConst; VAR v: T); content of the specified register n for T of any basic type, pointer or procedure type. VAX: 0 <= n <= 14, where R11 is local base pointer, R12 is frame pointer, R13 is argument pointer, R14 is the stack pointer. AXP: 0 <= n <= 31. If T is floating point type, n specifies a floating point register.
  • S.MOVE (a0,a1: LONGINT; n: integerType); Mem[a1..a1+n-1]:=Mem[a0..a0+n-1].
  • S.PUT (a: LONGINT; x: T); Mem[a]:=v; T of any basic type, pointer or procedure type.
  • S.PUTREG (n: integerConst; x: T); stores x for T of any basic type, pointer or procedure type in the the specified register n. VAX: 0 <= n <= 14, where R11 is local base pointer, R12 is frame pointer, R13 is argument pointer, R14 is the stack pointer. AXP: 0 <= n <= 31. If T is floating point type, n specifies a floating point register.
  • NEW(v: T) storage allocation for v^. T of any pointer type.
  • NEW(v: T; x0, ..., xn: integerType) storage allocation for v^ with lengths (dimensions) x0, ..., xn. T of dynamic array pointer type.
  • S.NEW(v: T; x: integerType) allocates storage block for v of any pointer type T of x bytes and assign its address to v.
• Types exported from SYSTEM: Except for BYTE and PTR, all other basic types are implementation specific for A2O.
  • BYTE (8 bit system storage type)
  • ADDRESS_32 (32 bit address)
  • ADDRESS_64 (64 bit address)
  • PTR (= ADDRESS_32 with /pointersize=32 otherwise = ADDRESS_64)
  • SHORTWORD (16 bit system storage type)
  • WORD (32 bit system storage type)
  • LONGWORD (= WORD)
  • QUADWORD (64 bit system storage type)
  • OCTAWORD (128 bit system storage type)
  • SIGNED_8 (8 bit integer = SHORTINT)
  • SIGNED_16 (32 bit integer = INTEGER)
  • SIGNED_32 (32 bit integer = LONGINT)
  • SIGNED_64 (64 bit integer, A2O only)
  • SET_32 (32 bit set)
  • SET_64 (64 bit set)
  • F_FLOATING (VAX data type = REAL)
  • D_FLOATING (VAX data type = LONG`REAL)
  • G_FLOATING (VAX 64 bit real)
  • S_FLOATING (IEEE 32 bit real, A2O only)
  • T_FLOATING (IEEE 64 bit real, A2O only)
  • H_FLOATING (VAX 128 bit real, H2O only)
  • F_COMPLEX (complex, base type F_FLOATING)
  • D_COMPLEX (complex, base type D_FLOATING)
  • G_COMPLEX (complex, base type G_FLOATING)
  • S_COMPLEX (complex, base type S_FLOATING, A2O only)
  • T_COMPLEX (complex, base type T_FLOATING, A2O only)

  All basic types are allowed as function result type. No arithmetic operations are defined for complex types in Oberon-2. Arithmetic for complex types is supported via library modules [Long]Complex[G,S,T][Math]. The functions and procedures of module SYSTEM are listed above in chap. 2; they are marked by the prefix "S.".

3. A2O Separate Library

3.1. Separate library modules for stand-alone applications:

3.2. Separate library modules for AlphaOberon:

3.3. Standard utility and operating system interface modules:

4. A2O Implementation Details

• fast one-pass compilation (no intermediate/interpass-file generation) with tree-traversal back-end.
• complies with OpenVMS procedure calling standard. Procedures written in foreign language can be called from Oberon-2 and vice versa.
• supports OpenVMS symbolic run-time debugger. Objects can be examined depending on their dynamic type (examine/type=).
• implementation specific language extension: function procedures may be of any type Structured function results must not be indexed, selected or dereferenced. This extension was introduced to allow the call of structured functions written other foreign languages.
• peristent objects: provides facilities to retrieve the run-time type-name from a pointer or to create a pointer with the tag derived from type-name (copying, cloning). Provides a library module for symetric load/store of persistent objects. The stand-alone applications, facilities are provided for dynamic module loading via run-time binding to symbols of shareable images (LIB$FIND_IMAGE_SYMBOL). See Persistent Objects in Oberon-2 (Feb-1993) and Dynamically Loaded Modules (Aug-1993). AlphaOberon features the Oberon System's module Types.
• directly generates efficient Alpha AXP machine code in OpenVMS-compatible object files, with optional disassembly of generated code (incl. line numbers and symbolic names).
• AXP instruction scheduler (A2O only).
• byte level packed or naturally aligned record fields can be controlled by compilation option (A2O only).
• symbol-file lookup-strategy allows full module name length and if not found file name is shortened to 9 and then 6 characters.
• symbol-file lookup-strategy allows directory search lists, i.e.: searches logical name MOD$LIB_LIST, looks-up MOD$SYSTEM, MOD$LIBRARY_x.
• module-name separator selectable in a compilation command qualifier (default = "_") in ModuleName.ProcName).
• global symbol definition: generation of module-name and separator may be suppressed alltogether which allows to write an implementation module for a foreign definition in Oberon-2 and procedures to be called by foreign languages.
• array index-, case label-, set index-error, arithmetic overflow, type-test checks, local pointer and heap initialisation, and assertion evaluation can be enabled/disabled by compilation qualifiers.
• No 16 bit restrictions. Size of arrays & records in assignments and in parameter substitution may be greater than 65535 bytes.
• 64 bit address extensions (A2O only; requires OpenVMS V7.0 or later). The compilation qualifier /pointersize=x, where x=32 or x=64, determines the size in bits of LONGINT-, pointer- and procedur-type. With AlphaOberon, the heap as well as the global data-, string/literal-, code-, and linkage-section are all located in OpenVMS' P2 space.
• Source program lines and string constants may have up to 508 characters.
• up to 5000 exported types per module.
• up to 6000 entries (procedures/functions) per module.
• up to 2500 entries (procedures/functions) to be exported per module.
• up to 15000 procedures may be declared and exported from a foreign interface module (dummy module without Oberon-2 implementation, indicated by a module-name containing a "$").
• unlimited number of identifiers per module.
• maximum code-size per procedure is up to 40000 instructions.
• the jump distance is only limited by the maximal procedure size.
• max. 255 parameters per procedure.
• shareable image support default through the use of procedure descriptors.
• maximum number of static record extension levels (per base type): 32. Type descriptor section in object code file with an entry for every record type.
• maximum number of (possibly hidden) methods: unlimited.
• initialisation of all pointer variables on global and local level to NIL. Heap storage is optionally always cleared to NIL at allocation time.
• fast type test and type guard with unique pointer signatures (type tag).
• fast method call via fixed offset to pointer's type tag (single inheritance).
• textually repositioning named exported objects in source file doesn't generate a new symbol file on recompilation. Note, any change in the structure of the declaration of exported objects or change in the declaration of hidden methods forces generation of a new symbol file.
• optional file-name specification for the old and new symbol file of the compiled module with the compilation qualifier/symbolfile[=filespec]. For default the symbol file name is constructed from the module-name.
• inter-language compatibility on AXP|VAX/OpenVMS (K2Syn: tool to copy the symbol file key from a Modula-2 symbol file to an Oberon-2 symbol file is part of the A2O distribution kit).
• Interface to Modula-2's coroutines for multiprogramming. Provides run-time system support for low-level procedures NEWPROCESS and TRANSFER. Provides module NewKernel and Eight-Queens multiprogramming example. Provides standardised process scheduler module Processes from ISO Modula-2's Standard Library.
• Oberon-2 make utility. This powerfull utility analyses the source module interdependencies, checks for symbol file change by invoking the Oberon-2 compiler automatically and checks symbol and object files.
• A2O supports AlphaOberon by generating so-called Oberon load-files (.OLF) in addition to .OBJ files for stand-alone programs. See Alpha Oberon User's Guide (Aug-1995).
• Stand-alone Oberon-2 applications profit from a portable, internationally standardised ISO Modula-2 library, with symbolic OpenVMS run-time debugger support and foreign language facilities for multi-language projects.
• AlphaOberon applications take advantage of the run-time extensibility, efficiency, and portability of the Oberon System. Many powerful third party tools are available for AlphaOberon, including Dialogs, a light-weight tool for the development of graphical user interfaces without programming.
• Development history: The compiler front-end is based on Regis Crelier's portable front-end OP2 developed at ETH-Zürich (1992). The back-end is based on MaX, modulAware's Modula-2 compiler for OpenVMS Alpha/VAX, designed and implemented at modulAware in 1992 (H2O). In 1994, modulAware developed A2O. In 1995, the ETHZ Oberon System V4 and in 1996, the Linz run-time debugger were ported to Alpha. See The AlphaOberon Run-Time Debugger (Jul/Aug-1996). In 1997, A2O was extended for the 64 bit addressing and became a true 64 bit compiler. See 64 bit address extension of Alpha Oberon-2 compiler (Sep-1996).

  A2O, H2O, and AlphaOberon were modulAware's largest self-funded projects, motivated by the enthusiasm to make Oberon available on a fast 64 bit processor running a high-quality operating system.

  Note: HP's (formerly Compaq's (formerly Digital)) 64 bit OpenVMS Alpha V8.3 operating system and layered products are free for personal use; see What is a 64 bit Compiler?.

All data is subject to change without notice.

Copyright (1992 - 2008) Günter Dotzel, modulAware.com