home *** CD-ROM | disk | FTP | other *** search
/ RISC DISC 2 / RISC_DISC_2.iso / pd_share / program / language / oberon / potsrc / src / mod / cocc < prev    next >
Encoding:
Text File  |  1995-02-22  |  13.3 KB  |  464 lines
  1. MODULE COCC; (* DVD 04 09 1993 02:01 *) (* Adapted to RISC OS naming conventions *)
  2.  (* Controlling code *)
  3.     IMPORT Strings, Files, COCS, COCT, COCD, COCQ, COCN, COCJ, COCO, COCH, COCY;
  4.  
  5.     CONST
  6.      (*object modes*)
  7.         Var = 1; Ind = 3; Con = 8; Fld = 12; Typ = 13;
  8.         LProc = 14; XProc = 15; SProc = 16; CProc = 17; IProc = 18;
  9.         Mod = 19;
  10.  
  11.      (*structure forms*)
  12.         Byte = 1; Pointer = 13; ProcTyp = 14; Array = 15; DynArr = 16; Record = 17;
  13.  
  14.      (*module export mark*)
  15.         NotYetExp = 0;
  16.  
  17.      (*variable modes*)
  18.         Defi = 0; Refe = 1; Twin = 2; Decl = 3;
  19.  
  20.      (*modifiers*)
  21.         Extern = 0; Static = 1; Interrupt = 2; Typedef = 3;
  22.  
  23.     VAR tempsafe*:BOOLEAN;
  24.  
  25.     PROCEDURE Logo;
  26.     BEGIN COCO.PutComment("This code is generated by pOt."); COCO.Wrap
  27.     END Logo;
  28.  
  29.     PROCEDURE TermStmt*;
  30.     BEGIN COCO.PutSeq(";"); COCO.Wrap
  31.     END TermStmt;
  32.  
  33.     PROCEDURE OpenScope*;
  34.     BEGIN COCO.PutSeq("{"); COCO.Wrap; COCO.Indent
  35.     END OpenScope;
  36.  
  37.     PROCEDURE CloseScope*;
  38.     BEGIN COCO.Undent; COCO.PutSeq("}"); COCO.Wrap
  39.     END CloseScope;
  40.  
  41.     PROCEDURE InitVar(VAR x: COCT.Item);
  42.         VAR np: INTEGER;
  43.     BEGIN
  44.         IF x.typ # COCT.undftyp THEN
  45.             COCQ.Link(x); COCN.CObjName(x, x.qoffs, np);
  46.             IF x.typ.form IN {Pointer, ProcTyp} THEN
  47.                 COCQ.Unlink(x); COCO.PutSeq("=pOt_NIL"); TermStmt
  48.             ELSIF x.typ.form IN {Array, Record} THEN
  49.                 COCO.PutSeq("pOt__init_var((pOt__TypDsc**)&"); COCQ.Unlink(x);
  50.                 COCO.PutSeq(",(pOt__TypDsc*)&");
  51.                 COCQ.Link(x); COCN.CTDName(x.typ, x.qoffs, np); COCQ.Unlink(x);
  52.                 COCO.PutSeq(")"); TermStmt
  53.             ELSE COCQ.Drop(x)
  54.             END
  55.         END
  56.     END InitVar;
  57.  
  58.     PROCEDURE OuterPrologue*(proc: COCT.Object; big: BOOLEAN);
  59.         VAR obj, firstvar: COCT.Object;
  60.     BEGIN
  61.         obj := COCT.topScope.next; firstvar := NIL;
  62.         WHILE (obj # NIL) & (obj.mode <= Typ) DO
  63.             IF obj.mode = Con THEN COCY.ConstObj(obj, Defi); obj := obj.next
  64.             ELSIF obj.mode = Typ THEN COCY.TypeObj(obj); obj := obj.next
  65.             ELSIF obj.mode <= Ind THEN
  66.                 IF big & (firstvar = NIL) THEN firstvar := obj END;
  67.                 REPEAT obj := obj.next UNTIL (obj = NIL) OR (obj.mode > Ind)
  68.             END
  69.         END; COCO.Wrap;
  70.         COCD.InitTypDescs; COCO.Wrap;
  71.  
  72.         obj := firstvar;
  73.         COCY.StartVOList;
  74.         WHILE (obj # NIL) & (obj.mode <= Typ) DO
  75.             IF obj.mode <= Ind THEN
  76.                 REPEAT COCY.VarObj(obj, Refe); obj := obj.next
  77.                 UNTIL (obj = NIL) OR (obj.mode > Ind);
  78.             ELSE obj := obj.next
  79.             END
  80.         END;
  81.         COCY.StopVOList; COCO.Wrap;
  82.  
  83.         IF big THEN COCY.ProcObj(proc, Refe); COCO.Wrap END
  84.     END OuterPrologue;
  85.  
  86.     PROCEDURE ForwardDeclaration*(proc: COCT.Object);
  87.     BEGIN COCY.ProcObj(proc, Refe); COCO.Wrap
  88.     END ForwardDeclaration;
  89.  
  90.     PROCEDURE InnerPrologue*(proc: COCT.Object; big: BOOLEAN);
  91.         VAR firstvar, obj: COCT.Object;
  92.             np: INTEGER; x: COCT.Item;
  93.             nptr, nstr: INTEGER;
  94.     BEGIN COCY.ProcObj(proc, Defi);
  95.         OpenScope;
  96.         IF proc.typ # COCT.notyp THEN COCY.RetObj(proc) END;
  97.         obj := COCT.topScope.next; firstvar := NIL;
  98.         nptr := 0; nstr := 0;
  99.         COCY.StartVOList;
  100.         WHILE (obj # NIL) & (obj.mode <= Typ) DO
  101.             IF obj.mode <= Ind THEN
  102.                 IF firstvar = NIL THEN firstvar := obj END;
  103.                 REPEAT
  104.                     IF obj.mode = Var THEN
  105.                         IF obj.typ.form = Pointer THEN INC(nptr)
  106.                         ELSIF (obj.typ.form IN {Array .. Record}) & COCT.HasPtr(obj.typ) THEN INC(nstr)
  107.                         END
  108.                     END;
  109.                     IF ~COCT.IsParam(obj) THEN COCY.VarObj(obj, Defi) END;
  110.                     IF big THEN COCY.VarObj(obj, Twin) END;
  111.                     obj := obj.next
  112.                 UNTIL (obj = NIL) OR (obj.mode > Ind);
  113.             ELSE obj := obj.next
  114.             END
  115.         END;
  116.         COCY.StopVOList;
  117.         IF tempsafe & (proc.typ # COCT.notyp) THEN COCY.GCLock
  118.         ELSE COCY.GCNode(nptr, nstr, firstvar)
  119.         END;
  120.         IF firstvar # NIL THEN
  121.             obj := firstvar;
  122.             REPEAT
  123.                 IF obj.mode <= Ind THEN
  124.                     REPEAT
  125.                         COCY.ObjToItem(obj, x);
  126.  
  127.                         IF big THEN
  128.                             DEC(COCT.level); COCQ.Link(x); COCN.CObjBaseName(x, x.qoffs, np); COCQ.Unlink(x); INC(COCT.level);
  129.                             COCO.PutSeq("=");
  130.                             INC(COCT.level); COCQ.Link(x); COCN.CObjBaseName(x, x.qoffs, np); COCQ.Unlink(x); DEC(COCT.level);
  131.                             TermStmt;
  132.  
  133.                             INC(COCT.level); COCQ.Link(x); COCN.CObjBaseName(x, x.qoffs, np); COCQ.Unlink(x); DEC(COCT.level);
  134.                             IF x.mode = Var THEN COCO.PutSeq("=&") ELSE COCO.PutSeq("=") END;
  135.                             COCQ.Link(x); COCN.CObjBaseName(x, x.qoffs, np); COCQ.Unlink(x);
  136.                             TermStmt
  137.                         END;
  138.  
  139.                         IF ~COCT.IsParam(obj) THEN InitVar(x) END;
  140.  
  141.                         obj := obj.next
  142.                     UNTIL (obj = NIL) OR (obj.mode > Ind);
  143.                 ELSE obj := obj.next
  144.                 END
  145.             UNTIL (obj = NIL) OR (obj.mode > Typ)
  146.         END;
  147.         COCO.Wrap
  148.     END InnerPrologue;
  149.  
  150.     PROCEDURE Epilogue*(proc: COCT.Object; big: BOOLEAN);
  151.         VAR obj: COCT.Object;
  152.             np: INTEGER; x: COCT.Item;
  153.     BEGIN
  154.         COCO.Wrap;
  155.         IF proc.typ # COCT.notyp THEN COCH.Trap(17); TermStmt END; (* function without return *)
  156.         COCO.Undent; COCO.PutSeq("pOt__Epilogue:"); TermStmt; COCO.Indent;
  157.         IF big THEN
  158.             obj := COCT.topScope.next;
  159.             WHILE (obj # NIL) & (obj.mode <= Typ) DO
  160.                 IF obj.mode <= Ind THEN
  161.                     COCY.ObjToItem(obj, x);
  162.                     INC(COCT.level); COCQ.Link(x); COCN.CObjBaseName(x, x.qoffs, np); COCQ.Unlink(x); DEC(COCT.level);
  163.                     COCO.PutSeq("=");
  164.                     DEC(COCT.level); COCQ.Link(x); COCN.CObjBaseName(x, x.qoffs, np); COCQ.Unlink(x); INC(COCT.level);
  165.                     TermStmt
  166.                 END;
  167.                 obj := obj.next
  168.             END
  169.         END;
  170.         IF tempsafe & (proc.typ # COCT.notyp) THEN
  171.             COCO.PutSeq("pOt__gc_enabled=pOt__gc_enabled_prev")
  172.         ELSE
  173.             COCO.PutSeq("pOt__gc_root=(struct pOt__tag_gc_node*)pOt__gc_ptrs.next")
  174.         END;
  175.         TermStmt;
  176.         obj := COCT.topScope.next;
  177.         WHILE COCT.IsParam(obj) DO
  178.             IF (obj.mode = Var) & (obj.typ.form IN {Array .. Record}) THEN
  179.                 COCY.ObjToItem(obj, x);
  180.                 COCQ.Link(x); COCN.CObjName(x, x.qoffs, np);
  181.                 IF (obj.typ.form = DynArr) & (obj.typ.BaseTyp.form = Byte) THEN
  182.                     COCO.PutSeq("pOt__rm_byte_arr(")
  183.                 ELSE
  184.                     COCO.PutSeq("pOt__rm_par((pOt__TypDsc**)")
  185.                 END;
  186.                 COCQ.Unlink(x);
  187.                 COCO.PutSeq(")"); TermStmt
  188.             END;
  189.             obj := obj.next
  190.         END;
  191.  
  192.         IF proc.typ # COCT.notyp THEN
  193.             COCQ.Link(x); COCN.CRetName(x.qoffs, np);
  194.             COCO.PutSeq("return"); COCO.Separate; COCQ.Unlink(x);
  195.             TermStmt
  196.         END;
  197.         CloseScope;
  198.         COCO.Wrap
  199.     END Epilogue;
  200.  
  201.     PROCEDURE ModulePrologue*;
  202.         CONST quote = 22X;
  203.         VAR obj, firstvar: COCT.Object;
  204.             nptr, nstr: INTEGER;
  205.     BEGIN
  206.         obj := COCT.topScope.next;
  207.         Logo; COCO.Wrap;
  208.         COCO.PutSeq("#include <pOtRTL.h>"); COCO.Wrap;
  209.         WHILE (obj # NIL) & (obj.mode = Mod) DO
  210.             IF obj.mnolev # 0 THEN
  211.                 COCO.PutSeq("#include "); COCO.PutSeq(quote);
  212.                 COCO.PutSeq(COCT.GlbMod[obj.mnolev-1].name); COCO.PutSeq(".h"); COCO.PutSeq(quote); COCO.Wrap
  213.             END;
  214.             obj := obj.next
  215.         END;
  216.         COCO.Wrap;
  217.         COCO.PutSeq("#include "); COCO.PutSeq(quote);
  218.         COCO.PutSeq("hi.");COCO.PutSeq(COCT.topScope.name);COCO.PutSeq(quote); COCO.Wrap;
  219.         COCO.Wrap;
  220.         firstvar := NIL;
  221.         WHILE (obj # NIL) & (obj.mode <= Typ) DO
  222.             IF obj.mode = Con THEN COCY.ConstObj(obj, Defi); obj := obj.next
  223.             ELSIF obj.mode = Typ THEN COCY.TypeObj(obj); obj := obj.next
  224.             ELSIF obj.mode = Var THEN
  225.                 IF firstvar = NIL THEN firstvar := obj END;
  226.                 REPEAT obj := obj.next UNTIL (obj = NIL) OR (obj.mode # Var);
  227.             END
  228.         END; COCO.Wrap;
  229.         COCD.InitTypDescs; COCO.Wrap;
  230.         nptr := 0; nstr := 0; obj := firstvar;
  231.         COCY.StartVOList;
  232.         WHILE (obj # NIL) & (obj.mode <= Typ) DO
  233.             IF obj.mode = Var THEN
  234.                 IF obj.typ.form = Pointer THEN INC(nptr)
  235.                 ELSIF (obj.typ.form IN {Array .. Record}) & COCT.HasPtr(obj.typ) THEN INC(nstr)
  236.                 END;
  237.                 COCY.VarObj(obj, Defi);
  238.             END;
  239.             obj := obj.next
  240.         END;
  241.         COCY.StopVOList; COCO.Wrap;
  242.         COCY.GCNode(nptr, nstr, firstvar); COCO.Wrap
  243.     END ModulePrologue;
  244.  
  245.     PROCEDURE BodyPrologue*;
  246.         VAR np: INTEGER; x: COCT.Item;
  247.             obj: COCT.Object;
  248.     BEGIN COCY.BodyObj(COCT.topScope, Defi);
  249.         OpenScope;
  250.         COCO.PutSeq("static int ");
  251.         COCQ.Link(x); COCN.CBodyFlagName(COCT.topScope, x.qoffs, np); COCQ.Unlink(x);
  252.         COCO.PutSeq("=0;"); COCO.Wrap;
  253.         COCO.PutSeq("if(!");
  254.         COCQ.Link(x); COCN.CBodyFlagName(COCT.topScope, x.qoffs, np); COCQ.Unlink(x);
  255.         COCO.PutSeq(")"); OpenScope;
  256.         COCQ.Link(x); COCN.CBodyFlagName(COCT.topScope, x.qoffs, np); COCQ.Unlink(x);
  257.         COCO.PutSeq("=1");  TermStmt;
  258.         COCO.Wrap;
  259.         obj := COCT.topScope.next;
  260.         WHILE (obj # NIL) & (obj.mode = Mod) DO
  261.             IF obj.mnolev # 0 THEN
  262.                 COCQ.Link(x); COCN.CBodyName(obj, x.qoffs, np); COCQ.Unlink(x);
  263.                 COCO.PutSeq("()"); TermStmt
  264.             END;
  265.             obj := obj.next
  266.         END;
  267.         COCO.Wrap;
  268.         COCO.PutSeq("pOt__gc_ptrs.next=pOt__gc_root"); TermStmt;
  269.         COCO.PutSeq("pOt__gc_root=(struct pOt__tag_gc_node*)&pOt__gc_strs"); TermStmt;
  270.         COCO.Wrap;
  271.         WHILE (obj # NIL) & (obj.mode <= Typ) DO
  272.             IF (obj.mode <= Ind) & ~COCT.IsParam(obj) THEN
  273.                 COCY.ObjToItem(obj, x); InitVar(x)
  274.             END;
  275.             obj := obj.next
  276.         END;
  277.         COCO.Wrap
  278.     END BodyPrologue;
  279.  
  280.     PROCEDURE BodyEpilogue*;
  281.     BEGIN
  282.         COCO.Wrap;
  283.         COCO.Undent; COCO.PutSeq("pOt__Epilogue:"); TermStmt; COCO.Indent;
  284.         CloseScope;
  285.         CloseScope
  286.     END BodyEpilogue;
  287.  
  288.     PROCEDURE Result*(VAR x: COCT.Item);
  289.         VAR np: INTEGER;
  290.     BEGIN COCN.CRetName(x.qoffs, np)
  291.     END Result;
  292.  
  293.     PROCEDURE Return*;
  294.     BEGIN COCO.PutSeq("goto pOt__Epilogue"); TermStmt
  295.     END Return;
  296.  
  297.     PROCEDURE Loop*;
  298.     BEGIN COCO.PutSeq("for(;;)"); COCO.Separate
  299.     END Loop;
  300.  
  301.     PROCEDURE LoopCondPfx*;
  302.     BEGIN COCO.PutSeq("if(")
  303.     END LoopCondPfx;
  304.  
  305.     PROCEDURE LoopCondSfx*(cont: BOOLEAN);
  306.     BEGIN COCO.PutSeq(")"); IF cont THEN COCO.PutSeq("; else") END;
  307.         COCO.Separate; COCO.PutSeq("break"); TermStmt
  308.     END LoopCondSfx;
  309.  
  310.     PROCEDURE LoopLabel*(loopno: INTEGER);
  311.         VAR s: ARRAY 9 OF CHAR;
  312.     BEGIN COCO.Undent;
  313.         COCO.PutSeq("pOt__LoopLabel_");
  314.         Strings.FromLInt(loopno, 16, s); COCO.PutSeq(s); COCO.PutSeq(":");
  315.         TermStmt;
  316.         COCO.Indent
  317.     END LoopLabel;
  318.  
  319.     PROCEDURE With*(x: COCT.Item; wobj: COCT.Object);
  320.         VAR np: INTEGER;
  321.     BEGIN
  322.         COCY.StartVOList;
  323.  
  324.         COCY.VarObj(wobj, Defi);
  325.         COCO.PutSeq("_=");
  326.         COCQ.Link(x); COCN.CObjName(x, x.qoffs, np);
  327.         IF x.mode = Var THEN COCJ.InRef(x); x.mode := Ind END; COCJ.Cast(x);
  328.         COCQ.Unlink(x);
  329.  
  330.         COCY.VarObj(wobj, Defi);
  331.         COCO.PutSeq("=");
  332.         COCY.ObjToItem(wobj,x);
  333.         COCQ.Link(x); COCN.CObjName(x, x.qoffs, np); COCQ.Unlink(x);
  334.         COCO.PutSeq("_");
  335.  
  336.         COCY.StopVOList
  337.     END With;
  338.  
  339.     PROCEDURE Exit*(loopno:INTEGER);
  340.         VAR s: ARRAY 9 OF CHAR;
  341.     BEGIN COCO.PutSeq("goto pOt__LoopLabel_");
  342.         Strings.FromLInt(loopno, 16, s); COCO.PutSeq(s); TermStmt
  343.     END Exit;
  344.  
  345.     PROCEDURE CasePfx*;
  346.     BEGIN COCO.PutSeq("switch(")
  347.     END CasePfx;
  348.  
  349.     PROCEDURE CaseSfx*;
  350.     BEGIN COCO.PutSeq(")"); COCO.Separate
  351.     END CaseSfx;
  352.  
  353.     PROCEDURE CaseLabelList*(VAR x,y: COCT.Item);
  354.         VAR first, last: LONGINT; np: INTEGER;
  355.     BEGIN COCO.Undent;
  356.         first := x.intval; last := y.intval + 1;
  357.         REPEAT COCO.PutSeq("case"); COCO.Separate;
  358.             COCQ.Link(x); COCJ.CConstValue(x, x.qoffs, np); COCQ.Unlink(x);
  359.             COCO.PutSeq(":"); COCO.Wrap;
  360.             INC(x.intval)
  361.         UNTIL x.intval = last;
  362.         x.intval := first;
  363.         COCO.Indent
  364.     END CaseLabelList;
  365.  
  366.     PROCEDURE CaseBar*;
  367.     BEGIN COCO.Undent; COCO.PutSeq("break"); TermStmt; COCO.Indent
  368.     END CaseBar;
  369.  
  370.     PROCEDURE CaseElse*;
  371.     BEGIN COCO.Undent;
  372.         COCO.PutSeq("break"); TermStmt;
  373.         COCO.PutSeq("default:"); TermStmt;
  374.         COCO.Indent
  375.     END CaseElse;
  376.  
  377.     PROCEDURE IfPfx*;
  378.     BEGIN COCO.PutSeq("if(")
  379.     END IfPfx;
  380.  
  381.     PROCEDURE IfSfx*;
  382.     BEGIN COCO.PutSeq(")"); COCO.Separate
  383.     END IfSfx;
  384.  
  385.     PROCEDURE Else*;
  386.     BEGIN COCO.Undent; COCO.PutSeq("} else"); COCO.Separate
  387.     END Else;
  388.  
  389.     PROCEDURE CExport*;
  390.         CONST quote = 22X;
  391.         VAR obj, firstvar, firstproc: COCT.Object; im: INTEGER;
  392.     BEGIN
  393.         COCO.PutSeq("#ifndef pOt_"); COCO.PutSeq(COCT.topScope.name); COCO.PutSeq("__INC"); COCO.Wrap;
  394.         COCO.PutSeq("#define pOt_"); COCO.PutSeq(COCT.topScope.name); COCO.PutSeq("__INC"); COCO.Wrap;
  395.         Logo; COCO.Wrap;
  396.         im := 0;
  397.         WHILE im # COCT.nofGmod DO
  398.             IF COCT.GlbMod[im].mode # NotYetExp THEN
  399.                 COCO.PutSeq("#include ");
  400.                 COCO.PutSeq(quote); COCO.PutSeq(COCT.GlbMod[im].name); COCO.PutSeq(".h"); COCO.PutSeq(quote);
  401.                 COCO.Wrap
  402.             END;
  403.             INC(im)
  404.         END; COCO.Wrap;
  405.         obj := COCT.topScope.next; firstvar := NIL;
  406.         WHILE (obj # NIL) & (obj.mode = Mod) DO obj := obj.next END;
  407.         WHILE (obj # NIL) & (obj.mode <= Typ) DO
  408.             IF (obj.mode = Typ) & (obj.typ.ref # 0) THEN COCY.TypeObj(obj); obj := obj.next
  409.             ELSIF (obj.mode = Con) & obj.marked THEN COCY.ConstObj(obj, Decl); obj := obj.next
  410.             ELSIF obj.mode = Var THEN
  411.                 IF firstvar = NIL THEN firstvar := obj END;
  412.                 REPEAT obj := obj.next UNTIL (obj = NIL) OR (obj.mode # Var)
  413.             ELSE obj := obj.next
  414.             END
  415.         END; COCO.Wrap; firstproc := obj;
  416.         COCD.DeclTypDescs; COCO.Wrap;
  417.         obj := firstvar;
  418.         COCY.StartVOList;
  419.         WHILE (obj # NIL) & (obj.mode <= Typ) DO
  420.             IF (obj.mode = Var) & obj.marked THEN COCY.VarObj(obj, Decl) END;
  421.             obj := obj.next
  422.       END;
  423.         COCY.StopVOList; COCO.Wrap;
  424.         obj := firstproc;
  425.         WHILE obj # NIL DO
  426.             IF (obj.mode IN {XProc, CProc, IProc}) & obj.marked THEN COCY.ProcObj(obj, Decl) END;
  427.             obj := obj.next
  428.         END;
  429.         COCY.BodyObj(COCT.topScope, Decl); COCO.Wrap;
  430.         COCO.PutSeq("#endif"); COCO.Wrap
  431.     END CExport;
  432.  
  433.     PROCEDURE CommitCExport*(VAR TmpFName, FName: ARRAY OF CHAR; VAR newHF: BOOLEAN);
  434.         VAR
  435.             oldFile, newFile: Files.File;
  436.             oldRider, newRider: Files.Rider;
  437.             ch0, ch1: CHAR;
  438.             res: INTEGER;
  439.     BEGIN newFile := Files.Old(TmpFName); oldFile := Files.Old(FName);
  440.         IF oldFile # NIL THEN
  441.             Files.Set(oldRider, oldFile, 0); Files.Set(newRider, newFile, 0);
  442.             REPEAT Files.Read(oldRider, ch0); Files.Read(newRider, ch1)
  443.             UNTIL (ch0 # ch1) OR newRider.eof;
  444.             IF oldRider.eof & newRider.eof THEN newHF := FALSE
  445.             ELSIF ~newHF THEN COCS.Mark(156)
  446.             END;
  447.             Files.Close(oldFile)
  448.         ELSE newHF := TRUE
  449.         END;
  450.         Files.Close(newFile);
  451.         IF newHF THEN Files.Delete(FName, res); Files.Rename(TmpFName, FName, res)
  452.         ELSE Files.Delete(TmpFName, res)
  453.         END;
  454.         IF res > 1 THEN HALT(21H) END
  455.     END CommitCExport;
  456.  
  457.     PROCEDURE InitData*;
  458.     BEGIN Logo; COCO.Wrap;
  459.         COCD.InitStrings; COCO.Wrap
  460.     END InitData;
  461.  
  462. BEGIN tempsafe := TRUE
  463. END COCC.
  464.