home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / oberonv4.zip / oberonv4.exe / oberon2r.inf (.txt) < prev    next >
OS/2 Help File  |  1996-02-25  |  54KB  |  1,532 lines

  1.  
  2. ΓòÉΓòÉΓòÉ 1. Title Page ΓòÉΓòÉΓòÉ
  3.  
  4.                         The Programming Language Oberon-2
  5.  
  6.                              H. M╨ñssenb╨ñck, N. Wirth
  7.  
  8.                     Institut f╨ær Computersysteme, ETH Z╨ærich
  9.  
  10.                                    March 1992
  11.  
  12.                            converted to INF-format by
  13.  
  14.                                    D. Steiner
  15.  
  16.                                 17. December 1994
  17.  
  18.  
  19. ΓòÉΓòÉΓòÉ 2. Introduction ΓòÉΓòÉΓòÉ
  20.  
  21. Oberon-2 is a general-purpose language in the tradition of Oberon and Modula-2. 
  22. Its most important features are block structure, modularity, separate 
  23. compilation, static typing with strong type checking (also across module 
  24. boundaries), and type extension with type-bound procedures. 
  25.  
  26. Type extension makes Oberon-2 an object-oriented language. An object is a 
  27. variable of an abstract data type consisting of private data (its state) and 
  28. procedures that operate on this data. Abstract data types are declared as 
  29. extensible records. Oberon-2 covers most terms of object-oriented languages by 
  30. the established vocabulary of imperative languages in order to minimize the 
  31. number of notions for similar concepts. 
  32.  
  33. This report is not intended as a programmer's tutorial. It is intentionally 
  34. kept concise. Its function is to serve as a reference for programmers, 
  35. implementors, and manual writers. What remains unsaid is mostly left so 
  36. intentionally, either because it can be derived from stated rules of the 
  37. language, or because it would require to commit the definition when a general 
  38. commitment appears as unwise. 
  39.  
  40. Appendix A defines some terms that are used to express the type checking rules 
  41. of Oberon-2. Where they appear in the text, they are written in italics to 
  42. indicate their special meaning (e.g. the same type). 
  43.  
  44.  
  45. ΓòÉΓòÉΓòÉ 3. Syntax ΓòÉΓòÉΓòÉ
  46.  
  47. An extended Backus-Naur Formalism (EBNF) is used to describe the syntax of 
  48. Oberon-2: Alternatives are separated by |. Brackets [ and ] denote optionality 
  49. of the enclosed expression, and braces { and } denote its repetition (possibly 
  50. 0 times). Non-terminal symbols start with an upper-case letter (e.g. 
  51. Statement). Terminal symbols either start with a lower-case letter (e.g. 
  52. ident), or are written all in upper-case letters (e.g. BEGIN), or are denoted 
  53. by strings (e.g. ":="). 
  54.  
  55.  
  56. ΓòÉΓòÉΓòÉ 4. Vocabulary and Representation ΓòÉΓòÉΓòÉ
  57.  
  58. The representation of (terminal) symbols in terms of characters is defined 
  59. using the ASCII set. Symbols are identifiers, numbers, strings, operators, and 
  60. delimiters. The following lexical rules must be observed: Blanks and line 
  61. breaks must not occur within symbols (except in comments, and blanks in 
  62. strings). They are ignored unless they are essential to separate two 
  63. consecutive symbols. Capital and lower-case letters are considered as distinct. 
  64.  
  65. 1. Identifiers are sequences of letters and digits. The first character must be 
  66. a letter. 
  67.  
  68.   ident = letter {letter | digit}.
  69.  
  70. Examples:   x   Scan   Oberon2   GetSymbol   firstLetter 
  71.  
  72. 2. Numbers are (unsigned) integer or real constants. The type of an integer 
  73. constant is the minimal type to which the constant value belongs (see Basic 
  74. types). If the constant is specified with the suffix H, the representation is 
  75. hexadecimal otherwise the representation is decimal. 
  76. A real number always contains a decimal point. Optionally it may also contain a 
  77. decimal scale factor. The letter E (or D) means "times ten to the power of". A 
  78. real number is of type REAL, unless it has a scale factor containing the letter 
  79. D. In this case it is of type LONGREAL. 
  80.  
  81.   number      = integer | real.
  82.   integer     = digit {digit} | digit {hexDigit} "H".
  83.   real        = digit {digit} "." {digit} [ScaleFactor].
  84.   ScaleFactor = ("E" | "D") ["+" | "-"] digit {digit}.
  85.   hexDigit    = digit | "A" | "B" | "C" | "D" | "E" | "F".
  86.   digit       = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9".
  87.  
  88. Examples: 
  89.   1991      INTEGER   1991 
  90.   0DH       SHORTINT   13 
  91.   12.3      REAL     12.3 
  92.   4.567E8     REAL     456700000 
  93.   0.57712566D-6  LONGREAL   0.00000057712566 
  94.  
  95. 3. Character constants are denoted by the ordinal number of the character in 
  96. hexadecimal notation followed by the letter X. 
  97.  
  98.   character  = digit {hexDigit} "X".
  99.  
  100. 4. Strings are sequences of characters enclosed in single (') or double (") 
  101. quote marks. The opening quote must be the same as the closing quote and must 
  102. not occur within the string. The number of characters in a string is called its 
  103. length. A string of length 1 can be used wherever a character constant is 
  104. allowed and vice versa. 
  105.  
  106. string  = ' " ' {char} ' " ' | " ' " {char} " ' ".
  107.  
  108. Examples:   "Oberon-2"   "Don't worry!"   "x" 
  109.  
  110. 5. Operators and delimiters are the special characters, character pairs, or 
  111. reserved words listed below. The reserved words consist exclusively of capital 
  112. letters and cannot be used as identifiers. 
  113.  
  114.    +        :=       ARRAY     IMPORT    RETURN
  115.    -        ^        BEGIN     IN        THEN
  116.    *        =        BY        IS        TO
  117.    /        #        CASE      LOOP      TYPE
  118.    ~        <        CONST     MOD       UNTIL
  119.    &        >        DIV       MODULE    VAR
  120.    .        <=       DO        NIL       WHILE
  121.    ,        >=       ELSE      OF        WITH
  122.    ;        ..       ELSIF     OR
  123.    |        :        END       POINTER
  124.    (        )        EXIT      PROCEDURE
  125.    [        ]        FOR       RECORD
  126.    {        }        IF        REPEAT
  127.  
  128. 6. Comments may be inserted between any two symbols in a program. They are 
  129. arbitrary character sequences opened by the bracket (* and closed by *). 
  130. Comments may be nested. They do not affect the meaning of a program. 
  131.  
  132.  
  133. ΓòÉΓòÉΓòÉ 5. Declarations and scope rules ΓòÉΓòÉΓòÉ
  134.  
  135. Every identifier occurring in a program must be introduced by a declaration, 
  136. unless it is a predeclared identifier. Declarations also specify certain 
  137. permanent properties of an object, such as whether it is a constant, a type, a 
  138. variable, or a procedure. The identifier is then used to refer to the 
  139. associated object. 
  140.  
  141. The scope of an object x extends textually from the point of its declaration to 
  142. the end of the block (module, procedure, or record) to which the declaration 
  143. belongs and hence to which the object is local. It excludes the scopes of 
  144. equally named objects which are declared in nested blocks. The scope rules are: 
  145.  
  146.       1. No identifier may denote more than one object within a given scope 
  147.          (i.e. no identifier may be declared twice in a block); 
  148.  
  149.       2. An object may only be referenced within its scope; 
  150.  
  151.       3. A type T of the form POINTER TO T1 (see Pointer types) can be declared 
  152.          at a point where T1 is still unknown. The declaration of T1 must 
  153.          follow in the same block to which T is local; 
  154.  
  155.       4. Identifiers denoting record fields (see Record types) or type-bound 
  156.          procedures (see  Type-bound procedures) are valid in record 
  157.          designators only. 
  158.  
  159.  An identifier declared in a module block may be followed by an export mark (" 
  160.  * " or " - ") in its declaration to indicate that it is exported. An 
  161.  identifier x exported by a module M may be used in other modules, if they 
  162.  import M (see Modules). The identifier is then denoted as M.x in these modules 
  163.  and is called a qualified identifier. Identifiers marked with " - " in their 
  164.  declaration are read-only in importing modules. 
  165.  
  166.     Qualident        = [ident "."] ident.
  167.     IdentDef         = ident [" * " | " - "].
  168.  
  169.  The following identifiers are predeclared; their meaning is defined in the 
  170.  indicated sections: 
  171.  
  172.     ABS                LEN
  173.     ASH                LONG
  174.     BOOLEAN            LONGINT
  175.     CAP                LONGREAL
  176.     CHAR               MAX
  177.     CHR                MIN
  178.     COPY               NEW
  179.     DEC                ODD
  180.     ENTIER             ORD
  181.     EXCL               REAL
  182.     FALSE              SET
  183.     HALT               SHORT
  184.     INC                SHORTINT
  185.     INCL               SIZE
  186.     INTEGER            TRUE
  187.  
  188.  
  189. ΓòÉΓòÉΓòÉ 6. Constant declarations ΓòÉΓòÉΓòÉ
  190.  
  191. A constant declaration associates an identifier with a constant value. 
  192.  
  193.   ConstantDeclaration     = IdentDef "=" ConstExpression.
  194.   ConstExpression         = Expression.
  195.  
  196. A constant expression is an expression that can be evaluated by a mere textual 
  197. scan without actually executing the program. Its operands are constants or 
  198. predeclared functions that can be evaluated at compile time. Examples of 
  199. constant declarations are: 
  200.  
  201.  N = 100 
  202.  limit = 2*N - 1 
  203.  fullSet = {MIN(SET) .. MAX(SET)} 
  204.  
  205.  
  206. ΓòÉΓòÉΓòÉ 7. Type declarations ΓòÉΓòÉΓòÉ
  207.  
  208. A data type determines the set of values which variables of that type may 
  209. assume, and the operators that are applicable. A type declaration associates an 
  210. identifier with a type. In the case of structured types (arrays and records) it 
  211. also defines the structure of variables of this type. 
  212.  
  213.   TypeDeclaration  = IdentDef "=" Type.
  214.   Type             = Qualident | ArrayType | RecordType | PointerType
  215.                      | ProcedureType.
  216.  
  217. Examples: 
  218.  
  219. Table = ARRAY N OF REAL 
  220. Tree  = POINTER TO Node 
  221. Node  = RECORD 
  222.       key : INTEGER; 
  223.       left, right: Tree 
  224.     END 
  225.  
  226. CenterTree = POINTER TO CenterNode 
  227. CenterNode = RECORD (Node) 
  228.         width: INTEGER; 
  229.         subnode: Tree 
  230.        END 
  231.  
  232. Function = PROCEDURE(x: INTEGER): INTEGER 
  233.  
  234.  
  235. ΓòÉΓòÉΓòÉ 7.1. Basic types ΓòÉΓòÉΓòÉ
  236.  
  237. The basic types are denoted by predeclared identifiers. The associated 
  238. operators are defined in Operators and the predeclared function procedures in 
  239. Predeclared procedures. The values of the given basic types are the following: 
  240.  
  241.       1. BOOLEAN   the truth values TRUE and FALSE 
  242.  
  243.       2. CHAR    the characters of the extended ASCII set (0X .. 0FFX) 
  244.  
  245.       3. SHORTINT  the integers between MIN(SHORTINT) and MAX(SHORTINT) 
  246.  
  247.       4. INTEGER   the integers between MIN(INTEGER) and MAX(INTEGER) 
  248.  
  249.       5. LONGINT   the integers between MIN(LONGINT) and MAX(LONGINT) 
  250.  
  251.       6. REAL    the real numbers between MIN(REAL) and MAX(REAL) 
  252.  
  253.       7. LONGREAL  the real numbers between MIN(LONGREAL) and MAX(LONGREAL) 
  254.  
  255.       8. SET     the sets of integers between 0 and MAX(SET) 
  256.  
  257.  Types 3 to 5 are integer types, types 6 and 7 are real types, and together 
  258.  they are called numeric types. They form a hierarchy; the larger type includes 
  259.  (the values of) the smaller type: 
  260.  
  261.           LONGREAL  >=  REAL  >=  LONGINT  >=  INTEGER  >=  SHORTINT
  262.  
  263.  
  264. ΓòÉΓòÉΓòÉ 7.2. Array types ΓòÉΓòÉΓòÉ
  265.  
  266. An array is a structure consisting of a number of elements which are all of the 
  267. same type, called the element type. The number of elements of an array is 
  268. called its length. The elements of the array are designated by indices, which 
  269. are integers between 0 and the length minus 1. 
  270.  
  271.   ArrayType      = ARRAY [Length {"," Length}] OF Type.
  272.   Length         = ConstExpression.
  273.  
  274. A type of the form 
  275.  
  276.     ARRAY L0, L1, ..., Ln OF T 
  277.  
  278. is understood as an abbreviation of 
  279.  
  280.         ARRAY L0 OF
  281.                 ARRAY L1 OF
  282.                 ...
  283.                    ARRAY Ln OF T
  284.  
  285. Arrays declared without length are called open arrays. They are restricted to 
  286. pointer base types (see Pointer types ), element types of open array types, and 
  287. formal parameter types (see Formal parameters). Examples: 
  288.  
  289.     ARRAY 10, N OF INTEGER 
  290.     ARRAY OF CHAR 
  291.  
  292.  
  293. ΓòÉΓòÉΓòÉ 7.3. Record types ΓòÉΓòÉΓòÉ
  294.  
  295. A record type is a structure consisting of a fixed number of elements, called 
  296. fields, with possibly different types. The record type declaration specifies 
  297. the name and type of each field. The scope of the field identifiers extends 
  298. from the point of their declaration to the end of the record type, but they are 
  299. also visible within designators referring to elements of record variables (see 
  300. Operands). If a record type is exported, field identifiers that are to be 
  301. visible outside the declaring module must be marked. They are called public 
  302. fields; unmarked elements are called private fields. 
  303.  
  304. RecordType       = RECORD ["("BaseType")"] FieldList {";" FieldList} END.
  305. BaseType         = Qualident.
  306. FieldList        = [IdentList ":" Type ].
  307.  
  308. Record types are extensible, i.e. a record type can be declared as an extension 
  309. of another record type. In the example 
  310.  
  311.     T0 = RECORD x: INTEGER END 
  312.     T1 = RECORD (T0) y: REAL END 
  313.  
  314. T1 is a (direct) extension of T0 and T0 is the (direct) base type of T1 (see 
  315. App. A). An extended type T1 consists of the fields of its base type and of the 
  316. fields which are declared in T1 (see  Type declarations). All identifiers 
  317. declared in the extended record must be different from the identifiers declared 
  318. in its base type record(s). 
  319.  
  320. Examples of record type declarations: 
  321.  
  322.  RECORD 
  323.   day, month, year: INTEGER 
  324.  END 
  325.  
  326.  RECORD 
  327.   name, firstname: ARRAY 32 OF CHAR; 
  328.   age: INTEGER; 
  329.   salary: REAL 
  330.  END 
  331.  
  332.  
  333. ΓòÉΓòÉΓòÉ 7.4. Pointer types ΓòÉΓòÉΓòÉ
  334.  
  335. Variables of a pointer type P assume as values pointers to variables of some 
  336. type T. T is called the pointer base type of P and must be a record or array 
  337. type. Pointer types inherit the extension relation of their pointer base types: 
  338. if a type T1 is an extension of T, and P1 is of type POINTER TO T1, then P1 is 
  339. also an extension of P. 
  340.  
  341.     PointerType = POINTER TO Type. 
  342.  
  343. If p is a variable of type P = POINTER TO T, a call of the predeclared 
  344. procedure NEW(p) (see Predeclared procedures) allocates a variable of type T in 
  345. free storage. If T is a record type or an array type with fixed length, the 
  346. allocation has to be done with NEW(p); if T is an n-dimensional open array type 
  347. the allocation has to be done with NEW(p, e0, ..., en-1) where T is allocated 
  348. with lengths given by the expressions e0, ..., en-1. In either case a pointer 
  349. to the allocated variable is assigned to p. p is of type P. The referenced 
  350. variable p^ (pronounced as p-referenced) is of type T. 
  351.  
  352. Any pointer variable may assume the value NIL, which points to no variable at 
  353. all. All pointer variables are initialized to NIL. 
  354.  
  355.  
  356. ΓòÉΓòÉΓòÉ 7.5. Procedure types ΓòÉΓòÉΓòÉ
  357.  
  358. Variables of a procedure type T have a procedure (or NIL) as value. If a 
  359. procedure P is assigned to a variable of type T, the formal parameter lists 
  360. (see Ch. Formal parameters) of P and T must match (see App. A). P must not be a 
  361. predeclared or type-bound procedure nor may it be local to another procedure. 
  362.  
  363.     ProcedureType = PROCEDURE [FormalParameters]. 
  364.  
  365.  
  366. ΓòÉΓòÉΓòÉ 8. Variable declarations ΓòÉΓòÉΓòÉ
  367.  
  368. Variable declarations introduce variables by defining an identifier and a data 
  369. type for them. 
  370.  
  371.     VariableDeclaration = IdentList ":" Type. 
  372.  
  373. Record and pointer variables have both a static type (the type with which they 
  374. are declared - simply called their type) and a dynamic type (the type they 
  375. assume at run time). For pointers and variable parameters of record type the 
  376. dynamic type may be an extension of their static type. The static type 
  377. determines which fields of a record are accessible. The dynamic type is used to 
  378. call type-bound procedures (see Type-bound procedures). 
  379.  
  380. Examples of variable declarations (refer to examples in Type declarations): 
  381.  
  382.  i, j, k: INTEGER 
  383.  x, y: REAL 
  384.  p, q: BOOLEAN 
  385.  s: SET 
  386.  F: Function 
  387.  a: ARRAY 100 OF REAL 
  388.  w: ARRAY 16 OF RECORD 
  389.           name: ARRAY 32 OF CHAR; 
  390.           count: INTEGER 
  391.          END 
  392.  t, c: Tree 
  393.  
  394.  
  395. ΓòÉΓòÉΓòÉ 9. Expressions ΓòÉΓòÉΓòÉ
  396.  
  397. Expressions are constructs denoting rules of computation whereby constants and 
  398. current values of variables are combined to compute other values by the 
  399. application of operators and function procedures. Expressions consist of 
  400. operands and operators. Parentheses may be used to express specific 
  401. associations of operators and operands. 
  402.  
  403.  
  404. ΓòÉΓòÉΓòÉ 9.1. Operands ΓòÉΓòÉΓòÉ
  405.  
  406. With the exception of set constructors and literal constants (numbers, 
  407. character constants, or strings), operands are denoted by designators. A 
  408. designator consists of an identifier referring to a constant, variable, or 
  409. procedure. This identifier may possibly be qualified by a module identifier 
  410. (see Declarations and scope rules and Modules) and may be followed by selectors 
  411. if the designated object is an element of a structure. 
  412.  
  413. Designator     = Qualident {"." ident | "[" ExpressionList "]" | "^" | "(" 
  414. Qualident ")"}. 
  415.  
  416. ExpressionList   = Expression {"," Expression}. 
  417.  
  418. If a designates an array, then a[e] denotes that element of a whose index is 
  419. the current value of the expression e. The type of e must be an integer type. A 
  420. designator of the form a[e0, e1,...,en] stands for a[e0][e1]...[en]. If r 
  421. designates a record, then r.f denotes the field f of r or the procedure f bound 
  422. to the dynamic type of r (Ch. Type-bound procedures). If p designates a 
  423. pointer, p^ denotes the variable which is referenced by p. The designators p^.f 
  424. and p^[e] may be abbreviated as p.f and p[e], i.e. record and array selectors 
  425. imply dereferencing. If a or r are read-only, then also a[e] and r.f are 
  426. read-only. 
  427.  
  428. A type guard v(T) asserts that the dynamic type of v is T (or an extension of 
  429. T), i.e. program execution is aborted, if the dynamic type of v is not T (or an 
  430. extension of T). Within the designator, v is then regarded as having the static 
  431. type T. The guard is applicable, if 
  432.  
  433.       1. v is a variable parameter of record type or v is a pointer, and if 
  434.  
  435.       2. T is an extension of the static type of v 
  436.  
  437.  If the designated object is a constant or a variable, then the designator 
  438.  refers to its current value. If it is a procedure, the designator refers to 
  439.  that procedure unless it is followed by a (possibly empty) parameter list in 
  440.  which case it implies an activation of that procedure and stands for the value 
  441.  resulting from its execution. The actual parameters must correspond to the 
  442.  formal parameters as in proper procedure calls (see Formal parameters). 
  443.  
  444.  Examples of designators (refer to examples in Ch.  Variable declarations): 
  445.  
  446.     i                       (INTEGER)
  447.     a[i]                    (REAL)
  448.     w[3].name[i]            (CHAR)
  449.     t.left.right            (Tree)
  450.     t(CenterTree).subnode   (Tree)
  451.  
  452.  
  453. ΓòÉΓòÉΓòÉ 9.2. Operators ΓòÉΓòÉΓòÉ
  454.  
  455. Four classes of operators with different precedences (binding strengths) are 
  456. syntactically distinguished in expressions. The operator ~ has the highest 
  457. precedence, followed by multiplication operators, addition operators, and 
  458. relations. Operators of the same precedence associate from left to right. For 
  459. example, x-y-z stands for (x-y)-z. 
  460.  
  461.   Expression        = SimpleExpression [Relation SimpleExpression].
  462.   SimpleExpression  = ["+" | "-"] Term {AddOperator Term}.
  463.   Term              = Factor {MulOperator Factor}.
  464.   Factor            = Designator [ActualParameters] |
  465.                       number | character | string | NIL | Set |
  466.                       "(" Expression ")" | "~" Factor.
  467.   Set               = "{" [Element {"," Element}] "}".
  468.   Element           = Expression [".." Expression].
  469.   ActualParameters  = "(" [ExpressionList] ")".
  470.   Relation          = "=" | "#" | "<" | "<=" | ">" | ">=" | IN | IS.
  471.   AddOperator       = "+" | "-" | OR.
  472.   MulOperator       = "*" | "/" | DIV | MOD | "&".
  473.  
  474. The available operators are listed in the following tables. Some operators are 
  475. applicable to operands of various types, denoting different operations. In 
  476. these cases, the actual operation is identified by the type of the operands. 
  477. The operands must be expression compatible with respect to the operator (see 
  478. App. A). 
  479.  
  480.  
  481. ΓòÉΓòÉΓòÉ 9.2.1. Logical operators ΓòÉΓòÉΓòÉ
  482.  
  483.   OR       logical disjunction      p OR q      "if p then TRUE, else q"
  484.   &        logical conjunction      p & q       "if p then q, else FALSE"
  485.   ~        negation                 ~p          "not p"
  486.  
  487. These operators apply to BOOLEAN operands and yield a BOOLEAN result. 
  488.  
  489.  
  490. ΓòÉΓòÉΓòÉ 9.2.2. Arithmetic operators ΓòÉΓòÉΓòÉ
  491.  
  492.   +        sum
  493.   -        difference
  494.   *        product
  495.   /        real quotient
  496.   DIV      integer quotient
  497.   MOD      modulus
  498.  
  499. The operators +, -, *, and / apply to operands of numeric types. The type of 
  500. the result is the type of that operand which includes the type of the other 
  501. operand, except for division (/), where the result is the smallest real type 
  502. which includes both operand types. When used as monadic operators, - denotes 
  503. sign inversion and + denotes the identity operation. The operators DIV and MOD 
  504. apply to integer operands only. They are related by the following formulas 
  505. defined for any x and positive divisors y: 
  506.  
  507.   x = (x DIV y) * y + (x MOD y)
  508.   0 <= (x MOD y) < y
  509.  
  510. Examples: 
  511.  x     y     x DIV y    x MOD y 
  512.  5     3     1       2 
  513.  -5     3     -2      1 
  514.  
  515.  
  516. ΓòÉΓòÉΓòÉ 9.2.3. Set Operators ΓòÉΓòÉΓòÉ
  517.  
  518.   +        union
  519.   -        difference (x - y = x * (-y))
  520.   *        intersection
  521.   /        symmetric set difference (x / y = (x-y) + (y-x))
  522.  
  523. Set operators apply to operands of type SET and yield a result of type SET. The 
  524. monadic minus sign denotes the complement of x, i.e. -x denotes the set of 
  525. integers between 0 and MAX(SET) which are not elements of x. 
  526.  
  527. A set constructor defines the value of a set by listing its elements between 
  528. curly brackets. The elements must be integers in the range 0.. MAX(SET). A 
  529. range a..b denotes all integers in the interval [a,b]. 
  530.  
  531.  
  532. ΓòÉΓòÉΓòÉ 9.2.4. Relations ΓòÉΓòÉΓòÉ
  533.  
  534.   =        equal
  535.   #        unequal
  536.   <        less
  537.   <=       less or equal
  538.   >        greater
  539.   >=       greater or equal
  540.   IN       set membership
  541.   IS       type test
  542.  
  543. Relations yield a BOOLEAN result. The relations =, #, <, <=, >, and >= apply to 
  544. the numeric types, CHAR, (open) character arrays, and strings. The relations = 
  545. and # also apply to BOOLEAN and SET, as well as to pointer and procedure types 
  546. (including the value NIL). x IN s stands for "x is an element of s". x must be 
  547. of an integer type, and s of type SET. v IS T stands for "the dynamic type of v 
  548. is T (or an extension of T)" and is called a type test. It is applicable if 
  549.  
  550.       1. v is a variable parameter of record type or v is a pointer, and if 
  551.  
  552.       2. T is an extension of the static type of v 
  553.  
  554.  Examples of expressions (refer to examples in  Variable declarations): 
  555.   1991            INTEGER 
  556.   i DIV 3          INTEGER 
  557.   ~p OR q          BOOLEAN 
  558.   (i+j) * (i-j)       INTEGER 
  559.   s - {8, 9, 13}       SET 
  560.   i + x           REAL 
  561.   a[i+j] * a[i-j]      REAL 
  562.   (0<=i) & (i<100)      BOOLEAN 
  563.   t.key = 0         BOOLEAN 
  564.   k IN {i..j-1}       BOOLEAN 
  565.   w[i].name <= "John"    BOOLEAN 
  566.   t IS CenterTree      BOOLEAN 
  567.  
  568.  
  569. ΓòÉΓòÉΓòÉ 10. Statements ΓòÉΓòÉΓòÉ
  570.  
  571. Statements denote actions. There are elementary and structured statements. 
  572. Elementary statements are not composed of any parts that are themselves 
  573. statements. They are the assignment, the procedure call, the return, and the 
  574. exit statement. Structured statements are composed of parts that are themselves 
  575. statements. They are used to express sequencing and conditional, selective, and 
  576. repetitive execution. A statement may also be empty, in which case it denotes 
  577. no action. The empty statement is included in order to relax punctuation rules 
  578. in statement sequences. 
  579.  
  580.   Statement =
  581.           [ Assignment | ProcedureCall | IfStatement
  582.           | CaseStatement | WhileStatement | RepeatStatement
  583.           | ForStatement | LoopStatement | WithStatement | EXIT
  584.           | RETURN [Expression] ].
  585.  
  586.  
  587. ΓòÉΓòÉΓòÉ 10.1. Assignments ΓòÉΓòÉΓòÉ
  588.  
  589. Assignments replace the current value of a variable by a new value specified by 
  590. an expression. The expression must be assignment compatible with the variable 
  591. (see App. A). The assignment operator is written as ":=" and pronounced as 
  592. becomes. 
  593.  
  594.   Assignment = Designator :=" Expression.
  595.  
  596. If an expression e of type Te is assigned to a variable v of type Tv, the 
  597. following happens: 
  598.  
  599.       1. if Tv and Te are record types, only those fields of Te are assigned 
  600.          which also belong to Tv ( projection); the dynamic type of v must be 
  601.          the same as the static type of v and is not changed by the assignment; 
  602.  
  603.       2. if Tv and Te are pointer types, the dynamic type of v becomes the 
  604.          dynamic type of e; 
  605.  
  606.       3. if Tv is ARRAY n OF CHAR and e is a string of length m<n, v[i] becomes 
  607.          ei for i = 0..m-1 and v[m] becomes 0X. 
  608.  
  609.  Examples of assignments (refer to examples in  Variable declarations): 
  610.  
  611.   i := 0 
  612.   p := i = j 
  613.   x := i + 1 
  614.   k := log2(i+j) 
  615.   F := log2            (* see Formal parameters *) 
  616.   s := {2, 3, 5, 7, 11, 13} 
  617.   a[i] := (x+y) * (x-y) 
  618.   t.key := i 
  619.   w[i+1].name := "John" 
  620.   t := c 
  621.  
  622.  
  623. ΓòÉΓòÉΓòÉ 10.2. Procedure calls ΓòÉΓòÉΓòÉ
  624.  
  625. A procedure call activates a procedure. It may contain a list of actual 
  626. parameters which replace the corresponding formal parameters defined in the 
  627. procedure declaration (see Procedure declarations). The correspondence is 
  628. established by the positions of the parameters in the actual and formal 
  629. parameter lists. There are two kinds of parameters: variable and value 
  630. parameters. 
  631.  
  632. If a formal parameter is a variable parameter, the corresponding actual 
  633. parameter must be a designator denoting a variable. If it denotes an element of 
  634. a structured variable, the component selectors are evaluated when the 
  635. formal/actual parameter substitution takes place, i.e. before the execution of 
  636. the procedure. If a formal parameter is a value parameter, the corresponding 
  637. actual parameter must be an expression. This expression is evaluated before the 
  638. procedure activation, and the resulting value is assigned to the formal 
  639. parameter (see also Formal parameters). 
  640.  
  641.   ProcedureCall = Designator [ActualParameters]. 
  642.  
  643. Examples: 
  644.  WriteInt(i*2+1)     (* see Formal parameters *) 
  645.  INC(w[k].count) 
  646.  t.Insert("John")    (* see Modules *) 
  647.  
  648.  
  649. ΓòÉΓòÉΓòÉ 10.3. Statement sequences ΓòÉΓòÉΓòÉ
  650.  
  651. Statement sequences denote the sequence of actions specified by the component 
  652. statements which are separated by semicolons. 
  653.  
  654.   StatementSequence = Statement {";" Statement}.
  655.  
  656.  
  657. ΓòÉΓòÉΓòÉ 10.4. If statements ΓòÉΓòÉΓòÉ
  658.  
  659.   IfStatement =
  660.          IF Expression THEN StatementSequence
  661.          {ELSIF Expression THEN StatementSequence}
  662.          [ELSE StatementSequence]
  663.          END.
  664.  
  665. If statements specify the conditional execution of guarded statement sequences. 
  666. The Boolean expression preceding a statement sequence is called its guard. The 
  667. guards are evaluated in sequence of occurrence, until one evaluates to TRUE, 
  668. whereafter its associated statement sequence is executed. If no guard is 
  669. satisfied, the statement sequence following the symbol ELSE is executed, if 
  670. there is one. 
  671.  
  672. Example: 
  673.  IF (ch >= "A") & (ch <= "Z") THEN ReadIdentifier 
  674.  ELSIF (ch >= "0") & (ch <= "9") THEN ReadNumber 
  675.  ELSIF (ch = " ' ") OR (ch = ' " ') THEN ReadString 
  676.  ELSE SpecialCharacter 
  677.  END 
  678.  
  679.  
  680. ΓòÉΓòÉΓòÉ 10.5. Case statements ΓòÉΓòÉΓòÉ
  681.  
  682. Case statements specify the selection and execution of a statement sequence 
  683. according to the value of an expression. First the case expression is 
  684. evaluated, then that statement sequence is executed whose case label list 
  685. contains the obtained value. The case expression must either be of an integer 
  686. type that includes the types of all case labels, or both the case expression 
  687. and the case labels must be of type CHAR. Case labels are constants, and no 
  688. value must occur more than once. If the value of the expression does not occur 
  689. as a label of any case, the statement sequence following the symbol ELSE is 
  690. selected, if there is one, otherwise the program is aborted. 
  691.  
  692.   CaseStatement    = CASE Expression OF Case {"|" Case}
  693.                        [ELSE StatementSequence] END.
  694.   Case             = [CaseLabelList ":" StatementSequence].
  695.   CaseLabelList    = CaseLabels {"," CaseLabels}.
  696.   CaseLabels       = ConstExpression [".." ConstExpression].
  697.  
  698. Example: 
  699.  CASE ch OF 
  700.   "A" .. "Z": ReadIdentifier 
  701.  | "0" .. "9": ReadNumber 
  702.  | " ' ", ' " ': ReadString 
  703.  ELSE SpecialCharacter 
  704.  END 
  705.  
  706.  
  707. ΓòÉΓòÉΓòÉ 10.6. While statements ΓòÉΓòÉΓòÉ
  708.  
  709. While statements specify the repeated execution of a statement sequence while 
  710. the Boolean expression (its guard) yields TRUE. The guard is checked before 
  711. every execution of the statement sequence. 
  712.  
  713.   WhileStatement = WHILE Expression DO StatementSequence END.
  714.  
  715. Examples: 
  716.  WHILE i > 0 DO i := i DIV 2; k := k + 1 END 
  717.  WHILE (t # NIL) & (t.key # i) DO t := t.left END 
  718.  
  719.  
  720. ΓòÉΓòÉΓòÉ 10.7. Repeat statements ΓòÉΓòÉΓòÉ
  721.  
  722. A repeat statement specifies the repeated execution of a statement sequence 
  723. until a condition specified by a Boolean expression is satisfied. The statement 
  724. sequence is executed at least once. 
  725.  
  726.   RepeatStatement = REPEAT StatementSequence UNTIL Expression.
  727.  
  728.  
  729. ΓòÉΓòÉΓòÉ 10.8. For statements ΓòÉΓòÉΓòÉ
  730.  
  731. A for statement specifies the repeated execution of a statement sequence for a 
  732. fixed number of times while a progression of values is assigned to an integer 
  733. variable called the control variable of the for statement. 
  734.  
  735.    ForStatement = FOR ident ":=" Expression TO Expression [BY ConstExpression] DO
  736.                     StatementSequence
  737.                   END.
  738.  
  739. The statement 
  740.  
  741.   FOR v := low TO high BY step DO statements END
  742.  
  743. is equivalent to 
  744.  
  745.   v := low; temp := high;
  746.   IF step > 0 THEN
  747.     WHILE v <= temp DO statements; v := v + step END
  748.   ELSE
  749.     WHILE v >= temp DO statements; v := v + step END
  750.   END
  751.  
  752. low must be assignment compatible with v (see App. A), high must be expression 
  753. compatible (i.e. comparable) with v, and step must be a nonzero constant 
  754. expression of an integer type. If step is not specified, it is assumed to be 1. 
  755.  
  756. Examples: 
  757.  FOR i := 0 TO 79 DO k := k + a[i] END 
  758.  FOR i := 79 TO 1 BY -1 DO a[i] := a[i-1] END 
  759.  
  760.  
  761. ΓòÉΓòÉΓòÉ 10.9. Loop statements ΓòÉΓòÉΓòÉ
  762.  
  763. A loop statement specifies the repeated execution of a statement sequence. It 
  764. is terminated upon execution of an exit statement within that sequence (see 
  765. Return and exit statements). 
  766.  
  767.   LoopStatement = LOOP StatementSequence END.
  768.  
  769. Example: 
  770.  LOOP 
  771.   ReadInt(i); 
  772.   IF i < 0 THEN EXIT END; 
  773.   WriteInt(i) 
  774.  END 
  775.  
  776. Loop statements are useful to express repetitions with several exit points or 
  777. cases where the exit condition is in the middle of the repeated statement 
  778. sequence. 
  779.  
  780.  
  781. ΓòÉΓòÉΓòÉ 10.10. Return and exit statements ΓòÉΓòÉΓòÉ
  782.  
  783. A return statement indicates the termination of a procedure. It is denoted by 
  784. the symbol RETURN, followed by an expression if the procedure is a function 
  785. procedure. The type of the expression must be assignment compatible (see App. 
  786. A) with the result type specified in the procedure heading (see Procedure 
  787. declarations). 
  788.  
  789. Function procedures require the presence of a return statement indicating the 
  790. result value. In proper procedures, a return statement is implied by the end of 
  791. the procedure body. Any explicit return statement therefore appears as an 
  792. additional (probably exceptional) termination point. 
  793.  
  794. An exit statement is denoted by the symbol EXIT. It specifies termination of 
  795. the enclosing loop statement and continuation with the statement following that 
  796. loop statement. Exit statements are contextually, although not syntactically 
  797. associated with the loop statement which contains them. 
  798.  
  799.  
  800. ΓòÉΓòÉΓòÉ 10.11. With statements ΓòÉΓòÉΓòÉ
  801.  
  802. With statements execute a statement sequence depending on the result of a type 
  803. test and apply a type guard to every occurrence of the tested variable within 
  804. this statement sequence. 
  805.  
  806.   WithStatement = WITH Guard DO StatementSequence
  807.                   {"|" Guard DO StatementSequence}
  808.                   [ELSE StatementSequence] END.
  809.   Guard         = Qualident ":" Qualident.
  810.  
  811. If v is a variable parameter of record type or a pointer variable, and if it is 
  812. of a static type T0, the statement 
  813.  
  814.   WITH v: T1 DO S1 | v: T2 DO S2 ELSE S3 END
  815.  
  816. has the following meaning: if the dynamic type of v is T1 , then the statement 
  817. sequence S1 is executed where v is regarded as if it had the static type T1; 
  818. else if the dynamic type of v is T2, then S2 is executed where v is regarded as 
  819. if it had the static type T2; else S3 is executed. T1 and T2 must be extensions 
  820. of T0. If no type test is satisfied and if an else clause is missing the 
  821. program is aborted. 
  822.  
  823. Example: 
  824.  WITH t: CenterTree DO i := t.width; c := t.subnode END 
  825.  
  826.  
  827. ΓòÉΓòÉΓòÉ 11. Procedure declarations ΓòÉΓòÉΓòÉ
  828.  
  829. A procedure declaration consists of a procedure heading and a procedure body. 
  830. The heading specifies the procedure identifier and the formal parameters. For 
  831. type-bound procedures it also specifies the receiver parameter. The body 
  832. contains declarations and statements. The procedure identifier is repeated at 
  833. the end of the procedure declaration. 
  834.  
  835. There are two kinds of procedures: proper procedures and function procedures. 
  836. The latter are activated by a function designator as a constituent of an 
  837. expression and yield a result that is an operand of the expression. Proper 
  838. procedures are activated by a procedure call. A procedure is a function 
  839. procedure if its formal parameters specify a result type. The body of a 
  840. function procedure must contain a return statement which defines its result. 
  841.  
  842. All constants, variables, types, and procedures declared within a procedure 
  843. body are local to the procedure. Since procedures may be declared as local 
  844. objects too, procedure declarations may be nested. The call of a procedure 
  845. within its declaration implies recursive activation. 
  846.  
  847. In addition to its formal parameters and locally declared objects, the objects 
  848. declared in the environment of the procedure are also visible in the procedure 
  849. (with the exception of those objects that have the same name as an object 
  850. declared locally). 
  851.  
  852.   ProcedureDeclaration  = ProcedureHeading ";" ProcedureBody ident.
  853.   ProcedureHeading      = PROCEDURE [Receiver] IdentDef [FormalParameters].
  854.   ProcedureBody         = DeclarationSequence [BEGIN StatementSequence] END.
  855.   DeclarationSequence   =
  856.           {CONST {ConstantDeclaration ";"} |
  857.            TYPE {TypeDeclaration ";"} |
  858.            VAR {VariableDeclaration ";"}
  859.           }
  860.           {ProcedureDeclaration ";" | ForwardDeclaration ";"}.
  861.   ForwardDeclaration    = PROCEDURE " ^ " [Receiver] IdentDef [FormalParameters].
  862.  
  863. If a procedure declaration specifies a receiver parameter, the procedure is 
  864. considered to be bound to a type (see Type-bound procedures). A forward 
  865. declaration serves to allow forward references to a procedure whose actual 
  866. declaration appears later in the text. The formal parameter lists of the 
  867. forward declaration and the actual declaration must match (see App. A). 
  868.  
  869.  
  870. ΓòÉΓòÉΓòÉ 11.1. Formal parameters ΓòÉΓòÉΓòÉ
  871.  
  872. Formal parameters are identifiers declared in the formal parameter list of a 
  873. procedure. They correspond to actual parameters specified in the procedure 
  874. call. The correspondence between formal and actual parameters is established 
  875. when the procedure is called. There are two kinds of parameters, value and 
  876. variable parameters, indicated in the formal parameter list by the absence or 
  877. presence of the keyword VAR. Value parameters are local variables to which the 
  878. value of the corresponding actual parameter is assigned as an initial value. 
  879. Variable parameters correspond to actual parameters that are variables, and 
  880. they stand for these variables. The scope of a formal parameter extends from 
  881. its declaration to the end of the procedure block in which it is declared. A 
  882. function procedure without parameters must have an empty parameter list. It 
  883. must be called by a function designator whose actual parameter list is empty 
  884. too. The result type of a procedure can be neither a record nor an array. 
  885.  
  886.   FormalParameters  = "(" [FPSection {";" FPSection}] ")" [":" Qualident].
  887.   FPSection         = [VAR] ident {"," ident} ":" Type.
  888.  
  889. Let Tf be the type of a formal parameter f (not an open array) and Ta the type 
  890. of the corresponding actual parameter a. For variable parameters, Ta must be 
  891. the same as Tf, or Tf must be a record type and Ta an extension of Tf. For 
  892. value parameters, a must be assignment compatible with f (see App. A). 
  893.  
  894. If Tf is an open array, then a must be array compatible with f (see App. A ). 
  895. The lengths of f are taken from a. 
  896.  
  897. Examples of procedure declarations: 
  898.  
  899.  PROCEDURE ReadInt(VAR x: INTEGER); 
  900.  VAR i: INTEGER; ch: CHAR; 
  901.  BEGIN i := 0; Read(ch); 
  902.   WHILE ("0" <= ch) & (ch <= "9") DO 
  903.    i := 10*i + (ORD(ch)-ORD("0")); Read(ch) 
  904.   END; 
  905.   x := i 
  906.  END ReadInt 
  907.  
  908.  PROCEDURE WriteInt(x: INTEGER); (*0 <= x <100000*) 
  909.  VAR i: INTEGER; buf: ARRAY 5 OF INTEGER; 
  910.  BEGIN i := 0; 
  911.   REPEAT buf[i] := x MOD 10; x := x DIV 10; INC(i) UNTIL x = 0; 
  912.   REPEAT DEC(i); Write(CHR(buf[i] + ORD("0"))) UNTIL i = 0 
  913.  END WriteInt 
  914.  
  915.  PROCEDURE WriteString(s: ARRAY OF CHAR); 
  916.  VAR i: INTEGER; 
  917.  BEGIN i := 0; 
  918.   WHILE (i < LEN(s)) & (s[i] # 0X) DO Write(s[i]); INC(i) END 
  919.  END WriteString; 
  920.  
  921.  PROCEDURE log2(x: INTEGER): INTEGER; 
  922.  VAR y: INTEGER; (*assume x>0*) 
  923.  BEGIN 
  924.   y := 0; WHILE x > 1 DO x := x DIV 2; INC(y) END; 
  925.   RETURN y 
  926.  END log2 
  927.  
  928.  
  929. ΓòÉΓòÉΓòÉ 11.2. Type-bound procedures ΓòÉΓòÉΓòÉ
  930.  
  931. Globally declared procedures may be associated with a record type declared in 
  932. the same module. The procedures are said to be bound to the record type. The 
  933. binding is expressed by the type of the  receiver in the heading of a procedure 
  934. declaration.  The receiver may be either a variable parameter of record type T 
  935. or a value parameter of type POINTER TO T (where T is a record type). The 
  936. procedure is bound to the type T and is considered local to it. 
  937.  
  938.   ProcedureHeading = PROCEDURE [Receiver] IdentDef [FormalParameters].
  939.   Receiver         = "(" [VAR] ident ":" ident ")".
  940.  
  941. If a procedure P is bound to a type T0, it is implicitly also bound to any type 
  942. T1 which is an extension of T0. However, a procedure P ' (with the same name as 
  943. P) may be explicitly bound to T1 in which case it overrides the binding of P. P 
  944. ' is considered a redefinition of P for T1. The formal parameters of P and P ' 
  945. must match (see  App. A). If P and T1 are exported (see Declarations and scope 
  946. rules) P ' must be exported too. 
  947.  
  948. If v is a designator and P is a type-bound procedure, then v.P denotes that 
  949. procedure P which is bound to the dynamic type of v (dynamic binding). Note, 
  950. that this may be a different procedure than the one bound to the static type of 
  951. v. v is passed to P's receiver according to the parameter passing rules 
  952. specified in Chapter  Formal parameters. 
  953.  
  954. If r is a receiver parameter declared with type T, r.P^ denotes the (redefined) 
  955. procedure P bound to the base type of T. 
  956.  
  957. In a forward declaration of a type-bound procedure the receiver parameter must 
  958. be of the same type as in the actual procedure declaration. The formal 
  959. parameter lists of both declarations must match (Appendix A). 
  960.  
  961. Examples: 
  962.  
  963.  PROCEDURE (t: Tree) Insert (node: Tree); 
  964.  VAR p, father: Tree; 
  965.  BEGIN p := t; 
  966.   REPEAT father := p; 
  967.    IF node.key = p.key THEN RETURN END; 
  968.    IF node.key < p.key THEN p := p.left ELSE p := p.right END 
  969.   UNTIL p = NIL; 
  970.   IF node.key < father.key THEN father.left := node ELSE father.right := node 
  971. END; 
  972.   node.left := NIL; node.right := NIL 
  973.  END Insert; 
  974.  
  975.  PROCEDURE (t: CenterTree) Insert (node: Tree);  (*redefinition*) 
  976.  BEGIN 
  977.   WriteInt(node(CenterTree).width); 
  978.   t.Insert^ (node)  (* calls the Insert procedure bound to Tree *) 
  979.  END Insert; 
  980.  
  981.  
  982. ΓòÉΓòÉΓòÉ 11.3. Predeclared procedures ΓòÉΓòÉΓòÉ
  983.  
  984. The following table lists the predeclared procedures. Some are generic 
  985. procedures, i.e. they apply to several types of operands. v stands for a 
  986. variable, x and n for expressions, and T for a type. 
  987.  
  988. Function procedures 
  989.  
  990.   Name        Argument type               Result type   Function
  991.  
  992.   ABS(x)      numeric type                type of x     absolute value
  993.   ASH(x, n)   x, n: integer type          LONGINT       arithmetic shift (x * 2n)
  994.   CAP(x)      CHAR                        CHAR          x is letter: corresponding capital letter
  995.   CHR(x)      integer type                CHAR          character with ordinal number x
  996.   ENTIER(x)   real type                   LONGINT       largest integer not greater than x
  997.   LEN(v, n)   v: array; n: integer const. LONGINT       length of v in dimension n (first dimension = 0)
  998.   LEN(v)      v: array                    LONGINT       equivalent to LEN(v, 0)
  999.   LONG(x)     SHORTINT                    INTEGER       identity
  1000.               INTEGER                     LONGINT
  1001.               REAL                        LONGREAL
  1002.   MAX(T)      T = basic type              T             maximum value of type T
  1003.               T = SET                     INTEGER       maximum element of a set
  1004.   MIN(T)      T = basic type              T             minimum value of type T
  1005.               T = SET                     INTEGER       0
  1006.   ODD(x)      integer type                BOOLEAN       x MOD 2 = 1
  1007.   ORD(x)      CHAR                        INTEGER       ordinal number of x
  1008.   SHORT(x)    LONGINT                     INTEGER       identity
  1009.               INTEGER                     SHORTINT      identity
  1010.               LONGREAL                    REAL          identity (truncation possible)
  1011.   SIZE(T)     any type                    integer type  number of bytes required by T
  1012.  
  1013. Proper procedures 
  1014.  
  1015.   Name                 Argument types                                  Function
  1016.  
  1017.   COPY(x, v)           x: character array, string; v: character array  v := x
  1018.   DEC(v)               integer type                                    v := v - 1
  1019.   DEC(v, n)            v, n: integer type                              v := v - n
  1020.   EXCL(v, x)           v: SET; x: integer type                         v := v - {x}
  1021.   HALT(x)              integer constant                                terminate program execution
  1022.   INC(v)               integer type                                    v := v + 1
  1023.   INC(v, n)            v, n: integer type                              v := v + n
  1024.   INCL(v, x)           v: SET; x: integer type                         v := v + {x}
  1025.   NEW(v)               pointer to record or fixed array                allocate v ^
  1026.   NEW(v, x0, ..., xn)  v: pointer to open array; xi: integer type      allocate v ^ with lengths x0.. xn
  1027.  
  1028. COPY allows the assignment between (open) character arrays with different 
  1029. types. If necessary, the source is shortened to the target length minus one. 
  1030. The target is always terminated by the character 0X. In HALT(x), the 
  1031. interpretation of x is left to the underlying system implementation. 
  1032.  
  1033.  
  1034. ΓòÉΓòÉΓòÉ 12. Modules ΓòÉΓòÉΓòÉ
  1035.  
  1036. A module is a collection of declarations of constants, types, variables, and 
  1037. procedures, together with a sequence of statements for the purpose of assigning 
  1038. initial values to the variables. A module constitutes a text that is compilable 
  1039. as a unit. 
  1040.  
  1041.   Module     = MODULE ident ";" [ImportList] DeclarationSequence
  1042.                     [BEGIN StatementSequence] END ident ".".
  1043.   ImportList = IMPORT Import {"," Import} ";".
  1044.   Import     = [ident ":="] ident.
  1045.  
  1046. The import list specifies the names of the imported modules. If a module A is 
  1047. imported by a module M and A exports an identifier x, then x is referred to as 
  1048. A.x within M. If A is imported as B := A, the object x must be referenced as 
  1049. B.x. This allows short alias names in qualified identifiers. Identifiers that 
  1050. are to be exported (i.e. that are to be visible in client modules) must be 
  1051. marked by an export mark in their declaration (see  Declarations and scope 
  1052. rules). 
  1053.  
  1054. The statement sequence following the symbol BEGIN is executed when the module 
  1055. is added to a system (loaded), which is done after the imported modules have 
  1056. been loaded. It follows that cyclic import of modules is illegal. Individual 
  1057. (parameterless and exported) procedures can be activated from the system, and 
  1058. these procedures serve as commands (see Commands). 
  1059.  
  1060.  MODULE Trees;     (* exports: Tree, Node, Insert, Search, Write, Init *) 
  1061.  IMPORT Texts, Oberon;     (* exports read-only: Node.name *) 
  1062.  
  1063.  TYPE 
  1064.   Tree* = POINTER TO Node; 
  1065.   Node* = RECORD 
  1066.        name-: POINTER TO ARRAY OF CHAR; 
  1067.        left, right: Tree 
  1068.       END; 
  1069.  
  1070.  VAR w: Texts.Writer; 
  1071.  
  1072.   PROCEDURE (t: Tree) Insert* (name: ARRAY OF CHAR); 
  1073.   VAR p, father: Tree; 
  1074.   BEGIN p := t; 
  1075.    REPEAT father := p; 
  1076.     IF name = p.name^ THEN RETURN END; 
  1077.     IF name < p.name^ THEN p := p.left ELSE p := p.right END 
  1078.    UNTIL p = NIL; 
  1079.    NEW(p); p.left := NIL; p.right := NIL; NEW(p.name, LEN(name)+1); COPY(name, 
  1080. p.name^); 
  1081.    IF name < father.name^ THEN father.left := p ELSE father.right := p END 
  1082.   END Insert; 
  1083.  
  1084.   PROCEDURE (t: Tree) Search* (name: ARRAY OF CHAR): Tree; 
  1085.   VAR p: Tree; 
  1086.   BEGIN p := t; 
  1087.    WHILE (p # NIL) & (name # p.name^) DO 
  1088.     IF name < p.name^ THEN p := p.left ELSE p := p.right END 
  1089.    END; 
  1090.    RETURN p 
  1091.   END Search; 
  1092.  
  1093.   PROCEDURE (t: Tree) Write*; 
  1094.   BEGIN 
  1095.    IF t.left # NIL THEN t.left.Write END; 
  1096.    Texts.WriteString(w, t.name^); Texts.WriteLn(w); Texts.Append(Oberon.Log, 
  1097. w.buf); 
  1098.    IF t.right # NIL THEN t.right.Write END 
  1099.   END Write; 
  1100.  
  1101.   PROCEDURE Init* (VAR t: Tree); 
  1102.   VAR t: Tree; 
  1103.   BEGIN NEW(t.name, 1); t.name[0] := 0X; t.left := NIL; t.right := NIL 
  1104.   END Init; 
  1105.  
  1106.  BEGIN Texts.OpenWriter(w) 
  1107.  END Trees. 
  1108.  
  1109.  
  1110. ΓòÉΓòÉΓòÉ 13. Appendix A: Definition of terms ΓòÉΓòÉΓòÉ
  1111.  
  1112. Integer types     SHORTINT, INTEGER, LONGINT 
  1113.  
  1114. Real types      REAL, LONGREAL 
  1115.  
  1116. Numeric types     integer types, real types 
  1117.  
  1118. Same types 
  1119.  
  1120. Two variables a and b with types Ta and Tb are of the same type if 
  1121.  
  1122.     1. Ta and Tb are both denoted by the same type identifier, or 
  1123.  
  1124.     2. Ta is declared to equal Tb in a type declaration of the form Ta = Tb, or 
  1125.  
  1126.     3. a and b appear in the same identifier list in a variable, record field, 
  1127.        or formal parameter declaration and are not open arrays. 
  1128.  
  1129.  Equal types 
  1130.  
  1131.  Two types Ta and Tb are equal if 
  1132.  
  1133.     1. Ta and Tb are the same type,  or 
  1134.  
  1135.     2. Ta and Tb are open array types with equal element types, or 
  1136.  
  1137.     3. Ta and Tb are procedure types whose formal parameter lists match. 
  1138.  
  1139.  Type inclusion 
  1140.  
  1141.  Numeric types include (the values of) smaller numeric types according to the 
  1142.  following hierarchy: 
  1143.  
  1144.      LONGREAL >= REAL >= LONGINT >= INTEGER >= SHORTINT 
  1145.  
  1146.  Type extension (base type) 
  1147.  
  1148.  Given a type declaration Tb = RECORD (Ta) ... END, Tb is a direct extension of 
  1149.  Ta, and Ta is a direct base type of Tb. A type Tb is an extension of a type Ta 
  1150.  (Ta is a base type of Tb) if 
  1151.  
  1152.     1. Ta and Tb are the same types, or 
  1153.  
  1154.     2. Tb is a direct extension of an extension of Ta 
  1155.  
  1156.  If Pa = POINTER TO Ta and Pb = POINTER TO Tb, Pb is an extension of Pa (Pa is 
  1157.  a base type of Pb) if Tb is an extension of Ta. 
  1158.  
  1159.  Assignment compatible 
  1160.  
  1161.  An expression e of type Te is assignment compatible with a variable v of type 
  1162.  Tv if one of the following conditions hold: 
  1163.  
  1164.     1. Te and Tv are the same type; 
  1165.  
  1166.     2. Te and Tv are numeric types and Tv includes Te; 
  1167.  
  1168.     3. Te and Tv are record types and Te is an extension of Tv and the dynamic 
  1169.        type of v is Tv ; 
  1170.  
  1171.     4. Te and Tv are pointer types and Te is an extension of Tv; 
  1172.  
  1173.     5. Tv is a pointer or a procedure type and e is NIL; 
  1174.  
  1175.     6. Tv is ARRAY n OF CHAR, e is a string constant with m characters, and m < 
  1176.        n; 
  1177.  
  1178.     7. Tv is a procedure type and e is the name of a procedure whose formal 
  1179.        parameters match those of Tv. 
  1180.  
  1181.  Array compatible 
  1182.  
  1183.  An actual parameter a of type Ta is array compatible with a formal parameter f 
  1184.  of type Tf if 
  1185.  
  1186.     1. Tf and Ta are the same type, or 
  1187.  
  1188.     2. Tf is an open array, Ta is any array, and their element types are array 
  1189.        compatible, or 
  1190.  
  1191.     3. Tf is ARRAY OF CHAR and a is a string. 
  1192.  
  1193.  Expression compatible 
  1194.  
  1195.  For a given operator, the types of its operands are expression compatible if 
  1196.  they conform to the following table (which shows also the result type of the 
  1197.  expression). Type T1 must be an extension of type T0: 
  1198.  
  1199.     operator      first operand              second operand              result type
  1200.     + - *         numeric                    numeric                     smallest numeric type including both operands
  1201.     /             numeric                    numeric                     smallest real type including both operands
  1202.     + - * /       SET                        SET                         SET
  1203.     DIV MOD       integer                    integer                     smallest integer type including both operands
  1204.     OR & ~        BOOLEAN                    BOOLEAN                     BOOLEAN
  1205.     = # < <= > >= numeric                    numeric                     BOOLEAN
  1206.                   CHAR                       CHAR                        BOOLEAN
  1207.                   character array, string    character array, string     BOOLEAN
  1208.     = #           BOOLEAN                    BOOLEAN                     BOOLEAN
  1209.                   SET                        SET                         BOOLEAN
  1210.                   NIL, pointer type T0 or T1 NIL, pointer type T0 or T1  BOOLEAN
  1211.                   procedure type T, NIL      procedure type T, NIL       BOOLEAN
  1212.     IN            integer                    SET                         BOOLEAN
  1213.     IS            type T0                    type T1                     BOOLEAN
  1214.  
  1215.  Matching formal parameter lists 
  1216.  
  1217.  Two formal parameter lists match if 
  1218.  
  1219.     1. they have the same number of parameters, and 
  1220.  
  1221.     2. they have either the same function result type or none, and 
  1222.  
  1223.     3. parameters at corresponding positions have equal types, and 
  1224.  
  1225.     4. parameters at corresponding positions are both either value or variable 
  1226.        parameters. 
  1227.  
  1228.  
  1229. ΓòÉΓòÉΓòÉ 14. Appendix B: Syntax of Oberon-2 ΓòÉΓòÉΓòÉ
  1230.  
  1231.   Module       =  MODULE ident ";" [ImportList] DeclSeq  [BEGIN StatementSeq] END ident ".".
  1232.   ImportList   =  IMPORT [ident ":="] ident {"," [ident ":="] ident} ";".
  1233.   DeclSeq      =  { CONST {ConstDecl ";" } | TYPE {TypeDecl ";"} | VAR {VarDecl ";"}} {ProcDecl ";" | ForwardDecl ";"}.
  1234.   ConstDecl    =  IdentDef "=" ConstExpr.
  1235.   TypeDecl     =  IdentDef "=" Type.
  1236.   VarDecl      =  IdentList ":" Type.
  1237.   ProcDecl     =  PROCEDURE [Receiver] IdentDef [FormalPars] ";" DeclSeq [BEGIN StatementSeq] END ident.
  1238.   ForwardDecl  =  PROCEDURE "^" [Receiver] IdentDef [FormalPars].
  1239.   FormalPars   =  "(" [FPSection {";" FPSection}] ")" [":" Qualident].
  1240.   FPSection    =  [VAR] ident {"," ident} ":" Type.
  1241.   Receiver     =  "(" [VAR] ident ":" ident ")".
  1242.   Type         =  Qualident
  1243.                |  ARRAY [ConstExpr {"," ConstExpr}] OF Type
  1244.                |  RECORD ["("Qualident")"] FieldList {";" FieldList} END
  1245.                |  POINTER TO Type
  1246.                |  PROCEDURE [FormalPars].
  1247.   FieldList    =  [IdentList ":" Type].
  1248.   StatementSeq =  Statement {";" Statement}.
  1249.   Statement    =  [  Designator ":=" Expr
  1250.                |  Designator ["(" [ExprList] ")"]
  1251.                |  IF Expr THEN StatementSeq {ELSIF Expr THEN StatementSeq} [ELSE StatementSeq] END
  1252.                |  CASE Expr OF Case {"|" Case} [ELSE StatementSeq] END
  1253.                |  WHILE Expr DO StatementSeq END
  1254.                |  REPEAT StatementSeq UNTIL Expr
  1255.                |  FOR ident ":=" Expr TO Expr [BY ConstExpr] DO StatementSeq END
  1256.                |  LOOP StatementSeq END
  1257.                |  WITH Guard DO StatementSeq {"|" Guard DO StatementSeq} [ELSE StatementSeq] END
  1258.                |  EXIT
  1259.                |  RETURN [Expr]
  1260.                   ].
  1261.   Case         =  [CaseLabels {"," CaseLabels} ":" StatementSeq].
  1262.   CaseLabels   =  ConstExpr [".." ConstExpr].
  1263.   Guard        =  Qualident ":" Qualident.
  1264.   ConstExpr    =  Expr.
  1265.   Expr         =  SimpleExpr [Relation SimpleExpr].
  1266.   SimpleExpr   =  ["+" | "-"] Term {AddOp Term}.
  1267.   Term         =  Factor {MulOp Factor}.
  1268.   Factor       =  Designator ["(" [ExprList] ")"] | number | character | string | NIL | Set | "(" Expr ")" | " ~ " Factor.
  1269.   Set          =  "{" [Element {"," Element}] "}".
  1270.   Element      =  Expr [".." Expr].
  1271.   Relation     =  "=" | "#" | "<" | "<=" | ">" | ">=" | IN | IS.
  1272.   AddOp        =   "+" | "-" | OR.
  1273.   MulOp        =  " * " | "/" | DIV | MOD | "&".
  1274.   Designator   =  Qualident {"." ident | "[" ExprList "]" | " ^ " | "(" Qualident ")"}.
  1275.   ExprList     =  Expr {"," Expr}.
  1276.   IdentList    =  IdentDef {"," IdentDef}.
  1277.   Qualident    =  [ident "."] ident.
  1278.   IdentDef     =  ident [" * " | "-"].
  1279.  
  1280.  
  1281. ΓòÉΓòÉΓòÉ 15. Appendix C: The module SYSTEM ΓòÉΓòÉΓòÉ
  1282.  
  1283. The module SYSTEM contains certain types and procedures that are necessary to 
  1284. implement low-level operations particular to a given computer and/or 
  1285. implementation. These include for example facilities for accessing devices that 
  1286. are controlled by the computer, and facilities to break the type compatibility 
  1287. rules otherwise imposed by the language definition. It is strongly recommended 
  1288. to restrict their use to specific modules (called low-level modules). Such 
  1289. modules are inherently non-portable, but easily recognized due to the 
  1290. identifier SYSTEM appearing in their import list. The following specifications 
  1291. hold for the implementation of Oberon-2 on the Ceres computer. 
  1292.  
  1293. Module SYSTEM exports a type BYTE with the following characteristics: Variables 
  1294. of type CHAR or SHORTINT can be assigned to variables of type BYTE. If a formal 
  1295. variable parameter is of type ARRAY OF BYTE then the corresponding actual 
  1296. parameter may be of any type. 
  1297.  
  1298. Another type exported by module SYSTEM is the type PTR. Variables of any 
  1299. pointer type may be assigned to variables of type PTR. If a formal variable 
  1300. parameter is of type PTR, the actual parameter may be of any pointer type. 
  1301.  
  1302. The procedures contained in module SYSTEM are listed in the following tables. 
  1303. Most of them correspond to single instructions compiled as in-line code. For 
  1304. details, the reader is referred to the processor manual. v stands for a 
  1305. variable, x, y, a, and n for expressions, and T for a type. 
  1306.  
  1307.   Function procedures
  1308.  
  1309.   Name        Argument types           Result type   Function
  1310.  
  1311.   ADR(v)      any                      LONGINT       address of variable v
  1312.   BIT(a, n)   a: LONGINT               BOOLEAN       bit n of Mem[a]
  1313.               n: integer
  1314.   CC(n)       integer constant         BOOLEAN       condition n (0 <= n <= 15)
  1315.   LSH(x, n)   x: integer, CHAR, BYTE   type of x     logical shift
  1316.               n: integer
  1317.   ROT(x, n)   x: integer, CHAR, BYTE   type of x     rotation
  1318.               n: integer
  1319.   VAL(T, x)   T, x: any type           T             x interpreted as of type T
  1320.  
  1321.   Proper procedures
  1322.  
  1323.   Name             Argument types                            Function
  1324.  
  1325.   GET(a, v)        a: LONGINT; v: any basic type,            v := Mem[a]
  1326.                    pointer, procedure type
  1327.   PUT(a, x)        a: LONGINT; x: any basic type,            Mem[a] := x
  1328.                    pointer, procedure type
  1329.   GETREG(n, v)     n: integer constant; v: any basic type,   v := Register n
  1330.                    pointer, procedure type
  1331.   PUTREG(n, x)     n: integer constant; x: any basic type,   Register n := v
  1332.                    pointer, procedure type
  1333.   MOVE(a0, a1, n)  a0, a1: LONGINT; n: integer               Mem[a1.. a1+n-1] := Mem[a0.. a0+n-1]
  1334.   NEW(v, n)        v: any pointer; n: integer                allocate storage block of n bytes
  1335.                                                              assign its address to v
  1336.  
  1337.  
  1338. ΓòÉΓòÉΓòÉ 16. Appendix D: The Oberon Environment ΓòÉΓòÉΓòÉ
  1339.  
  1340. Oberon-2 programs usually run in an environment that provides command 
  1341. activation, garbage collection, dynamic loading of modules, and certain run 
  1342. time data structures. Although not part of the language, this environment 
  1343. contributes to the power of Oberon-2 and is to some degree implied by the 
  1344. language definition. Appendix D describes the essential features of a typical 
  1345. Oberon environment and provides implementation hints. More details can be found 
  1346. in [1], [2], and [3]. 
  1347.  
  1348.  
  1349. ΓòÉΓòÉΓòÉ 16.1. Commands ΓòÉΓòÉΓòÉ
  1350.  
  1351. A command is any parameterless procedure P that is exported from a module M. It 
  1352. is denoted by M.P and can be activated under this name from the shell of the 
  1353. operating system. In Oberon, a user invokes commands instead of programs or 
  1354. modules. This gives him a finer grain of control and allows modules with 
  1355. multiple entry points. When a command M.P is invoked, the module M is 
  1356. dynamically loaded unless it is already in memory (see Dynamic Loading in 
  1357. Modules) and the procedure P is executed. When P terminates, M remains loaded. 
  1358. All global variables and data structures that can be reached from global 
  1359. pointer variables in M retain their values. When P (or another command of M) is 
  1360. invoked again, it may continue to use these values. 
  1361.  
  1362. The following module demonstrates the use of commands. It implements an 
  1363. abstract data structure Counter that encapsulates a counter variable and 
  1364. provides commands to increment and print its value. 
  1365.  
  1366.  
  1367.  MODULE Counter; 
  1368.  IMPORT Texts, Oberon; 
  1369.  
  1370.  VAR 
  1371.   counter: LONGINT; 
  1372.   w: Texts.Writer; 
  1373.   PROCEDURE Add*;  (* takes a numeric argument from the command line *) 
  1374.   VAR s: Texts.Scanner; 
  1375.   BEGIN 
  1376.    Texts.OpenScanner(s, Oberon.Par.text, Oberon.Par.pos); 
  1377.    Texts.Scan(s); 
  1378.    IF s.class = Texts.Int THEN INC(counter, s.i) END 
  1379.   END Add; 
  1380.  
  1381.   PROCEDURE Write*; 
  1382.   BEGIN 
  1383.    Texts.WriteInt(w, counter, 5); Texts.WriteLn(w); 
  1384.    Texts.Append(Oberon.Log, w.buf) 
  1385.   END Write; 
  1386.  
  1387.  BEGIN counter := 0; Texts.OpenWriter(w) 
  1388.  END Counter. 
  1389.  
  1390. The user may execute the following two commands: 
  1391.  
  1392.   Counter.Add   n     adds the value n to the variable counter
  1393.   Counter.Write       writes the current value of counter to the screen
  1394.  
  1395. Since commands are parameterless they have to get their arguments from the 
  1396. operating system. In general, commands are free to take arguments from 
  1397. everywhere (e.g. from the text following the command, from the most recent 
  1398. selection, or from a marked viewer). The command Add uses a scanner (a data 
  1399. type provided by the Oberon system) to read the value that follows it on the 
  1400. command line. 
  1401.  
  1402. When Counter.Add is invoked for the first time, the module Counter is loaded 
  1403. and its body is executed. Every call of Counter.Add n increments the variable 
  1404. counter by n. Every call of Counter.Write writes the current value of counter 
  1405. to the screen. 
  1406.  
  1407. Since a module remains loaded after the execution of its commands, there must 
  1408. be an explicit way to unload it (e.g. when the user wants to substitute the 
  1409. loaded version by a recompiled version.) The Oberon system provides a command 
  1410. to do that. 
  1411.  
  1412.  
  1413. ΓòÉΓòÉΓòÉ 16.2. Dynamic Loading of Modules ΓòÉΓòÉΓòÉ
  1414.  
  1415. A loaded module may invoke a command of a still unloaded module by specifying 
  1416. its name as a string. The specified module is then dynamically loaded and the 
  1417. designated command is executed. Dynamic loading allows the user to start a 
  1418. program as a small set of basic modules and to extend it by adding further 
  1419. modules at run time as the need becomes evident. 
  1420.  
  1421. A module M0 may cause the dynamic loading of a module M1 without importing it. 
  1422. M1 may of course import and use M0, but M0 need not know about the existence of 
  1423. M1. M1 can be a module that is designed and implemented long after M0. 
  1424.  
  1425.  
  1426. ΓòÉΓòÉΓòÉ 16.3. Garbage Collection ΓòÉΓòÉΓòÉ
  1427.  
  1428. In Oberon-2, the predeclared procedure NEW is used to allocate data blocks in 
  1429. free memory. There is, however, no way to explicitly dispose an allocated 
  1430. block. Rather, the Oberon environment uses a garbage collector to find the 
  1431. blocks that are not used any more and to make them available for allocation 
  1432. again. A block is in use as long as it can be reached from a global pointer 
  1433. variable via a pointer chain. Cutting this chain (e.g., setting a pointer to 
  1434. NIL) makes the block collectable. 
  1435.  
  1436. A garbage collector frees a programmer from the non-trivial task of 
  1437. deallocating data structures correctly and thus helps to avoid errors. However, 
  1438. it requires information about dynamic data at run time (see Run Time Data 
  1439. Structures). 
  1440.  
  1441.  
  1442. ΓòÉΓòÉΓòÉ 16.4. Browser ΓòÉΓòÉΓòÉ
  1443.  
  1444. The interface of a module (the declaration of the exported objects) is 
  1445. extracted from the module by a so-called browser which is a separate tool of 
  1446. the Oberon environment. For example, the browser produces the following 
  1447. interface of the module Trees from Modules 
  1448.  
  1449.  DEFINITION Trees; 
  1450.  TYPE 
  1451.   Tree = POINTER TO Node; 
  1452.   Node = RECORD 
  1453.        name: POINTER TO ARRAY OF CHAR; 
  1454.        PROCEDURE (t: Tree) Insert (name: ARRAY OF CHAR); 
  1455.        PROCEDURE (t: Tree) Search (name: ARRAY OF CHAR): Tree; 
  1456.        PROCEDURE (t: Tree) Write; 
  1457.       END; 
  1458.   PROCEDURE Init (VAR t: Tree); 
  1459.  END Trees. 
  1460.  
  1461. For a record type, the browser also collects all procedures bound to this type 
  1462. and shows their declaration in the record type declaration. 
  1463.  
  1464.  
  1465. ΓòÉΓòÉΓòÉ 16.5. Run Time Data Structures ΓòÉΓòÉΓòÉ
  1466.  
  1467. Certain information about records has to be available at run time: The dynamic 
  1468. type of records is needed for type tests and type guards. A table with the 
  1469. addresses of the procedures bound to a record is needed for calling them using 
  1470. dynamic binding. Finally, the garbage collector needs information about the 
  1471. location of pointers in dynamically allocated records. All that information is 
  1472. stored in so-called type descriptors of which there is one for every record 
  1473. type at run time. The following paragraphs show a possible implementation of 
  1474. type descriptors. 
  1475.  
  1476. The dynamic type of a record corresponds to the address of its type descriptor. 
  1477. For dynamically allocated records this address is stored in a so-called type 
  1478. tag which precedes the actual record data and which is invisible for the 
  1479. programmer. If t is a variable of type CenterTree (see example in Type 
  1480. declarations) Figure D5.1 shows one possible implementation of the run time 
  1481. data structures. 
  1482.  
  1483.                                  type descriptor
  1484.                                  of CenterNode
  1485.                                 ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  1486.                                 Γöé              Γöé  ProcTab
  1487.                                 Γö£ΓöÇ            ΓöÇΓöñ
  1488.                                 Γöé              Γöé
  1489.   ΓöîΓöÇΓöÇΓöÇΓöÉ      ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ     Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1490.   Γöé t Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇ>Γöé  tag       Γö£ΓöÇΓöÇΓöÇΓöÇ>Γöé  Node        Γöé  BaseTypes
  1491.   ΓööΓöÇΓöÇΓöÇΓöÿ      Γö£ΓöÇ          ΓöÇΓöñ     Γö£ΓöÇ            ΓöÇΓöñ
  1492.              Γöé  key       Γöé     Γöé  CenterNode  Γöé
  1493.              Γö£ΓöÇ          ΓöÇΓöñ     Γö£ΓöÇ            ΓöÇΓöñ
  1494.              Γöé  left      Γöé     Γöé  NIL         Γöé
  1495.              Γö£ΓöÇ          ΓöÇΓöñ     Γö£ΓöÇ            ΓöÇΓöñ
  1496.              Γöé  right     Γöé     Γöé  NIL         Γöé
  1497.              Γö£ΓöÇ          ΓöÇΓöñ     Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1498.              Γöé  width     Γöé     Γöé  4           Γöé  Offsets of pointers in t^
  1499.              Γö£ΓöÇ          ΓöÇΓöñ     Γö£ΓöÇ            ΓöÇΓöñ
  1500.              Γöé  subnode   Γöé     Γöé  8           Γöé  (for garbage collector)
  1501.              ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ     Γö£ΓöÇ            ΓöÇΓöñ
  1502.                                 Γöé  16          Γöé
  1503.                                 ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  1504.  
  1505.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Fig. D5.1  A variable t of type CenterTree, the record t^ it points to, and its type descriptor
  1506.  
  1507. Since both the table of procedure addresses and the table of pointer offsets 
  1508. must have a fixed offset from the type descriptor address, and since both may 
  1509. grow when the type is extended and further procedures and pointers are added, 
  1510. the tables are located at the opposite ends of the type descriptor and grow in 
  1511. different directions. 
  1512.  
  1513. A type-bound procedure t.P is called as  t^.tag^.ProcTab[IndexP]. The procedure 
  1514. table index of every type-bound procedure is known at compile time. A type test 
  1515. v IS T is translated into v^.tag^.BaseTypes[ExtensionLevelT] = TypeDescrAdrT. 
  1516. Both the extension level of a record type and the address of its type 
  1517. descriptor are known at compile time. For example, the extension level of Node 
  1518. is 0 (it has no base type), and the extension level of CenterNode is 1. 
  1519.  
  1520.  
  1521. ΓòÉΓòÉΓòÉ 17. Bibliographie ΓòÉΓòÉΓòÉ
  1522.  
  1523. [1]  N.Wirth, J.Gutknecht: The Oberon System. Software Practice and Experience 
  1524. 19, 9, Sept. 1989 
  1525.  
  1526. [2]  M.Reiser: The Oberon System. User Guide and Programming Manual. 
  1527. Addison-Wesley, 1991 
  1528.  
  1529. [3]  C.Pfister, B.Heeb, J.Templ: Oberon Technical Notes. Report 156, ETH 
  1530. Z╨òrich, March 1991 
  1531.  
  1532.