SUMMARY: MODULE | CLASS | TYPE | PROC | VAR | CONST | DETAIL: TYPE | PROC | VAR | CONST

# RT0

Proxy module for the run-time system. This module is used to pull in the executable code of the run-time system, and to mark the place of the run-time system's header files. This module's directory is added to the include path of the C compiler, so that ``__oo2c.h`', ``__typemap.h`', and so on, are picked up from here.

The compiler implicitly adds an import for this module to every module. A program may import this module directly, for example to gain access to meta data embedded by the compiler into a module's object file. Please note that this module should be considered a part of the compiler, not of the standard library. As such, it may differ across different compiler implementations, and for a given compiler its interface might change without prior notice.

Note: The math library ``libm`' is always linked in for the sake of the predefined function ENTIER.

Class List
Module |
Object |
Struct |

Class Summary: Module [Detail]
      +--RT0.Module
Field Summary
name-: Name Name of the module.
openCount-: LONGINT Number of times this module's open() function has been called from client modules.
typeDescriptors-: POINTER TO ARRAY OF Struct All type descriptors of this module that correspond to named types defined on the top level.
Constructor Summary
ThisModule(ARRAY OF CHAR): Module Returns the module descriptor for the module name.

Class Summary: Object [Detail]
      +--RT0.Object
Method Summary
Finalize() This procedure is called by the run-time system immediately before an object is collected by the garbage collector.

Class Summary: Struct [Detail]
      +--RT0.Struct
Field Summary
baseTypes-: POINTER TO ARRAY OF Struct Array element type, pointer base type, or list of record base types.
flags-: SET Holds attributes that control the way the run-time deals with values of this type (eg.
form-: SHORTINT Identifies which kind of type constructor variant is used.
len-: LONGINT Holds the length of an array, the number of open dimensions of an open array, or the extension level of a record.
module-: Module The module that defines this type descriptor.
name-: Name Type name.
size-: LONGINT Size of the data type in bytes.
tbProcs-: POINTER TO ARRAY OF PTR Table of type-bound procedures of a record type.
typeArgs-: POINTER TO ARRAY OF Struct For a qualified type strQualType, this array holds the base type followed by the type arguments applied to the base type, followed by NIL.
Constructor Summary
ThisType(Module, ARRAY OF CHAR): Struct Returns the type descriptor for the type name of module mid.
TypeOf(PTR): Struct Returns the type of the record pointer ptr.

Type Summary
CaseRange = RECORD ... END
Name = POINTER TO ARRAY OF CHAR
charPtr1d = POINTER TO ARRAY OF CHAR
charPtr2d = POINTER TO ARRAY OF charPtr1d

Procedure Summary
CollectGarbage() Explicitly trigger a full, world-stop garbage collection.
ErrorAssertionFailed(Module, LONGINT, LONGINT)
ErrorDerefOfNil(Module, LONGINT)
ErrorFailedCase(Module, LONGINT, LONGINT)
ErrorFailedFunction(Module, LONGINT)
ErrorFailedTypeAssert(Module, LONGINT)
ErrorFailedTypeGuard(Module, LONGINT, Struct)
ErrorFailedWith(Module, LONGINT, Struct)
ErrorIndexOutOfRange(Module, LONGINT, LONGINT, LONGINT)
FreeBlock(PTR) Frees a block of memory allocated with NewBlock.
Halt(LONGINT)
NewBlock(LONGINT): PTR Allocates a memory block on the heap with a size of at least bytes bytes.
NewObject(Struct): PTR Allocates a new array or record variable on the heap, using the type descriptor td.
RegisterDisappearingLink(VAR PTR) Register the pointer ptr to be cleared when the object that it references is collected by the garbage collector.
RegisterModule(Module) Registers the module descriptor with the run-time system.
ScanCaseRanges(ARRAY OF CaseRange, LONGINT): PTR
TypeTest(Struct, Struct, Struct): BOOLEAN Return TRUE if the type tag tag belongs to an object that is an instance of the type td.
UnregisterDisappearingLink(VAR PTR) Undoes a registration of pointer ptr created by RegisterDisappearingLink.
UnregisterModule(Module) Unregisters the module descriptor from the run-time system.

Variable Summary
argc-: LONGINT
argv-: charPtr2d
boolean-: StructDesc
byte-: StructDesc
char-: StructDesc
integer-: StructDesc
longchar-: StructDesc
longint-: StructDesc
longreal-: StructDesc
poisonHeap: LONGINT If set to a non-negative value, then memory allocated through NewObject and NewBlock is filled with this byte value.
procedure-: StructDesc
ptr-: StructDesc
real-: StructDesc
set32-: StructDesc
shortint-: StructDesc
ucs4char-: StructDesc

Constant Summary
flagAtomic Indicates that this record type does not contain any references that need to be considered by the garbage collector.
flagFinalize Indicates that this record type has a Finalize procedure which should be called by the run-time system upon collection by the GC.
flagVTable Indicates that this record type has a vtable entry which must be initialised by NewObject.
strArray An array definition with a fixed length, as in ``ARRAY 123 OF CHAR`'.
strBoolean
strByte
strChar
strInteger
strLongchar
strLongint
strLongreal
strOpenArray An array definition with an unspecified length, as in ``ARRAY OF CHAR`'.
strPointer A pointer definition of the form ``POINTER TO T`'.
strProcedure A procedure type.
strPtr
strQualType A qualified type, specifying type arguments for a parametric type's parameter list.
strReal
strRecord A record, either in its C struct or union variant.
strSet32
strShortint
strTypeVar A type variable, for example used in a type test within in a type-bound procedure.
strUCS4Char

