(**************************************************************************

     $RCSfile: Dos.mod $
  Description: Interface to dos.library

   Created by: fjc (Frank Copeland)
    $Revision: 1.2 $
      $Author: fjc $
        $Date: 1994/05/12 19:11:02 $

  Copyright © 1994, Frank Copeland.
  This file is part of the Oberon-A Library.
  See Oberon-A.doc for conditions of use and distribution.

  Log entries are at the end of the file.

***************************************************************************)

MODULE Dos;

(* $P- allow non-portable code *)

IMPORT Types, Exec, Timer, Utility, SYSTEM;

CONST

  DOSTRUE* = -1;
  DOSFALSE* = 0;

  modeOldFile        * = 1005;
  modeNewFile        * = 1006;
  modeReadWrite      * = 1004;

  offsetBeginning    * = -1;
  offsetCurrent      * =  0;
  offsetEnd          * =  1;

  offsetBegining     * = offsetBeginning;

  bitsPerByte         * = 8;
  bytesPerLong        * = 4;
  bitsPerLong         * = 32;
  maxInt              * = 7FFFFFFFH;
  minInt              * = 80000000H;

  sharedLock         * = -2;
  accessRead         * = -2;
  exclusiveLock      * = -1;
  accessWrite        * = -1;

TYPE

  DateStampPtr* = CPOINTER TO DateStamp;
  DateStamp* = RECORD
    dsDays  * : LONGINT;
    dsMinute* : LONGINT;
    dsTick  * : LONGINT;
  END;

CONST

  ticksPerSecond     * = 50;

TYPE

  FileInfoBlockPtr* = CPOINTER TO FileInfoBlock;
  FileInfoBlock* = RECORD
    fibDiskKey     * : LONGINT;
    fibDirEntryType* : LONGINT;
    fibFileName    * : ARRAY 108 OF CHAR;

    fibProtection  * : LONGINT;
    fibEntryType   * : LONGINT;
    fibSize        * : LONGINT;
    fibNumBlocks   * : LONGINT;
    fibDate        * : DateStamp;
    fibComment     * : ARRAY 80 OF CHAR;

    fibReserved    * : ARRAY 36 OF CHAR;
  END;

CONST

  fibScript   * = 6;
  fibPure     * = 5;
  fibArchive  * = 4;
  fibRead     * = 3;
  fibWrite    * = 2;
  fibExecute  * = 1;
  fibDelete   * = 0;

  faultMax      * = 82;

TYPE

  BPTR* = SYSTEM.BPTR;
  BSTR* = BPOINTER TO ARRAY 256 OF CHAR;

  InfoDataPtr* = CPOINTER TO InfoData;
  InfoData* = RECORD
    idNumSoftErrors* : LONGINT;
    idUnitNumber   * : LONGINT;
    idDiskState    * : LONGINT;
    idNumBlocks    * : LONGINT;
    idNumBlocksUsed* : LONGINT;
    idBytesPerBlock* : LONGINT;
    idDiskType     * : LONGINT;
    idVolumeNode   * : BPTR;
    idInUse        * : LONGINT;
  END;

CONST

  idWriteProtected * = 80;
  idValidating     * = 81;
  idValidated      * = 82;

  idNoDiskPresent      * = -1;
  idUnreadableDisk     * = 42414400H;
  idDosDisk            * = 444F5300H;
  idFfsDisk            * = 444F5301H;
  idInterDosDisk       * = 444F5302H;
  idInterFfsDisk       * = 444F5303H;
  idNotReallyDos       * = 4E444F53H;
  idKickstartDisk      * = 4B49434BH;
  idMsDosDisk          * = 4D534400H;

  errorNoFreeStore              * = 103;
  errorTaskTableFull            * = 105;
  errorBadTemplate              * = 114;
  errorBadNumber                * = 115;
  errorRequiredArgMissing       * = 116;
  errorKeyNeedsArg              * = 117;
  errorTooManyArgs              * = 118;
  errorUnmatchedQuotes          * = 119;
  errorLineTooLong              * = 120;
  errorFileNotObject            * = 121;
  errorInvalidResidentLibrary   * = 122;
  errorNoDefaultDir             * = 201;
  errorObjectInUse              * = 202;
  errorObjectExists             * = 203;
  errorDirNotFound              * = 204;
  errorObjectNotFound           * = 205;
  errorBadStreamName            * = 206;
  errorObjectTooLarge           * = 207;
  errorActionNotKnown           * = 209;
  errorInvalidComponentName     * = 210;
  errorInvalidLock              * = 211;
  errorObjectWrongType          * = 212;
  errorDiskNotValidated         * = 213;
  errorDiskWriteProtected       * = 214;
  errorRenameAcrossDevices      * = 215;
  errorDirectoryNotEmpty        * = 216;
  errorTooManyLevels            * = 217;
  errorDeviceNotMounted         * = 218;
  errorSeekError                * = 219;
  errorCommentTooBig            * = 220;
  errorDiskFull                 * = 221;
  errorDeleteProtected          * = 222;
  errorWriteProtected           * = 223;
  errorReadProtected            * = 224;
  errorNotADosDisk              * = 225;
  errorNoDisk                   * = 226;
  errorNoMoreEntries            * = 232;

  errorIsSoftLink               * = 233;
  errorObjectLinked             * = 234;
  errorBadHunk                  * = 235;
  errorNotImplemented           * = 236;
  errorRecordNotLocked          * = 240;
  errorLockCollision            * = 241;
  errorLockTimeout              * = 242;
  errorUnlockError              * = 243;

  returnOk                          * = 0;
  returnWarn                        * = 5;
  returnError                      * = 10;
  returnFail                       * = 20;

  sigBreakCtrlC  * = 12;
  sigBreakCtrlD  * = 13;
  sigBreakCtrlE  * = 14;
  sigBreakCtrlF  * = 15;

  lockDifferent         * = -1;
  lockSame              * = 0;
  lockSameVolume        * = 1;
  lockSameHandler       * = lockSameVolume;

  changeLock    * = 0;
  changeFH      * = 1;

  linkHard      * = 0;
  linkSoft      * = 1;

  itemEqual     * = -2;
  itemError     * = -1;
  itemNothing   * = 0;
  itemUnquoted  * = 1;
  itemQuoted    * = 2;

  dosFileHandle         * = 0;
  dosExallControl       * = 1;
  dosFib                * = 2;
  dosStdPkt             * = 3;
  dosCli                * = 4;
  dosRdArgs             * = 5;

TYPE

  DateTimePtr* = CPOINTER TO DateTime;
  DateTime* = RECORD
    datStamp  * : DateStamp;
    datFormat * : Types.UBYTE;
    datFlags  * : Types.BSET;
    datStrDay * : Types.STRPTR;
    datStrDate* : Types.STRPTR;
    datStrTime* : Types.STRPTR;
  END;

CONST

  lenDatString  * = 16;

  dtSubst      * = 0;
  dtFuture     * = 1;

  formatDOS     * = 0;
  formatINT     * = 1;
  formatUSA     * = 2;
  formatCDN     * = 3;
  formatMAX     * = formatCDN;

TYPE

  AChainPtr* = CPOINTER TO AChain;
  AChain* = RECORD
    anChild * : AChainPtr;
    anParent* : AChainPtr;
    anLock  * : BPTR;
    anInfo  * : FileInfoBlock;
    anFlags * : Types.BSET;
  END;

  AnchorPathPtr* = CPOINTER TO AnchorPath;
  AnchorPath* = RECORD
    apBase      * : AChainPtr;
    apLast      * : AChainPtr;
    apBreakBits * : SET;
    apFoundBreak* : SET;
    apFlags     * : Types.BSET;
    apReserved  * : SHORTINT;
    apStrlen    * : INTEGER;
    apInfo      * : FileInfoBlock;
  END;

