home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / turbo4 / dos.doc < prev    next >
Text File  |  1987-12-08  |  6KB  |  127 lines
  1. {*******************************************************}
  2. {                                                       }
  3. {       Turbo Pascal Version 4.0                        }
  4. {       Interface-Dokumentation zu DOS                  }
  5. {                                                       }
  6. {       Copyright (c) 1987 Borland International, Inc.  }
  7. {                                                       }
  8. {*******************************************************}
  9.  
  10. {$D-,I-,S-   keine Zusatzinformationen zur Fehlersuche,
  11.              keine automatische I/O-Prüfung,
  12.              keine Prüfung des Stacks }
  13.  
  14. unit Dos;
  15.  
  16. interface
  17.  
  18. const
  19.   FCarry     = $0001;    { Zur Prüfung einzelner Bits des Flag-         }
  20.   FParity    = $0004;    { Registers nach Aufrufen von MsDos oder Intr. }
  21.   FAuxiliary = $0010;    { Wenn R ein Record des Typs Registers ist,    }
  22.   FZero      = $0040;    { dann liefert R.Flags and FCarry das Ergebnis }
  23.   FSign      = $0080;    { TRUE, wenn das Carry-Flag gesetzt ist,       }
  24.   FOverflow  = $0800;    { R.Flags and FZero prüft auf Z-Flag<> 0 usw.  }
  25.  
  26.   fmClosed = $D7B0;      { "Magische" Konstanten für das Feld Mode }
  27.   fmInput  = $D7B1;      { in einer Datei-Variablen }
  28.   fmOutput = $D7B2;
  29.   fmInOut  = $D7B3;
  30.  
  31.   ReadOnly  = $01;  { Datei-Attribute: schreibgeschützt  }
  32.   Hidden    = $02;                       { versteckt     }
  33.   SysFile   = $04;                       { Systemdatei   }
  34.   VolumeID  = $08;                       { Volume-Label  }
  35.   Directory = $10;
  36.   Archive   = $20;
  37.   AnyFile   = $3F;                       { beliebige Datei }
  38.  
  39. { -------------- Datentypen ----------------------- }
  40.  
  41. type
  42.   { Zum Setzen bzw. der Übergabe von Registern des Prozessors
  43.     für die Prozeduren Intr und MsDos }
  44.   Registers = record
  45.                 case Integer of
  46.                   0: (AX,BX,CX,DX,BP,SI,DI,DS,ES,Flags: Word);
  47.                   1: (AL,AH,BL,BH,CL,CH,DL,DH: Byte);
  48.               end;
  49.  
  50.   { Datei-Variable für untypisierte und typisierte Dateien }
  51.   FileRec = record
  52.               Handle:   Word;     { DOS-Handle (Referenznummer) }
  53.               Mode:     Word;     { Zugriffsart: Lesen, Schreiben ... }
  54.               RecSize:  Word;     { Recordgröße }
  55.               Private:  array[1..26] of Byte;  { von DOS reserviert }
  56.               UserData: array[1..16] of Byte;  { beliebig verwendbar }
  57.               Name:     array[0..79] of Char;  { Dateiname }
  58.             end;
  59.  
  60.   { Datei-Variable für Textdateien }
  61.   TextBuf = array[0..127] of Char;   { Puffer, kann mit SetTextBuf
  62.                                        "umdirigiert" werden }
  63.   TextRec = record
  64.               Handle:    Word;        { DOS-Handle (Referenznummer) }
  65.               Mode:      Word;        { Zugrifffsart }
  66.               BufSize:   Word;        { Puffergröße }
  67.               Private:   Word;        { von DOS reserviert }
  68.               BufPos:    Word;        { Position (Index) im Puffer }
  69.               BufEnd:    Word;        { Zahl momentan gespeicherter Zeichen }
  70.               BufPtr:    ^TextBuf;    { zeigt auf den Puffer }
  71.               OpenFunc:  Pointer;     { zeigt auf die Open-Routine }
  72.               InOutFunc: Pointer;     { zeigt auf die Ein-/Ausgaberoutine }
  73.               FlushFunc: Pointer;     { zeigt auf die Flush-Routine }
  74.               CloseFunc: Pointer;     { zeigt auf die Close-Routine }
  75.               UserData:  array[1..16] of Byte;  { beliebig verwendbar }
  76.               Name:      array[0..79] of Char;  { Dateiname }
  77.               Buffer:    TextBuf;     { Standard-Textpuffer }
  78.             end;
  79.  
  80.   { Parametertyp von FindFirst und FindNext }
  81.   SearchRec = record
  82.                 Fill: array[1..21] of Byte;   { von DOS reserviert }
  83.                 Attr: Byte;                   { Dateiattribute }
  84.                 Time: LongInt;                { Datum/Uhrzeit (gepackt) }
  85.                 Size: LongInt;                { Größe in Bytes }
  86.                 Name: string[12];             { Name }
  87.               end;
  88.  
  89.   { Datums-/Uhrzeit-Record für PackTime und UnpackTime }
  90.   DateTime = record
  91.                Year,Month,     { Jahr: 1980..2099, Monat: 1..12 }
  92.                Day,Hour,       { Tag: 1..31, Stunde: 0..23 }
  93.                Min,Sec: Word;
  94.              end;
  95.  
  96. { --------------------- Variablen ------------------------ }
  97. var
  98.   DosError: Integer;          { Enthält den Status der
  99.                                jeweils letzten DOS-Operation }
  100.  
  101.  
  102. { -------------------- Routinen -------------------------- }
  103.  
  104. procedure Intr(IntNo: Byte; var Regs: Registers);
  105. procedure MsDos(var Regs: Registers);
  106. procedure GetDate(var Year,Month,Day,DayOfWeek: Word);
  107. procedure SetDate(Year,Month,Day: Word);
  108. procedure GetTime(var Hour,Minute,Second,Sec100: Word);
  109. procedure SetTime(Hour,Minute,Second,Sec100: Word);
  110. function DiskFree(Drive: Byte): LongInt;
  111. function DiskSize(Drive: Byte): LongInt;
  112. procedure GetFAttr(var F; var Attr: Word);
  113. procedure SetFAttr(var F; Attr: Word);
  114. procedure GetFTime(var F; var Time: LongInt);
  115. procedure SetFTime(var F; Time: LongInt);
  116. procedure FindFirst(Path: String; Attr: Word; var F: SearchRec);
  117. procedure FindNext(var F: SearchRec);
  118. procedure UnpackTime(P: LongInt; var T: DateTime);
  119. procedure PackTime(var T: DateTime; var P: LongInt);
  120. procedure GetIntVec(IntNo: Byte; var Vector: Pointer);
  121. procedure SetIntVec(IntNo: Byte; Vector: Pointer);
  122. procedure Keep(ExitCode: Word);
  123. procedure Exec(Path,CmdLine: String);
  124. function DosExitCode: Word;
  125.  
  126. implementation
  127.