home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / program / m2posx02 / file.dpp < prev    next >
Encoding:
Modula Definition  |  1993-10-23  |  25.5 KB  |  510 lines
  1. DEFINITION MODULE file;
  2.  
  3. (*****************************************************************************)
  4. (* Funktionen, die ``normale'' Dateien bearbeiten.                           *)
  5. (*                                                                           *)
  6. (* Ein Fehler ist immer dann aufgetreten, wenn bei Funktionen mit Typ INTEGER*)
  7. (* ein negativer Wert zurueckgegeben wird.                                   *)
  8. (* Die genaue Fehlerursache kann bei Bedarf ueber "err.errno" und die ent-   *)
  9. (* sprechenden Konstanten ermittelt werden. Die Funktionen veraendern "errno"*)
  10. (* nur dann, wenn ein Fehler aufgetreten ist, bei erfolgreicher Ausfuehrung  *)
  11. (* wird "errno" nicht veraendert.                                            *)
  12. (*                                                                           *)
  13. (* "GEMDOS":                                                                 *)
  14. (* Die Eigenschaften der Funktionen unter dem ``blanken'' "GEMDOS" sind z.T. *)
  15. (* stark eingeschraenkt; unter dem Stichwort "GEMDOS" ist deswegen immer     *)
  16. (* angegeben, in wieweit die Funktion emuliert werden kann. Ist MiNT-Unter-  *)
  17. (* stuetzung angegeben, so ist unter der Betriebssystemerweiterung "MiNT"    *)
  18. (* eine bessere Unterstuetzung der Funktionen zu erwarten; wie weit diese    *)
  19. (* allerdings geht, haengt vom verwendeten Dateisystem ab.                   *)
  20. (*                                                                           *)
  21. (* Intern sind alle Pfadangaben auf die Laenge von 'PathName' begrenzt. Ist  *)
  22. (* ein Pfad laenger (evtl. nach der Umwandlung vom "*IX"-Stil in den "DOS"-  *)
  23. (* Stil), wird ein Fehler gemeldet, und 'errno' auf 'ENAMETOOLONG' gesetzt.  *)
  24. (* --------------------------------------------------------------------------*)
  25. (* 12-Feb-93, Holger Kleinschmidt                                            *)
  26. (*****************************************************************************)
  27.  
  28. FROM SYSTEM IMPORT
  29. (* TYPE *) ADDRESS;
  30.  
  31. FROM types IMPORT
  32. (* TYPE *) SIGNEDWORD, UNSIGNEDWORD, UNSIGNEDLONG, SIGNEDLONG, uidT, gidT,
  33.            inoT, timeT, offT, sizeT, ssizeT, devT, nlinkT;
  34.  
  35. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  36.  
  37. (*======= "stat()", "open()", "creat()", "umask()", "chmod()" ===============*)
  38.  
  39. TYPE
  40. #if reverse_set
  41.   FileModes = (
  42.     Type15,   (* = 100000B *)
  43.     Type14,   (* = 040000B *)
  44.     Type13,   (* = 020000B *)
  45.     Type12,   (* = 010000B *)
  46.  
  47.     sISUID,   (* = 004000B, effektive Benutzer-ID bei Ausfuehrung setzen *)
  48.     sISGID,   (* = 002000B, effektive Gruppen-ID bei Ausfuehrung setzen *)
  49.     sISVTX,   (* = 001000B  reserviert, nicht POSIX *)
  50.  
  51.     sIRUSR,   (* = 000400B, Besitzer: Leseberechtigung *)
  52.     sIWUSR,   (* = 000200B, Besitzer: Schreibberechtigung *)
  53.     sIXUSR,   (* = 000100B, Besitzer: Ausfuehr/Suchberechtigung *)
  54.     sIRGRP,   (* = 000040B, Gruppe  : Leseberechtigung *)
  55.     sIWGRP,   (* = 000020B, Gruppe  : Schreibberechtigung *)
  56.     sIXGRP,   (* = 000010B, Gruppe  : Ausfuehr/Suchberechtigung *)
  57.     sIROTH,   (* = 000004B, Andere  : Leseberechtigung *)
  58.     sIWOTH,   (* = 000002B, Andere  : Schreibberechtigung *)
  59.     sIXOTH    (* = 000001B, Andere  : Ausfuehr/Suchberechtigung *)
  60.   );
  61. #else
  62.   FileModes = (
  63.     sIXOTH,   (* = 000001B, Andere  : Ausfuehr/Suchberechtigung *)
  64.     sIWOTH,   (* = 000002B, Andere  : Schreibberechtigung *)
  65.     sIROTH,   (* = 000004B, Andere  : Leseberechtigung *)
  66.     sIXGRP,   (* = 000010B, Gruppe  : Ausfuehr/Suchberechtigung *)
  67.     sIWGRP,   (* = 000020B, Gruppe  : Schreibberechtigung *)
  68.     sIRGRP,   (* = 000040B, Gruppe  : Leseberechtigung *)
  69.     sIXUSR,   (* = 000100B, Besitzer: Ausfuehr/Suchberechtigung *)
  70.     sIWUSR,   (* = 000200B, Besitzer: Schreibberechtigung *)
  71.     sIRUSR,   (* = 000400B, Besitzer: Leseberechtigung *)
  72.  
  73.     sISVTX,   (* = 001000B  reserviert, nicht POSIX *)
  74.     sISGID,   (* = 002000B, effektive Gruppen-ID bei Ausfuehrung setzen *)
  75.     sISUID,   (* = 004000B, effektive Benutzer-ID bei Ausfuehrung setzen *)
  76.  
  77.     Type12,   (* = 010000B *)
  78.     Type13,   (* = 020000B *)
  79.     Type14,   (* = 040000B *)
  80.     Type15    (* = 100000B *)
  81.   );
  82. #endif
  83.   modeT = PACKEDSET OF FileModes;
  84.  
  85.  
  86. CONST
  87.   sIRWXU = modeT{sIRUSR, sIWUSR, sIXUSR};
  88.   sIRWXG = modeT{sIRGRP, sIWGRP, sIXGRP};
  89.   sIRWXO = modeT{sIROTH, sIWOTH, sIXOTH};
  90.  
  91. (* Die folgenden Konstanten sind nicht POSIX: *)
  92. CONST
  93. #if reverse_set
  94.   sIFMT  = modeT{Type15..Type12};         (* 170000B, Maske fuer Dateityp *)
  95. #else
  96.   sIFMT  = modeT{Type12..Type15};         (* 170000B, Maske fuer Dateityp *)
  97. #endif
  98.   sIFCHR = modeT{Type13};                 (* 020000B, zeichenor. Geraet *)
  99.   sIFDIR = modeT{Type14};                 (* 040000B, Verzeichnis *)
  100.   sIFBLK = modeT{Type13, Type14};         (* 060000B, blockor. Geraet *)
  101.   sIFREG = modeT{Type15};                 (* 100000B, normale Datei *)
  102.   sIFIFO = modeT{Type13, Type15};         (* 120000B, Pipe *)
  103.   sIFLNK = modeT{Type13, Type14, Type15}; (* 160000B, symb. Link, *)
  104.  
  105. (* IF st.stMode * sIFMT = sIFCHR THEN
  106.  *           ...
  107.  *)
  108.  
  109.  
  110. TYPE
  111.   StatRec = RECORD
  112.     stMode  : modeT;    (* Dateityp & Zugriffsberechtigung *)
  113.     stIno   : inoT;     (* INODE, zus. mit 'stDev' eindeutiger Index *)
  114.     stDev   : devT;     (* zustaendiges Geraet *)
  115.     stNlink : nlinkT;   (* Anzahl der Links *)
  116.     stUid   : uidT;     (* Benutzerkennung des Besitzers *)
  117.     stGid   : gidT;     (* Gruppenkennung des Besitzers *)
  118.     stSize  : offT;     (* Dateilaenge in Bytes *)
  119.     stAtime : timeT;    (* Datum/Zeit des letzten Dateizugriffs *)
  120.     stMtime : timeT;    (* Datum/Zeit der letzten Dateiveraenderung *)
  121.     stCtime : timeT;    (* Datum/Zeit der letzten INODE-Aenderung *)
  122.   END;
  123.  
  124. (*======================= "access()" ========================================*)
  125.  
  126. TYPE
  127. #if reverse_set
  128.   AccessModes = (
  129.     Access15,Access14,Access13,Access12,Access11, (* --> keine 8-Bit-Menge *)
  130.     Access10,Access9, Access8, Access7,
  131.     Access6, Access5, Access4, Access3,
  132.     rOK,        (* = 0004H, Leseberechtigung *)
  133.     wOK,        (* = 0002H, Schreibberechtigung *)
  134.     xOK         (* = 0001H, Ausfuehr/Suchberechtigung *)
  135.   );
  136. #else
  137.   AccessModes = (
  138.     xOK,        (* = 0001H, Ausfuehr/Suchberechtigung *)
  139.     wOK,        (* = 0002H, Schreibberechtigung *)
  140.     rOK,        (* = 0004H, Leseberechtigung *)
  141.     Access3, Access4, Access5, Access6,
  142.     Access7, Access8, Access9, Access10,
  143.     Access11,Access12,Access13,Access14,Access15  (* --> keine 8-Bit-Menge *)
  144.   );
  145. #endif
  146.  
  147.   AccessMode = PACKEDSET OF AccessModes;
  148.  
  149. CONST
  150.   fOK = AccessMode{}; (* = 0000H, Existenz *)
  151.  
  152.  
  153. (*======================= "utime()" =========================================*)
  154.  
  155. TYPE
  156.   UTimeBuf = RECORD
  157.     actime  : timeT;
  158.     modtime : timeT;
  159.   END;
  160.  
  161. (*======================= "open()" ==========================================*)
  162.  
  163. TYPE
  164. #if reverse_set
  165.   OpenModes = (
  166.     Open15, Open14, Open13, Open12,   (* --> keine 8-Bit-Menge *)
  167.     Open11, Open10, Open9,  Open8,
  168.     oNONBLOCK,  (* nicht fuer regulaere Dateien *)
  169.     oNOCTTY,    (* nicht fuer regulaere Dateien *)
  170.     oEXCL,      (* Neu Anlegen nicht erlaubt, falls schon vorhanden *)
  171.     oTRUNC,     (* vorhandene Datei auf Laenge 0 kuerzen *)
  172.     oCREAT,     (* Datei anlegen, falls nicht vorhanden *)
  173.     oAPPEND,    (* Schreiben immer ans Ende des Files *)
  174.  
  175.     rw1,
  176.     rw0
  177.   );
  178. #else
  179.   OpenModes = (
  180.     rw0,
  181.     rw1,
  182.  
  183.     oAPPEND,    (* Schreiben immer ans Ende des Files *)
  184.     oCREAT,     (* Datei anlegen, falls nicht vorhanden *)
  185.     oTRUNC,     (* vorhandene Datei auf Laenge 0 kuerzen *)
  186.     oEXCL,      (* Neu Anlegen nicht erlaubt, falls schon vorhanden *)
  187.     oNOCTTY,    (* nicht fuer regulaere Dateien *)
  188.     oNONBLOCK,  (* nicht fuer regulaere Dateien *)
  189.     Open8,  Open9,  Open10, Open11,
  190.     Open12, Open13, Open14, Open15    (* --> keine 8-Bit-Menge *)
  191.   );
  192. #endif
  193.  
  194.   OpenMode = PACKEDSET OF OpenModes;
  195.  
  196. CONST
  197.   oACCMODE = OpenMode{rw0, rw1}; (* Maske fuer erlaubte Operationen *)
  198.  
  199.   oRDONLY  = OpenMode{ };   (* 0000H, nur Lesen erlaubt *)
  200.   oWRONLY  = OpenMode{rw0}; (* 0001H, nur Schreiben erlaubt *)
  201.   oRDWR    = OpenMode{rw1}; (* 0002H, Lesen und Schreiben erlaubt *)
  202.  
  203. (*======================= "lseek()" =========================================*)
  204.  
  205. TYPE
  206.   SeekMode = (
  207.     SeekSet, (* = 0, absolute Positionsangabe *)
  208.     SeekCur, (* = 1, Positionsangabe relativ zur augenblicklichen Position *)
  209.     SeekEnd  (* = 2, Positionsangabe relativ zum Dateiende *)
  210.   );
  211.  
  212. (*======================= "pipe()" ==========================================*)
  213.  
  214. TYPE
  215.   PipeBuf = RECORD
  216.     readh  : INTEGER;
  217.     writeh : INTEGER;
  218.   END;
  219.  
  220. (*===================== "open()", "creat()" =================================*)
  221.  
  222. CONST (* kleinstes gueltiges Handle, nicht POSIX: *)
  223. #if GEMDOS
  224.   MINHANDLE = -3;
  225. #else
  226.   MINHANDLE = 0;
  227. #endif
  228.  
  229. (*===========================================================================*)
  230.  
  231. CONST (* Die immer geoeffneten Standardkanaele *)
  232.   StdinFileNo  = 0;
  233.   StdoutFileNo = 1;
  234.   StderrFileNo = 2; (* "GEMDOS": Durch 'DosFile' sichergestellt *)
  235.  
  236. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  237.  
  238.  PROCEDURE creat ((* EIN/ -- *) REF file : ARRAY OF CHAR;
  239.                   (* EIN/ -- *)     mode : modeT         ): INTEGER;
  240.  
  241.  PROCEDURE open ((* EIN/ -- *) REF file   : ARRAY OF CHAR;
  242.                  (* EIN/ -- *)     access : OpenMode;
  243.                  (* EIN/ -- *)     mode   : modeT         ): INTEGER;
  244.  
  245. (*--------------------------------------------------------------------------
  246.  | "open()" oeffnet eine bereits vorhandene Datei namens <file> in dem durch|
  247.  | <mode> festgelegten Modus (Funktionalitaet siehe Def. von 'FileModes'),  |
  248.  | bzw. erzeugt eine neue, falls in <mode> 'oCREAT' gesetzt ist. Die Datei  |
  249.  | wird gleich geoeffnet und ist ueber die als Funktionswert zurueckgelie-  |
  250.  | ferte Kennung referenzierbar, falls diese nicht kleiner als 'MINHANDLE'  |
  251.  | ist.                                                                     |
  252.  | "creat()" entspricht: "open(file,OpenMode{oCREAT,oTRUNC,oWRONLY},mode)"  |
  253.  |                                                                          |
  254.  | "GEMDOS": Es koennen auch Geraete geoeffnet werden (muessen aber nicht), |
  255.  |           sodass auch negative Werte auftreten koennen. Ein Fehler ist   |
  256.  |           erst aufgetreten, falls der Funktionswert 'MINHANDLE' unter-   |
  257.  |           schreitet.                                                     |
  258.  |           <access>: oNOCTTY und oNONBLOCK und oAPPEND werden ignoriert.  |
  259.  |           <mode>: Die Datei kann lediglich schreibgeschuetzt werden.     |
  260.  |           ("MiNT"-Unterstuetzung.)                                       |
  261.   --------------------------------------------------------------------------*)
  262.  
  263.  
  264.  PROCEDURE close ((* EIN/ -- *) h : INTEGER ): INTEGER;
  265.  
  266. (*--------------------------------------------------------------------------
  267.  | Die Datei mit der Kennung <h> wird geschlossen. Danach kann nicht mehr   |
  268.  | ueber <h> auf die Datei zugegriffen werden. Die Kennung <h> ist jetzt    |
  269.  | ``frei'', sodass sie wieder mit einer anderen Datei verbunden werden     |
  270.  | kann.                                                                    |
  271.   --------------------------------------------------------------------------*)
  272.  
  273.  
  274.  
  275.  PROCEDURE read ((* EIN/ -- *) h   : INTEGER;
  276.                  (* EIN/ -- *) buf : ADDRESS;
  277.                  (* EIN/ -- *) len : sizeT   ): ssizeT;
  278.  
  279.  PROCEDURE write ((* EIN/ -- *) h   : INTEGER;
  280.                   (* EIN/ -- *) buf : ADDRESS;
  281.                   (* EIN/ -- *) len : sizeT   ): ssizeT;
  282.  
  283. (*--------------------------------------------------------------------------
  284.  | "read()" liest <len> Bytes aus der Datei mit der Kennung <h> in den Puf- |
  285.  | fer ab der Adresse <buf>. Als Funktionswert wird die Anzahl der gelesenen|
  286.  | Bytes zurueckgeliefert (0 = Dateiende, -1 = Fehler).                     |
  287.  | "write()" schreibt <len> Bytes aus dem Puffer mit der Startadresse <buf> |
  288.  | in die Datei mit der Kennung <h>. Als Funktionswert wird die Anzahl der  |
  289.  | geschriebenen Bytes zurueckgeliefert (<> len = Fehler).                  |
  290.  |                                                                          |
  291.  | "GEMDOS": Das Lesen/Schreiben von/auf Terminals kann nicht beeinflusst   |
  292.  |           werden (Interpretation von ^C u.ae.).                          |
  293.   --------------------------------------------------------------------------*)
  294.  
  295.  
  296.  PROCEDURE lseek ((* EIN/ -- *) h    : INTEGER;
  297.                   (* EIN/ -- *) off  : offT;
  298.                   (* EIN/ -- *) mode : SeekMode ): offT;
  299.  
  300. (*--------------------------------------------------------------------------
  301.  | Die aktuelle Lese/Schreibposition der Datei mit der Kennung <h> wird, je |
  302.  | nach <mode>, Beschreibung siehe dort, um <off> Bytes verschoben, bzw.    |
  303.  | auf Position <off> gesetzt. Hierbei kann auch ueber das Ende der Datei   |
  304.  | positioniert werden, die Datei wird aber erst dann (virtuell) verlaengert|
  305.  | (-> ``gap'') wenn ein Schreibvorgang hinter dem tatsaechlichen bisherigen|
  306.  | Dateiende stattfindet.                                                   |
  307.  | Als Funktionswert wird die aktuelle Schreib/Leseposition geliefert.      |
  308.  |                                                                          |
  309.  | "GEMDOS": Es ist kein Verlaengern der Datei durch ein "Fseek" hinter das |
  310.  |           augenblickliche Dateiende moeglich, daher wird bei "lseek" das |
  311.  |           Verlaengern durch blockweises (jeweils 1kB) Schreiben mit Null-|
  312.  |           bytes realisiert; das kann natuerlich je nach Umfang der Erwei-|
  313.  |           terung ein bisschen dauern.                                    |
  314.  |           ("MiNT"-Unterstuetzung.)                                       |
  315.   --------------------------------------------------------------------------*)
  316.  
  317.  
  318.  
  319.  
  320.  PROCEDURE dup ((* EIN/ -- *) h : INTEGER ): INTEGER;
  321.  
  322.  PROCEDURE dup2 ((* EIN/ -- *) h  : INTEGER;
  323.                  (* EIN/ -- *) h2 : INTEGER ): INTEGER;
  324.  
  325. (*--------------------------------------------------------------------------
  326.  | "dup()" liefert zur Dateikennung <h> eine zweite Kennung (die kleinste   |
  327.  | freie Kennung), sodass die entsprechende Datei ueber beide Kennungen an- |
  328.  | gesprochen werden kann.                                                  |
  329.  | Bei "dup2()" kann die kleinstmoegliche neue Kennung (<h2>) vorgegeben    |
  330.  | werden; Als Funktionswert wird die kleinste freie Kennung geliefert, die |
  331.  | nicht kleiner als <h2> ist.                                              |
  332.  |                                                                          |
  333.  | "GEMDOS": Hier funktionieren die Umlenkungen erst ab TOS 1.04 einiger-   |
  334.  |           massen, aber auch nicht voellig korrekt (z.B. keine mehrfache  |
  335.  |           Umlenkung, kein Pexec nach "dup()").                           |
  336.  |           "dup()" : <h> muss die Nummer eines Standardkanals sein, also  |
  337.  |           0 <= h <= 5.                                                   |
  338.  |           "dup2()": <h2> muss die Nummer eines Standardkanals sein, also |
  339.  |           0 <= h2 <= 5; weiterhin muss <h> ein Nicht-Standard-Handle     |
  340.  |           (normales Datei- oder Geraetehandle) sein.                     |
  341.  |           ("MiNT"-Unterstuetzung.)                                       |
  342.   --------------------------------------------------------------------------*)
  343.  
  344.  
  345.  PROCEDURE isatty ((* EIN/ -- *) h : INTEGER ): BOOLEAN;
  346.  
  347. (*--------------------------------------------------------------------------
  348.  | Liefert TRUE, falls <h> das Handle eines (Pseudo)Terminals ist.          |
  349.  |                                                                          |
  350.  | "GEMDOS": Der Test wird mit "DosFile.IsDevice()" durchgefuehrt.          |
  351.   --------------------------------------------------------------------------*)
  352.  
  353.  
  354.  PROCEDURE umask ((* EIN/ -- *) excl : modeT ): modeT;
  355.  
  356. (*--------------------------------------------------------------------------
  357.  | Setzt die Dateierstellungsmaske, die als Filter fuer die Zugriffsberech- |
  358.  | tigung benutzt wird, wenn eine Datei mit "open()" oder "creat()" neu     |
  359.  | erstellt, oder ein Verzeichnis mit "mkdir()" angelegt wird: Von der ange-|
  360.  | gebenen Zugriffsberechtigung wird immer zuerst die Maske subtrahiert,    |
  361.  | sodass Dateien z.B. grundsaetzlich fuer Gruppe und andere schreibge-     |
  362.  | schuetzt werden koennen.                                                 |
  363.  | Als Funktionswert wird die alte Maske zurueckgeliefert.                  |
  364.  |                                                                          |
  365.  | "GEMDOS": nicht sonderlich sinnvoll                                      |
  366.  |           ("MiNT"-Unterstuetzung.)                                       |
  367.   --------------------------------------------------------------------------*)
  368.  
  369.  
  370.  PROCEDURE chmod ((* EIN/ -- *) REF file : ARRAY OF CHAR;
  371.                   (* EIN/ -- *)     mode : modeT         ): INTEGER;
  372.  
  373. (*--------------------------------------------------------------------------
  374.  | Setzt die Schreib-, Lese- und Ausfuehrungsrechte und die ``set user id'' |
  375.  | und ``set group id'' Flags der Datei <file>.                             |
  376.  |                                                                          |
  377.  | "GEMDOS": Es wird nur sIWUSR ausgewertet: wenn das Bit gesetzt ist, wird |
  378.  |           'faRDONLY' im Dateiattribut geloescht und umgekehrt.           |
  379.  |           Das Dateiattribut 'faCHANGED' wird nicht geaendert. Attribute  |
  380.  |           von Verzeichnissen koennen nicht geaendert werden (ist aber    |
  381.  |           kein Fehler).                                                  |
  382.  |           ("MiNT"-Unterstuetzung.)                                       |
  383.   --------------------------------------------------------------------------*)
  384.  
  385.  
  386.  PROCEDURE chown ((* EIN/ -- *) REF file : ARRAY OF CHAR;
  387.                   (* EIN/ -- *)     uid  : uidT;
  388.                   (* EIN/ -- *)     gid  : gidT          ): INTEGER;
  389.  
  390. (*--------------------------------------------------------------------------
  391.  | Setzt die Besitzer- und Gruppenkennung der Datei <file>.                 |
  392.  |                                                                          |
  393.  | "GEMDOS": funktioniert nur unter MiNT, sonst wird ein Fehler gemeldet.   |
  394.  |           ("MiNT"-Unterstuetzung.)                                       |
  395.   --------------------------------------------------------------------------*)
  396.  
  397.  
  398.  PROCEDURE utime ((* EIN/ -- *) REF file : ARRAY OF CHAR;
  399.                   (* EIN/ -- *)     time : UTimeBuf      ): INTEGER;
  400.  
  401. (*--------------------------------------------------------------------------
  402.  | Setzt die Zeit des letzten Dateizugriffs (st.stAtime) der Datei <file>   |
  403.  | auf <time.actime> und die Zeit der letzten Dateiveraenderung (st.stMtime)|
  404.  | auf <time.modtime>. Die Zeit der letzten Statusaenderung (st.stCtime)    |
  405.  | wird automatisch auf das aktuelle Datum gesetzt. Wird fuer eine Zeit eine|
  406.  | Null uebergeben, wird das aktuelle Datum eingesetzt.                     |
  407.  |                                                                          |
  408.  | "GEMDOS": Zeit und Datum sind im DOS-Format, siehe 'types.timeT'. Es wird|
  409.  |           nur <time.modtime> ausgewertet.                                |
  410.   --------------------------------------------------------------------------*)
  411.  
  412.  
  413.  PROCEDURE stat ((* EIN/ -- *) REF file : ARRAY OF CHAR;
  414.                  (* -- /AUS *) VAR st   : StatRec       ): INTEGER;
  415.  
  416.  PROCEDURE fstat ((* EIN/ -- *)     hndl : INTEGER;
  417.                   (* -- /AUS *) VAR st   : StatRec  ): INTEGER;
  418.  
  419.  PROCEDURE lstat ((* EIN/ -- *) REF file : ARRAY OF CHAR;
  420.                   (* -- /AUS *) VAR st   : StatRec       ): INTEGER;
  421.  
  422. (*--------------------------------------------------------------------------
  423.  | Die Prozeduren liefern zum Namen <file> einer Datei bzw. einer Datei-    |
  424.  | kennung <hndl> die Informationen aus dem INODE (siehe Def. von 'modeT'   |
  425.  | und 'StatRec'.                                                           |
  426.  | Bei einem 'Symbolischen Link' liefert "stat()" Informationen ueber die   |
  427.  | physikalisch referenzierte Datei, "lstat()" Informationen ueber den Link |
  428.  | selber, ansonsten sind die beiden Funktionen identisch.                  |
  429.  |                                                                          |
  430.  | "GEMDOS":                                                                |
  431.  |          o 'stMode': Die Berechtigungen fuer Besitzer, Gruppe und Andere |
  432.  |            sind identisch; Leseberechtigung ist immer gegeben, Schreib-  |
  433.  |            berechtigung ist vorhanden, falls 'faRDONLY' im Dateiattribut |
  434.  |            nicht gesetzt ist, die Ausfuehrberechtigung bei regulaeren    |
  435.  |            Dateien wird mit 'DosFile.IsExec' festgestellt, Verzeichnisse |
  436.  |            haben immer Suchberechtigung. Geraete werden mit              |
  437.  |            'DosFile.IsDosDevice' ermittelt, Verzeichnisse durch ein      |
  438.  |            gesetztes 'faSUBDIR' im Dateiattribut, alles andere sind      |
  439.  |            regulaere Dateien.                                            |
  440.  |          o 'stIno': ein fortlaufender Wert, der keine Beziehung zur Datei|
  441.  |            hat.                                                          |
  442.  |          o 'stDev': die (aktuelle) Laufwerksnummer (A = 0, B = 1...).    |
  443.  |          o 'stNlink': bei Verzeichnissen zwei (wegen ".."), sonst eins.  |
  444.  |          o 'stSize': bei Verzeichnissen konstant 1024.                   |
  445.  |          o 'stAtime', 'stMtime', 'stCtime': die Zeiten sind identisch    |
  446.  |            und im kodierten DOS-Format, aber das Datum ist im hoeherwer- |
  447.  |            tigen Wort, sodass durch einen direkten Vergleich des gesamten|
  448.  |            Langwortes die zeitliche Reihenfolge korrekt ermittelt wird.  |
  449.  |            Bei Geraeten werden aktuelle Zeit und aktuelles Datum genommen|
  450.  |            Bei Wurzelverzeichnissen ist der Wert Null.                   |
  451.  |          ("MiNT"-Unterstuetzung)                                         |
  452.  |                                                                          |
  453.  |          "lstat()": ohne MiNT ist diese Funktion mit "stat()" identisch. |
  454.  |          Diese Funktion ist noch nicht POSIX-Standard.                   |
  455.  |          ("MiNT"-Unterstuetzung)                                         |
  456.  |                                                                          |
  457.  |          "fstat()": ohne MiNT sind die einzigen zuverlaeesigen Informa-  |
  458.  |          tionen 'stSize' und 'stMtime', falls <hndl> eine gueltige Ken-  |
  459.  |          nung einer regulaeren Datei ist.                                |
  460.  |          ("MiNT"-Unterstuetzung)                                         |
  461.   --------------------------------------------------------------------------*)
  462.  
  463.  PROCEDURE sISCHR  ((* EIN/ -- *) stMode : modeT ): BOOLEAN;
  464.  PROCEDURE sISDIR  ((* EIN/ -- *) stMode : modeT ): BOOLEAN;
  465.  PROCEDURE sISBLK  ((* EIN/ -- *) stMode : modeT ): BOOLEAN;
  466.  PROCEDURE sISREG  ((* EIN/ -- *) stMode : modeT ): BOOLEAN;
  467.  PROCEDURE sISFIFO ((* EIN/ -- *) stMode : modeT ): BOOLEAN;
  468.  (* noch nicht POSIX: *)
  469.  PROCEDURE sISLNK  ((* EIN/ -- *) stMode : modeT ): BOOLEAN;
  470.  
  471. (*--------------------------------------------------------------------------
  472.  | Diese Funktionen sind bei POSIX als Makros definiert, und liefern TRUE,  |
  473.  | falls der im 'stMode'-Feld der StatRec-Struktur kodierte Dateityp dem    |
  474.  | durch den Prozedurnamen angedeuteten entspricht.                         |
  475.  | Es sollten nur diese Prozeduren verwendet werden, um den Dateityp zu     |
  476.  | bestimmen.                                                               |
  477.   --------------------------------------------------------------------------*)
  478.  
  479.  
  480.  
  481.  PROCEDURE access ((* EIN/ -- *) REF file : ARRAY OF CHAR;
  482.                    (* EIN/ -- *)     acc  : AccessMode    ): INTEGER;
  483.  
  484. (*--------------------------------------------------------------------------
  485.  | Es wird die Existenz (<acc> = fOK) oder die Lese-, Schreib oder Ausfuehr-|
  486.  | bzw. Suchberechtigung einer Datei getestet. Beim Test wird beruecksich-  |
  487.  | tigt, ob der ausfuehrende Prozess der Besitzer der Datei ist, der Gruppe |
  488.  | des Besitzers angehoert oder ein Aussenstehender ist (Es werden die      |
  489.  | realen Kennungen getestet).                                              |
  490.  |                                                                          |
  491.  | "GEMDOS": Die bei "stat()" genannten Einschraenkungen gelten.            |
  492.  |           ("MiNT"-Unterstuetzung.)                                       |
  493.   --------------------------------------------------------------------------*)
  494.  
  495.  
  496.  PROCEDURE pipe ((* -- /AUS *) VAR ph : PipeBuf ): INTEGER;
  497.  
  498. (*--------------------------------------------------------------------------
  499.  | Generiert einen Kommunikationskanal zwischen zwei (Unter)Prozessen. Der  |
  500.  | eine Prozess kann ueber <ph.writeh> etwas schreiben, das der andere      |
  501.  | ueber <ph.readh> lesen kann. Die Groesse einer ``Pipe'' ist intern be-   |
  502.  | grenzt (z.B. auf 2kB oder 4kB), sodass der schreibende Prozess zeitweise |
  503.  | gestoppt werden kann, bis wieder etwas Platz in der Pipe vorhanden ist.  |
  504.  |                                                                          |
  505.  | "GEMDOS": funktioniert nur unter MiNT, sonst wird ein Fehler gemeldet.   |
  506.  |           ("MiNT"-Unterstuetzung.)                                       |
  507.   --------------------------------------------------------------------------*)
  508.  
  509. END file.
  510.