CONST

  apDoWild     * = 0;

  apItsWild    * = 1;

  apDoDir      * = 2;

  apDidDir     * = 3;

  apNoMemErr   * = 4;

  apDoDot      * = 5;

  apDirChanged * = 6;

  apFollowHLinks* = 7;

CONST

  ddPatternBit * = 0;
  ddExaminedBit* = 1;
  ddCompleted  * = 2;
  ddAllBit     * = 3;
  ddSingle     * = 4;

  pAny          * = 80H;
  pSingle       * = 81H;
  pOrStart      * = 82H;
  pOrNext       * = 83H;
  pOeEnd        * = 84H;
  pNot          * = 85H;
  pNotEnd       * = 86H;
  pNotClass     * = 87H;
  pClass        * = 88H;
  pRepBeg       * = 89H;
  pRepEnd       * = 8AH;
  pStop         * = 8BH;

  complexBit    * = 1;
  examineBit    * = 2;

  errorBufferOverflow  * = 303;
  errorBreak           * = 304;
  errorNotExecutable   * = 305;

CONST

  hunkUNIT      * = 999;
  hunkNAME      * = 1000;
  hunkCODE      * = 1001;
  hunkDATA      * = 1002;
  hunkBSS       * = 1003;
  hunkRELOC32   * = 1004;
  hunkRELOC16   * = 1005;
  hunkRELOC8    * = 1006;
  hunkEXT       * = 1007;
  hunkSYMBOL    * = 1008;
  hunkDEBUG     * = 1009;
  hunkEND       * = 1010;
  hunkHEADER    * = 1011;

  hunkOVERLAY   * = 1013;
  hunkBREAK     * = 1014;

  hunkDREL32    * = 1015;
  hunkDREL16    * = 1016;
  hunkDREL8     * = 1017;

  hunkLIB       * = 1018;
  hunkINDEX     * = 1019;

  extSYMB       * = 0;
  extDEF        * = 1;
  extABS        * = 2;
  extRES        * = 3;
  extREF32      * = 129;
  extCOMMON     * = 130;
  extREF16      * = 131;
  extREF8       * = 132;
  extDEXT32     * = 133;
  extDEXT16     * = 134;
  extDEXT8      * = 135;

TYPE

  DosEnvecPtr* = BPOINTER TO DosEnvec;
  DosEnvec* = RECORD
    deTableSize     * : Types.ULONG;
    deSizeBlock     * : Types.ULONG;
    deSecOrg        * : Types.ULONG;
    deSurfaces      * : Types.ULONG;
    deSectorPerBlock* : Types.ULONG;
    deBlocksPerTrack* : Types.ULONG;
    deReserved      * : Types.ULONG;
    dePreAlloc      * : Types.ULONG;
    deInterleave    * : Types.ULONG;
    deLowCyl        * : Types.ULONG;
    deHighCyl       * : Types.ULONG;
    deNumBuffers    * : Types.ULONG;
    deBufMemType    * : Types.ULONG;
    deMaxTransfer   * : Types.ULONG;
    deMask          * : Types.ULONG;
    deBootPri       * : LONGINT;
    deDosType       * : Types.ULONG;
    deBaud          * : Types.ULONG;
    deControl       * : Types.ULONG;
    deBootBlocks    * : Types.ULONG;

  END;

CONST

  deTableSize   * = 0;
  deSizeBlock   * = 1;
  deSecOrg      * = 2;
  deNumHeads    * = 3;
  deSecsPerBlk  * = 4;
  deBlksPerTrack* = 5;
  deReservedBlks* = 6;
  dePrefac      * = 7;
  deInterleave  * = 8;
  deLowCyl      * = 9;
  deUpperCyl    * = 10;
  deNumBuffers  * = 11;
  deMemBufType  * = 12;
  deBufMemType  * = 12;
  deMaxTransfer * = 13;
  deMask        * = 14;
  deBootPri     * = 15;
  deDosType     * = 16;
  deBaud        * = 17;
  deControl     * = 18;
  deBootBlocks  * = 19;

TYPE

  FileSysStartupMsgPtr* = BPOINTER TO FileSysStartupMsg;
  FileSysStartupMsg* = RECORD
    fssmUnit   * : Types.ULONG;
    fssmDevice * : BSTR;
    fssmEnviron* : BPTR;
    fssmFlags  * : SET;
  END;

  DeviceNodePtr* = CPOINTER TO DeviceNode;
  DeviceNode* = RECORD
    dnNext     * : BPTR;
    dnType     * : Types.ULONG;
    dnTask     * : Exec.MsgPortPtr;
    dnLock     * : BPTR;
    dnHandler  * : BSTR;
    dnStackSize* : Types.ULONG;
    dnPriority * : LONGINT;
    dnStartup  * : BPTR;
    dnSegList  * : BPTR;
    dnGlobalVec* : BPTR;
    dnName     * : BSTR;
  END;

CONST

  notifyClass   * = 40000000H;

  notifyCode    * = 1234H;

TYPE

  NotifyRequestPtr* = CPOINTER TO NotifyRequest;
  NotifyRequest* = RECORD
    nrName    * : Types.STRPTR;
    nrFullName* : Types.STRPTR;
    nrUserData* : Types.ULONG;
    nrFlags   * : SET;

    nrstuff* : RECORD
      nrSignal* : RECORD
        nrTask     * : Exec.TaskPtr;
        nrSignalNum* : Types.UBYTE;
        nrpad      * : ARRAY 3 OF Types.UBYTE;
      END;
    END;

    nrReserved* : ARRAY 4 OF Types.ULONG;

    nrMsgCount* : Types.ULONG;
    nrHandler * : Exec.MsgPortPtr;
  END;

  NotifyMessagePtr* = CPOINTER TO NotifyMessage;
  NotifyMessage* = RECORD (Exec.Message)

    nmClass      * : Types.ULONG;
    nmCode       * : Types.UWORD;
    nmNReq       * : NotifyRequestPtr;
    nmDoNotTouch * : Types.ULONG;
    nmDoNotTouch2* : Types.ULONG;
  END;

CONST

  nrSendMessage       * = 0;
  nrSendSignal        * = 1;
  nrWaitReply         * = 3;
  nrNotifyInitial     * = 4;

  nrMagic              * = 31;

  nrHandlerFlags       * = {16 .. 31};

TYPE

  CSourcePtr* = CPOINTER TO CSource;
  CSource* = RECORD
    csBuffer* : Types.STRPTR;
    csLength* : LONGINT;
    csCurChr* : LONGINT;
  END;

TYPE

  RDArgsPtr* = CPOINTER TO RDArgs;
  RDArgs* = RECORD
    rdaSource * : CSource;
    rdaDAList * : LONGINT;
    rdaBuffer * : Types.STRPTR;
    rdaBufSiz * : LONGINT;
    rdaExtHelp* : Types.STRPTR;
    rdaFlags  * : SET;
  END;

CONST

  rdaStdIn     * = 0;
  rdaNoAlloc   * = 1;
  rdaNoPrompt  * = 2;

  maxTemplateItems     * = 100;

  maxMultiArgs          * = 128;

CONST

  recExclusive         * = 0;
  recExclusiveImmed    * = 1;
  recShared            * = 2;
  recSharedImmed       * = 3;

TYPE

  RecordLockPtr* = CPOINTER TO RecordLock;
  RecordLock* = RECORD
    recFH    * : BPTR;
    recOffset* : Types.ULONG;
    recLength* : Types.ULONG;
    recMode  * : Types.ULONG;
  END;

TYPE

  LocalVarPtr* = CPOINTER TO LocalVar;
  LocalVar* = RECORD (Exec.Node)

    lvFlags* : Types.WSET;
    lvValue* : Types.STRPTR;
    lvLen  * : Types.ULONG;
  END;

