home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / dev / obero / oberon-a / source / oc / ocm.mod < prev    next >
Encoding:
Text File  |  1995-07-02  |  20.2 KB  |  681 lines
  1. (*************************************************************************
  2.  
  3.      $RCSfile: OCM.mod $
  4.   Description: Machine-specific declarations and operations.
  5.  
  6.    Created by: fjc (Frank Copeland)
  7.     $Revision: 5.18 $
  8.       $Author: fjc $
  9.         $Date: 1995/06/02 18:30:56 $
  10.  
  11.   Copyright © 1993-1995, Frank Copeland
  12.   This module forms part of the OC program
  13.   See OC.doc for conditions of use and distribution
  14.  
  15.   Log entries are at the end of the file.
  16.  
  17. *************************************************************************)
  18.  
  19. <* STANDARD- *> <* MAIN- *>
  20.  
  21. MODULE OCM;
  22.  
  23. IMPORT
  24.   SYS := SYSTEM, e := Exec, d := Dos, du := DosUtil,
  25.   str := Strings, wb := Workbench, i := Icon;
  26.  
  27. CONST
  28.  
  29.   (* Sizes in bytes of basic data types. *)
  30.  
  31.   ByteSize * = 1; BoolSize * = 1; CharSize * = 1;
  32.   SIntSize * = 1; IntSize * = 2; LIntSize * = 4;
  33.   RealSize * = 4; LRealSize * = RealSize;
  34.   BSetSize * = 1; WSetSize * = 2; SetSize * = 4;
  35.   PtrSize * = 4; ProcSize * = 4;
  36.  
  37.   (* Minima and Maxima of basic data types. *)
  38.  
  39.   MinBool * = 0; MaxBool * = 1; MinChar * = 0; MaxChar * = 0FFH;
  40.   MinSInt * = -80H; MaxSInt * = 7FH;
  41.   MinInt * = -8000H; MaxInt * = 7FFFH;
  42.   MinLInt * = 80000000H; MaxLInt * = 7FFFFFFFH;
  43.   MinSet * = 0; MaxBSet * = 7; MaxWSet * = 15; MaxSet * = 31;
  44.  
  45.   (* REALs are implemented as Motorola FFP Single-Precision reals. *)
  46.   MinReal * = MIN (REAL); (*-9.22337177E18*)
  47.   MaxReal * = MAX (REAL); (*+9.22337177E18*)
  48.   MaxExp * = 18;
  49.  
  50.   (*
  51.     For now, LONGREALs are the same as REALs.  In future, they will be
  52.     implemented as IEEE double-precision reals.
  53.   *)
  54.   MinLReal * = MinReal; MaxLReal * = MaxReal; MaxLExp * = MaxExp;
  55.  
  56.   (*
  57.   ** Maximum size of a procedure's parameter list. This must correspond
  58.   ** to the constant used by the stack checking code. See STACKCHK.asm.
  59.   ** *Must* be at least 1500, to allow for the stack requirements of
  60.   ** dos.library functions.
  61.   *)
  62.  
  63.   ParLimit * = 1500;
  64.  
  65.   (* Maximum size of a module's global variables. Note that this value
  66.   ** far exceeds the maximum amount of memory installed in any Amiga
  67.   ** produced so far.
  68.   *)
  69.  
  70.   VarLimit * = MAX (LONGINT) - 3;
  71.  
  72.   (* Maximum size of a procedure's local variables. *)
  73.  
  74.   LVarLimit * = MIN (INTEGER);
  75.  
  76.   (* Maximum size of a compound type. *)
  77.  
  78.   MaxTypeSize * = MAX (LONGINT) - 1;
  79.  
  80.   (*
  81.   ** Maximum number of extensions allowed for record types. This equals
  82.   ** the number of slots available in the type descriptor.
  83.   *)
  84.  
  85.   ExtendLimit * = 15;
  86.  
  87.   (*
  88.    * Object and item modes, used by Module OCT and others. These are
  89.    * subject to change.
  90.    *)
  91.  
  92.   Undef    * =  0;
  93.   Var      * =  1; (* local and global variables and value parameters *)
  94.   VarR     * =  2; (* value parameter in register *)
  95.   VarX     * =  3; (* indexed array variables *)
  96.   VarArg   * =  4; (* C-style vararg pushed on stack *)
  97.   Ind      * =  5; (* variable parameters *)
  98.   IndR     * =  6; (* variable parameter in register *)
  99.   IndX     * =  7; (* indexed dynamic array parameters *)
  100.   RegI     * =  8; (* register indirect mode with displacement *)
  101.   RegX     * =  9; (* register indirect mode with displacement and index *)
  102.   Lab      * = 10; (* absolute mode, the address of a label *)
  103.   LabI     * = 11; (* immediate mode, the address of a label *)
  104.   Abs      * = 12; (* absolute mode *)
  105.   Con      * = 13; (* constants *)
  106.   Push     * = 14; (* register indirect mode with predecrement *)
  107.   Pop      * = 15; (* register indirect mode with postincrement *)
  108.   Coc      * = 16; (* condition code *)
  109.   Reg      * = 17; (* register direct mode *)
  110.   RList    * = 18; (* Register list for MOVEM *)
  111.   Fld      * = 19; (* record fields *)
  112.   Typ      * = 20; (* types *)
  113.   LProc    * = 21; (* local (non-exportable) procedures *)
  114.   XProc    * = 22; (* exportable procedures *)
  115.   TProc    * = 23; (* Type-bound procedures *)
  116.   SProc    * = 24; (* standard procedures *)
  117.   LibCall  * = 25; (* Amiga library functions *)
  118.   M2Proc   * = 26; (* External procedure (Modula-2 conventions) *)
  119.   CProc    * = 27; (* External procedure (C conventions) *)
  120.   AProc    * = 28; (* External procedure (Assembly conventions) *)
  121.   CallBack * = 29; (* CallBack procedure (Assembly conventions) *)
  122.   Mod      * = 30; (* Modules *)
  123.   Head     * = 31; (* symbol scope header *)
  124.  
  125. (* System flags, used in the foreign code interface *)
  126.  
  127.   DefaultFlag * = -1; (* Use current default *)
  128.   OberonFlag  * =  0; (* Use Oberon conventions (default) *)
  129.   M2Flag      * =  1; (* Use Modula-2 conventions *)
  130.   CFlag       * =  2; (* Use C conventions *)
  131.   BCPLFlag    * =  3; (* Use BCPL conventions *)
  132.   AsmFlag     * =  4; (* Use Assembler conventions *)
  133.   CBackFlag   * =  5; (* Call-back procedure, with register parameters *)
  134.  
  135. (* Preferences settings *)
  136.  
  137. CONST
  138.  
  139.   PathLen* = 256;                     (* Max length of a path name.      *)
  140.   ExtLen* = 16;                       (* Max length of an extension.     *)
  141.   maxPaths* = 10;                     (* Max number of search paths.     *)
  142.   OCPF = 04F435046H; (* "OCPF" *)     (* Tag for preferences file.       *)
  143.   PrefsVersion = 5;                   (* Preferences file version.       *)
  144.  
  145.   (* Icon types *)
  146.   iconSym* = 0; iconObj* = 1; iconErr* = 2;
  147.  
  148. TYPE
  149.   Path = ARRAY PathLen OF CHAR;
  150.   Extension = ARRAY ExtLen OF CHAR;
  151.  
  152. VAR
  153.   PrefsFile*,                        (* Name of current prefs file.     *)
  154.   SymPath*,                          (* Destination for symbol files.   *)
  155.   ObjPath*,                          (* Destination for object files.   *)
  156.   ErrPath*,                          (* Destination for error files.    *)
  157.   SetNames*,                         (* Selectors to be set.            *)
  158.   ClearNames*                        (* Selectors to be cleared.        *)
  159.     : Path;
  160.   SymExt*,                           (* Extension for symbol files      *)
  161.   ObjExt*,                           (* Extension for object files      *)
  162.   ErrExt*                            (* Extension for error files       *)
  163.     : Extension;
  164.  
  165.   Standard*,
  166.   Initialise*,
  167.   Main*,
  168.   Warnings*,
  169.   Register*,
  170.   Debug*,                            (* Output symbol hunks             *)
  171.   SmallCode*,
  172.   SmallData*,
  173.   Resident*,
  174.  
  175.   TypeChk*,
  176.   OvflChk*,
  177.   IndexChk*,
  178.   RangeChk*,
  179.   CaseChk*,
  180.   NilChk*,                           (* Default values for pragmas      *)
  181.   ReturnChk*,
  182.   StackChk*,
  183.   LongVars*,
  184.   ClearVars*,
  185.   AssertChk*,
  186.  
  187.   Verbose*,                          (* Verbose compiler output.        *)
  188.   MakeIcons*                         (* Create icons for symbol, object
  189.                                      ** and error files.
  190.                                      *)
  191.     : BOOLEAN;
  192.   CodeSize*,                         (* Size of code buffer.            *)
  193.   ConstSize*                         (* Size of constants buffer.       *)
  194.     : LONGINT;
  195.  
  196.   searchPath-                        (* Array of search paths.          *)
  197.     : ARRAY maxPaths + 1 OF e.LSTRPTR;
  198.   pathx- : INTEGER;                  (* Current # of search paths.      *)
  199.  
  200. CONST
  201.  
  202.   defSymPath = "";                   (* Default symbol file path.       *)
  203.   defObjPath = "";                   (* Default object file path.       *)
  204.   defErrPath = "T:";                 (* Default error file path.        *)
  205.   defSymExt = ".sym";                (* Default symbol file extension.  *)
  206.   defObjExt = ".obj";                (* Default object file extension.  *)
  207.   defErrExt = ".err";                (* Default error file extension.   *)
  208.  
  209.   defStandard   = TRUE;
  210.   defInitialise = TRUE;
  211.   defMain       = TRUE;
  212.   defWarnings   = TRUE;
  213.   defRegister   = FALSE;
  214.   defSmallCode  = FALSE;
  215.   defSmallData  = FALSE;
  216.   defResident   = FALSE;
  217.  
  218.   defTypeChk    = TRUE;
  219.   defOvflChk    = TRUE;
  220.   defIndexChk   = TRUE;
  221.   defRangeChk   = TRUE;
  222.   defCaseChk    = TRUE;
  223.   defNilChk     = TRUE;
  224.   defReturnChk  = TRUE;
  225.   defStackChk   = TRUE;
  226.   defLongVars   = FALSE;
  227.   defClearVars  = FALSE;
  228.   defAssertChk  = TRUE;
  229.  
  230.   defCodeSize   = 32000;
  231.   defConstSize  = 32000;
  232.  
  233. (* Force generation of symbol and object files *)
  234.  
  235. VAR
  236.  
  237.   Force* : BOOLEAN;
  238.  
  239. (*------------------------------------*)
  240. PROCEDURE LoadPrefs* ( fileName : ARRAY OF CHAR ) : BOOLEAN;
  241.  
  242.   VAR
  243.     pf   : d.FileHandlePtr;
  244.     s    : ARRAY PathLen OF CHAR;
  245.     dir  : ARRAY 3 OF e.LSTRPTR;
  246.     tag  : LONGINT; i, ver : INTEGER;
  247.     c    : CHAR;
  248.  
  249.   PROCEDURE Read ( fh : d.FileHandlePtr; VAR x : SYS.BYTE );
  250.     VAR i : LONGINT;
  251.   BEGIN (* Read *)
  252.     i := d.FGetC (fh); x := CHR (i)
  253.   END Read;
  254.  
  255.   PROCEDURE ReadBytes
  256.     ( fh : d.FileHandlePtr; VAR x : ARRAY OF SYS.BYTE; n : LONGINT );
  257.     VAR i : LONGINT;
  258.   BEGIN (* ReadBytes *)
  259.     i := d.FRead (fh, x, 1, n)
  260.   END ReadBytes;
  261.  
  262.   PROCEDURE ReadString ( fh : d.FileHandlePtr; VAR x : ARRAY OF CHAR );
  263.     VAR ch : CHAR; i : INTEGER;
  264.   BEGIN (* ReadString *)
  265.     i := 0;
  266.     REPEAT
  267.       Read (fh, ch); x [i] := ch; INC (i)
  268.     UNTIL ch = 0X
  269.   END ReadString;
  270.  
  271.   PROCEDURE ReadBool ( fh : d.FileHandlePtr; VAR x : BOOLEAN );
  272.     VAR i : SHORTINT;
  273.   BEGIN (* ReadBool *)
  274.     Read (fh, i); x := (i # 0)
  275.   END ReadBool;
  276.  
  277.   PROCEDURE ReadInt ( fh : d.FileHandlePtr; VAR i : LONGINT );
  278.     VAR res : LONGINT;
  279.   BEGIN (* ReadInt *)
  280.     res := d.FRead (fh, i, 4, 1)
  281.   END ReadInt;
  282.  
  283. <*$CopyArrays-*>
  284. BEGIN (* LoadPrefs *)
  285.   dir [0] := SYS.ADR ("PROGDIR:");
  286.   dir [1] := SYS.ADR ("ENV:OC");
  287.   dir [2] := NIL;
  288.   IF du.Search (dir, fileName, s) THEN
  289.     pf := d.Open (s, d.oldFile);
  290.     IF pf # NIL THEN
  291.       ReadBytes (pf, tag, 4);
  292.       IF tag = OCPF THEN
  293.         Read (pf, c); ver := ORD (c);
  294.         IF ver >= 1 THEN
  295.           ReadString (pf, SymPath);
  296.           ReadString (pf, ObjPath);
  297.           ReadString (pf, ErrPath);
  298.           ReadString (pf, SetNames);
  299.           ReadString (pf, ClearNames);
  300.           ReadString (pf, SymExt);
  301.           ReadString (pf, ObjExt);
  302.           ReadString (pf, ErrExt);
  303.  
  304.           pathx := 0;
  305.           LOOP
  306.             ReadString (pf, s);
  307.             IF s = "" THEN EXIT END;
  308.             SYS.NEW (searchPath [pathx], str.Length (s) + 1);
  309.             COPY (s, searchPath [pathx]^); INC (pathx)
  310.           END;
  311.           searchPath [pathx] := NIL;
  312.  
  313.           ReadBool (pf, Verbose);
  314.           ReadBool (pf, MakeIcons);
  315.           ReadBool (pf, Debug);
  316.  
  317.           SmallCode := defSmallCode;
  318.           SmallData := defSmallData;
  319.           Resident := defRegister;
  320.           Register := defRegister;
  321.           CodeSize := defCodeSize;
  322.           ConstSize := defConstSize;
  323.           Standard := defStandard;
  324.           Initialise := defInitialise;
  325.           Main := defMain;
  326.           Warnings := defWarnings;
  327.           TypeChk := defTypeChk;
  328.           OvflChk := defOvflChk;
  329.           IndexChk := defIndexChk;
  330.           RangeChk := defRangeChk;
  331.           CaseChk := defCaseChk;
  332.           NilChk := defNilChk;
  333.           ReturnChk := defReturnChk;
  334.           StackChk := defStackChk;
  335.           LongVars := defLongVars;
  336.           ClearVars := defClearVars;
  337.           AssertChk := defAssertChk;
  338.  
  339.           IF ver >= 2 THEN
  340.             ReadBool (pf, SmallCode);
  341.             ReadBool (pf, SmallData);
  342.             ReadBool (pf, Register);
  343.             IF ver >= 3 THEN
  344.               ReadInt (pf, CodeSize);
  345.               ReadInt (pf, ConstSize);
  346.               IF ver >= 4 THEN
  347.                 ReadBool (pf, Resident);
  348.                 IF ver >= 5 THEN
  349.                   ReadBool (pf, Standard);
  350.                   ReadBool (pf, Initialise);
  351.                   ReadBool (pf, Main);
  352.                   ReadBool (pf, Warnings);
  353.                   ReadBool (pf, TypeChk);
  354.                   ReadBool (pf, OvflChk);
  355.                   ReadBool (pf, IndexChk);
  356.                   ReadBool (pf, RangeChk);
  357.                   ReadBool (pf, CaseChk);
  358.                   ReadBool (pf, NilChk);
  359.                   ReadBool (pf, ReturnChk);
  360.                   ReadBool (pf, StackChk);
  361.                   ReadBool (pf, LongVars);
  362.                   ReadBool (pf, ClearVars);
  363.                   ReadBool (pf, AssertChk);
  364.                 END;
  365.               END
  366.             END
  367.           END;
  368.  
  369.           d.OldClose (pf);
  370.           COPY (fileName, PrefsFile);
  371.           RETURN TRUE
  372.         ELSE
  373.           d.OldClose (pf);
  374.           RETURN FALSE
  375.         END;
  376.       ELSE
  377.         d.OldClose (pf);
  378.         RETURN FALSE
  379.       END;
  380.     ELSE
  381.       RETURN FALSE
  382.     END;
  383.   ELSE
  384.     RETURN FALSE
  385.   END;
  386. END LoadPrefs;
  387.  
  388. (*------------------------------------*)
  389. PROCEDURE SavePrefs* ( fileName : ARRAY OF CHAR ) : BOOLEAN;
  390.  
  391.   VAR pf : d.FileHandlePtr; tag : LONGINT; i : INTEGER; ver : CHAR;
  392.  
  393.   PROCEDURE Write ( fh : d.FileHandlePtr; x : SYS.BYTE );
  394.     VAR i : LONGINT;
  395.   BEGIN (* Write *)
  396.     i := d.FPutC (fh, ORD (x))
  397.   END Write;
  398.  
  399.   PROCEDURE WriteBytes
  400.     ( fh : d.FileHandlePtr; VAR x : ARRAY OF SYS.BYTE; n : LONGINT );
  401.     VAR i : LONGINT;
  402.   BEGIN (* WriteBytes *)
  403.     i := d.FWrite (fh, x, 1, n)
  404.   END WriteBytes;
  405.  
  406.   PROCEDURE WriteString ( fh : d.FileHandlePtr; x : ARRAY OF CHAR );
  407.   <*$CopyArrays-*>
  408.   BEGIN (* WriteString *)
  409.     WriteBytes (fh, x, str.Length (x)); Write (fh, 0X)
  410.   END WriteString;
  411.  
  412.   PROCEDURE WriteBool ( fh : d.FileHandlePtr; x : BOOLEAN );
  413.     VAR i : SHORTINT;
  414.   BEGIN (* WriteBool *)
  415.     IF x THEN i := 1 ELSE i := 0 END; Write (fh, i)
  416.   END WriteBool;
  417.  
  418.   PROCEDURE WriteInt ( fh : d.FileHandlePtr; VAR i : LONGINT );
  419.     VAR res : LONGINT;
  420.   BEGIN (* WriteInt *)
  421.     res := d.FWrite (fh, i, 4, 1)
  422.   END WriteInt;
  423.  
  424. <*$CopyArrays-*>
  425. BEGIN (* SavePrefs *)
  426.   pf := d.Open (fileName, d.newFile);
  427.   IF pf # NIL THEN
  428.     tag := OCPF; WriteBytes (pf, tag, 4);
  429.     Write (pf, CHR (PrefsVersion));
  430.     WriteString (pf, SymPath);
  431.     WriteString (pf, ObjPath);
  432.     WriteString (pf, ErrPath);
  433.     WriteString (pf, SetNames);
  434.     WriteString (pf, ClearNames);
  435.     WriteString (pf, SymExt);
  436.     WriteString (pf, ObjExt);
  437.     WriteString (pf, ErrExt);
  438.     FOR i := 0 TO pathx - 1 DO WriteString (pf, searchPath [i]^) END;
  439.     WriteString (pf, "");
  440.     WriteBool (pf, Verbose);
  441.     WriteBool (pf, MakeIcons);
  442.     WriteBool (pf, Debug);
  443.     WriteBool (pf, SmallCode);
  444.     WriteBool (pf, SmallData);
  445.     WriteBool (pf, Register);
  446.     WriteInt (pf, CodeSize);
  447.     WriteInt (pf, ConstSize);
  448.     WriteBool (pf, Resident);
  449.     WriteBool (pf, Standard);
  450.     WriteBool (pf, Initialise);
  451.     WriteBool (pf, Main);
  452.     WriteBool (pf, Warnings);
  453.     WriteBool (pf, TypeChk);
  454.     WriteBool (pf, OvflChk);
  455.     WriteBool (pf, IndexChk);
  456.     WriteBool (pf, RangeChk);
  457.     WriteBool (pf, CaseChk);
  458.     WriteBool (pf, NilChk);
  459.     WriteBool (pf, ReturnChk);
  460.     WriteBool (pf, StackChk);
  461.     WriteBool (pf, LongVars);
  462.     WriteBool (pf, ClearVars);
  463.     WriteBool (pf, AssertChk);
  464.  
  465.     d.OldClose (pf);
  466.     COPY (fileName, PrefsFile);
  467.     RETURN TRUE
  468.   ELSE
  469.     RETURN FALSE
  470.   END
  471. END SavePrefs;
  472.  
  473. (*------------------------------------*)
  474. PROCEDURE ClearSearchPaths*;
  475. BEGIN (* ClearSearchPaths *)
  476.   pathx := 0; searchPath [0] := NIL
  477. END ClearSearchPaths;
  478.  
  479. (*------------------------------------*)
  480. PROCEDURE AddSearchPath * (newPath : e.LSTRPTR);
  481.  
  482. BEGIN (* AddSearchPath *)
  483.   IF pathx >= maxPaths THEN
  484.     HALT (922)
  485.   ELSE
  486.     searchPath [pathx] := newPath; INC (pathx); searchPath [pathx] := NIL
  487.   END;
  488. END AddSearchPath;
  489.  
  490. (*------------------------------------*)
  491. PROCEDURE FindSymbolFile *
  492.   ( module   : ARRAY OF CHAR;
  493.     VAR path : ARRAY OF CHAR )
  494.   : BOOLEAN;
  495.  
  496.   VAR name : ARRAY 32 OF CHAR;
  497.  
  498. <*$CopyArrays-*>
  499. BEGIN (* FindSymbolFile *)
  500.   COPY (module, name); str.Append (SymExt, name);
  501.   RETURN du.Search (searchPath, name, path)
  502. END FindSymbolFile;
  503.  
  504. (*------------------------------------*)
  505. PROCEDURE MakeFileName
  506.   ( module, ext : ARRAY OF CHAR;
  507.     VAR path    : ARRAY OF CHAR );
  508.  
  509.   VAR name : ARRAY 32 OF CHAR;
  510.  
  511. <*$CopyArrays-*>
  512. BEGIN (* MakeFileName *)
  513.   COPY (module, name); str.Append (ext, name);
  514.   IF d.AddPart (path, name, LEN (path)) THEN END
  515. END MakeFileName;
  516.  
  517. (*------------------------------------*)
  518. PROCEDURE SymbolFileName *
  519.   ( module   : ARRAY OF CHAR;
  520.     VAR path : ARRAY OF CHAR;
  521.     fullPath : BOOLEAN );
  522.  
  523. <*$CopyArrays-*>
  524. BEGIN (* SymbolFileName *)
  525.   IF fullPath THEN
  526.     COPY (SymPath, path); MakeFileName (module, SymExt, path)
  527.   ELSE
  528.     COPY (module, path); str.Append (SymExt, path)
  529.   END
  530. END SymbolFileName;
  531.  
  532. (*------------------------------------*)
  533. PROCEDURE ObjectFileName *
  534.   ( module   : ARRAY OF CHAR;
  535.     VAR path : ARRAY OF CHAR );
  536.  
  537. <*$CopyArrays-*>
  538. BEGIN (* ObjectFileName *)
  539.   COPY (ObjPath, path); MakeFileName (module, ObjExt, path)
  540. END ObjectFileName;
  541.  
  542. (*------------------------------------*)
  543. PROCEDURE ErrorFileName *
  544.   ( module   : ARRAY OF CHAR;
  545.     VAR path : ARRAY OF CHAR );
  546.  
  547. <*$CopyArrays-*>
  548. BEGIN (* ErrorFileName *)
  549.   COPY (ErrPath, path); MakeFileName (module, ErrExt, path);
  550. END ErrorFileName;
  551.  
  552.  
  553. (*------------------------------------*)
  554. PROCEDURE MakeIcon* ( file : ARRAY OF CHAR; type : INTEGER );
  555.  
  556.   VAR
  557.     icon : Path;
  558.     diskObj : wb.DiskObjectPtr;
  559.     filePart : e.LSTRPTR;
  560.  
  561. <*$CopyArrays-*>
  562. BEGIN (* MakeIcon *)
  563.   IF MakeIcons THEN
  564.     ASSERT (i.base # NIL, 100);
  565.     COPY (file, icon); str.Append (".info", icon);
  566.     IF ~du.FileExists (icon) THEN
  567.       CASE type OF
  568.         iconSym : icon := "ENV:OC/def_sym" |
  569.         iconObj : icon := "ENV:OC/def_obj" |
  570.         iconErr : icon := "ENV:OC/def_err" |
  571.       END;
  572.       diskObj := i.GetDiskObject (icon);
  573.       IF diskObj = NIL THEN diskObj := i.GetDefDiskObject (wb.project) END;
  574.       IF diskObj # NIL THEN
  575.         diskObj.currentX := wb.noIconPosition;
  576.         diskObj.currentY := wb.noIconPosition;
  577.         IF ~i.PutDiskObject (file, diskObj) THEN
  578.           IF d.PrintFault (d.IoErr(), "PutDiskObject") THEN END;
  579.         END;
  580.         i.FreeDiskObject (diskObj)
  581.       ELSE
  582.         IF d.PrintFault (d.IoErr(), "GetDiskObject") THEN END;
  583.       END
  584.     END
  585.   END
  586. END MakeIcon;
  587.  
  588. BEGIN
  589.   Verbose := TRUE; MakeIcons := FALSE; Debug := FALSE; Force := FALSE;
  590.  
  591.   SymPath := defSymPath; ObjPath := defObjPath; ErrPath := defErrPath;
  592.   SymExt := defSymExt; ObjExt := defObjExt; ErrExt := defErrExt;
  593.   SmallCode := defSmallCode; SmallData := defSmallData;
  594.   Resident := defResident; Register := defRegister;
  595.   CodeSize := defCodeSize; ConstSize := defConstSize;
  596.   Standard := defStandard; Initialise := defInitialise;
  597.   Main := defMain; Warnings := defWarnings;
  598.   TypeChk := defTypeChk; OvflChk := defOvflChk;
  599.   IndexChk := defIndexChk; RangeChk := defRangeChk;
  600.   CaseChk := defCaseChk; NilChk := defNilChk;
  601.   ReturnChk := defReturnChk; StackChk := defStackChk;
  602.   LongVars := defLongVars; ClearVars := defClearVars;
  603.   AssertChk := defAssertChk;
  604.  
  605.   searchPath [0] := NIL; pathx := 0;
  606.   PrefsFile := ""
  607. END OCM.
  608.  
  609. (***************************************************************************
  610.  
  611.   $Log: OCM.mod $
  612.   Revision 5.18  1995/06/02  18:30:56  fjc
  613.   - Declared ExtendLimit.
  614.   - Added compiler options and pragmas to settings file.
  615.  
  616.   Revision 5.17  1995/05/19  15:58:52  fjc
  617.   - Moved console IO to module OCOut.
  618.  
  619.   Revision 5.16  1995/05/13  23:01:00  fjc
  620.   - Exported some constants.
  621.  
  622.   Revision 5.15  1995/05/08  17:05:36  fjc
  623.   - Now holds the preferences file's name in PrefsFile.
  624.  
  625.   Revision 5.13  1995/04/02  13:33:58  fjc
  626.   - Added CODESIZE and CONSTSIZE settings.
  627.  
  628.   Revision 5.12  1995/03/13  11:19:17  fjc
  629.   - Added new modes: VarR and IndR.
  630.   - Added new flag : CBackProc.
  631.  
  632.   Revision 5.11  1995/02/27  16:45:13  fjc
  633.   - Removed tracing code.
  634.   - Added SmallCode, SmallData and Register settings, and
  635.     changed preferences file format to reflect this.
  636.  
  637.   Revision 5.10  1995/01/26  00:17:17  fjc
  638.   - Release 1.5
  639.  
  640.   Revision 5.9  1995/01/16  10:30:02  fjc
  641.   - Uses direct calls to AmigaDOS for reading and writing
  642.     preferences files.
  643.  
  644.   Revision 5.8  1995/01/09  13:44:53  fjc
  645.   - Deleted icon names from preferences file format.
  646.   - Added MakeIcon().
  647.   - Added checks for the existence of directories when
  648.     constructing file names.
  649.  
  650.   Revision 5.7  1995/01/05  11:27:26  fjc
  651.   - Added check for Ctrl-C break to console I/O procedures.
  652.  
  653.   Revision 5.6  1995/01/03  21:00:03  fjc
  654.   - Renamed from OCG to OCM.
  655.   - Added support for preferences settings:
  656.     - Added variables to hold current settings.
  657.     - Added LoadPrefs() and SavePrefs().
  658.   - Added ClearSearchPaths().
  659.   - Added console I/O procedures to replace module Out.
  660.   - Added support for catalogs using module OCStrings.
  661.  
  662.   Revision 5.5  1994/12/16  16:59:59  fjc
  663.   - Added code for constructing file names and searching for
  664.     symbol files.
  665.  
  666.   Revision 5.4  1994/09/25  17:30:29  fjc
  667.   - Overhauled object modes.
  668.   - Added system flag declarations.
  669.  
  670.   Revision 5.3  1994/09/19  23:10:05  fjc
  671.   - Re-implemented Amiga library calls
  672.  
  673.   Revision 5.2  1994/09/15  10:10:58  fjc
  674.   - Replaced switches with pragmas.
  675.   - Uses Kernel instead of SYSTEM.
  676.  
  677.   Revision 5.1  1994/09/03  19:29:08  fjc
  678.   - Bumped version number
  679.  
  680. ***************************************************************************)
  681.