Global Amiga Experience/globalamigaexperience.iso/compressed/development/clusterdemo.dms/clusterdemo.adf/Modules.lha/modules/txt/DosSupport.def

Text File | 1994-05-25 | 20KB | 587 lines

|##########|
|#MAGIC   #|CLABLMBE
|#PROJECT #|"ImportHelp"
|#PATHS   #|"StdProject"
|#FLAGS   #|xx---x--x---x-x-----------------
|#USERSW  #|--------------------------------
|#USERMASK#|--------------------------------
|#SWITCHES#|xx-x-x----------
|##########|
DEFINITION MODULE DosSupport;

FROM System         IMPORT Regs;
FROM Exceptions     IMPORT RangeViolation;
FROM Resources      IMPORT NotEnoughMemory,ContextPtr;
FROM Lists          IMPORT BiLists,TextLists;
FROM Trees          IMPORT StdTrees;
                    IMPORT Dos;

TYPE
  DrivePtr    = POINTER TO Drive;
  DirNodePtr  = POINTER TO DirNode;
  DirTreePtr  = POINTER TO DirTree;

DEFINITION MODULE DriveLists = TextLists(DrivePtr);

DEFINITION MODULE DirLists   = BiLists(DirNodePtr);

DEFINITION MODULE DirTrees   = StdTrees(DirTreePtr);

TYPE
  Drive         = DriveLists.TextNode;
  DriveList     = RECORD OF DriveLists.TextList
                    context : ContextPtr;
                  END;

  FileData      = RECORD
                    dir    : BOOLEAN;  | Flag, ob Directory
                    name,
                    comment: CLASSPTR TO STRING;
                    flags  : Dos.ProtectionFlagSet;
                    date   : Dos.Date;
                    length : LONGINT;  | länge des Files;
                  END;
  DirData       = RECORD
                    size,
                    fullSize    : LONGINT;
                    entries,
                    fullEntries,
                    dirs,
                    fullDirs    : INTEGER;
                  END;
  DirDataPtr    = POINTER TO DirData;
  DirNode       = RECORD OF DirLists.BiNode;
                    data : FileData;
                  END;
  DirTree       = RECORD OF DirTrees.Leaf;
                    data        : FileData;
                    dirData     : DirDataPtr;
                  END;
  Selection     = (selectFiles,selectDirs);
  DirSelectType = SET OF Selection;
  DirList       = RECORD OF DirLists.BiList
                    context : ContextPtr;
                    entries,
                    dirs    : INTEGER;
                    size    : LONGINT;
                  END;

  FileErrors    = (ok,unknownError,objectInUse,objectExists,objectNotFound,
                   objectWrongType,diskNotValidated,writeProtected,
                   renameAcrossDevices,directoryNotEmpty,deviceNotMounted,
                   seekError,diskFull,deleteProtected,readProtected,
                   notADosDisk);

  FileTexts   = ARRAY FileErrors OF POINTER TO STRING;


CONST
  FileErrTexts = FileTexts; | Fehlermeldungen im Klartext

(*============== Directory ===================================================*)

TYPE
  PutProc  = PROCEDURE(data : FileData);

|
|  Funktion   : Untersucht ein Verzeichnis auf die verschiedenen Einträge
|               und ruft für jeden Eintrag für den das Pattern stimmt eine
|               übergebene Prozedur auf, der die Eintragsdaten übergeben
|               werden.
|  Parameter  : put     <- Prozedur, der die Eintragsdaten übergeben werden,
|                          und die mit ihnen machen kann was sie will
|               path    <- Pfad des zu untersuchenden Verzeichnisses
|               pattern <- Pattern, für die Einträge, für die "put"
|                          aufgerufen werden soll
|               type    <- Gibt an, ob Files und/oder Verzeichnisse
|                          bearbeitet werden sollen
|
|tested
PROCEDURE ScanDir(    put        : PutProc;
                  REF path       : STRING;
                  REF pattern    : STRING:="#?";
                      type       := DirSelectType:{selectFiles,selectDirs});


|
|  Funktion  : Untersucht ein File/Directory und gibt eine einen FileData-
|              Block zurück.
|  Parameter : data        -> Datablock;
|              path       <-  Pfad des Files/Directorys, das untersucht
|                             werden soll
| tested
METHOD Get(VAR data       : FileData;
           REF path       : STRING)

|
|  Funktion  : Gibt eine DirList frei.
|  Parameter : list     <- freizugebende Liste.
|
| tested
METHOD Delete(VAR list : DirList);


|
|  Funktion  : Untersucht ein Directory und gibt eine Liste der Einträge
|              zurück
|  Parameter : list        -> Liste
|              path       <-  Pfad des Directorys, das untersucht werden soll
|              pattern    <-  Dos-Pattern der Einträge, die in die Liste
|                             aufgenommen werden soll
|              type       <-  Nach was gesucht werden soll
|
| tested
METHOD Get(VAR list       : DirList;
           REF path       : STRING;
           REF pattern    : STRING:="#?";
               type       := DirSelectType:{selectDirs,selectFiles};
               context    : ContextPtr := NIL);


|
|  Funktion  : Gibt einen DirTree frei.
|  Parameter : tree     <- freizugebender Baum.
|

METHOD Delete(VAR tree : DirTreePtr);

|
|  Funktion  : Untersucht ein Directory und die darin enthaltenen und gibt
|              einen Baum der Einträge zurück.
|  Parameter : tree        -> Baum
|              path       <-  Pfad des Directorys, das untersucht werden soll
|              pattern    <-  Dos-Pattern der Einträge, die in die Liste
|                             aufgenommen werden soll
|              type       <-  Nach was gesucht werden soll
|
| tested
METHOD Get(VAR tree       : DirTreePtr;
           REF path       : STRING;
           REF pattern    : STRING:="#?";
               type       := DirSelectType:{selectDirs,selectFiles};
               context    :  ContextPtr:=NIL);

TYPE
  CmpProc = PROCEDURE(REF d1,d2 : FileData):BOOLEAN;

PROCEDURE byName(REF d1,d2 : FileData):BOOLEAN; | Sortiert nach Namen

PROCEDURE bySize(REF d1,d2 : FileData):BOOLEAN; | Sortiert nach Länge

PROCEDURE byDate(REF d1,d2 : FileData):BOOLEAN; | Sortiert nach Datum


|
|  Funktion  :  Sortiert eine DirList nach obenstehenden Kriterien
|  Parameter :  list <-> Liste die sortiert werden soll.
|               cmp  <-  Vergleichsprozedur, nach der aufsteigend sortiert
|                        werden soll.
| tested
METHOD Sort(VAR list : DirList;cmp : CmpProc);


|
|  Funktion  :  Sortiert einen DirTree nach obenstehenden Kriterien
|  Parameter :  father <-  Knoten, von dem ab sortiert werden soll
|               cmp    <-  Vergleichsprozedur, nach der aufsteigend sortiert
|                          werden soll.
| tested
METHOD Sort(father : DirTreePtr;cmp : CmpProc := byName);


|
|  Funktion   : Prüft ob ein File/Verzeichnis, dessen Namen übergeben worden,
|               ist, existiert.
|  Parameter  : name  <- Name des Verzeichnisses
|               retry <- Flag, ob im Falle, das der Name auf einem nicht im
|                        Laufwerk liegenden Volume sich befindet, ein System-
|                        requester erst zum einlegen auffordern soll.
|                     -> TRUE wenn das Verzeichnis/File existiert.
| tested
PROCEDURE Exists(REF name : STRING;retry  : BOOLEAN := FALSE ):BOOLEAN;


|
|  Funktion   : Prüft ob ein File/Verzeichnis, ein File ist.
|  Parameter  : name <- Name des Files/Verzeichnisses.
|                    -> TRUE wenn es sich um ein File handelt.
|
| tested
PROCEDURE IsFile(REF name : STRING):BOOLEAN;

|
|  Funktion   : Füllt eine übergebene Liste mit Einträgen der angeschlossenen
|               Laufwerke (Drive.special = TRUE), sowie der logischen
|               Laufwerke (Drive.special = FALSE).
|  Parameter  : list     <-> Liste die gefüllt werden soll.
|               physical <-  Flag, das angibt ob nur physikalische Laufwerke
|                            in die Liste aufgenommen werden sollen
|
| tested
METHOD Get(VAR list     : DriveList;
               physical : BOOLEAN := TRUE;
               context  : ContextPtr := NIL);


|
|  Funktion   : Gibt eine gefüllte DriveList wieder frei.
|  Parameter  : list  <- Liste die freigegeben werden soll
|
| tested
METHOD Delete(VAR list : DriveList);

GROUP
  DirGrp  = DirTree,DirTreePtr,byName,bySize,byDate,DirNodePtr,DirNode,
            Selection,DirSelectType,Drive,DriveList,DrivePtr,DirList,
            ScanDir,FileData;


(*============== Path ========================================================*)


|
|  Funktion   : Zerlegt einen Filename in Pfad,name und Erweiterung
|               (Pfad/Name.Erweiterung)
|  Parameter  : path     <-  Beim Aufruf der gesammte FileNamen
|                        ->  nach Prozedurende der reine Pfad des Files.
|               name      -> Name des Files.
|               extension -> Erweiterung nach "." am Namenende z.B. ".iff"
|
| tested
PROCEDURE SplitName(VAR path,name,extension : STRING);


|
|  Funktion  : Zerlegt einen String mit kombiniertem Pfad+FileNamen in einen
|              getrennten Pfad und einen FileNamen
|  Parameter : path    <-  Pfad kombiniert
|                      ->  reiner Pfad
|              name    -> abgtrennter Name
|tested
PROCEDURE GetPathName(VAR path IN A0,name IN A1 : STRING);

|
|  Funktion  : Gibt den, in einem Pfad enthaltenen Dateinamen, ohne angehängte
|              Erweiterung zurück
|  Parameter : path    <- Pfad
|                      -> Name
|tested
$$OwnHeap:=TRUE
PROCEDURE Name(REF path IN A0 : STRING):STRING;

|
|  Funktion  : Gibt den, in einem Pfad enthaltenen Dateinamen, inklusive
|              einer eventuell angehängte Erweiterung zurück.
|  Parameter : path    <- Pfad
|                      -> Name
|tested
$$OwnHeap:=TRUE
PROCEDURE ExtendedName(REF path IN A0 : STRING):STRING;

|
|  Funktion  : Gibt den, in einem Pfad enthaltenen reinen Pfad zurück
|  Parameter : fullPath    <- kompletter Pfad, mit Dateinamen
|                          -> reiner Pfad
|tested
$$OwnHeap:=TRUE;
PROCEDURE Path(REF fullPath IN A0 : STRING):STRING;

|
|  Funktion  : Gibt die, in einem Namen enthaltene Erweiterung zurück
|  Parameter : name    <- Name
|                      -> Erweiterung
|tested
$$OwnHeap:=TRUE
PROCEDURE Extension(REF name IN A0 : STRING):STRING;

|
|  Funktion  : Fügt an einen Pfad ein Unterverzeichnis an
|  Parameter : path    <-  Pfad an den Subdir angefügt werden soll
|                      ->  Pfad mit angehängtem SubDir
|              subDir  <-  Namen des Verzeichnis, das angefügtg werden soll
|  Bemerkung : Beim anfügen wird automatisch ein "/" eingefügt wenn nötig
|
|tested
PROCEDURE GetSubDir(VAR path : STRING;REF subDir : STRING);

|
|  Funktion  : Wie GetSubDir, jedoch als Funktion
|
|tested
$$OwnHeap:=TRUE;
PROCEDURE SubDir(REF path,subDir : STRING):STRING;


|
|  Funktion  : Liefert den Pfad des übergeordneten Directorys
|  Parameter : pfad    <-  Pfad von dem das ParentDirectory ermittelt werden
|                          soll.
|                       -> Pfad des übergeordneten Verzeichnises
|tested
PROCEDURE GetParentDir(VAR path IN A0 : STRING);

|
|  Funktion  : Wie GetParentDir, jedoch als Funktion
|
|tested
$$OwnHeap:=TRUE
PROCEDURE ParentDir(REF path IN A0 : STRING):STRING;

|
| Funktion  : Setzt aus einem Pfad, einem Namen und einer Erweiterung einen
|             kompletten Pfad zusammen.
| Parameter : path      <-  einzelner Pfad
|                       ->  zusammengesetzter Pfad
|             name      <-  Name
|             extension <-  Erweiterung
|tested
PROCEDURE BuildName(VAR path : STRING;REF name,extension : STRING);

|
|  Funktion  : Wie BuildName, jedoch als Funktion
|
|tested
$$OwnHeap:=TRUE
PROCEDURE FName(REF path,name,extension : STRING):STRING;


|
|  Funktion  : Gibt den kompletten Pfad eines Unterverzeichnises
|  Parameter : smallPath <-  Name des Unterverzeichnises
|              path       -> Kompletter Pfad
|
|tested
PROCEDURE GetFullPath(REF smallPath : STRING;VAR path : STRING);

|
|  Funktion  : Wie GetFullPath, jedoch als Funktion
|
|tested
$$OwnHeap:=TRUE
PROCEDURE FullPath(REF smallPath : STRING):STRING;

|  Funktion  : Setzt aus den übergebenen Werten einen Pfad zusammen, wie man
|              ihn zum öffnen eines Consol-Fensters benötigt.
|  Parameter : title    <-  Titel des Fensters
|                       ->  zusammengesetzter Pfad
|              leftEdge <-  x Position der linken, oberen Ecke des Fensters
|              topEdge  <-  y Position der linken, oberen Ecke des Fensters
|              width    <-  Breite des Fensters
|              heigth   <-  Höhe des Fensters
|tested
PROCEDURE BuildConsolePath(VAR title : STRING;leftEdge,topEdge,width,height : CARDINAL);

|
|  Funktion  : Wie BuilConsolePath, jedoch als Funktion
|
|tested
$$OwnHeap:=TRUE
PROCEDURE ConsolePath(REF title : STRING;leftEdge,topEdge,width,height : CARDINAL):STRING;



GROUP
  PathGrp   = SplitName,GetFullPath,GetPathName,SubDir,GetSubDir,GetParentDir,
              ParentDir,BuildName,FName,FullPath,BuildConsolePath,ConsolePath,
              Path,Name,ExtendedName,Extension;


(*======================= Global files =======================================*)

|
|  Funktion  : Löscht ein File/Verzeichnis.
|  Parameter : name    <- Pfad des Files
|              all     <- Gibt an, ob auch Unterverzeichnisse rekursiv
|                         gelöscht werden sollen.
|
|tested
PROCEDURE Delete(REF name : STRING;all : BOOLEAN := FALSE);


|
|  Funktion  : Erzeugt ein Verzeichnis.
|  Parameter : name  <- Name des neuen Verzeichnisses
|
|tested
PROCEDURE MakeDir(REF name : STRING);

|
|  Funktion  : Benennt ein File um.
|  Parameter : oldName <- Alter Name des Files
|              newName <- Neuer Name des Files
|  Bemerkung : newName muß sich auf dem selben Gerät befinden wie OldPath.
|
|tested
PROCEDURE Rename(REF oldName,
                     newName  : STRING)


TYPE
  CopyProc    = PROCEDURE(VAR name : STRING;dir : BOOLEAN);
  CheckProc   = PROCEDURE(REF path,name : STRING):BOOLEAN;

|
|  Funktion  : Kopiert ein oder mehrere Files oder Verzeichnisse, der Quell-
|              pfad, darf dabei ein Dos-Pattern enthalten z.B. "#?.(def|mod)
|  Parameter : src   <- Quellpfad
|              dest  <- Zielpfad
|              all   <- Flag, das bestimmt, ob bei der Kopie eines
|                       Verzeichnisses, darin liegende Verzeichnisse rekursiv
|                       mitkopiert werden sollen
|              overWrite
|                    <- Prozedur, der der Pfad und der Name des Files über-
|                       geben wird, im Falle das ein File gleichen Namens im
|                       Zielverzeichnis schon enthalten ist. Sie muß einen
|                       BOOLEAN-Wert zurückgeben, ob das File überschrieben
|                       werden soll. Ist existCheck = NIL, werden evemtuell
|                       existierende Files gleichen Namens überschrieben.
|                       Achtung, von "overWrite" darf weder Pfad noch Name
|                       verändert werden.
|              apply <- Prozedur, der der Name des als nächsten zu
|                       kopierenden Files/Verzeichnisses, sowie ein Flag, das
|                       angibt, ob es sich um ein Verzeichnis handelt,
|                       übergeben wird. Verändert "apply" den Namen, wird
|                       beim schreiben des Files dieser neue Namen verwendet
|              clone <- Flag, ob beim Kopieren auch das Datum mitkopiert werden
|                       soll.
|tested
PROCEDURE Copy(src,
               dest         : STRING;
               all          : BOOLEAN   :=FALSE;
               overWrite    : CheckProc :=NIL;
               apply        : CopyProc  :=NIL;
               clone        : BOOLEAN   :=FALSE);

|
|  Funktion   : Verschiebt ein File/Verzeichnis in ein anderes Verzeichnis,
|               auch von einem Laufwerk auf ein anderes.
|  Parameter  : src  <- File/Verzeichnis, das verschoben werden soll
|               dest <- Ziel der Operation
|
|tested
PROCEDURE Move(REF src,dest : STRING);


TYPE
  SearchProc = PROCEDURE(REF path : STRING;data : FileData);

|
|  Funktion   : Sucht ein File/Verzeichnis im Verzeichnis "startDir" und
|               dessen Unterverzeichnissen. Wird ein Eintrag mit passendem
|               Namen gefunden, wird eine Prozedur aufgerufen, der der Pfad
|               dieses Eintrags, sowie sein FileData-Block übergeben wird.
|  Parameter :  startDir <- Name des Verzeichnisses, in dem gesucht werden
|                           soll.
|               name     <- Name oder Pattern, nach dem gesucht werden soll
|               react    <- Prozedur, die beim Auffinden des gesuchten Namens
|                           aufgerufen wird.
|
PROCEDURE Search(REF startDir,name : STRING;react : SearchProc);


TYPE
  WorkProc  = PROCEDURE(REF path,name : STRING;data : FileData);

|
|  Funktion  :  Geht eine Verzeichnisstruktur rekursiv durch, und ruft für
|               jeden Eintrag die Prozedur "apply" auf.
|  Parameter :  path      <- Pfad des Verzeichnisses, das bearbeitet werden
|                            soll.
|               pattern   <- Pattern für die Einträge, für die "apply"
|                            aufgerufen werden soll.
|               recursive <- Gibt an, ob auch in dem Verzeichnis liegende
|                            Unterverzeichnisse rekursiv untersucht werden
|                            sollen.
|               apply     <- Prozedur, die für jeden Eintrag aufgerufen wird,
|                            auf den "pattern" paßt. Ihr wird der Name des
|                            Eintrags, sein Pfad sowie dessen FileData-Block
|                            übergeben. Sie darf den Pfad und den Namen nicht
|                            verändern.
|               type      <- Set, ob nur Files, nur Directories oder beide
|                            bearbeitet werden sollen.
|               scanFirst <- Zuerst werden alle in Frage kommenden Einträge
|                            ausgewählt, und danach die Prozedur auf jeden
|                            einzelnen ausgeführt. Sinnvoll, beispielsweise,
|                            falls die Bearbeitungsprozedur etwas an der
|                            Verzeichnisstruktur ändert, oder gar diese löscht.
|
|tested
PROCEDURE WorkOnFiles(REF path,pattern : STRING;
                          apply        : WorkProc;
                          recursive    : BOOLEAN:=FALSE;
                          type         := DirSelectType:{selectDirs,selectFiles};
                          scanFirst    : BOOLEAN:=FALSE);

|
|  Funktion  : Setzt Protectionbits für ein File
|  Parameter : name    <- Name des Files
|              flags   <- Neue Protectionbits
|tested
PROCEDURE SetProtect(REF name  : STRING;
                         flags : Dos.ProtectionFlagSet);


|
|  Funktion  : Ließt Protectionbits eines Files
|  Parameter : name    <- Name des Files
|              flags   -> Flags des Files
|tested
PROCEDURE GetProtect(REF name  : STRING;
                     VAR flags : Dos.ProtectionFlagSet);


(*=========== Utilities ======================================================*)

|
|  Funktion   : Leitet Dos-Requester auf den Screen mit dem angegebenen
|               Fenster um.
|
TYPE
  WindowPtr = DEFERRED POINTER Intuition.WindowPtr;

|tested
PROCEDURE GetSystemRequest(REF window : WindowPtr);

|
|  Funktion   : Sorgt dafür, daß Dos-Requester wieder auf der Screen
|               erscheinen, die beim Programmbegin eingetragen war.
|tested
PROCEDURE RestoreSystemRequest;

|
|  Funktion   : Sorgt dafür, daß im Falle eines vom User korigierbaren Dos-
|               Errors (z.B. Disk is writeProtected) kein Systemrequester
|               erscheint, sondern die Fehlermeldung unmittelbar vom Programm
|               behandelt werden kann.
|tested
PROCEDURE SysReqOff;

|
|  Funktion   : Sorgt dafür, daß Dos-Errors wieder normal behndelt werden.
|  Bemerkung  : Rufen Sie SysReqOn nicht auf, wenn Sie davor nocht SysReqOff
|               benutz haben.
|tested
PROCEDURE SysReqOn;

|
|  Funktion   : Wandelt eine Dos-Fehlernummer in einen FileError um
|  Parameter  : error <- DosFehlernummer
|
PROCEDURE FileError2(error : LONGINT):FileErrors;


|
|  Funktion  : Gibt den zuletzt aufgetretenen Dos-Fehler als FileError zurück
|
|tested
(* $E-*)
PROCEDURE FileError():FileErrors;

GROUP
  GlobalGrp   = Delete,Rename,Copy,WorkOnFiles,SetProtect,GetProtect,
                FileError,FileError2,FileErrors,FileErrTexts,Search;

  All         = DirGrp,PathGrp,GlobalGrp;

END DosSupport.