CONST

  lvVar                 * = 0;
  lvAlias               * = 1;

  lvIgnore              * = 7;

  gvGlobalOnly        * = 8;
  gvLocalOnly         * = 9;
  gvBinaryVar         * = 10;
  gvDontNullTerm      * = 11;

CONST

  sysDummy      * = Utility.tagUser + 32;
  sysInput      * = sysDummy + 1;

  sysOutput     * = sysDummy + 2;

  sysAsynch     * = sysDummy + 3;

  sysUserShell  * = sysDummy + 4;

  sysCustomShell* = sysDummy + 5;

  npDummy       * = Utility.tagUser + 1000;
  npSeglist     * = npDummy + 1;

  npFreeSeglist * = npDummy + 2;

  npEntry       * = npDummy + 3;

  npInput       * = npDummy + 4;

  npOutput      * = npDummy + 5;

  npCloseInput  * = npDummy + 6;

  npCloseOutput * = npDummy + 7;

  npError       * = npDummy + 8;

  npCloseError  * = npDummy + 9;

  npCurrentDir  * = npDummy + 10;

  npStackSize   * = npDummy + 11;

  npName        * = npDummy + 12;

  npPriority    * = npDummy + 13;

  npConsoleTask * = npDummy + 14;

  npWindowPtr   * = npDummy + 15;

  npHomeDir     * = npDummy + 16;

  npCopyVars    * = npDummy + 17;

  npCli         * = npDummy + 18;

  npPath        * = npDummy + 19;

  npCommandName * = npDummy + 20;

  npArguments   * = npDummy + 21;

  npNotifyOnDeath* = npDummy + 22;

  npSynchronous * = npDummy + 23;

  npExitCode    * = npDummy + 24;

  npExitData    * = npDummy + 25;

  adoDummy     * = Utility.tagUser + 2000;
  adoFhMode    * = adoDummy + 1;

  adoDirLen     * = adoDummy + 2;

  adoCommNameLen* = adoDummy + 3;

  adoCommFileLen* = adoDummy + 4;

  adoPromptLen  * = adoDummy + 5;

CONST

  edName        * = 1;
  edType        * = 2;
  edSize        * = 3;
  edProtection  * = 4;
  edDate        * = 5;
  edComment     * = 6;

TYPE

  ExAllDataPtr* = CPOINTER TO ExAllData;
  ExAllData* = RECORD
    edNext   * : ExAllDataPtr;
    edName   * : Types.STRPTR;
    edType   * : LONGINT;
    edSize   * : Types.ULONG;
    edProt   * : SET;
    edDays   * : Types.ULONG;
    edMins   * : Types.ULONG;
    edTicks  * : Types.ULONG;
    edComment* : Types.STRPTR;
  END;

  ExAllControlPtr* = CPOINTER TO ExAllControl;
  ExAllControl* = RECORD
    eacEntries    * : Types.ULONG;
    eacLastKey    * : Types.ULONG;
    eacMatchString* : Types.STRPTR;
    eacMatchFunc  * : Utility.HookPtr;
  END;

TYPE

  ProcessPtr* = CPOINTER TO Process;
  Process* = RECORD (Exec.Task)

    prMsgPort       * : Exec.MsgPort;
    prPad           * : INTEGER;
    prSegList       * : BPTR;
    prStackSize     * : LONGINT;
    prGlobVec       * : Types.APTR;
    prTaskNum       * : LONGINT;
    prStackBase     * : BPTR;
    prResult2       * : LONGINT;
    prCurrentDir    * : BPTR;
    prCIS           * : BPTR;
    prCOS           * : BPTR;
    prConsoleTask   * : Types.APTR;
    prFileSystemTask* : Types.APTR;
    prCLI           * : BPTR;
    prReturnAddr    * : Types.APTR;
    prPktWait       * : Types.APTR;
    prWindowPtr     * : Types.APTR;

    prHomeDir       * : BPTR;
    prFlags         * : SET;
    prExitCode      * : Types.PROC;
    prExitData      * : LONGINT;
    prArguments     * : Types.STRPTR;
    prLocalVars     * : Exec.MinList;
    prShellPrivate  * : Types.ULONG;
    prCES           * : BPTR;
  END;

CONST

  prFreeSegList        * = 0;
  prFreeCurrDir        * = 1;
  prFreeCli            * = 2;
  prCloseInput         * = 3;
  prCloseOutput        * = 4;
  prFreeArgs           * = 5;

TYPE

  FileHandlePtr* = BPOINTER TO FileHandle;
  FileHandle* = RECORD
    fhLink * : Exec.MessagePtr;
    fhPort * : Exec.MsgPortPtr;
    fhType * : Exec.MsgPortPtr;
    fhBuf  * : LONGINT;
    fhPos  * : LONGINT;
    fhEnd  * : LONGINT;
    fhFunc1* : LONGINT;
    fhFunc2* : LONGINT;
    fhFunc3* : LONGINT;
    fhArg1 * : LONGINT;
    fhArg2 * : LONGINT;
  END;

  DosPacketPtr* = CPOINTER TO DosPacket;
  DosPacket* = RECORD
    dpLink* : Exec.MessagePtr;
    dpPort* : Exec.MsgPortPtr;

    dpType* : LONGINT;
    dpRes1* : LONGINT;
    dpRes2* : LONGINT;
    dpArg1* : LONGINT;
    dpArg2* : LONGINT;
    dpArg3* : LONGINT;
    dpArg4* : LONGINT;
    dpArg5* : LONGINT;
    dpArg6* : LONGINT;
    dpArg7* : LONGINT;
  END;

  StandardPacketPtr* = CPOINTER TO StandardPacket;
  StandardPacket* = RECORD (Exec.Message)

    spPkt* : DosPacket;
  END;

CONST

  actionNil             * = 0;
  actionStartup         * = 0;
  actionGetBlock        * = 2;
  actionSetMap          * = 4;
  actionDie             * = 5;
  actionEvent           * = 6;
  actionCurrentVolume   * = 7;
  actionLocateObject    * = 8;
  actionRenameDisk      * = 9;
  actionWrite           * = ORD ("W");
  actionRead            * = ORD ("R");
  actionFreeLock        * = 15;
  actionDeleteObject    * = 16;
  actionRenameObject    * = 17;
  actionMoreCache       * = 18;
  actionCopyDir         * = 19;
  actionWaitChar        * = 20;
  actionSetProtect      * = 21;
  actionCreateDir       * = 22;
  actionExamineObject   * = 23;
  actionExamineNext     * = 24;
  actionDiskInfo        * = 25;
  actionInfo            * = 26;
  actionFlush           * = 27;
  actionSetComment      * = 28;
  actionParent          * = 29;
  actionTimer           * = 30;
  actionInhibit         * = 31;
  actionDiskType        * = 32;
  actionDiskChange      * = 33;
  actionSetDate         * = 34;

  actionScreenMode      * = 994;

  actionReadReturn      * = 1001;
  actionWriteReturn     * = 1002;
  actionSeek            * = 1008;
  actionFindUpdate      * = 1004;
  actionFindInput       * = 1005;
  actionFindOutput      * = 1006;
  actionEnd             * = 1007;
  actionSetFileSize     * = 1022;
  actionWriteProtect    * = 1023;

  actionSameLock       * = 40;
  actionChangeSignal   * = 995;
  actionFormat         * = 1020;
  actionMakeLink       * = 1021;

  actionReadLink       * = 1024;
  actionFhfromLock     * = 1026;
  actionIsFileSystem   * = 1027;
  actionChangeMode     * = 1028;

  actionCopyDirFH      * = 1030;
  actionParentFH       * = 1031;
  actionExamineAll     * = 1033;
  actionExamineFH      * = 1034;

  actionLockRecord     * = 2008;
  actionFreeRecord     * = 2009;

  actionAddNotify      * = 4097;
  actionRemoveNotify   * = 4098;

  actionSerializeDisk  * = 4200;

