## Index

    # operator,  *
    & operator,  *
    (* *) (comment),  *
    * operator,  *
    + operator,  *
    - operator,  *
    . operator,  *
    .. in set and array constructors,  *  *
    / operator,  *
    <* *> (pragma),  *
    <: declaration,  *  *
    = operator,  *
    ^ operator,  *

### A

    ABS,  *
    abstract type,  *
    Ada programming language,  *  *  *
    addition,  *
    ADDRESS,  *
    ADDRESS, assignment of,  *  *
    ADR,  *
    ADRSIZE,  *
    aggregate, see records or arrays
    Algol programming language,  *
    aliasing, of VAR parameters,  *
    alignment, see packed types
    allocated type,  *
    allocation,  *
    AND,  *
    arithmetic operations,  *
    arrays,  *
    arrays, assigning,  *  *  *  *  *  *  *  *  *  *
    ASCII, see ISO-Latin-1
    assignable,  *
    assignable, READONLY/VALUE formals,  *  *  *  *  *  *  *  *  *  *
    assignment statements,  *
    automatic dereferencing,  *

### B

    B programming language,  *
    backslash, in literals,  *
    base type,  *
    BCPL programming language,  *
    binding power, of operators,  *
    bindings, in procedure call,  *
    bit operations,  *
    BITS FOR,  *  *  *  *
    BITSIZE,  *
    Bliss programming language,  *
    block,  *
    block, module,  *  *  *
    body, of procedure,  *
    BOOLEAN,  *
    BOOLEAN, operations on,  *
    BRANDED,  *
    BYTESIZE,  *

### C

    C programming language,  *
    C++ programming language,  *
    call, procedure,  *
    CARDINAL,  *
    carriage return, in literals,  *
    CASE statement,  *
    case, in keywords,  *  *
    Cedar programming language,  *
    CEILING,  *
    CHAR,  *
    character literals,  *  *
    checked runtime error,  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *
    circularities, in imports lists,  *  *
    CLU programming language,  *
    coercions, checked,  *  *
    comments,  *
    comments, tokenizing,  *
    comparison operation,  *
    complete revelation,  *
    concatenating texts,  *
    concrete types,  *
    constant expression,  *  *
    constants,  *
    constants, declarations,  *  *  *
    constructors, array,  *  *  *
    contain (value in type),  *
    conversion, enumerations and integers,  *  *
    covers, for procedure signatures,  *
    cyclic imports,  *

### D

    dangling pointer,  *
    data record, of object,  *
    deallocation,  *
    DEC,  *
    DEC, on addresses (unsafe),  *
    declaration,  *
    declaration, recursive,  *  *
    default values, in record fields,  *  *  *
    delimiters, complete list,  *
    dereferencing,  *
    designators,  *
    designators, operators allowed in,  *  *  *
    dimension,  *
    DISPOSE,  *
    DIV,  *
    division by zero,  *
    division, real,  *
    double quote, in literals,  *

### E

    element type, of array,  *
    empty type,  *
    enumerations,  *
    enumerations, first and last elements,  *  *  *  *
    environment, of procedure,  *
    equality operator,  *
    errors, static and runtime,  *
    escape sequences, in literals,  *
    EVAL,  *
    example, pathological,  *  *
    exceptions,  *  *
    exceptions, RAISE,  *  *  *  *  *  *
    EXIT,  *
    exit-exception,  *  *  *
    expanded definition (of type),  *
    exporting an interface,  *
    EXPORTS clause,  *
    expression,  *  *
    expression, constant,  *  *  *
    EXTENDED,  *
    EXTENDED, literals,  *
    EXTERNAL,  *

### F

    FALSE,  *
    field selection, records/objects,  *
    fields, of record,  *
    FIRST,  *
    fixed arrays,  *  *  *
    FLOAT,  *
    floating point numbers,  *
    floating-point interfaces,  *
    FLOOR,  *
    Fmt interface,  *
    FOR statement,  *
    fork (of a thread),  *
    form feed, in literals,  *
    formatting data as texts,  *
    FROM ... IMPORT,  *
    function procedures,  *  *  *

### G

    garbage collection,  *  *
    generic interface,  *  *  *
    generics,  *  *

### H

    handlers, for exceptions,  *
    hash tables, see Table interface  *
    hexadecimal literal,  *

### I

    identifiers,  *
    identifiers, lexical structure,  *  *  *  *  *
    IF,  *
    import cycle,  *
    imports,  *
    IN (a set),  *
    INC,  *  *
    index type, of array,  *
    inheritance,  *
    initialization, during allocation,  *  *  *  *
    INLINE,  *
    INTEGER,  *
    interfaces,  *  *
    interfaces, exporting,  *  *  *  *
    intersection, set,  *
    intrinsically safe,  *
    ISO-Latin-1,  *
    ISTYPE,  *

### J

    join (of a thread),  *

### K

    keyword binding,  *
    keywords, complete list,  *

### L

    LAST,  *
    Lisp programming language,  *
    literals, character,  *  *  *  *
    local procedures,  *  *  *
    location,  *
    LOCK statement,  *
    LONGREAL,  *
    LONGREAL, literals,  *
    LOOP,  *
    LOOPHOLE,  *