Class Detail: Module

Field Detail

### name

    FIELD name-: Name

> Name of the module.

### openCount

    FIELD openCount-: LONGINT

> Number of times this module's open() function has been called from client modules. At the same time, this is the number of client modules actively using this module.

### typeDescriptors

    FIELD typeDescriptors-: POINTER TO ARRAY OF Struct

> All type descriptors of this module that correspond to named types defined on the top level. Descriptors are listed in no particular order. The last element of the array has the value NIL.

Constructor Detail

### ThisModule

    PROCEDURE ThisModule(name: ARRAY OF CHAR): Module

> Returns the module descriptor for the module name. Result is NIL if no module of this name has been registered.

Class Detail: Object

Method Detail

### Finalize

    PROCEDURE (o: Object) Finalize()

> This procedure is called by the run-time system immediately before an object is collected by the garbage collector. This procedure may be used to reclaim any system resources (other than GC-managed memory) associated with this object (eg. OS handles). Any type that overrides this method is automatically registered for finalization by the run-time system.

> The Boehm GC finalizes objects in topological order. That is, if A points to B, and both are registered for finalization, it is guaranteed the A will be finalized first. This usually guarantees that finalization procedures see only unfinalized objects. For more details on finalization, see: http://www.hpl.hp.com/personal/Hans_Boehm/gc/finalization.html.

> Important: Program behaviour is undefined if this procedure raises an exception and passes it on to its caller. In this case, the caller is the garbage collector and it is not prepared to handle exceptions.

Class Detail: Struct

Field Detail

### baseTypes

    FIELD baseTypes-: POINTER TO ARRAY OF Struct

> Array element type, pointer base type, or list of record base types. For predefined scalar types this field is NIL.

### flags

    FIELD flags-: SET

> Holds attributes that control the way the run-time deals with values of this type (eg. see flagAtomic, flagVTable).

### form

    FIELD form-: SHORTINT

> Identifies which kind of type constructor variant is used.

### len

    FIELD len-: LONGINT

> Holds the length of an array, the number of open dimensions of an open array, or the extension level of a record.

### module

    FIELD module-: Module

> The module that defines this type descriptor. For predefined types, this is a reference to module ``RT0`'.

### name

    FIELD name-: Name

> Type name. NIL for anonymous types. For instances of strQualType, this is a fully expanded qualified type constructor of the form ``T(A1,A2,...)`'.

### size

    FIELD size-: LONGINT