TYPE

  TaskArrayPtr* = BPOINTER TO TaskArray;
  TaskArray* = RECORD
    maxCLI   * : LONGINT;
    processId* : ARRAY 32767 OF Types.APTR;
  END;

  RootNodePtr* = CPOINTER TO RootNode;
  RootNode* = RECORD
    rnTaskArray     * : TaskArrayPtr;
    rnConsoleSegment* : BPTR;
    rnTime          * : DateStamp;
    rnRestartSeg    * : LONGINT;

    rnInfo          * : BPTR;

    rnFileHandlerSegment* : BPTR;

    rnCliList       * : Exec.MinList;

    rnBootProc      * : Exec.MsgPortPtr;

    rnShellSegment  * : BPTR;
    rnFlags         * : SET;
  END;

CONST

  rnWildStar   * = 24;
  rnPrivate1   * = 1;

TYPE

  ErrorStringPtr* = CPOINTER TO ErrorString;
  ErrorString* = RECORD
    estrNums   * : Types.APTR;
    estrStrings* : Types.STRPTR;
  END;

  DosLibraryPtr* = CPOINTER TO DosLibrary;
  DosLibrary* = RECORD (Exec.Library)

    dlRoot        * : RootNodePtr;
    dlGV          * : Types.APTR;
    dlA2          * : LONGINT;
    dlA5          * : LONGINT;
    dlA6          * : LONGINT;
    dlErrors      * : ErrorStringPtr;

    dlTimeReq     * : Timer.timerequestPtr;

    dlUtilityBase * : Exec.LibraryPtr;
    dlIntuitionBase* : Exec.LibraryPtr
  END;

TYPE

  CliProcListPtr* = CPOINTER TO CliProcList;
  CliProcList* = RECORD (Exec.MinNode)

    cplFirst* : LONGINT;
    cplArray* : CPOINTER TO ARRAY 1 OF Exec.MsgPortPtr;
  END;

  DosInfoPtr* = BPOINTER TO DosInfo;
  DosInfo* = RECORD
    diMcName    * : BPTR;
    diDevInfo   * : BPTR;
    diDevices   * : BPTR;
    diHandlers  * : BPTR;
    diNetHand   * : Types.APTR;
    diDevLock   * : Exec.SignalSemaphore;
    diEntryLock * : Exec.SignalSemaphore;
    diDeleteLock* : Exec.SignalSemaphore;
  END;

  SegmentPtr* = CPOINTER TO Segment;
  Segment* = RECORD
    segNext* : BPTR;
    segUC  * : LONGINT;
    segSeg * : BPTR;
    segName* : ARRAY 4 OF CHAR;
  END;

CONST

  cmdSystem     * = -1;
  cmdInternal   * = -2;
  cmdDisabled   * = -999;

TYPE

  CommandLineInterfacePtr* = BPOINTER TO CommandLineInterface;
  CommandLineInterface* = RECORD
    cliResult2       * : LONGINT;
    cliSetName       * : BSTR;
    cliCommandDir    * : BPTR;
    cliReturnCode    * : LONGINT;
    cliCommandName   * : BSTR;
    cliFailLevel     * : LONGINT;
    cliPrompt        * : BSTR;
    cliStandardInput * : BPTR;
    cliCurrentInput  * : BPTR;
    cliCommandFile   * : BSTR;
    cliInteractive   * : LONGINT;
    cliBackground    * : LONGINT;
    cliCurrentOutput * : BPTR;
    cliDefaultStack  * : LONGINT;
    cliStandardOutput* : BPTR;
    cliModule        * : BPTR;
  END;

  DeviceListPtr* = BPOINTER TO DeviceList;
  DeviceList* = RECORD
    dlNext      * : BPTR;
    dlType      * : LONGINT;
    dlTask      * : Exec.MsgPortPtr;
    dlLock      * : BPTR;
    dlVolumeDate* : DateStamp;
    dlLockList  * : BPTR;
    dlDiskType  * : LONGINT;
    dlunused    * : LONGINT;
    dlName      * : BSTR;
  END;

  DevInfoPtr* = BPOINTER TO DevInfo;
  DevInfo* = RECORD
    dviNext     * : BPTR;
    dviType     * : LONGINT;
    dviTask     * : Types.APTR;
    dviLock     * : BPTR;
    dviHandler  * : BSTR;
    dviStackSize* : LONGINT;
    dviPriority * : LONGINT;
    dviStartup  * : LONGINT;
    dviSegList  * : BPTR;
    dviGlobVec  * : BPTR;
    dviName     * : BSTR;
  END;

  AssignListPtr* = CPOINTER TO AssignList;
  AssignList* = RECORD
    alNext* : AssignListPtr;
    alLock* : BPTR;
  END;

  DosListPtr* = BPOINTER TO DosList;

  DosList* = RECORD
    dolNext      * : BPTR;
    dolType      * : LONGINT;
    dolTask      * : Exec.MsgPortPtr;
    dolLock      * : BPTR;
    dolAssignName* : Types.STRPTR;
    dolList      * : AssignListPtr;
    unused       * : ARRAY 4 OF LONGINT;

    dolName      * : BSTR;
  END;

CONST

  dltDevice     * = 0;
  dltDirectory  * = 1;
  dltVolume     * = 2;
  dltLate       * = 3;
  dltNonBinding * = 4;
  dltPrivate    * = -1;

TYPE

  DevProcPtr* = CPOINTER TO DevProc;
  DevProc* = RECORD
    dvpPort   * : Exec.MsgPortPtr;
    dvpLock   * : BPTR;
    dvpFlags  * : SET;
    dvpDevNode* : DosListPtr;
  END;

CONST

  dvpUnlock    * = 0;
  dvpAssign    * = 1;

  ldDevices    * = 2;
  ldVolumes    * = 3;
  ldAssigns    * = 4;
  ldEntry      * = 5;
  ldDelete     * = 6;

  ldRead       * = 0;
  ldWrite      * = 1;

  ldAll        * = {ldDevices, ldVolumes, ldAssigns};

TYPE

  FileLockPtr* = BPOINTER TO FileLock;
  FileLock* = RECORD
    flLink  * : BPTR;
    flKey   * : LONGINT;
    flAccess* : LONGINT;
    flTask  * : Exec.MsgPortPtr;
    flVolume* : BPTR;
  END;

CONST

  reportStream          * = 0;
  reportTask            * = 1;
  reportLock            * = 2;
  reportVolume          * = 3;
  reportInsert          * = 4;

  abortDiskError        * = 296;
  abortBusy             * = 288;

  runExecute            * = -1;
  runSystem             * = -2;
  runSystemAsynch       * = -3;

  stRoot        * = 1;
  stUserDir     * = 2;
  stSoftLink    * = 3;
  stLinkDir     * = 4;
  stFile        * = -3;
  stLinkFile    * = -4;
  stPipeFile    * = -5;

(*-- Library Base variable --------------------------------------------*)

CONST

  Name* =  "dos.library";

VAR

  Base* : DosLibraryPtr;
  cleanup : PROCEDURE (rc : LONGINT);

(*-- Library Functions ------------------------------------------------*)

LIBCALL (base : DosLibraryPtr) Open*
  ( name       {1} : ARRAY OF CHAR;
    accessMode {2} : LONGINT)
  : FileHandlePtr;
  -30;
LIBCALL (base : DosLibraryPtr) Close*
  ( file {1} : FileHandlePtr )
  : BOOLEAN;
  -36;
LIBCALL (base : DosLibraryPtr) OldClose*
  ( file {1} : FileHandlePtr );
  -36;