### M

    main module,  *
    masked field,  *
    MAX,  *
    member (value in type),  *
    Mesa programming language,  *
    method suite,  *
    methods,  *
    methods, declaring,  *  *  *  *
    MIN,  *
    ML programming language,  *
    MOD,  *
    mode, see parameter mode
    Modula-2 programming language,  *
    Modula-3 Abstract Syntax Trees,  *
    modules,  *  *
    modules, initialization,  *  *
    monitor,  *
    multi-dimensional arrays,  *
    multiplication,  *
    MUTEX,  *  *

### N

    NARROW,  *
    NEW,  *
    newline, in literals,  *
    NIL,  *
    normal outcome,  *
    NOT,  *
    NULL,  *
    NUMBER,  *
    numbers, literal,  *

### O

    Oberon programming language,  *
    objects,  *  *
    objects, accessing fields and methods,  *  *  *  *  *  *  *  *  *
    octal literal,  *
    opaque types,  *
    open arrays,  *  *  *  *  *
    operators, complete list,  *  *  *
    OR,  *
    ORD,  *
    order (<, >, ...),  *  *
    ordinal types,  *  *  *  *
    overflow,  *
    overloading, of operation,  *
    overriding,  *  *

### P

    package, see module
    packed types,  *  *
    parameter mode,  *  *
    partial expansion (of type),  *  *  *
    partially opaque type,  *  *
    Pascal programming language,  *
    persistent storage, see Pkl interface  *
    Pkl (pickle) interface,  *
    pointer, see reference
    positional binding,  *
    pragmas,  *
    precedence, of operators,  *
    procedural operator,  *
    procedure call,  *
    procedures,  *
    procedures, RETURN,  *  *  *  *  *  *  *  *  *  *  *  *  *
    process algebra,  *
    process, see thread
    program, definition of,  *
    proper procedure,  *

### Q

    qualified identifier,  *

### R

    RAISE,  *
    RAISES,  *
    raises set, of procedure,  *
    RAISES, dangling,  *  *
    readonly designator,  *  *
    READONLY parameters,  *
    REAL,  *
    real division,  *
    REAL, conversions to,  *  *  *
    records,  *
    records, constructors for,  *  *  *
    recursive declarations,  *
    REFANY,  *
    reference class,  *
    references,  *
    references, TYPECASE,  *  *  *  *  *  *  *  *
    referent,  *  *
    reflexive relation,  *
    relational operators,  *
    remainder, see MOD
    REPEAT statement,  *
    required interfaces,  *
    result type, of procedure,  *
    RETURN,  *
    return-exception,  *  *
    REVEAL,  *
    revelations,  *
    revelations, imported,  *
    ROOT,  *
    ROUND,  *
    rounding of arithmetic operations,  *
    runtime error,  *

### S

    safety,  *  *
    scale factors, in numeric literals,  *
    scope,  *
    scope, block statement,  *  *  *  *  *  *  *  *  *  *  *
    selection of fields,  *
    sequential composition,  *
    sets,  *
    sets, IN operator,  *  *  *  *  *  *  *  *
    shape, of array,  *
    shared variables,  *
    sign inversion,  *
    signature,  *  *
    signature, covers,  *
    single quote, in literals,  *
    size, of type,  *
    Smalltalk programming language,  *
    statements,  *
    static error,  *  *
    storage allocation,  *  *  *
    strings,  *
    strings, see texts  *
    structural equivalence,  *
    SUBARRAY,  *
    subranges,  *
    subranges, subtyping rules,  *
    subscript operator,  *
    subset operation,  *
    subtraction,  *
    subtype relation,  *
    supertype (subtyping relation),  *
    symmetric set difference,  *
    syntax,  *

### T

    tab, in literals,  *
    Table interface,  *
    task, see thread
    termination of program,  *
    TEXT,  *
    Text interface,  *
    texts,  *
    texts, concatenating,  *  *  *
    Thread creation,  *
    threads,  *
    tokenizing,  *
    top-level procedure,  *
    Topaz system,  *
    traced, object types,  *  *  *
    transitive relation,  *
    TRUE,  *
    TRUNC,  *
    TRY EXCEPT,  *  *
    type,  *  *  *  *  *
    type, assignable,  *  *  *  *  *  *  *  *
    TYPECASE,  *
    TYPECODE,  *

### U

    unchecked runtime errors,  *  *
    undefined procedure,  *
    underflow,  *
    union, of sets,  *
    UNSAFE,  *
    unsafe features,  *
    unsigned integers,  *  *
    UNTRACED ROOT,  *
    UNTRACED, in reference declarations,  *  *

### V

    VAL,  *
    value,  *
    VALUE parameters,  *  *
    VAR declarations,  *  *  *
    variables,  *  *
    variables, initialization,  *  *  *
    variant records,  *
    visibility, see scope

### W

    WHILE statement,  *
    WITH statement,  *
    Word interface,  *
    word size, of type,  *
    writable designator,  *  *

### X

### Y

### Z

    zero, division by,  *

    Last modified on Wed Apr  3 09:39:04 PST 1996 by heydon
         modified on Mon Apr 18 14:48:58 PDT 1994 by kalsow