home *** CD-ROM | disk | FTP | other *** search
/ Amiga MA Magazine 1998 #6 / amigamamagazinepolishissue1998.iso / coders / jËzyki_programowania / oberon / nonfpu / opt.mod (.txt) < prev    next >
Oberon Text  |  1977-12-31  |  36KB  |  865 lines
  1. Syntax24b.Scn.Fnt
  2. ParcElems
  3. Alloc
  4. Syntax10.Scn.Fnt
  5. Syntax10b.Scn.Fnt
  6. Syntax10i.Scn.Fnt
  7. Courier10.Scn.Fnt
  8. (* Amiga NonFPU *) 
  9. MODULE OPT;    (* NW, RC 6.3.89 / 9.2.94 *)
  10.     IMPORT
  11.         OPS, OPM, AmigaMathL;
  12.     CONST
  13.         MaxConstLen* = OPS.MaxStrLen;
  14.     TYPE
  15.         Const* = POINTER TO ConstDesc;
  16.         Object* = POINTER TO ObjDesc;
  17.         Struct* = POINTER TO StrDesc;
  18.         Node* = POINTER TO NodeDesc;
  19.         ConstExt* = POINTER TO OPS.String;
  20.         ConstDesc* = RECORD
  21.             ext*: ConstExt;    (* string or code for code proc *)
  22.             intval*: LONGINT;    (* constant value or adr, proc par size, text position or least case label *)
  23.             intval2*: LONGINT;    (* string length, proc var size or larger case label *)
  24.             setval*: SET;    (* constant value, procedure body present or "ELSE" present in case *)
  25.             realval*: LONGREAL    (* real or longreal constant value *)
  26.         END ;
  27.         ObjDesc* = RECORD
  28.             left*, right*, link*, scope*: Object;
  29.             name*: OPS.Name;
  30.             leaf*: BOOLEAN;
  31.             mode*, mnolev*: SHORTINT;    (* mnolev < 0 -> mno = -mnolev *)
  32.             vis*: SHORTINT;    (* 0: internal; 1: external; 2: externalR *)
  33.             typ*: Struct;
  34.             conval*: Const;
  35.             adr*, linkadr*: LONGINT
  36.         END ;
  37.         StrDesc* = RECORD
  38.             form*, comp*, mno*, extlev*: SHORTINT;
  39.             ref*, sysflag*: INTEGER;
  40.             n*, size*, tdadr*, offset*, txtpos*: LONGINT;
  41.             BaseTyp*: Struct;
  42.             link*, strobj*: Object
  43.         END ;
  44.         NodeDesc* = RECORD
  45.             left*, right*, link*: Node;
  46.             class*, subcl*: SHORTINT;
  47.             readonly*: BOOLEAN;
  48.             typ*: Struct;
  49.             obj*: Object;
  50.             conval*: Const
  51.         END ;
  52. (* Objects:
  53.     mode  | adr   conval  link     scope    leaf
  54.     ---------------------------------------------
  55.     Undef |                                        Not used
  56.     Var   | adr           next              regopt Glob or loc var or proc value parameter
  57.     VarPar| vadr          next              regopt Procedure var parameter
  58.     Con   |       val                              Constant
  59.     Fld   | off           next                     Record field
  60.     Typ   |                                        Named type
  61.     LProc |       sizes   firstpar scope    leaf   Local procedure
  62.     XProc | pno   sizes   firstpar scope    leaf   External procedure
  63.     SProc | fno   sizes                            Standard procedure
  64.     CProc |       code    firstpar scope           Code procedure
  65.     IProc | pno   sizes            scope    leaf   Interrupt procedure
  66.     Mod   | key                    scope           Module
  67.     Head  | txtpos        owner    firstvar        Scope anchor
  68.     TProc | index sizes   firstpar scope    leaf   Bound procedure, index = 10000H*mthno+pno
  69.                                                     
  70. Structures:
  71.     form    comp  | n      BaseTyp   link     mno  tdadr  offset txtpos   sysflag
  72.     -----------------------------------------------------------------------------
  73.     Undef   Basic |
  74.     Byte    Basic |
  75.     Bool    Basic |
  76.     Char    Basic |
  77.     SInt    Basic |
  78.     Int     Basic |
  79.     LInt    Basic |
  80.     Real    Basic |
  81.     LReal   Basic |
  82.     Set     Basic |
  83.     String  Basic |
  84.     NilTyp  Basic |
  85.     NoTyp   Basic |
  86.     Pointer Basic |        PBaseTyp           mno                txtpos   sysflag
  87.     ProcTyp Basic |        ResTyp    params   mno                txtpos   sysflag
  88.     Comp    Array | nofel  ElemTyp            mno                txtpos   sysflag
  89.     Comp    DynArr| dim    ElemTyp            mno         lenoff txtpos   sysflag
  90.     Comp    Record| nofmth RBaseTyp  fields   mno  tdadr         txtpos   sysflag
  91. Nodes:
  92. design   = Nvar|Nvarpar|Nfield|Nderef|Nindex|Nguard|Neguard|Ntype|Nproc.
  93. expr     = design|Nconst|Nupto|Nmop|Ndop|Ncall.
  94. nextexpr = NIL|expr.
  95. ifstat   = NIL|Nif.
  96. casestat = Ncaselse.
  97. sglcase  = NIL|Ncasedo.
  98. stat     = NIL|Ninittd|Nenter|Nassign|Ncall|Nifelse|Ncase|Nwhile|Nrepeat|
  99.            Nloop|Nexit|Nreturn|Nwith|Ntrap.
  100.               class     subcl     obj      left      right     link      
  101.               ---------------------------------------------------------
  102. design        Nvar                var                          nextexpr
  103.               Nvarpar             varpar                       nextexpr
  104.               Nfield              field    design              nextexpr
  105.               Nderef                       design              nextexpr
  106.               Nindex                       design    expr      nextexpr
  107.               Nguard                       design              nextexpr (typ = guard type)
  108.               Neguard                      design              nextexpr (typ = guard type)
  109.               Ntype               type                         nextexpr
  110.               Nproc     normal    proc                         nextexpr
  111.                         super     proc                         nextexpr
  112. expr          design
  113.               Nconst              const                                 (val = node^.conval)
  114.               Nupto                        expr      expr      nextexpr 
  115.               Nmop      not                expr                nextexpr
  116.                         minus              expr                nextexpr
  117.                         is        tsttype  expr                nextexpr
  118.                         conv               expr                nextexpr
  119.                         abs                expr                nextexpr
  120.                         cap                expr                nextexpr
  121.                         odd                expr                nextexpr
  122.                         adr                expr                nextexpr SYSTEM.ADR
  123.                         cc                 Nconst              nextexpr SYSTEM.CC
  124.                         val                expr                nextexpr SYSTEM.VAL
  125.               Ndop      times              expr      expr      nextexpr
  126.                         slash              expr      expr      nextexpr
  127.                         div                expr      expr      nextexpr
  128.                         mod                expr      expr      nextexpr
  129.                         and                expr      expr      nextexpr
  130.                         plus               expr      expr      nextexpr
  131.                         minus              expr      expr      nextexpr
  132.                         or                 expr      expr      nextexpr
  133.                         eql                expr      expr      nextexpr
  134.                         neq                expr      expr      nextexpr
  135.                         lss                expr      expr      nextexpr
  136.                         leq                expr      expr      nextexpr
  137.                         grt                expr      expr      nextexpr
  138.                         geq                expr      expr      nextexpr
  139.                         in                 expr      expr      nextexpr
  140.                         ash                expr      expr      nextexpr
  141.                         msk                expr      Nconst    nextexpr
  142.                         len                design    Nconst    nextexpr
  143.                         bit                expr      expr      nextexpr SYSTEM.BIT
  144.                         lsh                expr      expr      nextexpr SYSTEM.LSH
  145.                         rot                expr      expr      nextexpr SYSTEM.ROT
  146.               Ncall               fpar     design    nextexpr  nextexpr
  147. nextexpr      NIL
  148.               expr
  149. ifstat        NIL
  150.               Nif                          expr      stat      ifstat
  151. casestat      Ncaselse                     sglcase   stat            (minmax = node^.conval)
  152. sglcase       NIL
  153.               Ncasedo                      Nconst    stat      sglcase
  154. stat          NIL
  155.               Ninittd                                          stat     (of node^.typ)
  156.               Nenter              proc     stat      stat      stat     (proc=NIL for mod)
  157.               Nassign   assign             design    expr      stat
  158.                         newfn              design              stat
  159.                         incfn              design    expr      stat
  160.                         decfn              design    expr      stat
  161.                         inclfn             design    expr      stat
  162.                         exclfn             design    expr      stat
  163.                         copyfn             design    expr      stat
  164.                         getfn              design    expr      stat     SYSTEM.GET
  165.                         putfn              expr      expr      stat     SYSTEM.PUT
  166.                         getrfn             design    Nconst    stat     SYSTEM.GETREG
  167.                         putrfn             Nconst    expr      stat     SYSTEM.PUTREG
  168.                         sysnewfn           design    expr      stat     SYSTEM.NEW
  169.                         movefn             expr      expr      stat     SYSTEM.MOVE
  170.                                                                         (right^.link = 3rd par)
  171.               Ncall               fpar     design    nextexpr  stat
  172.               Nifelse                      ifstat    stat      stat
  173.               Ncase                        expr      casestat  stat
  174.               Nwhile                       expr      stat      stat
  175.               Nrepeat                      stat      expr      stat
  176.               Nloop                        stat                stat 
  177.               Nexit                                            stat 
  178.               Nreturn             proc     nextexpr            stat     (proc = NIL for mod)
  179.               Nwith                        ifstat    stat      stat
  180.               Ntrap                                  expr      stat
  181.     CONST
  182.         maxImps = 31;    (* must be < 128 *)
  183.         topScope*: Object;
  184.         undftyp*, bytetyp*, booltyp*, chartyp*, sinttyp*, inttyp*, linttyp*,
  185.         realtyp*, lrltyp*, settyp*, stringtyp*, niltyp*, notyp*, sysptrtyp*: Struct;
  186.         nofGmod*: SHORTINT;    (*nof imports*)
  187.         GlbMod*:  ARRAY maxImps OF Object;    (* GlbMod[i]^.mode = exported module number *)
  188.         SYSimported*: BOOLEAN;
  189.     CONST
  190.         (* object modes *)
  191.         Var = 1; VarPar = 2; Con = 3; Fld = 4; Typ = 5; LProc = 6; XProc = 7;
  192.         SProc = 8; CProc = 9; IProc = 10; Mod = 11; Head = 12; TProc = 13;
  193.         (* structure forms *)
  194.         Undef = 0; Byte = 1; Bool = 2; Char = 3; SInt = 4; Int = 5; LInt = 6;
  195.         Real = 7; LReal = 8; Set = 9; String = 10; NilTyp = 11; NoTyp = 12;
  196.         Pointer = 13; ProcTyp = 14; Comp = 15;
  197.         (* composite structure forms *)
  198.         Basic = 1; Array = 2; DynArr = 3; Record = 4;
  199.         (*function number*)
  200.         assign = 0;
  201.         haltfn = 0; newfn = 1; absfn = 2; capfn = 3; ordfn = 4;
  202.         entierfn = 5; oddfn = 6; minfn = 7; maxfn = 8; chrfn = 9;
  203.         shortfn = 10; longfn = 11; sizefn = 12; incfn = 13; decfn = 14;
  204.         inclfn = 15; exclfn = 16; lenfn = 17; copyfn = 18; ashfn = 19; assertfn = 32;
  205.         (*SYSTEM function number*)
  206.         adrfn = 20; ccfn = 21; lshfn = 22; rotfn = 23;
  207.         getfn = 24; putfn = 25; getrfn = 26; putrfn = 27;
  208.         bitfn = 28; valfn = 29; sysnewfn = 30; movefn = 31;
  209.         (* module visibility of objects *)
  210.         internal = 0; external = 1; externalR = 2;
  211.         firstStr = 16;
  212.         maxStruct = OPM.MaxStruct;    (* must be < 256 *)
  213.         maxUndPtr = 64;
  214.         NotYetExp = 0;
  215.         universe, syslink: Object;
  216.         strno, udpinx: INTEGER;
  217.         nofExp: SHORTINT;
  218.         nofhdfld: LONGINT;
  219.         undPtr: ARRAY maxUndPtr OF Struct;
  220.     PROCEDURE Init*;
  221.     BEGIN topScope := universe; strno := 0; udpinx := 0; nofGmod := 0; SYSimported := FALSE
  222.     END Init;
  223.     PROCEDURE Close*;
  224.         VAR i: INTEGER;
  225.     BEGIN i := 0;
  226.         WHILE i < maxImps DO GlbMod[i] := NIL; INC(i) END    (* garbage collection *)
  227.     END Close;
  228.     PROCEDURE err(n: INTEGER);
  229.     BEGIN OPM.err(n)
  230.     END err;
  231.     PROCEDURE NewConst*(): Const;
  232.         VAR const: Const;
  233.     BEGIN NEW(const); (*const^.ext := NIL;*) RETURN const
  234.     END NewConst;
  235.     PROCEDURE NewObj*(): Object;
  236.         VAR obj: Object;
  237.     BEGIN NEW(obj); (*obj^.left := NIL; obj^.right := NIL; obj^.link := NIL; obj^.scope := NIL; *)
  238.         (*obj^.typ := NIL; obj^.conval := NIL;*) RETURN obj
  239.     END NewObj;
  240.     PROCEDURE NewStr*(form, comp: SHORTINT): Struct;
  241.         VAR typ: Struct;
  242.     BEGIN NEW(typ); (*typ^.link := NIL; typ^.strobj := NIL;*)
  243.         typ^.form := form; typ^.comp := comp;
  244.         (*typ^.mno := 0; typ^.ref := 0; typ^.sysflag := 0; typ^.extlev := 0; typ^.n := 0;*)
  245.         typ^.tdadr := OPM.TDAdrUndef; typ^.offset := OPM.TDAdrUndef;
  246.         typ^.txtpos := OPM.errpos; typ^.size := -1; typ^.BaseTyp := undftyp; RETURN typ
  247.     END NewStr;
  248.     PROCEDURE NewNode*(class: SHORTINT): Node;
  249.         VAR node: Node;
  250.     BEGIN
  251.         NEW(node); node^.class := class; (*node^.left := NIL; node^.right := NIL; node^.link := NIL;*)
  252.         (*node^.typ := NIL; node^.obj := NIL; node^.conval := NIL;*)
  253.         RETURN node
  254.     END NewNode;
  255.     PROCEDURE NewExt*(): ConstExt;
  256.         VAR ext: ConstExt;
  257.     BEGIN NEW(ext); RETURN ext
  258.     END NewExt;
  259.     PROCEDURE FindImport*(mod: Object; VAR res: Object);
  260.         VAR obj: Object;
  261.     BEGIN obj := mod^.scope;
  262.         LOOP
  263.             IF obj = NIL THEN EXIT END ;
  264.             IF OPS.name < obj^.name THEN obj := obj^.left
  265.             ELSIF OPS.name > obj^.name THEN obj := obj^.right
  266.             ELSE (*found*)
  267.                 IF (obj^.mode = Typ) & (obj^.vis = internal) THEN obj := NIL END ;
  268.                 EXIT
  269.             END
  270.         END ;
  271.         res := obj
  272.     END FindImport;
  273.     PROCEDURE Find*(VAR res: Object);
  274.         VAR obj, head: Object;
  275.     BEGIN head := topScope;
  276.         LOOP obj := head^.right;
  277.             LOOP
  278.                 IF obj = NIL THEN EXIT END ;
  279.                 IF OPS.name < obj^.name THEN obj := obj^.left
  280.                 ELSIF OPS.name > obj^.name THEN obj := obj^.right
  281.                 ELSE (*found*) EXIT
  282.                 END
  283.             END ;
  284.             IF obj # NIL THEN EXIT END ;
  285.             head := head^.left;
  286.             IF head = NIL THEN EXIT END
  287.         END ;
  288.         res := obj
  289.     END Find;
  290.     PROCEDURE FindField*(VAR name: OPS.Name; typ: Struct; VAR res: Object);
  291.         VAR obj: Object;
  292.     BEGIN 
  293.         WHILE typ # NIL DO obj := typ^.link;
  294.             WHILE obj # NIL DO
  295.                 IF name < obj^.name THEN obj := obj^.left
  296.                 ELSIF name > obj^.name THEN obj := obj^.right
  297.                 ELSE (*found*) res := obj; RETURN
  298.                 END
  299.             END ;
  300.             typ := typ^.BaseTyp
  301.         END ;
  302.         res := NIL
  303.     END FindField;
  304.     PROCEDURE Insert*(VAR name: OPS.Name; VAR obj: Object);
  305.         VAR ob0, ob1: Object; left: BOOLEAN;
  306.     BEGIN ob0 := topScope; ob1 := ob0^.right; left := FALSE;
  307.         LOOP
  308.             IF ob1 # NIL THEN
  309.                 IF name < ob1^.name THEN ob0 := ob1; ob1 := ob0^.left; left := TRUE
  310.                 ELSIF name > ob1^.name THEN ob0 := ob1; ob1 := ob0^.right; left := FALSE
  311.                 ELSE (*double def*) err(1); ob0 := ob1; ob1 := ob0^.right
  312.                 END
  313.             ELSE (*insert*) ob1 := NewObj(); ob1^.leaf := TRUE;
  314.                 IF left THEN ob0^.left := ob1 ELSE ob0^.right := ob1 END ;
  315.                 ob1^.left := NIL; ob1^.right := NIL; COPY(name, ob1^.name);
  316.                 ob1^.mnolev := topScope^.mnolev; EXIT
  317.             END
  318.         END ;
  319.         obj := ob1
  320.     END Insert;
  321.     PROCEDURE OpenScope*(level: SHORTINT; owner: Object);
  322.         VAR head: Object;
  323.     BEGIN head := NewObj();
  324.         head^.mode := Head; head^.mnolev := level; head^.link := owner;
  325.         IF owner # NIL THEN owner^.scope := head END ;
  326.         head^.left := topScope; head^.right := NIL; head^.scope := NIL; topScope := head
  327.     END OpenScope;
  328.     PROCEDURE CloseScope*;
  329.     BEGIN topScope := topScope^.left
  330.     END CloseScope;
  331.     PROCEDURE InsertImport(obj, root: Object; VAR old: Object);
  332.         VAR ob0, ob1: Object; left: BOOLEAN;
  333.     BEGIN ob0 := root; ob1 := ob0^.right; left := FALSE;
  334.         LOOP
  335.             IF ob1 # NIL THEN
  336.                 IF obj^.name < ob1^.name THEN ob0 := ob1; ob1 := ob1^.left; left := TRUE
  337.                 ELSIF obj^.name > ob1^.name THEN ob0 := ob1; ob1 := ob1^.right; left := FALSE
  338.                 ELSE old := ob1; EXIT
  339.                 END
  340.             ELSE ob1 := obj;
  341.                 IF left THEN ob0^.left := ob1 ELSE ob0^.right := ob1 END ;
  342.                 ob1^.left := NIL; ob1^.right := NIL; ob1^.mnolev := root^.mnolev; old := NIL; EXIT
  343.             END
  344.         END
  345.     END InsertImport;
  346.     PROCEDURE ReadId(VAR name: ARRAY OF CHAR; VAR len: LONGINT);
  347.         VAR i: INTEGER; ch: CHAR;
  348.     BEGIN i := 0;
  349.         REPEAT
  350.             OPM.SymRCh(ch); name[i] := ch; INC(i)
  351.         UNTIL ch = 0X;
  352.         len := i
  353.     END ReadId;
  354.     PROCEDURE WriteId(VAR name: ARRAY OF CHAR);
  355.         VAR i: INTEGER; ch: CHAR;
  356.     BEGIN i := 0;
  357.         REPEAT ch := name[i]; OPM.SymWCh(ch); INC(i)
  358.         UNTIL ch = 0X
  359.     END WriteId;
  360.     PROCEDURE Import*(VAR aliasName, impName, selfName: OPS.Name);
  361.         VAR i, m, s, class: INTEGER;
  362.                 k, len: LONGINT; rval: REAL;
  363.                 ch: CHAR; done: BOOLEAN;
  364.                 nofLmod, strno, parlev, fldlev: INTEGER;
  365.                 obj, head, old: Object;
  366.                 typ: Struct;
  367.                 ext: ConstExt;
  368.                 mname: OPS.Name;
  369.                 LocMod:  ARRAY maxImps + 1 OF Object;
  370.                 struct:  ARRAY maxStruct OF Struct;
  371.                 param, lastpar, fldlist, lastfld: ARRAY 6 OF Object;
  372.         PROCEDURE reverseList(p: Object; mnolev: SHORTINT);
  373.             VAR q, r: Object;
  374.         BEGIN q := NIL;
  375.             WHILE p # NIL DO p^.mnolev := mnolev;
  376.                 r := p^.link; p^.link := q; q := p; p := r
  377.             END
  378.         END reverseList;
  379.     BEGIN nofLmod := 0; strno := firstStr;
  380.         parlev := -1; fldlev := -1;
  381.         IF impName = "SYSTEM" THEN SYSimported := TRUE;
  382.             Insert(aliasName, obj); obj^.mode := Mod; obj^.mnolev := 0; obj^.scope := syslink;
  383.             obj^.adr := 0; obj^.typ := notyp
  384.         ELSE OPM.OldSym(impName, FALSE, done);
  385.             IF done THEN
  386.                 struct[Undef] := undftyp; struct[Byte] := bytetyp;
  387.                 struct[Bool] := booltyp;  struct[Char] := chartyp;
  388.                 struct[SInt] := sinttyp;  struct[Int] := inttyp;
  389.                 struct[LInt] := linttyp;  struct[Real] := realtyp;
  390.                 struct[LReal] := lrltyp;  struct[Set] := settyp;
  391.                 struct[String] := stringtyp; struct[NilTyp] := niltyp;
  392.                 struct[NoTyp] := notyp;
  393.                 struct[Pointer] := sysptrtyp;
  394.                 NEW(head); (*for bound procedures*)
  395.                 LOOP (*read next item from symbol file*)
  396.                     OPM.SymRTag(class);
  397.                     IF OPM.eofSF() THEN EXIT END ;
  398.                     IF (class < 8) OR (class = 23) OR (class = 25) THEN (*object*)
  399.                         obj := NewObj(); m := 0;
  400.                         OPM.SymRTag(s); obj^.typ := struct[s];
  401.                         CASE class OF
  402.                            1:
  403.                             obj^.mode := Con; obj^.conval := NewConst();
  404.                             CASE obj^.typ^.form OF
  405.                               Byte, Char:
  406.                                 OPM.SymRCh(ch); obj^.conval^.intval := ORD(ch)
  407.                             | SInt, Bool:
  408.                                 OPM.SymRCh(ch); i := ORD(ch);
  409.                                 IF i > OPM.MaxSInt THEN i := i + 2*OPM.MinSInt END ;
  410.                                 obj^.conval^.intval := i
  411.                             | Int:
  412.                                 OPM.SymRInt(obj^.conval^.intval)
  413.                             | LInt:
  414.                                 OPM.SymRLInt(obj^.conval^.intval)
  415.                             | Set:
  416.                                 OPM.SymRSet(obj^.conval^.setval)
  417.                             | Real:
  418.                                 OPM.SymRReal(rval);
  419.                                 (* obj^.conval^.realval := rval;*) AmigaMathL.Long(rval,obj^.conval^.realval);
  420.                                 obj^.conval^.intval := OPM.ConstNotAlloc
  421.                             | LReal:
  422.                                 OPM.SymRLReal(obj^.conval^.realval);
  423.                                 obj^.conval^.intval := OPM.ConstNotAlloc
  424.                             | String:
  425.                                 obj^.conval^.ext := NewExt();
  426.                                 ReadId(obj^.conval^.ext^, obj^.conval^.intval2);
  427.                                 obj^.conval^.intval := OPM.ConstNotAlloc
  428.                             | NilTyp:
  429.                                 obj^.conval^.intval := OPM.nilval
  430.                             END
  431.                         | 2, 3:
  432.                             obj^.mode := Typ; OPM.SymRTag(m);
  433.                             IF obj^.typ^.strobj = NIL THEN obj^.typ^.strobj := obj END ;
  434.                             IF class = 2 THEN obj^.vis := external ELSE obj^.vis := internal END
  435.                         | 4, 23:
  436.                             obj^.mode := Var;
  437.                             IF OPM.ExpVarAdr THEN OPM.SymRLInt(obj^.adr)
  438.                             ELSE OPM.SymRTag(s); obj^.adr := s
  439.                             END ;
  440.                             IF class = 23 THEN obj^.vis := externalR ELSE obj^.vis := external END
  441.                         | 5, 6, 7, 25:
  442.                             obj^.conval := NewConst();
  443.                             IF class = 5 THEN obj^.mode := IProc; OPM.SymRTag(s); obj^.adr := s
  444.                             ELSIF class = 6 THEN obj^.mode := XProc; OPM.SymRTag(s); obj^.adr := s
  445.                             ELSIF class = 7 THEN  obj^.mode := CProc; ext := NewExt(); obj^.conval^.ext := ext;
  446.                                 OPM.SymRCh(ch); s := ORD(ch); ext^[0] := ch; i := 1; obj^.adr := 0;
  447.                                 WHILE i <= s DO OPM.SymRCh(ext^[i]); INC(i) END
  448.                             ELSE obj^.mode := TProc; obj^.vis := external; OPM.SymRTag(s); typ := struct[s];
  449.                                 OPM.SymRTag(i); OPM.SymRTag(s); obj^.adr := 10000H*i + s
  450.                             END ;
  451.                             obj^.linkadr := OPM.LANotAlloc;    (* link adr *)
  452.                             obj^.conval^.intval := -1;
  453.                             reverseList(lastpar[parlev], LocMod[0]^.mnolev);
  454.                             obj^.link := param[parlev]^.right; DEC(parlev)
  455.                         END ;
  456.                         ReadId(obj^.name, len);
  457.                         IF class = 25 THEN
  458.                             head^.right := typ^.link; head^.mnolev := -typ^.mno; InsertImport(obj, head, old); typ^.link := head^.right
  459.                         ELSE InsertImport(obj, LocMod[m], old)
  460.                         END ;
  461.                         IF (old # NIL) & (obj^.mode = Typ) THEN struct[s] := old^.typ END
  462.                     ELSIF class < 13 THEN (*structure*)
  463.                         typ := NewStr(Undef, Basic); OPM.SymRTag(s); typ^.BaseTyp := struct[s];
  464.                         OPM.SymRTag(s); typ^.mno := -LocMod[s]^.mnolev;
  465.                         CASE class OF
  466.                           8:
  467.                             typ^.form := Pointer; typ^.size := OPM.PointerSize; typ^.n := 0
  468.                         | 9:
  469.                             typ^.form := ProcTyp; typ^.size := OPM.ProcSize; 
  470.                             reverseList(lastpar[parlev], -typ^.mno);
  471.                             typ^.link := param[parlev]^.right; DEC(parlev)
  472.                         | 10:
  473.                             typ^.form := Comp; typ^.comp := Array; OPM.SymRLInt(typ^.size);
  474.                             typ^.n := typ^.size DIV typ^.BaseTyp^.size
  475.                         | 11:
  476.                             typ^.form := Comp; typ^.comp := DynArr;
  477.                             OPM.SymRLInt(typ^.size); OPM.SymRInt(typ^.offset);
  478.                             IF typ^.BaseTyp^.comp = DynArr THEN typ^.n := typ^.BaseTyp^.n + 1
  479.                             ELSE typ^.n := 0
  480.                             END
  481.                         | 12:
  482.                             typ^.form := Comp; typ^.comp := Record;
  483.                             OPM.SymRLInt(typ^.size); typ^.n := 0;
  484.                             reverseList(lastfld[fldlev], -typ^.mno); typ^.link := fldlist[fldlev]^.right; DEC(fldlev);
  485.                             IF typ^.BaseTyp = notyp THEN typ^.BaseTyp := NIL; typ^.extlev := 0
  486.                             ELSE typ^.extlev := typ^.BaseTyp^.extlev + 1
  487.                             END ;
  488.                             OPM.SymRInt(typ^.tdadr)
  489.                         END ;
  490.                         struct[strno] := typ; INC(strno)
  491.                     ELSIF class = 13 THEN (*parameter list start*)
  492.                         obj := NewObj(); obj^.mode := Head; obj^.right := NIL;
  493.                         IF parlev < 5 THEN INC(parlev); param[parlev] := obj; lastpar[parlev] := NIL
  494.                         ELSE err(229)
  495.                         END
  496.                     ELSIF class < 16 THEN (*parameter*)
  497.                         obj := NewObj();
  498.                         IF class = 14 THEN obj^.mode := Var ELSE obj^.mode := VarPar END ;
  499.                         OPM.SymRTag(s); obj^.typ := struct[s];
  500.                         IF OPM.ExpParAdr THEN OPM.SymRLInt(obj^.adr) END ;
  501.                         ReadId(obj^.name, len);
  502.                         obj^.link := lastpar[parlev]; lastpar[parlev] := obj;
  503.                         IF param[parlev]^.right = NIL THEN param[parlev]^.right := obj END
  504.                     ELSIF class = 16 THEN (*start field list*)
  505.                         obj := NewObj(); obj^.mode := Head; obj^.right := NIL;
  506.                         IF fldlev < 5 THEN INC(fldlev); fldlist[fldlev] := obj; lastfld[fldlev] := NIL
  507.                         ELSE err(229)
  508.                         END
  509.                     ELSIF (class = 17) OR (class = 24) THEN (*field*)
  510.                         obj := NewObj(); obj^.mode := Fld; OPM.SymRTag(s);
  511.                         obj^.typ := struct[s]; OPM.SymRLInt(obj^.adr);
  512.                         ReadId(obj^.name, len);
  513.                         obj^.link := lastfld[fldlev]; lastfld[fldlev] := obj;
  514.                         InsertImport(obj, fldlist[fldlev], old);
  515.                         IF class = 24 THEN obj^.vis := externalR ELSE obj^.vis := external END
  516.                     ELSIF (class = 18) OR (class = 19) THEN (*hidden pointer or proc*)
  517.                         obj := NewObj(); obj^.mode := Fld; OPM.SymRLInt(obj^.adr);
  518.                         IF class = 18 THEN obj^.name := OPM.HdPtrName
  519.                         ELSE obj^.name := OPM.HdProcName
  520.                         END ;
  521.                         obj^.typ := notyp; obj^.vis := internal;
  522.                         obj^.link := lastfld[fldlev]; lastfld[fldlev] := obj;
  523.                         IF fldlist[fldlev]^.right = NIL THEN
  524.                             fldlist[fldlev]^.right := obj
  525.                         END
  526.                     ELSIF class = 20 THEN (*fixup pointer typ*)
  527.                         OPM.SymRTag(s); typ := struct[s]; OPM.SymRTag(s);
  528.                         IF typ^.BaseTyp = undftyp THEN typ^.BaseTyp := struct[s] END
  529.                     ELSIF class = 21 THEN (*sysflag*)
  530.                         OPM.SymRTag(s); typ := struct[s]; OPM.SymRTag(s); typ^.sysflag := s
  531.                     ELSIF class = 22 THEN (*module anchor*)
  532.                         OPM.SymRLInt(k); ReadId(mname, len);
  533.                         IF mname = selfName THEN err(154) END ;
  534.                         i := 0;
  535.                         WHILE (i < nofGmod) & (mname # GlbMod[i]^.name) DO
  536.                             INC(i)
  537.                         END ;
  538.                         IF i < nofGmod THEN (*module already present*)
  539.                             IF k # GlbMod[i]^.adr THEN err(150) END ;
  540.                             obj := GlbMod[i]
  541.                         ELSE obj := NewObj();
  542.                             IF nofGmod < maxImps THEN GlbMod[nofGmod] := obj; INC(nofGmod)
  543.                             ELSE err(227)
  544.                             END ;
  545.                             obj^.mode := NotYetExp; COPY(mname, obj^.name);
  546.                             obj^.adr := k; obj^.mnolev := -nofGmod; obj^.right := NIL
  547.                         END ;
  548.                         IF nofLmod < maxImps + 1 THEN LocMod[nofLmod] := obj; INC(nofLmod)
  549.                         ELSE err(227)
  550.                         END
  551.                     ELSIF class = 26 THEN (*nof methods*)
  552.                         OPM.SymRTag(s); typ := struct[s]; OPM.SymRTag(s); typ^.n := s
  553.                     ELSIF class = 27 THEN (*hidden method*)
  554.                         obj := NewObj(); obj^.mode := TProc; obj^.name := OPM.HdTProcName; obj^.typ := undftyp;
  555.                         OPM.SymRTag(s); typ := struct[s]; obj^.mnolev := -typ^.mno;
  556.                         OPM.SymRTag(i); OPM.SymRTag(s); obj^.adr := 10000H*i + s;
  557.                         obj^.linkadr := OPM.LANotAlloc; obj^.vis := internal;
  558.                         obj^.link := NewObj(); obj^.link^.typ := typ; old := typ^.link;
  559.                         IF old = NIL THEN typ^.link := obj
  560.                         ELSE WHILE old^.left # NIL DO old := old^.left END ;
  561.                             old^.left := obj
  562.                         END
  563.                     END
  564.                 END (*LOOP*) ;
  565.                 Insert(aliasName, obj);
  566.                 obj^.mode := Mod; obj^.scope := LocMod[0]^.right;
  567.                 obj^.mnolev  := LocMod[0]^.mnolev; obj^.typ := notyp;
  568.                 OPM.CloseOldSym
  569.             END
  570.         END
  571.     END Import;
  572.     PROCEDURE^ OutStr(typ: Struct);
  573.     PROCEDURE^ OutObjs(obj: Object);
  574.     PROCEDURE ^OutFlds(fld: Object; adr: LONGINT; visible: BOOLEAN);
  575.     PROCEDURE OutPars(par: Object);
  576.     BEGIN
  577.         OPM.SymWTag(13);
  578.         WHILE par # NIL DO
  579.             OutStr(par^.typ);
  580.             IF par^.mode = Var THEN OPM.SymWTag(14) ELSE OPM.SymWTag(15) END ;
  581.             OPM.SymWTag(par^.typ^.ref);
  582.             IF OPM.ExpParAdr THEN OPM.SymWLInt(par^.adr) END ;
  583.             WriteId(par^.name); par := par^.link
  584.         END
  585.     END OutPars;
  586.     PROCEDURE OutHdFld(typ: Struct; fld: Object; adr: LONGINT);
  587.         VAR i, j, n: LONGINT; btyp: Struct;
  588.     BEGIN
  589.         IF typ^.comp = Record THEN OutFlds(typ^.link, adr, FALSE)
  590.         ELSIF typ^.comp = Array THEN btyp := typ^.BaseTyp; n := typ^.n;
  591.             WHILE btyp^.comp = Array DO n := btyp^.n * n; btyp := btyp^.BaseTyp END ;
  592.             IF (btyp^.form = Pointer) OR (btyp^.comp = Record) THEN
  593.                 j := nofhdfld; OutHdFld(btyp, fld, adr);
  594.                 IF j # nofhdfld THEN i := 1;
  595.                     WHILE (i < n) & (nofhdfld <= OPM.MaxHdFld) DO
  596.                         INC(adr, btyp^.size); OutHdFld(btyp, fld, adr); INC(i)
  597.                     END
  598.                 END
  599.             END
  600.         ELSIF OPM.ExpHdPtrFld & ((typ^.form = Pointer) OR (fld^.name = OPM.HdPtrName)) THEN
  601.             OPM.SymWTag(18); OPM.SymWLInt(adr); INC(nofhdfld)
  602.         ELSIF OPM.ExpHdProcFld & ((typ^.form = ProcTyp) OR (fld^.name = OPM.HdProcName)) THEN
  603.             OPM.SymWTag(19); OPM.SymWLInt(adr); INC(nofhdfld)
  604.         END
  605.     END OutHdFld;
  606.     PROCEDURE OutFlds(fld: Object; adr: LONGINT; visible: BOOLEAN);
  607.     BEGIN
  608.         IF visible THEN OPM.SymWTag(16) END ;
  609.         WHILE (fld # NIL) & (fld^.mode = Fld) DO
  610.             IF (fld^.vis # internal) & visible THEN
  611.                 OutStr(fld^.typ);
  612.                 IF fld^.vis = external THEN OPM.SymWTag(17) ELSE OPM.SymWTag(24) END ;
  613.                 OPM.SymWTag(fld^.typ^.ref); OPM.SymWLInt(fld^.adr); WriteId(fld^.name)
  614.             ELSE OutHdFld(fld^.typ, fld, fld^.adr + adr)
  615.             END ;
  616.             fld := fld^.link
  617.         END
  618.     END OutFlds;
  619.     PROCEDURE OutStr(typ: Struct);
  620.         VAR m, em, r: INTEGER; btyp: Struct; mod: Object;
  621.     BEGIN
  622.         IF typ^.ref < 0 THEN OPM.Mark(234, typ^.txtpos)
  623.         ELSIF typ^.ref = 0 THEN
  624.             typ^.ref := -1;
  625.             m := typ^.mno; btyp := typ^.BaseTyp;
  626.             IF m > 0 THEN mod := GlbMod[m-1]; em := mod^.mode;
  627.                 IF em = NotYetExp THEN
  628.                     mod^.mode := nofExp; m := nofExp; INC(nofExp);
  629.                     OPM.SymWTag(22); OPM.SymWLInt(mod^.adr); WriteId(mod^.name)
  630.                 ELSE m := em
  631.                 END
  632.             END ;
  633.             CASE typ^.form OF
  634.               Undef .. NoTyp:
  635.             | Pointer:
  636.                 OPM.SymWTag(8);
  637.                 IF btyp^.ref > 0 THEN OPM.SymWTag(btyp^.ref)
  638.                 ELSE OPM.SymWTag(Undef);
  639.                     IF udpinx < maxUndPtr THEN undPtr[udpinx] := typ; INC(udpinx) ELSE err(224) END
  640.                 END ;
  641.                 OPM.SymWTag(m)
  642.             | ProcTyp:
  643.                 OutStr(btyp); OutPars(typ^.link); OPM.SymWTag(9);
  644.                 OPM.SymWTag(btyp^.ref); OPM.SymWTag(m)
  645.             | Comp:
  646.                 IF typ^.comp = Array THEN
  647.                     OutStr(btyp); OPM.SymWTag(10); OPM.SymWTag(btyp^.ref);
  648.                     OPM.SymWTag(m); OPM.SymWLInt(typ^.size)
  649.                 ELSIF typ^.comp = DynArr THEN
  650.                     OutStr(btyp); OPM.SymWTag(11); OPM.SymWTag(btyp^.ref); OPM.SymWTag(m);
  651.                     OPM.SymWLInt(typ^.size); OPM.SymWInt(typ^.offset)
  652.                 ELSE (* typ^.comp = Record *)
  653.                     IF btyp = NIL THEN r := NoTyp
  654.                     ELSE OutStr(btyp); r := btyp^.ref
  655.                     END ;
  656.                     nofhdfld := 0; OutFlds(typ^.link, 0, TRUE);
  657.                     IF nofhdfld > OPM.MaxHdFld THEN OPM.Mark(221, typ^.txtpos) END ;
  658.                     OPM.SymWTag(12); OPM.SymWTag(r); OPM.SymWTag(m);
  659.                     OPM.SymWLInt(typ^.size);
  660.                     OPM.SymWInt(typ^.tdadr)
  661.                 END
  662.             END ;
  663.             IF typ^.sysflag # 0 THEN OPM.SymWTag(21); OPM.SymWTag(strno); OPM.SymWTag(typ^.sysflag) END ;
  664.             IF (typ^.comp = Record) & (typ^.n > 0) THEN
  665.                 OPM.SymWTag(26); OPM.SymWTag(strno); OPM.SymWTag(SHORT(typ^.n))
  666.             END ;
  667.             IF typ^.strobj # NIL THEN
  668.                 IF typ^.strobj^.vis # internal THEN OPM.SymWTag(2) ELSE OPM.SymWTag(3) END ;
  669.                 OPM.SymWTag(strno); OPM.SymWTag(m); WriteId(typ^.strobj^.name)
  670.             END ;
  671.             typ^.ref := strno; INC(strno);
  672.             IF strno > maxStruct THEN err(228) END ;
  673.             IF typ^.comp = Record THEN OutObjs(typ^.link) END (*bound procedures*)
  674.         END
  675.     END OutStr;
  676.     PROCEDURE OutTyps(obj: Object);
  677.         VAR strobj: Object;
  678.     BEGIN
  679.         IF obj # NIL THEN
  680.             OutTyps(obj^.left); 
  681.             IF (obj^.vis # internal) & (obj^.mode = Typ) THEN
  682.                 IF obj^.typ^.ref = 0 THEN OutStr(obj^.typ) END ;
  683.                 strobj := obj^.typ^.strobj;
  684.                 IF (strobj # obj) & (strobj # NIL) THEN
  685.                     OPM.SymWTag(2); OPM.SymWTag(obj^.typ^.ref); OPM.SymWTag(0); WriteId(obj^.name)
  686.                 END
  687.             END ;
  688.             OutTyps(obj^.right)
  689.         END
  690.     END OutTyps;
  691.     PROCEDURE OutObjs(obj: Object);
  692.         VAR f, m: INTEGER; rval: REAL; ext: ConstExt; typ: Struct; k: LONGINT;
  693.     BEGIN
  694.         IF obj # NIL THEN
  695.             OutObjs(obj^.left);
  696.             IF (obj^.vis # internal) OR (obj^.mode = TProc) THEN
  697.                 IF obj^.mode = Var THEN
  698.                     OutStr(obj^.typ);
  699.                     IF obj^.vis = externalR THEN OPM.SymWTag(23) ELSE OPM.SymWTag(4) END ;
  700.                     OPM.SymWTag(obj^.typ^.ref);
  701.                     IF OPM.ExpVarAdr THEN OPM.SymWLInt(obj^.adr)
  702.                     ELSE OPM.SymWTag(SHORT(obj^.adr))
  703.                     END ;
  704.                     WriteId(obj^.name)
  705.                 ELSIF obj^.mode = Con THEN
  706.                     OPM.SymWTag(1); f := obj^.typ^.form; OPM.SymWTag(f);
  707.                     CASE f OF
  708.                        Byte, Char:
  709.                         OPM.SymWCh(CHR(obj^.conval^.intval))
  710.                     | Bool, SInt:
  711.                         k := obj^.conval^.intval;
  712.                         IF k < 0 THEN k := k - 2*OPM.MinSInt END ;
  713.                         OPM.SymWCh(CHR(k))
  714.                     | Int:
  715.                         OPM.SymWInt(obj^.conval^.intval)
  716.                     | LInt:
  717.                         OPM.SymWLInt(obj^.conval^.intval)
  718.                     | Set:
  719.                         OPM.SymWSet(obj^.conval^.setval)
  720.                     | Real:
  721.                         AmigaMathL.Short(obj^.conval^.realval,rval); (*rval := SHORT(obj^.conval^.realval);*)
  722.                         OPM.SymWReal(rval)
  723.                     | LReal:
  724.                         OPM.SymWLReal(obj^.conval^.realval)
  725.                     | String:
  726.                         WriteId(obj^.conval^.ext^)
  727.                     | NilTyp:
  728.                     ELSE err(127)
  729.                     END ;
  730.                     WriteId(obj^.name)
  731.                 ELSIF obj^.mode = XProc THEN
  732.                     OutStr(obj^.typ); OutPars(obj^.link); OPM.SymWTag(6);
  733.                     OPM.SymWTag(obj^.typ^.ref); OPM.SymWTag(SHORT(obj^.adr)); WriteId(obj^.name)
  734.                 ELSIF obj^.mode = IProc THEN
  735.                     OutStr(obj^.typ); OutPars(obj^.link); OPM.SymWTag(5);
  736.                     OPM.SymWTag(obj^.typ^.ref); OPM.SymWTag(SHORT(obj^.adr)); WriteId(obj^.name)
  737.                 ELSIF obj^.mode = CProc THEN
  738.                     OutStr(obj^.typ); OutPars(obj^.link); OPM.SymWTag(7);
  739.                     OPM.SymWTag(obj^.typ^.ref); ext := obj^.conval^.ext;
  740.                     m := ORD(ext^[0]); f := 1; OPM.SymWCh(CHR(m));
  741.                     WHILE f <= m DO OPM.SymWCh(ext^[f]); INC(f) END ;
  742.                     WriteId(obj^.name)
  743.                 ELSIF obj^.mode = TProc THEN
  744.                     typ := obj^.link^.typ; IF typ^.form = Pointer THEN typ := typ^.BaseTyp END ;
  745.                     IF (typ^.BaseTyp # NIL) & (obj^.adr DIV 10000H < typ^.BaseTyp^.n) & (obj^.vis = internal) THEN
  746.                         OPM.Mark(109, typ^.txtpos)
  747.                         (* hidden and overriding, not detected in OPP because record exported indirectly or via aliasing *)
  748.                     END ;
  749.                     IF OPM.ExpHdTProc OR (obj^.vis # internal) THEN
  750.                         IF obj^.vis # internal THEN OutStr(obj^.typ); OutPars(obj^.link);
  751.                             OPM.SymWTag(25); OPM.SymWTag(obj^.typ^.ref)
  752.                         ELSE OPM.SymWTag(27)
  753.                         END ;
  754.                         OPM.SymWTag(typ^.ref); OPM.SymWTag(SHORT(obj^.adr DIV 10000H));
  755.                         OPM.SymWTag(SHORT(obj^.adr MOD 10000H));
  756.                         IF obj^.vis # internal THEN WriteId(obj^.name) END
  757.                     END
  758.                 END
  759.             END ;
  760.             OutObjs(obj^.right)
  761.         END
  762.     END OutObjs;
  763.     PROCEDURE Export*(VAR modName: OPS.Name; VAR newSF: BOOLEAN; VAR key: LONGINT);
  764.         VAR i: INTEGER; done: BOOLEAN;
  765.             oldkey: LONGINT;
  766.             typ: Struct;
  767.     BEGIN
  768.         OPM.NewSym(modName, done);
  769.         IF done THEN strno := firstStr;
  770.             OPM.SymWTag(22); OPM.SymWLInt(key); WriteId(modName); nofExp := 1;
  771.             OutTyps(topScope^.right); OutObjs(topScope^.right); i := 0;
  772.             WHILE i < udpinx DO
  773.                 typ := undPtr[i]; undPtr[i] := NIL(*garbage collection*); INC(i); OutStr(typ^.BaseTyp);
  774.                 OPM.SymWTag(20); (*fixup*)
  775.                 OPM.SymWTag(typ^.ref); OPM.SymWTag(typ^.BaseTyp^.ref)
  776.             END ;
  777.             IF OPM.noerr THEN
  778.                 OPM.OldSym(modName, TRUE, done);
  779.                 IF done THEN (*compare*)
  780.                     IF OPM.EqualSym(oldkey) THEN OPM.DeleteNewSym; newSF := FALSE; key := oldkey
  781.                     ELSIF newSF THEN OPM.RegisterNewSym(modName)
  782.                     ELSE OPM.DeleteNewSym; err(155)
  783.                     END
  784.                 ELSE OPM.RegisterNewSym(modName); newSF := TRUE
  785.                 END
  786.             ELSE OPM.DeleteNewSym; newSF := FALSE
  787.             END
  788.         ELSE newSF := FALSE
  789.         END
  790.     END Export;
  791.     PROCEDURE InitStruct(VAR typ: Struct; form: SHORTINT);
  792.     BEGIN typ := NewStr(form, Basic); typ^.ref := form; typ^.size := OPM.ByteSize;
  793.         typ^.tdadr := 0; typ^.offset := 0; typ^.strobj := NewObj()
  794.     END InitStruct;
  795.     PROCEDURE EnterBoolConst(name: OPS.Name; value: LONGINT);
  796.         VAR obj: Object;
  797.     BEGIN Insert(name, obj); obj^.conval := NewConst();
  798.         obj^.mode := Con; obj^.typ := booltyp; obj^.conval^.intval := value
  799.     END EnterBoolConst;
  800.     PROCEDURE EnterTyp(name: OPS.Name; form: SHORTINT; size: INTEGER; VAR res: Struct);
  801.         VAR obj: Object; typ: Struct;
  802.     BEGIN Insert(name, obj);
  803.         typ := NewStr(form, Basic); obj^.mode := Typ; obj^.typ := typ; obj^.vis := external;
  804.         typ^.strobj := obj; typ^.size := size; typ^.tdadr := 0; typ^.offset := 0; typ^.ref := form; res := typ
  805.     END EnterTyp;
  806.     PROCEDURE EnterProc(name: OPS.Name; num: INTEGER);
  807.         VAR obj: Object;
  808.     BEGIN Insert(name, obj);
  809.         obj^.mode := SProc; obj^.typ := notyp; obj^.adr := num
  810.     END EnterProc;
  811. BEGIN
  812.     topScope := NIL; OpenScope(0, NIL);  OPM.errpos := 0;
  813.     InitStruct(undftyp, Undef); InitStruct(notyp, NoTyp);
  814.     InitStruct(stringtyp, String); InitStruct(niltyp, NilTyp);
  815.     undftyp^.BaseTyp := undftyp;
  816.     (*initialization of module SYSTEM*)
  817.     EnterTyp("BYTE", Byte, OPM.ByteSize, bytetyp);
  818.     EnterTyp("PTR", Pointer, OPM.PointerSize, sysptrtyp);
  819.     EnterProc("ADR", adrfn);
  820.     EnterProc("CC", ccfn);
  821.     EnterProc("LSH", lshfn);
  822.     EnterProc("ROT", rotfn);
  823.     EnterProc("GET", getfn);
  824.     EnterProc("PUT", putfn);
  825.     EnterProc("GETREG", getrfn);
  826.     EnterProc("PUTREG", putrfn);
  827.     EnterProc("BIT", bitfn);
  828.     EnterProc("VAL", valfn);
  829.     EnterProc("NEW", sysnewfn);
  830.     EnterProc("MOVE", movefn);
  831.     syslink := topScope^.right;
  832.     universe := topScope; topScope^.right := NIL;
  833.     EnterTyp("CHAR", Char, OPM.CharSize, chartyp);
  834.     EnterTyp("SET", Set, OPM.SetSize, settyp);
  835.     EnterTyp("REAL", Real, OPM.RealSize, realtyp);
  836.     EnterTyp("INTEGER", Int, OPM.IntSize, inttyp);
  837.     EnterTyp("LONGINT",  LInt, OPM.LIntSize, linttyp);
  838.     EnterTyp("LONGREAL", LReal, OPM.LRealSize, lrltyp);
  839.     EnterTyp("SHORTINT", SInt, OPM.SIntSize, sinttyp);
  840.     EnterTyp("BOOLEAN", Bool, OPM.BoolSize, booltyp);
  841.     EnterBoolConst("FALSE", 0);    (* 0 and 1 are compiler internal representation only *)
  842.     EnterBoolConst("TRUE",  1);
  843.     EnterProc("HALT", haltfn);
  844.     EnterProc("NEW", newfn);
  845.     EnterProc("ABS", absfn);
  846.     EnterProc("CAP", capfn);
  847.     EnterProc("ORD", ordfn);
  848.     EnterProc("ENTIER", entierfn);
  849.     EnterProc("ODD", oddfn);
  850.     EnterProc("MIN", minfn);
  851.     EnterProc("MAX", maxfn);
  852.     EnterProc("CHR", chrfn);
  853.     EnterProc("SHORT", shortfn);
  854.     EnterProc("LONG", longfn);
  855.     EnterProc("SIZE", sizefn);
  856.     EnterProc("INC", incfn);
  857.     EnterProc("DEC", decfn);
  858.     EnterProc("INCL", inclfn);
  859.     EnterProc("EXCL", exclfn);
  860.     EnterProc("LEN", lenfn);
  861.     EnterProc("COPY", copyfn);
  862.     EnterProc("ASH", ashfn);
  863.     EnterProc("ASSERT", assertfn) 
  864. END OPT.
  865.