LIBCALL (base : DosLibraryPtr) Read*
  ( file       {1} : FileHandlePtr;
    VAR buffer {2} : ARRAY OF SYSTEM.BYTE;
    length     {3} : LONGINT)
  : LONGINT;
  -42;
LIBCALL (base : DosLibraryPtr) Write*
  ( file   {1} : FileHandlePtr;
    buffer {2} : ARRAY OF SYSTEM.BYTE;
    length {3} : LONGINT)
  : LONGINT;
  -48;
LIBCALL (base : DosLibraryPtr) Input* ()
  : FileHandlePtr;
  -54;
LIBCALL (base : DosLibraryPtr) Output* ()
  : FileHandlePtr;
  -60;
LIBCALL (base : DosLibraryPtr) Seek*
  ( file     {1} : FileHandlePtr;
    position {2} : LONGINT;
    offset   {3} : LONGINT)
  : LONGINT;
  -66;
LIBCALL (base : DosLibraryPtr) DeleteFile*
  ( name {1} : ARRAY OF CHAR )
  : BOOLEAN;
  -72;
LIBCALL (base : DosLibraryPtr) Rename*
  ( oldName {1} : ARRAY OF CHAR;
    newName {2} : ARRAY OF CHAR )
  : BOOLEAN;
  -78;
LIBCALL (base : DosLibraryPtr) Lock*
  ( name {1} : ARRAY OF CHAR;
    type {2} : LONGINT)
  : FileLockPtr;
  -84;
LIBCALL (base : DosLibraryPtr) UnLock*
  ( lock {1} : FileLockPtr );
  -90;
LIBCALL (base : DosLibraryPtr) DupLock*
  ( lock {1} : FileLockPtr )
  : FileLockPtr;
  -96;
LIBCALL (base : DosLibraryPtr) Examine*
  ( lock          {1} : FileLockPtr;
    fileInfoBlock {2} : FileInfoBlockPtr )
  : BOOLEAN;
  -102;
LIBCALL (base : DosLibraryPtr) ExNext*
  ( lock          {1} : FileLockPtr;
    fileInfoBlock {2} : FileInfoBlockPtr )
  : BOOLEAN;
  -108;
LIBCALL (base : DosLibraryPtr) Info*
  ( lock           {1} : FileLockPtr;
    parameterBlock {2} : InfoDataPtr )
  : BOOLEAN;
  -114;
LIBCALL (base : DosLibraryPtr) CreateDir*
  ( name {1} : ARRAY OF CHAR )
  : FileLockPtr;
  -120;
LIBCALL (base : DosLibraryPtr) CurrentDir*
  ( lock {1} : FileLockPtr )
  : FileLockPtr;
  -126;
LIBCALL (base : DosLibraryPtr) IoErr* ()
  : LONGINT;
  -132;
LIBCALL (base : DosLibraryPtr) CreateProc*
  ( name      {1} : ARRAY OF CHAR;
    pri       {2} : LONGINT;
    segList   {3} : BPTR;
    stackSize {4} : LONGINT)
  : Exec.MsgPortPtr;
  -138;
LIBCALL (base : DosLibraryPtr) Exit*
  ( returnCode {1} : LONGINT);
  -144;
LIBCALL (base : DosLibraryPtr) LoadSeg*
  ( name {1} : ARRAY OF CHAR )
  : BPTR;
  -150;
LIBCALL (base : DosLibraryPtr) UnLoadSeg*
  ( seglist {1} : BPTR )
  : BOOLEAN;
  -156;
LIBCALL (base : DosLibraryPtr) OldUnLoadSeg*
  ( seglist {1} : BPTR );
  -156;
LIBCALL (base : DosLibraryPtr) DeviceProc*
  ( name {1} : ARRAY OF CHAR )
  : Exec.MsgPortPtr;
  -174;
LIBCALL (base : DosLibraryPtr) SetComment*
  ( name    {1} : ARRAY OF CHAR;
    comment {2} : ARRAY OF CHAR )
  : BOOLEAN;
  -180;
LIBCALL (base : DosLibraryPtr) SetProtection*
  ( name    {1} : ARRAY OF CHAR;
    protect {2} : SET)
  : BOOLEAN;
  -186;
LIBCALL (base : DosLibraryPtr) DateStamp*
  ( VAR date {1} : DateStamp );
  -192;
LIBCALL (base : DosLibraryPtr) Delay*
  ( timeout {1} : Types.ULONG);
  -198;
LIBCALL (base : DosLibraryPtr) WaitForChar*
  ( file    {1} : FileHandlePtr;
    timeout {2} : LONGINT)
  : BOOLEAN;
  -204;
LIBCALL (base : DosLibraryPtr) ParentDir*
  ( lock {1} : FileLockPtr )
  : FileLockPtr;
  -210;
LIBCALL (base : DosLibraryPtr) IsInteractive*
  ( file {1} : FileHandlePtr )
  : BOOLEAN;
  -216;
LIBCALL (base : DosLibraryPtr) Execute*
  ( string {1} : ARRAY OF CHAR;
    file   {2} : FileHandlePtr;
    file2  {3} : FileHandlePtr )
  : LONGINT;
  -222;

LIBCALL (base : DosLibraryPtr) AllocDosObject*
  ( type     {1} : Types.ULONG;
    VAR tags {2} : ARRAY OF Utility.TagItem )
  : Types.APTR;
  -228;
LIBCALL (base : DosLibraryPtr) FreeDosObject*
  ( type {1} : Types.ULONG;
    ptr  {2} : Types.APTR );
  -234;

LIBCALL (base : DosLibraryPtr) DoPkt*
  ( VAR port {1} : Exec.MsgPort;
    action   {2} : LONGINT;
    arg1     {3} : LONGINT;
    arg2     {4} : LONGINT;
    arg3     {5} : LONGINT;
    arg4     {6} : LONGINT;
    arg5     {7} : LONGINT)
  : LONGINT;
  -240;
LIBCALL (base : DosLibraryPtr) DoPkt0*
  ( VAR port {1} : Exec.MsgPort;
    action   {2} : LONGINT)
  : LONGINT;
  -240;
LIBCALL (base : DosLibraryPtr) DoPkt1*
  ( VAR port {1} : Exec.MsgPort;
    action   {2} : LONGINT;
    arg1     {3} : LONGINT)
  : LONGINT;
  -240;
LIBCALL (base : DosLibraryPtr) DoPkt2*
  ( VAR port {1} : Exec.MsgPort;
    action   {2} : LONGINT;
    arg1     {3} : LONGINT;
    arg2     {4} : LONGINT)
  : LONGINT;
  -240;
LIBCALL (base : DosLibraryPtr) DoPkt3*
  ( VAR port {1} : Exec.MsgPort;
    action   {2} : LONGINT;
    arg1     {3} : LONGINT;
    arg2     {4} : LONGINT;
    arg3     {5} : LONGINT)
  : LONGINT;
  -240;
LIBCALL (base : DosLibraryPtr) DoPkt4*
  ( VAR port {1} : Exec.MsgPort;
    action   {2} : LONGINT;
    arg1     {3} : LONGINT;
    arg2     {4} : LONGINT;
    arg3     {5} : LONGINT;
    arg4     {6} : LONGINT)
  : LONGINT;
  -240;
LIBCALL (base : DosLibraryPtr) SendPkt*
  ( VAR dp        {1} : DosPacket;
    VAR port      {2} : Exec.MsgPort;
    VAR replyport {3} : Exec.MsgPort );
  -246;
LIBCALL (base : DosLibraryPtr) WaitPkt* ()
  : DosPacketPtr;
  -252;
LIBCALL (base : DosLibraryPtr) ReplyPkt*
  ( VAR dp {1} : DosPacket;
    res1   {2} : LONGINT;
    res2   {3} : LONGINT);
  -258;
