home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / source / obrn-a_1.5_src.lha / oberon-a / source3.lha / Source / FPE / Data.mod < prev    next >
Encoding:
Text File  |  1995-01-26  |  16.8 KB  |  662 lines
  1. (*************************************************************************
  2.  
  3.      $RCSfile: Data.mod $
  4.   Description: Global data declarations and operations for the FPE utility
  5.                program.
  6.  
  7.    Created by: fjc (Frank Copeland)
  8.     $Revision: 1.10 $
  9.       $Author: fjc $
  10.         $Date: 1995/01/26 00:15:33 $
  11.  
  12.   Copyright © 1993-1995, Frank Copeland.
  13.   This file is part of FPE.
  14.   See FPE.doc for conditions of use and distribution.
  15.  
  16.   Log entries are at the end of the file.
  17.  
  18. *************************************************************************)
  19.  
  20. <* STANDARD- *> <* INITIALISE- *> <* MAIN- *> <*$ NilChk- *>
  21.  
  22. MODULE Data;
  23.  
  24. IMPORT
  25.   SYS := SYSTEM, Kernel, e := Exec, es := ExecSupport, eu := ExecUtil,
  26.   u := Utility, d := Dos, du := DosUtil, is := IntuiSup,
  27.   isu := IntuiSupUtil, str := Strings, str2 := Strings2;
  28.  
  29. CONST
  30.  
  31.   NumFiles * = 4;
  32.   NumTools * = 12;
  33.  
  34.   FileChars *      = 32;
  35.   ExtensionChars * = 8;
  36.   PathChars *      = 254;
  37.   ButtonChars *    = 10;
  38.   ConsoleChars *   = 60;
  39.  
  40.   Notice    = "FPE Notice";
  41.  
  42.   FPEPF = 046504500H;
  43.   PrefsVersion = 1;
  44.  
  45. TYPE
  46.  
  47.   FileName * = ARRAY FileChars + 1 OF CHAR;
  48.   Path * = ARRAY PathChars + 1 OF CHAR;
  49.   Extension * = ARRAY ExtensionChars + 1 OF CHAR;
  50.  
  51.   ModuleNodePtr * = POINTER [2] TO ModuleNode;
  52.   ModuleNode = RECORD [2] (e.Node)
  53.     modName : FileName;
  54.   END; (* ModuleNode *)
  55.  
  56.   ButtonText = ARRAY ButtonChars + 1 OF CHAR;
  57.   Console = ARRAY ConsoleChars + 1 OF CHAR;
  58.  
  59.   ToolInfo * = RECORD
  60.     title *      : ButtonText;
  61.     command *,
  62.     arguments *  : Path;
  63.     isActive *,
  64.     hasConsole * : BOOLEAN;
  65.     console *    : Console;
  66.     stack *      : LONGINT;
  67.   END; (* ToolInfo *)
  68.  
  69.   FileSet         = SYS.BYTESET;
  70.   ToolsArray      = ARRAY NumTools OF ToolInfo;
  71.   SkeletonsArray  = ARRAY NumFiles OF Path;
  72.   ExtensionsArray = ARRAY NumFiles OF Extension;
  73.  
  74. VAR
  75.  
  76.   currentPath *     : Path;
  77.   programName *     : FileName;
  78.   moduleList *      : e.List;
  79.   currentModule *   : ModuleNodePtr;
  80.   currentModuleNo * : LONGINT;
  81.   currentFiles *    : FileSet;
  82.   tools *           : ToolsArray;
  83.   extensions *      : ExtensionsArray;
  84.   currentDir *      : d.FileLockPtr;
  85.  
  86.   DefSetupPath : Path;
  87.   AltSetupPath : Path;
  88.   (*skeletons : SkeletonsArray;*)
  89.   (*icon      : Path;*)
  90.  
  91.  
  92. (*------------------------------------*)
  93. PROCEDURE ChangeDirectory * ( newDir : ARRAY OF CHAR );
  94.  
  95. VAR result : LONGINT; dirLock : d.FileLockPtr;
  96.  
  97. <*$CopyArrays-*>
  98. BEGIN (* ChangeDirectory *)
  99.   dirLock := d.Lock (newDir, d.sharedLock);
  100.   IF dirLock # NIL THEN
  101.     IF currentDir # NIL THEN d.UnLock( currentDir ) END;
  102.     currentDir := dirLock;
  103.     dirLock := d.CurrentDir (dirLock);
  104.     ASSERT (d.NameFromLock (currentDir, currentPath, PathChars))
  105.   ELSE
  106.     isu.DoNotice (NIL, SYS.ADR (Notice), "Could not lock new directory");
  107.   END
  108. END ChangeDirectory;
  109.  
  110. (*------------------------------------*)
  111. PROCEDURE MakeModule * ( module : ARRAY OF CHAR );
  112.  
  113. VAR
  114.   newNode : ModuleNodePtr;
  115.  
  116. <*$CopyArrays-*>
  117. BEGIN (* MakeModule *)
  118.   NEW (newNode); ASSERT (newNode # NIL, 137);
  119.   newNode.name := SYS.ADR(newNode.modName);
  120.   COPY (module, newNode.modName);
  121.   e.AddTail (moduleList, newNode);
  122.   IF currentModule = NIL THEN
  123.     currentModule := SYS.VAL (ModuleNodePtr, moduleList.head);
  124.     currentModuleNo := 0
  125.   END
  126. END MakeModule;
  127.  
  128.  
  129. (*------------------------------------*)
  130. PROCEDURE RemoveModule * ();
  131.  
  132. VAR module : ModuleNodePtr;
  133.  
  134. BEGIN (* RemoveModule *)
  135.   IF currentModule # NIL THEN
  136.     module := currentModule;
  137.     IF module.succ.succ = NIL THEN
  138.       currentModule := SYS.VAL (ModuleNodePtr, moduleList.head);
  139.       currentModuleNo := 0
  140.     ELSE
  141.       currentModule := SYS.VAL (ModuleNodePtr, module.succ);
  142.     END;
  143.     e.Remove (module);
  144.     SYS.DISPOSE (module)
  145.   END
  146. END RemoveModule;
  147.  
  148.  
  149. (*------------------------------------*)
  150. PROCEDURE ScanModules * () : BOOLEAN;
  151.  
  152. VAR
  153.   module : FileName;
  154.   fileInfo : d.FileInfoBlockPtr;
  155.   file, fileLength, dotPos : INTEGER;
  156.   extLength : ARRAY NumFiles OF INTEGER;
  157.   extension : Extension;
  158.   result : BOOLEAN;
  159.   thisModule : e.MinNodePtr;
  160.  
  161. BEGIN (* ScanModules *)
  162.   result := TRUE;
  163.   NEW (fileInfo); ASSERT (fileInfo # NIL, 137);
  164.  
  165.   thisModule := SYS.VAL (e.MinNodePtr, e.RemHead (moduleList));
  166.   WHILE thisModule # NIL DO
  167.     SYS.DISPOSE (thisModule);
  168.     thisModule := SYS.VAL (e.MinNodePtr, e.RemHead (moduleList));
  169.   END;
  170.   currentModule := NIL; currentModuleNo := 0;
  171.  
  172.   file := 0;
  173.   WHILE file < NumFiles DO
  174.     extLength [file] := SHORT (str.Length (extensions [file])); INC (file)
  175.   END;
  176.  
  177.   IF d.Examine (currentDir, fileInfo^) THEN
  178.     WHILE d.ExNext (currentDir, fileInfo^) DO
  179.       IF fileInfo.dirEntryType < 0 THEN
  180.         file := 0;
  181.         LOOP
  182.           IF file >= NumFiles THEN EXIT; END;
  183.           fileLength := SHORT (str.Length (fileInfo.fileName));
  184.           dotPos := fileLength - extLength [file] - 1;
  185.           IF (dotPos >= 0) & (fileInfo.fileName [dotPos] = ".") THEN
  186.             str.Extract
  187.               (fileInfo.fileName, dotPos + 1, extLength [file], extension);
  188.             IF str2.CompareCAP (extension, extensions [file]) = 0 THEN
  189.               str.Extract (fileInfo.fileName, 0, dotPos, module);
  190.               IF e.FindName (moduleList, module) = NIL THEN
  191.                 MakeModule (module);
  192.               END;
  193.               EXIT
  194.             END;
  195.           END;
  196.           INC (file)
  197.         END; (* LOOP *)
  198.       END; (* IF *)
  199.     END; (* WHILE *)
  200.   ELSE
  201.     result := FALSE
  202.   END;
  203.  
  204.   SYS.DISPOSE (fileInfo);
  205.   RETURN result;
  206. END ScanModules;
  207.  
  208.  
  209. (*------------------------------------*)
  210. PROCEDURE LoadProgram * ( program : ARRAY OF CHAR ) : BOOLEAN;
  211.  
  212. VAR
  213.   progFile : is.FileDataPtr;
  214.   prgName : Path;
  215.   module : FileName;
  216.   thisModule : e.MinNodePtr;
  217.   fileResult : INTEGER;
  218.   result : BOOLEAN;
  219.  
  220. <*$CopyArrays-*>
  221. BEGIN (* LoadProgram *)
  222.   result := TRUE;
  223.  
  224.   thisModule := SYS.VAL (e.MinNodePtr, e.RemHead (moduleList));
  225.   WHILE thisModule # NIL DO
  226.     SYS.DISPOSE (thisModule);
  227.     thisModule := SYS.VAL (e.MinNodePtr, e.RemHead (moduleList))
  228.   END;
  229.   currentModule := NIL; currentModuleNo := 0;
  230.  
  231.   COPY (program, programName);
  232.   COPY (program, prgName);
  233.   str.Append (".prg", prgName);
  234.  
  235.   progFile :=
  236.     is.OpenTextFile
  237.       ( prgName, 1000, 100, {is.tfTrimLine .. is.tfSkipEmptyLines});
  238.   IF progFile # NIL THEN
  239.     module := "";
  240.     LOOP
  241.       fileResult := is.ReadTextLine (progFile);
  242.       IF fileResult # is.normal THEN EXIT END;
  243.       COPY (progFile.line^, module);
  244.       IF module [0] # 0X THEN MakeModule (module) END
  245.     END;
  246.     is.CloseTextFile (progFile)
  247.   ELSE
  248.     result := FALSE
  249.   END;
  250.  
  251.   RETURN result;
  252. END LoadProgram;
  253.  
  254.  
  255. (*------------------------------------*)
  256. PROCEDURE SaveProgram * () : BOOLEAN;
  257.  
  258. VAR
  259.   progFile : d.FileHandlePtr;
  260.   prgName : Path;
  261.   module : ModuleNodePtr;
  262.   result : BOOLEAN;
  263.  
  264.   PROCEDURE WriteLine ( string : ARRAY OF CHAR );
  265.  
  266.   VAR ch : CHAR;
  267.       fileResult : LONGINT;
  268.  
  269.   <*$CopyArrays-*>
  270.   BEGIN (* WriteLine *)
  271.     fileResult := d.Write (progFile, string, str.Length (string));
  272.     ch := "\n"; fileResult := d.Write (progFile, ch, 1);
  273.   END WriteLine;
  274.  
  275. BEGIN (* SaveProgram *)
  276.   result := TRUE;
  277.   COPY (programName, prgName);
  278.   str.Append (".prg", prgName);
  279.  
  280.   progFile := d.Open (prgName, d.newFile);
  281.   IF progFile # NIL THEN
  282.     module := SYS.VAL (ModuleNodePtr, eu.GetHead (moduleList));
  283.     WHILE module # NIL DO
  284.       WriteLine (module.modName);
  285.       module := SYS.VAL (ModuleNodePtr, eu.GetSucc (module))
  286.     END;
  287.     d.OldClose( progFile );
  288.   ELSE
  289.     result := FALSE;
  290.   END;
  291.  
  292.   RETURN result;
  293. END SaveProgram;
  294.  
  295.  
  296. (*------------------------------------*)
  297. PROCEDURE LoadSetup * ( setupDir, setupFile : ARRAY OF CHAR );
  298.  
  299.   VAR
  300.     setupPath : Path; pf : d.FileHandlePtr; tag : LONGINT;
  301.     i, ver : INTEGER; c : CHAR;
  302.  
  303.   PROCEDURE Read ( fh : d.FileHandlePtr; VAR x : SYS.BYTE );
  304.     VAR i : LONGINT;
  305.   BEGIN (* Read *)
  306.     i := d.FGetC (fh); x := CHR (i)
  307.   END Read;
  308.  
  309.   PROCEDURE ReadBytes
  310.     ( fh : d.FileHandlePtr; VAR x : ARRAY OF SYS.BYTE; n : LONGINT );
  311.     VAR i : LONGINT;
  312.   BEGIN (* ReadBytes *)
  313.     i := d.FRead (fh, x, 1, n)
  314.   END ReadBytes;
  315.  
  316.   PROCEDURE ReadString ( fh : d.FileHandlePtr; VAR x : ARRAY OF CHAR );
  317.     VAR ch : CHAR; i : INTEGER;
  318.   BEGIN (* ReadString *)
  319.     i := 0;
  320.     REPEAT
  321.       Read (fh, ch); x [i] := ch; INC (i)
  322.     UNTIL ch = 0X
  323.   END ReadString;
  324.  
  325.   PROCEDURE ReadBool ( fh : d.FileHandlePtr; VAR x : BOOLEAN );
  326.     VAR i : SHORTINT;
  327.   BEGIN (* ReadBool *)
  328.     Read (fh, i); x := (i # 0)
  329.   END ReadBool;
  330.  
  331. <*$CopyArrays-*>
  332. BEGIN (* LoadSetup *)
  333.   COPY (setupDir, setupPath);
  334.   ASSERT (d.AddPart (setupPath, setupFile, PathChars));
  335.   pf := d.Open (setupPath, d.oldFile);
  336.   IF pf # NIL THEN
  337.     ReadBytes (pf, tag, 4);
  338.     IF tag = FPEPF THEN
  339.       Read (pf, c); ver := ORD (c);
  340.       IF ver >= 1 THEN
  341.         FOR i := 0 TO NumTools-1 DO
  342.           ReadString (pf, tools[i].title);
  343.           ReadString (pf, tools[i].command);
  344.           ReadString (pf, tools[i].arguments);
  345.           ReadBool (pf, tools[i].isActive);
  346.           ReadBool (pf, tools[i].hasConsole);
  347.           ReadString (pf, tools[i].console);
  348.           ReadBytes (pf, tools[i].stack, 4)
  349.         END;
  350.         FOR i := 0 TO NumFiles-1 DO
  351.           ReadString (pf, extensions[i])
  352.         END;
  353.       ELSE
  354.         isu.DoNotice
  355.           ( NIL, SYS.ADR (Notice), "Invalid version # for preferences" )
  356.       END
  357.     ELSE
  358.       isu.DoNotice
  359.         ( NIL, SYS.ADR (Notice), "Not a preferences file" )
  360.     END;
  361.     d.OldClose (pf);
  362.   ELSE
  363.     isu.DoNotice
  364.       ( NIL, SYS.ADR (Notice), "Could not open setup file for load" )
  365.   END;
  366. END LoadSetup;
  367.  
  368.  
  369. (*------------------------------------*)
  370. PROCEDURE LoadDefSetup * (defSetup : BOOLEAN);
  371.  
  372.   VAR
  373.     searchPaths : ARRAY 4 OF e.LSTRPTR; baseName : e.LSTRPTR;
  374.     fileName : FileName; path : Path;
  375.  
  376. BEGIN (* LoadDefSetup *)
  377.   searchPaths [0] := SYS.ADR ("S/");
  378.   searchPaths [1] := SYS.ADR ("FPE:S/");
  379.   searchPaths [2] := SYS.ADR ("S:");
  380.   searchPaths [3] := NIL;
  381.   IF defSetup THEN fileName := "Default.fpe"
  382.   ELSE fileName := "Alternate.fpe"
  383.   END;
  384.   IF du.Search (searchPaths, fileName, path) THEN
  385.     IF defSetup THEN COPY (path, DefSetupPath)
  386.     ELSE COPY (path, AltSetupPath)
  387.     END;
  388.     LoadSetup ("", path);
  389.   ELSE
  390.     LoadSetup ("", fileName);
  391.   END;
  392. END LoadDefSetup;
  393.  
  394.  
  395. (*------------------------------------*)
  396. PROCEDURE SaveSetup * ( setupDir, setupFile : ARRAY OF CHAR );
  397.  
  398.   VAR
  399.     setupPath : Path; pf : d.FileHandlePtr;
  400.     tag : LONGINT; i : INTEGER; ver : CHAR;
  401.  
  402.   PROCEDURE Write ( fh : d.FileHandlePtr; x : SYS.BYTE );
  403.     VAR i : LONGINT;
  404.   BEGIN (* Write *)
  405.     i := d.FPutC (fh, ORD (x))
  406.   END Write;
  407.  
  408.   PROCEDURE WriteBytes
  409.     ( fh : d.FileHandlePtr; VAR x : ARRAY OF SYS.BYTE; n : LONGINT );
  410.     VAR i : LONGINT;
  411.   BEGIN (* WriteBytes *)
  412.     i := d.FWrite (fh, x, 1, n)
  413.   END WriteBytes;
  414.  
  415.   PROCEDURE WriteString ( fh : d.FileHandlePtr; x : ARRAY OF CHAR );
  416.   <*$CopyArrays-*>
  417.   BEGIN (* WriteString *)
  418.     WriteBytes (fh, x, str.Length (x)); Write (fh, 0X)
  419.   END WriteString;
  420.  
  421.   PROCEDURE WriteBool ( fh : d.FileHandlePtr; x : BOOLEAN );
  422.     VAR i : SHORTINT;
  423.   BEGIN (* WriteBool *)
  424.     IF x THEN i := 1 ELSE i := 0 END; Write (fh, i)
  425.   END WriteBool;
  426.  
  427. <*$CopyArrays-*>
  428. BEGIN (* SaveSetup *)
  429.   COPY (setupDir, setupPath);
  430.   ASSERT (d.AddPart (setupPath, setupFile, PathChars));
  431.  
  432.   pf := d.Open (setupPath, d.newFile);
  433.   IF pf # NIL THEN
  434.     tag := FPEPF; WriteBytes (pf, tag, 4);
  435.     Write (pf, CHR (PrefsVersion));
  436.  
  437.     FOR i := 0 TO NumTools-1 DO
  438.       WriteString (pf, tools[i].title);
  439.       WriteString (pf, tools[i].command);
  440.       WriteString (pf, tools[i].arguments);
  441.       WriteBool (pf, tools[i].isActive);
  442.       WriteBool (pf, tools[i].hasConsole);
  443.       WriteString (pf, tools[i].console);
  444.       WriteBytes (pf, tools[i].stack, 4)
  445.     END;
  446.     FOR i := 0 TO NumFiles-1 DO
  447.       WriteString (pf, extensions[i])
  448.     END;
  449.  
  450.     d.OldClose (pf);
  451.   ELSE
  452.     isu.DoNotice
  453.       (NIL, SYS.ADR (Notice), "Could not open setup file for save")
  454.   END
  455. END SaveSetup;
  456.  
  457.  
  458. (*------------------------------------*)
  459. PROCEDURE SaveDefSetup * (defSetup : BOOLEAN);
  460.  
  461. BEGIN (* SaveDefSetup *)
  462.   IF defSetup THEN
  463.     SaveSetup ("", DefSetupPath);
  464.   ELSE
  465.     SaveSetup ("", AltSetupPath)
  466.   END
  467. END SaveDefSetup;
  468.  
  469.  
  470. (*------------------------------------*)
  471. PROCEDURE DoTool * ( which : INTEGER );
  472.  
  473.   CONST
  474.     NoInput   = "Failed to open input for tool";
  475.     NoOutput  = "Failed to open output for tool";
  476.     LoadError = "Error loading tool";
  477.  
  478.   VAR
  479.     tempCommand, tempArgs : Path;
  480.     console : Console;
  481.     result : LONGINT;
  482.  
  483.   PROCEDURE Expand
  484.     ( VAR newString : ARRAY OF CHAR; oldString : ARRAY OF CHAR );
  485.  
  486.     VAR oldIndex, newIndex, file : INTEGER;
  487.  
  488.   <*$CopyArrays-*>
  489.   BEGIN (* Expand *)
  490.     oldIndex := 0;
  491.     newIndex := 0;
  492.     newString [0] := 0X;
  493.     LOOP
  494.       IF
  495.         (newIndex >= (LEN(newString) - 1)) OR (oldString [oldIndex] = 0X)
  496.       THEN
  497.         newString [newIndex] := 0X; EXIT
  498.       END; (* IF *)
  499.       IF oldString [oldIndex] = "!" THEN
  500.         INC( oldIndex );
  501.         CASE oldString [oldIndex] OF
  502.           "D" :
  503.             newString [newIndex] := 0X;
  504.             str.Append (currentPath, newString);
  505.             newIndex := SHORT (str.Length (newString));
  506.           |
  507.           "F" :
  508.             newString [newIndex] := 0X;
  509.             file := 0;
  510.             WHILE file < NumFiles DO
  511.               IF file IN currentFiles THEN
  512.                 str.Append (currentModule.modName, newString);
  513.                 str.Append (".", newString);
  514.                 str.Append (extensions [file], newString);
  515.                 str.Append (" ", newString);
  516.               END; (* IF *)
  517.               INC (file)
  518.             END; (* WHILE *)
  519.             newIndex := SHORT (str.Length (newString));
  520.           |
  521.           "M" :
  522.             newString [newIndex] := 0X;
  523.             str.Append (currentModule.modName, newString);
  524.             newIndex := SHORT (str.Length (newString));
  525.           |
  526.           "P" :
  527.             newString [newIndex] := 0X;
  528.             str.Append (programName, newString);
  529.             newIndex := SHORT (str.Length (newString));
  530.           |
  531.         ELSE
  532.           newString [newIndex] := oldString [oldIndex];
  533.           INC( newIndex );
  534.         END; (* CASE oldString *)
  535.         INC( oldIndex );
  536.       ELSE
  537.         newString [newIndex] := oldString [oldIndex];
  538.         INC( oldIndex ); INC( newIndex )
  539.       END;
  540.     END; (* LOOP *)
  541.   END Expand;
  542.  
  543.   (*------------------------------------*)
  544.   PROCEDURE DosCall ();
  545.  
  546.     VAR file : d.FileHandlePtr;
  547.  
  548.   BEGIN (* DosCall *)
  549.     IF tools [which].hasConsole THEN
  550.       file := d.Open (console, d.oldFile);
  551.       IF file = NIL THEN
  552.         isu.DoNotice (NIL, SYS.ADR (Notice), "Could not open console");
  553.         RETURN
  554.       END
  555.     ELSE
  556.       file := NIL
  557.     END;
  558.  
  559.     str.Append (" ", tempCommand);
  560.     str.Append (tempArgs, tempCommand);
  561.     IF
  562.       d.SystemTags
  563.         ( tempCommand,
  564.           d.sysInput,     file,
  565.           d.sysOutput,    NIL,
  566.           d.sysAsynch,    d.DOSTRUE,
  567.           d.npStackSize,  tools [which].stack,
  568.           u.done )
  569.       = -1
  570.     THEN
  571.       IF file # NIL THEN d.OldClose (file) END;
  572.       isu.DoNotice (NIL, SYS.ADR (Notice), LoadError)
  573.     END;
  574.   END DosCall;
  575.  
  576. BEGIN (* DoTool *)
  577.   Expand (tempCommand, tools [which].command);
  578.   Expand (tempArgs, tools [which].arguments);
  579.   IF tools [which].hasConsole THEN
  580.     Expand (console, tools [which].console);
  581.   END;
  582.   DosCall ()
  583. END DoTool;
  584.  
  585.  
  586. (*------------------------------------*)
  587. PROCEDURE* CleanupProc (VAR rc : LONGINT);
  588.  
  589. BEGIN (* CleanupProc *)
  590.   IF currentDir # NIL THEN d.UnLock (currentDir) END
  591. END CleanupProc;
  592.  
  593.  
  594. (*------------------------------------*)
  595. PROCEDURE Init * ();
  596.  
  597. BEGIN (* Init *)
  598.   Kernel.SetCleanup (CleanupProc);
  599.  
  600.   tools [0].title := "Button0";
  601.   tools [1].title := "Button1";
  602.   tools [2].title := "Button2";
  603.   tools [3].title := "Button3";
  604.   tools [4].title := "Button4";
  605.   tools [5].title := "Button5";
  606.   tools [6].title := "Button6";
  607.   tools [7].title := "Button7";
  608.   tools [8].title := "Button8";
  609.   tools [9].title := "Button9";
  610.   tools [10].title := "Button10";
  611.   tools [11].title := "Button11";
  612.   extensions [0] := "ex0";
  613.   extensions [1] := "ex1";
  614.   extensions [2] := "ex2";
  615.   extensions [3] := "ex3";
  616.  
  617.   es.NewList (moduleList);
  618.   LoadDefSetup (TRUE);
  619. END Init;
  620.  
  621. BEGIN
  622.   DefSetupPath := "FPE:S/Default.fpe"; AltSetupPath := "FPE:S/Alternate.fpe"
  623. END Data.
  624.  
  625. (***************************************************************************
  626.  
  627.   $Log: Data.mod $
  628.   Revision 1.10  1995/01/26  00:15:33  fjc
  629.   - Release 1.5
  630.  
  631.   Revision 1.9  1994/09/25  18:20:54  fjc
  632.   - Uses new syntax for external code declarations
  633.  
  634.   Revision 1.8  1994/08/08  16:13:09  fjc
  635.   Release 1.4
  636.  
  637.   Revision 1.7  1994/06/21  22:03:49  fjc
  638.   - Added code to conditionally use V37+ dos.library instead
  639.     of arp.library.
  640.  
  641.   Revision 1.6  1994/06/17  17:26:27  fjc
  642.   - Updated for release
  643.  
  644.   Revision 1.5  1994/06/09  13:33:46  fjc
  645.   - Incorporated changes in Amiga interface
  646.  
  647.   Revision 1.4  1994/06/04  23:49:52  fjc
  648.   - Changed to use new Amiga interface
  649.  
  650.   Revision 1.3  1994/05/12  21:26:09  fjc
  651.   - Prepared for release
  652.  
  653.   Revision 1.2  1994/01/24  14:33:33  fjc
  654.   Changed version control header
  655.  
  656.   Revision 1.1  1994/01/15  17:32:38  fjc
  657.   Start of revision control
  658.  
  659. ***************************************************************************)
  660.  
  661.  
  662.