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