LIBCALL (base : DosLibraryPtr) AbortPkt*
  ( VAR port {1} : Exec.MsgPort;
    VAR pkt  {2} : DosPacket );
  -264;

LIBCALL (base : DosLibraryPtr) LockRecord*
  ( fh      {1} : FileHandlePtr;
    offset  {2} : Types.ULONG;
    length  {3} : Types.ULONG;
    mode    {4} : Types.ULONG;
    timeout {5} : Types.ULONG )
  : BOOLEAN;
  -270;
LIBCALL (base : DosLibraryPtr) LockRecords*
  ( VAR recArray {1} : ARRAY OF RecordLock;
    timeout      {2} : Types.ULONG )
  : BOOLEAN;
  -276;
LIBCALL (base : DosLibraryPtr) UnLockRecord*
  ( fh     {1} : FileHandlePtr;
    offset {2} : Types.ULONG;
    length {3} : Types.ULONG )
  : BOOLEAN;
  -282;
LIBCALL (base : DosLibraryPtr) UnLockRecords*
  ( VAR recArray {1} : ARRAY OF RecordLock )
  : BOOLEAN;
  -288;

LIBCALL (base : DosLibraryPtr) SelectInput*
  ( fh {1} : FileHandlePtr )
  : FileHandlePtr;
  -294;
LIBCALL (base : DosLibraryPtr) SelectOutput*
  ( fh {1} : FileHandlePtr )
  : FileHandlePtr;
  -300;
LIBCALL (base : DosLibraryPtr) FGetC*
  ( fh {1} : FileHandlePtr )
  : LONGINT;
  -306;
LIBCALL (base : DosLibraryPtr) FPutC*
  ( fh {1} : FileHandlePtr;
    ch {2} : LONGINT )
  : LONGINT;
  -312;
LIBCALL (base : DosLibraryPtr) UnGetC*
  ( fh        {1} : FileHandlePtr;
    character {2} : LONGINT)
  : LONGINT;
  -318;
LIBCALL (base : DosLibraryPtr) FRead*
  ( fh        {1} : FileHandlePtr;
    VAR block {2} : ARRAY OF SYSTEM.BYTE;
    blocklen  {3} : Types.ULONG;
    number    {4} : Types.ULONG )
  : LONGINT;
  -324;
LIBCALL (base : DosLibraryPtr) FWrite*
  ( fh       {1} : FileHandlePtr;
    block    {2} : ARRAY OF SYSTEM.BYTE;
    blocklen {3} : Types.ULONG;
    number   {4} : Types.ULONG )
  : LONGINT;
  -330;
LIBCALL (base : DosLibraryPtr) FGets*
  ( fh      {1} : FileHandlePtr;
    VAR buf {2} : ARRAY OF CHAR;
    buflen  {3} : Types.ULONG )
  : Types.STRPTR;
  -336;
LIBCALL (base : DosLibraryPtr) FPuts*
  ( fh  {1} : FileHandlePtr;
    str {2} : ARRAY OF CHAR )
  : LONGINT;
  -342;
LIBCALL (base : DosLibraryPtr) VFWritef*
  ( fh       {1} : FileHandlePtr;
    format   {2} : ARRAY OF CHAR;
    VAR argv {3} : ARRAY OF LONGINT );
  -348;
LIBCALL (base : DosLibraryPtr) VFPrintf*
  ( fh       {1} : FileHandlePtr;
    format   {2} : ARRAY OF CHAR;
    VAR argv {3} : ARRAY OF LONGINT )
  : LONGINT;
  -354;
LIBCALL (base : DosLibraryPtr) Flush*
  ( fh {1} : FileHandlePtr )
  : BOOLEAN;
  -360;
LIBCALL (base : DosLibraryPtr) SetVBuf*
  ( fh   {1} : FileHandlePtr;
    buff {2} : SYSTEM.CPTR;
    type {3} : LONGINT;
    size {4} : LONGINT)
  : LONGINT;
  -366;

LIBCALL (base : DosLibraryPtr) DupLockFromFH*
  ( fh {1} : FileHandlePtr )
  : FileLockPtr;
  -372;
LIBCALL (base : DosLibraryPtr) OpenFromLock*
  ( lock {1} : FileLockPtr )
  : FileHandlePtr;
  -378;
LIBCALL (base : DosLibraryPtr) ParentOfFH*
  ( fh {1} : FileHandlePtr )
  : FileLockPtr;
  -384;
LIBCALL (base : DosLibraryPtr) ExamineFH*
  ( fh  {1} : FileHandlePtr;
    fib {2} : FileInfoBlockPtr )
  : BOOLEAN;
  -390;
LIBCALL (base : DosLibraryPtr) SetFileDate*
  ( name     {1} : ARRAY OF CHAR;
    VAR date {2} : DateStamp )
  : BOOLEAN;
  -396;
LIBCALL (base : DosLibraryPtr) NameFromLock*
  ( lock       {1} : FileLockPtr;
    VAR buffer {2} : ARRAY OF CHAR;
    len        {3} : LONGINT)
  : BOOLEAN;
  -402;
LIBCALL (base : DosLibraryPtr) NameFromFH*
  ( fh         {1} : FileHandlePtr;
    VAR buffer {2} : ARRAY OF CHAR;
    len        {3} : LONGINT)
  : BOOLEAN;
  -408;
LIBCALL (base : DosLibraryPtr) SplitName*
  ( name      {1} : ARRAY OF CHAR;
    seperator {2} : LONGINT;
    VAR buf   {3} : ARRAY OF CHAR;
    oldpos    {4} : LONGINT;
    size      {5} : LONGINT)
  : INTEGER;
  -414;
LIBCALL (base : DosLibraryPtr) SameLock*
  ( lock1 {1} : FileLockPtr;
    lock2 {2} : FileLockPtr )
  : LONGINT;
  -420;
LIBCALL (base : DosLibraryPtr) SetMode*
  ( fh   {1} : FileHandlePtr;
    mode {2} : LONGINT)
  : BOOLEAN;
  -426;
LIBCALL (base : DosLibraryPtr) ExAll*
  ( lock    {1} : FileLockPtr;
    buffer  {2} : ExAllDataPtr;
    size    {3} : LONGINT;
    data    {4} : LONGINT;
    control {5} : ExAllControlPtr )
  : BOOLEAN;
  -432;
LIBCALL (base : DosLibraryPtr) ReadLink*
  ( VAR port   {1} : Exec.MsgPort;
    lock       {2} : FileLockPtr;
    path       {3} : ARRAY OF CHAR;
    VAR buffer {4} : ARRAY OF CHAR;
    size       {5} : Types.ULONG )
  : BOOLEAN;
  -438;
LIBCALL (base : DosLibraryPtr) MakeLink*
  ( name {1} : ARRAY OF CHAR;
    dest {2} : LONGINT;
    soft {3} : LONGINT)
  : BOOLEAN;
  -444;
LIBCALL (base : DosLibraryPtr) ChangeMode*
  ( type    {1} : LONGINT;
    fh      {2} : LONGINT;
    newmode {3} : LONGINT)
  : BOOLEAN;
  -450;
LIBCALL (base : DosLibraryPtr) SetFileSize*
  ( fh   {1} : FileHandlePtr;
    pos  {2} : LONGINT;
    mode {3} : LONGINT)
  : LONGINT;
  -456;

LIBCALL (base : DosLibraryPtr) SetIoErr*
  ( result {1} : LONGINT)
  : LONGINT;
  -462;
LIBCALL (base : DosLibraryPtr) Fault*
  ( code       {1} : LONGINT;
    header     {2} : ARRAY OF CHAR;
    VAR buffer {3} : ARRAY OF CHAR;
    len        {4} : LONGINT)
  : BOOLEAN;
  -468;
LIBCALL (base : DosLibraryPtr) PrintFault*
  ( code   {1} : LONGINT;
    header {2} : ARRAY OF CHAR )
  : BOOLEAN;
  -474;
LIBCALL (base : DosLibraryPtr) ErrorReport*
  ( code   {1} : LONGINT;
    type   {2} : LONGINT;
    arg1   {3} : LONGINT;
    device {8} : Exec.MsgPortPtr )
  : BOOLEAN;
  -480;

LIBCALL (base : DosLibraryPtr) Cli* ()
  : CommandLineInterfacePtr;
  -492;
LIBCALL (base : DosLibraryPtr) CreateNewProc*
  ( VAR tags {1} : ARRAY OF Utility.TagItem )
  : ProcessPtr;
  -498;
LIBCALL (base : DosLibraryPtr) RunCommand*
  ( seg      {1} : BPTR;
    stack    {2} : LONGINT;
    paramptr {3} : ARRAY OF CHAR;
    paramlen {4} : LONGINT)
  : LONGINT;
  -504;
LIBCALL (base : DosLibraryPtr) GetConsoleTask* ()
  : Exec.MsgPortPtr;
  -510;
LIBCALL (base : DosLibraryPtr) SetConsoleTask*
  ( VAR task {1} : Exec.MsgPort )
  : Exec.MsgPortPtr;
  -516;
LIBCALL (base : DosLibraryPtr) GetFileSysTask* ()
  : Exec.MsgPortPtr;
  -522;
LIBCALL (base : DosLibraryPtr) SetFileSysTask*
  ( VAR task {1} : Exec.MsgPort )
  : Exec.MsgPortPtr;
  -528;
LIBCALL (base : DosLibraryPtr) GetArgStr* ()
  : Types.STRPTR;
  -534;
LIBCALL (base : DosLibraryPtr) SetArgStr*
  ( string {1} : ARRAY OF CHAR )
  : Types.STRPTR;
  -540;
LIBCALL (base : DosLibraryPtr) FindCliProc*
  ( num {1} : Types.ULONG )
  : ProcessPtr;
  -546;
LIBCALL (base : DosLibraryPtr) MaxCli* ()
  : Types.ULONG;
  -552;
LIBCALL (base : DosLibraryPtr) SetCurrentDirName*
  ( name {1} : ARRAY OF CHAR )
  : BOOLEAN;
  -558;
LIBCALL (base : DosLibraryPtr) GetCurrentDirName*
  ( VAR buf {1} : ARRAY OF CHAR;
    len     {2} : LONGINT)
  : BOOLEAN;
  -564;
LIBCALL (base : DosLibraryPtr) SetProgramName*
  ( name {1} : ARRAY OF CHAR )
  : BOOLEAN;
  -570;
LIBCALL (base : DosLibraryPtr) GetProgramName*
  ( VAR buf {1} : ARRAY OF CHAR;
    len     {2} : LONGINT)
  : BOOLEAN;
  -576;
LIBCALL (base : DosLibraryPtr) SetPrompt*
  ( name {1} : ARRAY OF CHAR )
  : BOOLEAN;
  -582;
LIBCALL (base : DosLibraryPtr) GetPrompt*
  ( VAR buf {1} : ARRAY OF CHAR;
    len     {2} : LONGINT)
  : BOOLEAN;
  -588;
LIBCALL (base : DosLibraryPtr) SetProgramDir*
  ( lock {1} : FileLockPtr )
  : FileLockPtr;
  -594;
LIBCALL (base : DosLibraryPtr) GetProgramDir* ()
  : FileLockPtr;
  -600;

LIBCALL (base : DosLibraryPtr) System*
  ( command  {1} : ARRAY OF CHAR;
    VAR tags {2} : ARRAY OF Utility.TagItem )
  : LONGINT;
  -606;
LIBCALL (base : DosLibraryPtr) AssignLock*
  ( name {1} : ARRAY OF CHAR;
    lock {2} : FileLockPtr )
  : BOOLEAN;
  -612;
LIBCALL (base : DosLibraryPtr) AssignLate*
  ( name {1} : ARRAY OF CHAR;
    path {2} : ARRAY OF CHAR )
  : BOOLEAN;
  -618;
LIBCALL (base : DosLibraryPtr) AssignPath*
  ( name {1} : ARRAY OF CHAR;
    path {2} : ARRAY OF CHAR )
  : BOOLEAN;
  -624;
LIBCALL (base : DosLibraryPtr) AssignAdd*
  ( name {1} : ARRAY OF CHAR;
    lock {2} : FileLockPtr )
  : BOOLEAN;
  -630;
LIBCALL (base : DosLibraryPtr) RemAssignList*
  ( name {1} : ARRAY OF CHAR;
    lock {2} : FileLockPtr )
  : BOOLEAN;
  -636;
LIBCALL (base : DosLibraryPtr) GetDeviceProc*
  ( name {1} : ARRAY OF CHAR;
    dp   {2} : DevProcPtr )
  : DevProcPtr;
  -642;
LIBCALL (base : DosLibraryPtr) FreeDeviceProc*
  ( dp {1} : DevProcPtr );
  -648;
LIBCALL (base : DosLibraryPtr) LockDosList*
  ( flags {1} : SET )
  : DosListPtr;
  -654;
LIBCALL (base : DosLibraryPtr) UnLockDosList*
  ( flags {1} : SET );
  -660;
LIBCALL (base : DosLibraryPtr) AttemptLockDosList*
  ( flags {1} : SET )
  : DosListPtr;
  -666;
LIBCALL (base : DosLibraryPtr) RemDosEntry*
  ( dlist {1} : DosListPtr )
  : BOOLEAN;
  -672;
LIBCALL (base : DosLibraryPtr) AddDosEntry*
  ( dlist {1} : DosListPtr )
  : BOOLEAN;
  -678;
LIBCALL (base : DosLibraryPtr) FindDosEntry*
  ( dlist {1} : DosListPtr;
    name  {2} : ARRAY OF CHAR;
    flags {3} : SET )
  : DosListPtr;
  -684;
LIBCALL (base : DosLibraryPtr) NextDosEntry*
  ( dlist {1} : DosListPtr;
    flags {2} : SET )
  : DosListPtr;
  -690;
LIBCALL (base : DosLibraryPtr) MakeDosEntry*
  ( name {1} : ARRAY OF CHAR;
    type {2} : LONGINT)
  : DosListPtr;
  -696;
LIBCALL (base : DosLibraryPtr) FreeDosEntry*
  ( dlist {1} : DosListPtr );
  -702;
LIBCALL (base : DosLibraryPtr) IsFileSystem*
  ( name {1} : ARRAY OF CHAR )
  : BOOLEAN;
  -708;

LIBCALL (base : DosLibraryPtr) Format*
  ( filesystem {1} : ARRAY OF CHAR;
    volumename {2} : ARRAY OF CHAR;
    dostype    {3} : Types.ULONG )
  : BOOLEAN;
  -714;
LIBCALL (base : DosLibraryPtr) Relabel*
  ( drive   {1} : ARRAY OF CHAR;
    newname {2} : ARRAY OF CHAR )
  : BOOLEAN;
  -720;
LIBCALL (base : DosLibraryPtr) Inhibit*
  ( name  {1} : ARRAY OF CHAR;
    onoff {2} : LONGINT)
  : BOOLEAN;
  -726;
LIBCALL (base : DosLibraryPtr) AddBuffers*
  ( name   {1} : ARRAY OF CHAR;
    number {2} : LONGINT)
  : BOOLEAN;
  -732;

LIBCALL (base : DosLibraryPtr) CompareDates*
  ( VAR date1 {1} : DateStamp;
    VAR date2 {2} : DateStamp )
  : LONGINT;
  -738;
LIBCALL (base : DosLibraryPtr) DateToStr*
  ( VAR datetime {1} : DateTime )
  : BOOLEAN;
  -744;
