where TypeOf(x) means the identifier of type x and ElemType means the identifier of the element type of the indeterminate field of a record of indeterminate type.

TODO(str) prints str to console, causes warning in DEBUG mode, or error otherwise

TODO causes compile time warning when in DEBUG mode, otherwise compile time error

FIRST(c) returns first value of collection c
LAST(c) returns last value of collection c

INSERT(c, ...) inserts values in set or list, or values at index, or key/value pairs in collection c
APPEND(c, v1, v2, v3) appends values to list or array collection c
REMOVE(c, ...) removes elements from set or list, or values in index range, or key/value pairs from collection c

COUNT(c) returns the item count of collection c

MIN(v1, v2, v3 ...) returns smallest value from argument list
MAX(v1, v2, v3 ...) returns largest value from argument list

SORTNEW(t, s, order) creates new target collection t with sorted values from source collection s

The constant NIL represents an invalid pointer. It is compatible with any pointer type. Its value is defined as:

CONST NIL = 0 :: POINTER TO IMMUTABLE OCTET;

to do: add primitive SEEK

Detailed Descriptions

SORT(t, s, order) sorts values of source collection s into target collectiont

ABS(x) returns the absolute (sign removed) value of x

MAX(v1, v2, v3 ...) returns largest value from argument list

moved to pseudo-module RUNTIME:

to be moved to pseudo-module for primitives

STORE(c, ...) stores values in set or list, or value at index, or key for value in collection c

ABS(x) returns the absolute value of x

TMIN(T) returns smallest legal value of type T
TMAX(T) returns largest legal value of type T
TLIMIT(T) returns the capacity of collection type T
TSIZE(T) returns allocation size required for type T

moved to pseudo-module RUNTIME: SIZE(v) returns the allocated size of variable v

MIN(c1, c2, c3 ...) inserts smallest constant
MAX(c1, c2, c3 ...) inserts largest constant

NEG(x) returns the sign reversed value of x

SIZE(v) returns the allocated size of variable v
HIGH(a) returns highest subscript for array a

NEXTV(v) returns pointer to next variadic tuple of v

VAL(T, x) equivalent to type conversion expression x :: T

Unsigned types: OCTET, CARDINAL, LONGCARD
Integer types: INTEGER, LONGINT

NEW(p) invokes ALLOCATE(p, TSIZE(TypeOf(p^)))
NEW(p, n) invokes ALLOCATE(p, TSIZE(TypeOf(p^)) + n * TSIZE(ElemType))
DISPOSE(p) invokes DEALLOCATE(p, SIZE(p^))

Procedure NEW

Procedure NEW is used to dynamically allocate storage at runtime. The procedure is defined as:

<*INLINE*> PROCEDURE NEW ( VAR p : <PointerType>; (* OPTIONAL *) n : <unsignedTypes> );
  (* calculates the required storage size for the base type of p, allocates a block of
     storage of the determined size and passes its address back in p, if p points to
     an indeterminate type, then the determinant value must be passed in n *)

Static Semantics:

A call of NEW must have one or two actual parameters. The first parameter may be a variable of any pointer type. If the first parameter is a pointer to an indeterminate type, then a second parameter must be passed in. The second parameter may be a value of type OCTET, CARDINAL or LONGCARD. A library procedure named ALLOCATE must be visible in the lexical scope where NEW is called. The library procedure must conform to the following signature:

PROCEDURE ALLOCATE ( VAR p : ADDRESS; size : LONGCARD );

Dynamic Semantics:

Procedure NEW allocates storage at runtime and passes a pointer to the allocated storage back in its first parameter. It calls function TSIZE to calculate the required storage size and it calls library procedure ALLOCATE to allocate storage. The semantics are defined as:

  targetType := baseTypeOf(p)
  baseSize := evaluate TSIZE(targetType)
  if isDeterminateType(targetType) then
    insert ALLOCATE(p, baseSize)
  elsif isIndeterminateType(targetType) and isPresent(n) then
    indeterminateComponent := symTabLookup(targetType, indeterminateField, name)
    componentType :=  baseTypeOf(p^.indeterminateComponent)
    insert ALLOCATE(p, baseSize + n * TSIZE(componentType))
    determinant := symTabLookup(targetType, determinantField, name)
    insert p^.determinant := n
  else
    raiseCompileTimeError
  endif

Procedure DISPOSE

Procedure DISPOSE is used to release dynamically allocated storage that was reserved by a call to procedure NEW. The procedure is defined as:

<*INLINE*> PROCEDURE DISPOSE ( VAR p : <AnyPointerType> );
  (* release the storage previously allocated by a call to NEW and pointed to by p *)

Static Semantics:

A call of DISPOSE must have one actual parameter. The parameter may be a variable of any pointer type. A library procedure named DEALLOCATE must be visible in the lexical scope where DISPOSE is called. The library procedure must conform to the following signature:

PROCEDURE DEALLOCATE ( VAR p : ADDRESS; size : LONGCARD );

Dynamic Semantics:

Procedure DISPOSE first calls function SIZE to determine the allocation size of the storage block pointed to by its first argument and then it deallocates the storage block by calling library procedure DEALLOCATE passing the pointer and allocated size. The semantics are defined as:

  insert DEALLOCATE(p, SIZE (p^))

Predefined identifiers are language defined identifiers that are visible in any lexical scope without import. They fall into five categories:

Pervasives are predefined identifiers that are visible in any lexical scope without import. Unlike reserved words, pervasives may be redefined. Pervasives fall into five categories: constants, types, procedures, functions and compile-time macros: