|##########| |#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.