LIBCALL (base : DosLibraryPtr) StrToDate*
  ( VAR datetime {1} : DateTime )
  : BOOLEAN;
  -750;

LIBCALL (base : DosLibraryPtr) InternalLoadSeg*
  ( fh            {1} : FileHandlePtr;
    table         {8} : BPTR;
    VAR funcarray {9} : ARRAY OF Types.PROC;
    VAR stack    {10} : LONGINT )
  : BPTR;
  -756;
LIBCALL (base : DosLibraryPtr) InternalUnLoadSeg*
  ( seglist  {1} : BPTR;
    freefunc {9} : Types.PROC )
  : BOOLEAN;
  -762;
LIBCALL (base : DosLibraryPtr) NewLoadSeg*
  ( file     {1} : ARRAY OF CHAR;
    VAR tags {2} : ARRAY OF Utility.TagItem )
  : BPTR;
  -768;
LIBCALL (base : DosLibraryPtr) AddSegment*
  ( name   {1} : ARRAY OF CHAR;
    seg    {2} : BPTR;
    system {3} : LONGINT)
  : BOOLEAN;
  -774;
LIBCALL (base : DosLibraryPtr) FindSegment*
  ( name   {1} : ARRAY OF CHAR;
    seg    {2} : SegmentPtr;
    system {3} : LONGINT)
  : SegmentPtr;
  -780;
LIBCALL (base : DosLibraryPtr) RemSegment*
  ( VAR seg {1} : Segment )
  : BOOLEAN;
  -786;

LIBCALL (base : DosLibraryPtr) CheckSignal*
  ( mask {1} : SET)
  : SET;
  -792;
LIBCALL (base : DosLibraryPtr) ReadArgs*
  ( template  {1} : ARRAY OF CHAR;
    VAR array {2} : ARRAY OF LONGINT;
    args      {3} : RDArgsPtr )
  : RDArgsPtr;
  -798;
LIBCALL (base : DosLibraryPtr) FindArg*
  ( template {1} : ARRAY OF CHAR;
    keyword  {2} : ARRAY OF CHAR )
  : LONGINT;
  -804;
LIBCALL (base : DosLibraryPtr) ReadItem*
  ( VAR name {1} : ARRAY OF CHAR;
    maxchars {2} : LONGINT;
    cSource  {3} : CSourcePtr )
  : LONGINT;
  -810;
LIBCALL (base : DosLibraryPtr) StrToLong*
  ( string    {1} : ARRAY OF CHAR;
    VAR value {2} : LONGINT )
  : LONGINT;
  -816;
LIBCALL (base : DosLibraryPtr) MatchFirst*
  ( pat    {1} : ARRAY OF CHAR;
    anchor {2} : AnchorPathPtr )
  : LONGINT;
  -822;
LIBCALL (base : DosLibraryPtr) MatchNext*
  ( anchor {1} : AnchorPathPtr )
  : LONGINT;
  -828;
LIBCALL (base : DosLibraryPtr) MatchEnd*
  ( anchor {1} : AnchorPathPtr );
  -834;
LIBCALL (base : DosLibraryPtr) ParsePattern*
  ( pat     {1} : ARRAY OF CHAR;
    VAR buf {2} : ARRAY OF CHAR;
    buflen  {3} : LONGINT)
  : LONGINT;
  -840;
LIBCALL (base : DosLibraryPtr) MatchPattern*
  ( pat {1} : ARRAY OF CHAR;
    str {2} : ARRAY OF CHAR )
  : BOOLEAN;
  -846;
LIBCALL (base : DosLibraryPtr) FreeArgs*
  ( args {1} : RDArgsPtr );
  -858;
LIBCALL (base : DosLibraryPtr) FilePart*
  ( path {1} : ARRAY OF CHAR )
  : Types.STRPTR;
  -870;
LIBCALL (base : DosLibraryPtr) PathPart*
  ( path {1} : ARRAY OF CHAR )
  : Types.STRPTR;
  -876;
LIBCALL (base : DosLibraryPtr) AddPart*
  ( VAR dirname {1} : ARRAY OF CHAR;
    filename    {2} : ARRAY OF CHAR;
    size        {3} : Types.ULONG )
  : BOOLEAN;
  -882;

LIBCALL (base : DosLibraryPtr) StartNotify*
  ( VAR notify {1} : NotifyRequest )
  : BOOLEAN;
  -888;
LIBCALL (base : DosLibraryPtr) EndNotify*
  ( VAR notify {1} : NotifyRequest );
  -894;

LIBCALL (base : DosLibraryPtr) SetVar*
  ( name       {1} : ARRAY OF CHAR;
    VAR buffer {2} : ARRAY OF CHAR;
    size       {3} : LONGINT;
    flags      {4} : SET)
  : BOOLEAN;
  -900;
LIBCALL (base : DosLibraryPtr) GetVar*
  ( name       {1} : ARRAY OF CHAR;
    VAR buffer {2} : ARRAY OF CHAR;
    size       {3} : LONGINT;
    flags      {4} : SET)
  : LONGINT;
  -906;
LIBCALL (base : DosLibraryPtr) DeleteVar*
  ( name  {1} : ARRAY OF CHAR;
    flags {2} : SET )
  : BOOLEAN;
  -912;
LIBCALL (base : DosLibraryPtr) FindVar*
  ( name {1} : ARRAY OF CHAR;
    type {2} : Types.ULONG )
  : LocalVarPtr;
  -918;
LIBCALL (base : DosLibraryPtr) CliInitNewcli*
  ( dp {8} : DosPacketPtr )
  : SET;
  -930;
LIBCALL (base : DosLibraryPtr) CliInitRun*
  ( dp {8} : DosPacketPtr )
  : SET;
  -936;
LIBCALL (base : DosLibraryPtr) WriteChars*
  ( buf    {1} : ARRAY OF CHAR;
    buflen {2} : LONGINT )
  : LONGINT;
  -942;
LIBCALL (base : DosLibraryPtr) PutStr*
  ( str {1} : ARRAY OF CHAR )
  : LONGINT;
  -948;
LIBCALL (base : DosLibraryPtr) VPrintf*
  ( format       {1} : ARRAY OF CHAR;
    VAR argarray {2} : ARRAY OF LONGINT )
  : LONGINT;
  -954;

LIBCALL (base : DosLibraryPtr) ParsePatternNoCase*
  ( pat     {1} : ARRAY OF CHAR;
    VAR buf {2} : ARRAY OF CHAR;
    buflen  {3} : LONGINT)
  : LONGINT;
  -966;
LIBCALL (base : DosLibraryPtr) MatchPatternNoCase*
  ( pat {1} : ARRAY OF CHAR;
    str {2} : ARRAY OF CHAR )
  : BOOLEAN;
  -972;

LIBCALL (base : DosLibraryPtr) SameDevice*
  ( lock1 {1} : FileLockPtr;
    lock2 {2} : FileLockPtr )
  : BOOLEAN;
  -984;

(*-- Library Initialisation -------------------------------------------*)

PROCEDURE* Close (rc : LONGINT);

BEGIN
  IF Base # NIL THEN Exec.Base.CloseLibrary (Base) END;
  IF cleanup # NIL THEN cleanup (rc) END;
END Close;

BEGIN
  Base := Exec.Base.OpenLibrary (Name, Exec.libraryMinimum);
  IF Base = NIL THEN HALT (100) END;
  SYSTEM.SETCLEANUP (Close, cleanup)
END Dos.

(**************************************************************************

  $Log: Dos.mod $
  Revision 1.2  1994/05/12  19:11:02  fjc
  - Prepared for release

  Revision 1.1  1994/01/15  20:49:58  fjc
  - Start of revision control

***************************************************************************)



(* Comments stripped by StripComments 1.0 *)