> Size of the data type in bytes. For an open array type, which has no static size of its own, this field is size of the first element type that is not an open array.

### tbProcs

    FIELD tbProcs-: POINTER TO ARRAY OF PTR

> Table of type-bound procedures of a record type. This field is NIL for all other types.

### typeArgs

    FIELD typeArgs-: POINTER TO ARRAY OF Struct

> For a qualified type strQualType, this array holds the base type followed by the type arguments applied to the base type, followed by NIL. For the type arguments, the type descriptor of the record base type is stored, not that of the pointer type. For types other than strQualType, this field is NIL.

Constructor Detail

### ThisType

    PROCEDURE ThisType(mid: Module;
                       name: ARRAY OF CHAR): Struct

> Returns the type descriptor for the type name of module mid. If name defines a qualified type and there is no match in mid, then all modules of the program are searched. Result is NIL if there is no such type descriptor.

### TypeOf

    PROCEDURE TypeOf(ptr: PTR): Struct

> Returns the type of the record pointer ptr. The address ptr must be a previous result of NewObject. Result is undefined if ptr is not a reference to a record object.

Type Detail

### CaseRange

    TYPE CaseRange = RECORD
                         low-: LONGINT;
                         high-: LONGINT;
                         jmp-: PTR;
                     END

### Name

    TYPE Name = POINTER TO ARRAY OF CHAR

### charPtr1d

    TYPE charPtr1d = POINTER TO ARRAY OF CHAR

### charPtr2d

    TYPE charPtr2d = POINTER TO ARRAY OF charPtr1d

Procedure Detail

### CollectGarbage

    PROCEDURE CollectGarbage()

> Explicitly trigger a full, world-stop garbage collection.

### ErrorAssertionFailed

    PROCEDURE ErrorAssertionFailed(mid: Module;
                                   pos: LONGINT;
                                   code: LONGINT)

### ErrorDerefOfNil

    PROCEDURE ErrorDerefOfNil(mid: Module;
                              pos: LONGINT)

### ErrorFailedCase

    PROCEDURE ErrorFailedCase(mid: Module;
                              pos: LONGINT;
                              select: LONGINT)

### ErrorFailedFunction

    PROCEDURE ErrorFailedFunction(mid: Module;
                                  pos: LONGINT)

### ErrorFailedTypeAssert

    PROCEDURE ErrorFailedTypeAssert(mid: Module;
                                    pos: LONGINT)

### ErrorFailedTypeGuard

    PROCEDURE ErrorFailedTypeGuard(mid: Module;
                                   pos: LONGINT;
                                   typeTag: Struct)

### ErrorFailedWith

    PROCEDURE ErrorFailedWith(mid: Module;
                              pos: LONGINT;
                              typeTag: Struct)

### ErrorIndexOutOfRange

    PROCEDURE ErrorIndexOutOfRange(mid: Module;
                                   pos: LONGINT;
                                   index: LONGINT;
                                   length: LONGINT)

### FreeBlock

    PROCEDURE FreeBlock(ptr: PTR)

> Frees a block of memory allocated with NewBlock.

### Halt

    PROCEDURE Halt(code: LONGINT)

### NewBlock

    PROCEDURE NewBlock(bytes: LONGINT): PTR

> Allocates a memory block on the heap with a size of at least bytes bytes. Pointers in the allocated block are ignored during garbage collection. That is, the block must not contain any references to objects on the heap that are not kept live by other pointers.

### NewObject

    PROCEDURE NewObject(td: Struct): PTR

> Allocates a new array or record variable on the heap, using the type descriptor td. For an open array object, the lengths of the array's dimensions are passed as second, third, and so on, parameter. They must be of type LONGINT.

### RegisterDisappearingLink

    PROCEDURE RegisterDisappearingLink(VAR ptr: PTR)

> Register the pointer ptr to be cleared when the object that it references is collected by the garbage collector. Note: it is only safe to register pointers from heap objects, or global module variables. NEVER use this procedure for a pointer allocated on the stack (ie. a local variable or procedure parameter).

### RegisterModule

    PROCEDURE RegisterModule(mid: Module)

> Registers the module descriptor with the run-time system.

### ScanCaseRanges

    PROCEDURE ScanCaseRanges(table: ARRAY OF CaseRange;
                             value: LONGINT): PTR

### TypeTest

    PROCEDURE TypeTest(tag: Struct;
                       td: Struct;
                       receiverTag: Struct): BOOLEAN

> Return TRUE if the type tag tag belongs to an object that is an instance of the type td. For normal (that is, non-qualified) types, this is a constant type operation that is basically a pointer comparison. For qualified types, it compares the structure of both types. In this case, the function returns TRUE if the relevant base type of tag and td have the same base type, and if the corresponding type arguments are of the same type.

> Pre-condition: tag and td is the type descriptor of a ``RECORD`' type. If not NIL, receiverTag is the type descriptor of the record to which the procedure is bound.

### UnregisterDisappearingLink

    PROCEDURE UnregisterDisappearingLink(VAR ptr: PTR)

> Undoes a registration of pointer ptr created by RegisterDisappearingLink.

### UnregisterModule

    PROCEDURE UnregisterModule(mid: Module)

> Unregisters the module descriptor from the run-time system. Currently, this procedure is a noop.

Variable Detail

### argc

    VAR argc-: LONGINT

### argv

    VAR argv-: charPtr2d

### boolean

    VAR boolean-: StructDesc

### byte

    VAR byte-: StructDesc

### char

    VAR char-: StructDesc

### integer

    VAR integer-: StructDesc

### longchar

    VAR longchar-: StructDesc

### longint

    VAR longint-: StructDesc

### longreal

    VAR longreal-: StructDesc

### poisonHeap

    VAR poisonHeap: LONGINT

> If set to a non-negative value, then memory allocated through NewObject and NewBlock is filled with this byte value. Otherwise, the memory is left as provided by the used libc or libgc library. This is the default.

### procedure

    VAR procedure-: StructDesc

### ptr

    VAR ptr-: StructDesc

### real

    VAR real-: StructDesc

### set32

    VAR set32-: StructDesc

### shortint

    VAR shortint-: StructDesc

### ucs4char

    VAR ucs4char-: StructDesc

Constant Detail

### flagAtomic

    CONST flagAtomic

> Indicates that this record type does not contain any references that need to be considered by the garbage collector. It may be allocated as an atomic object.

### flagFinalize

    CONST flagFinalize

> Indicates that this record type has a Finalize procedure which should be called by the run-time system upon collection by the GC. This flag is set by the compiler for record types that override the method ObjectDesc.Finalize.

### flagVTable

    CONST flagVTable

> Indicates that this record type has a vtable entry which must be initialised by NewObject.

### strArray

    CONST strArray

> An array definition with a fixed length, as in ``ARRAY 123 OF CHAR`'.

### strBoolean

    CONST strBoolean

### strByte

    CONST strByte

### strChar

    CONST strChar

### strInteger

    CONST strInteger

### strLongchar

    CONST strLongchar

### strLongint

    CONST strLongint

### strLongreal

    CONST strLongreal

### strOpenArray

    CONST strOpenArray

> An array definition with an unspecified length, as in ``ARRAY OF CHAR`'.

### strPointer

    CONST strPointer

> A pointer definition of the form ``POINTER TO T`'.

### strProcedure

    CONST strProcedure

> A procedure type. Currently, all procedure types are mapped onto the single type descriptor procedure, even though they may differ in the number, type or mode of their parameters, or their result type.

### strPtr

    CONST strPtr

### strQualType

    CONST strQualType

> A qualified type, specifying type arguments for a parametric type's parameter list.

### strReal

    CONST strReal

### strRecord

    CONST strRecord

> A record, either in its C struct or union variant.

### strSet32

    CONST strSet32

### strShortint

    CONST strShortint

### strTypeVar

    CONST strTypeVar

> A type variable, for example used in a type test within in a type-bound procedure.

### strUCS4Char

    CONST strUCS4Char