AmigaOS4: library units for utility.library, timer.device and dos.library

git-svn-id: trunk@33552 -

.gitattributes

@@ -6316,7 +6316,10 @@ packages/os4units/Makefile svneol=native#text/plain
 packages/os4units/Makefile.fpc svneol=native#text/plain
 packages/os4units/Makefile.fpc.fpcmake svneol=native#text/plain
 packages/os4units/fpmake.pp svneol=native#text/pascal
+packages/os4units/src/amigados.pas svneol=native#text/pascal
 packages/os4units/src/exec.pas svneol=native#text/pascal
+packages/os4units/src/timer.pas svneol=native#text/pascal
+packages/os4units/src/utility.pas svneol=native#text/pascal
 packages/palmunits/Makefile svneol=native#text/plain
 packages/palmunits/Makefile.fpc svneol=native#text/plain
 packages/palmunits/Makefile.fpc.fpcmake svneol=native#text/plain

packages/os4units/fpmake.pp

@@ -32,6 +32,9 @@ begin
     P.IncludePath.Add('src');
 
     T:=P.Targets.AddUnit('exec.pas');
+    T:=P.Targets.AddUnit('timer.pas');
+    T:=P.Targets.AddUnit('utility.pas');
+    T:=P.Targets.AddUnit('amigados.pas');
 
 {$ifndef ALLPACKAGES}
     Run;

packages/os4units/src/amigados.pas

@@ -0,0 +1,2780 @@
+{
+    This file is part of the Free Pascal run time library.
+    Copyright (c) 2016 by Free Pascal development team
+
+    dos.library functions for Amiga OS 4.x
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ **********************************************************************}
+
+{$PACKRECORDS 2}
+
+unit amigados;
+
+interface
+
+uses
+  exec, utility, timer;
+
+const
+// Predefined Amiga DOS global constants
+  DOSTRUE     = -1;
+  DOSFALSE    =  0;
+
+  BITSPERBYTE  = 8;
+  BYTESPERLONG = 4;
+  BITSPERLONG  = 32;
+  MAXINT       = $7FFFFFFF;
+  MININT       = $80000000;
+
+// Mode parameter to Open(), all files are positioned at beginning of file.
+  MODE_OLDFILE   = 1005; // Open existing file read/write positioned at beginning of file.
+  MODE_NEWFILE   = 1006; // Open freshly created file (delete old file) read/write
+  MODE_READWRITE = 1004; // Open old file w/exclusive lock
+
+// Relative position to Seek(deprecated) and ChangeFilePosition()
+  OFFSET_BEGINNING = -1; // relative to Begining Of File
+  OFFSET_CURRENT   = 0;  // relative to Current file position
+  OFFSET_END       = 1;  // relative to End Of File
+
+// Passed as 'accessMode' to Lock()
+  SHARED_LOCK    = -2; // File is readable by others
+  ACCESS_READ    = -2; //   Somewhat misleading old synonym
+  EXCLUSIVE_LOCK = -1; // No other access allowed
+  ACCESS_WRITE   = -1; //   Somewhat misleading old synonym
+
+// *********************************************************************
+// Flags for the bitmasks returned by LockTags() when using LK_InfoMask tag.*/
+// These provide detailed information on the string being resolved.  V53.57 */
+
+  LOCKB_SOFTLINK_MIDPART = 8;  // One or more soft links were found in the middle of the path
+                               // but none of these formed the last component of the path.
+  LOCKB_SOFTLINK_ENDPART = 9;  // One soft link exists as the last component of the path.
+  LOCKB_DEVICE           = 16; // The supplied path is a device relative specification.
+  LOCKB_VOLUME           = 17; // The supplied path is a volume relative specification.
+  LOCKB_ASSIGNMENT       = 18; // The supplied path is an assignment relative specification.
+  LOCKB_PROGDIR          = 19; // The supplied path is a PROGDIR: relative specification.
+  LOCKB_CURRDIR          = 20; // The supplied path is a CURRDIR: relative specification.
+  LOCKB_ROOTDIR          = 21; // The supplied path is a root directory relative specification.
+  LOCKB_FILESYS          = 24; // The supplied path returned the root of the default filesystem.
+
+// Field definitions of the above.
+  LOCKF_SOFTLINK_MIDPART = 1 shl LOCKB_SOFTLINK_MIDPART;
+  LOCKF_SOFTLINK_ENDPART = 1 shl LOCKB_SOFTLINK_ENDPART;
+  LOCKF_DEVICE           = 1 shl LOCKB_DEVICE;
+  LOCKF_VOLUME           = 1 shl LOCKB_VOLUME;
+  LOCKF_ASSIGNMENT       = 1 shl LOCKB_ASSIGNMENT;
+  LOCKF_PROGDIR          = 1 shl LOCKB_PROGDIR;
+  LOCKF_CURRDIR          = 1 shl LOCKB_CURRDIR;
+  LOCKF_ROOTDIR          = 1 shl LOCKB_ROOTDIR;
+  LOCKF_FILESYS          = 1 shl LOCKB_FILESYS;
+
+// *********************************************************************
+// Result flags for WaitForData().
+  WFDB_READ  = 0; // Stream has data ready to be read
+  WFDB_WRITE = 1; // Stream is ready to accept more data to be written.
+
+  WFDF_READ  = 1 shl WFDB_READ;
+  WFDF_WRITE = 1 shl WFDB_WRITE;
+
+// *********************************************************************
+// NotifyProcListChange(), NotifyDosListChange(), termination signal value.
+  NPLC_END = $FFFFFFFF;
+  NDLC_END = $FFFFFFFF;
+
+// *********************************************************************
+// SetBlockingMode() mode values which define whether read/write access to a
+// stream will block until a request is satisfied or will return immediately.
+  SBM_BLOCKING     = 1;
+  SBM_NON_BLOCKING = 2;
+
+// *********************************************************************
+// GetPID() function, this flag determins which PID is returned. 53.58
+  GPID_PROCESS = 1;
+  GPID_PARENT  = 2;
+
+// *********************************************************************
+// Length constants specifically for new vector-port based filesystems.
+// Older packet filesystem designs may not support these lengths,
+// so use FileSystemAttr() to find out filesystem specific values.
+  MAX_VP_FILENAME   = 255;
+  MAX_VP_COMMENT    = 255;
+  MAX_VP_SOFTLINK_TARGET = 4000;
+
+type
+  FileHandle = BPTR;
+  FileLock   = BPTR;
+
+// *********************************************************************
+  PDateStamp = ^TDateStamp;
+  TDateStamp = record
+    ds_Days: LongInt;   // Number of days since Jan. 1, 1978
+    ds_Minute: LongInt; // Number of minutes past midnight
+    ds_Tick: LongInt;   // Number of ticks past minute
+  end;
+
+const
+  TICKS_PER_SECOND = 50; // Fifty ticks = one second One tick = twenty milliseconds
+
+// *********************************************************************
+// V52 Struct ExamineData, returned by ExamineObject() and ExamineDir().
+// This structure supports unlimited string lengths, 64 bit file sizes,
+// automatic resolution of link targets and extended auxilliary information.
+//
+// NOTE; Applications DO NOT allocate these, the filesystem does it.
+//       Also, the filesystem itself must always allocate these using
+//       AllocDosObject(), otherwise they will simply not work.
+type
+  // (RO) = Read Only, these fields must not be modified by the application.
+  PExamineData = ^TExamineData;
+  TExamineData = record
+    EXDnode: TMinNode;     // MinList node.
+    EXDinfo: LongWord;     // General purpose user data.
+
+    // These are private members exclusively for the FS & DOS.
+    FSPrivate: LongWord;   // FILESYSTEM ONLY - Private usage.
+    Reserved0: LongWord;   // DOS RESERVED - Private usage.
+    DOSPrivate: APTR;      // DOSLIB ONLY - Private usage.
+
+    // The following are public fields.
+    StructSize: LongWord;  // (RO) Full size of the structure.
+    Type_: LongWord;       // Entry type; use EXD_IS_ macros below.
+    FileSize: Int64;       // Size of a file, otherwise set to -1.
+    Date: TDateStamp;      // Days, Mins, Ticks.
+    RefCount: LongWord;    // Object hardlink references.    [Note 1]
+    ObjectID: QWord;       // Unique object identifier.      [Note 2]
+    Name: STRPTR;          // (RO) Nul-terminated object name.
+    NameSize: LongWord;    // (RO) Allocated size of the name buffer.
+    Comment: STRPTR;       // (RO) Nul-terminated comment string.
+    CommentSize: LongWord; // (RO) Allocated size of comment buffer.
+    Link: STRPTR;          // (RO) Nul-terminated target name string.
+    LinkSize: LongWord;    // (RO) Allocated size of target buffer.
+    Protection: LongWord;  // Protection status bitmask.
+    OwnerUID: LongWord;    // Owner info. [Note 3]
+    OwnerGID: LongWord;    // Group info. [Note 3]
+    Reserved2: LongWord;   // DOS reserved field.
+    Reserved3: LongWord;   // DOS reserved field.
+    Reserved4: LongWord;   // DOS reserved field.
+  end;
+{
+ [Note 1] If possible, this field should be supported by filesystems that
+          support hardlinks, it is used to indicate the hardlink reference
+          count for objects.  A value of one indicates that the object has
+          no additional references other than itself, a value of two will
+          indicate that it has one additional hardlink reference,
+          a value of three means it has two hardlink references, etc...
+          All hardlinks themselves always show a value of 1 in this field
+          when supported, otherwise this field MUST be set to zero for
+          all objects, if the filesystem does not support it.
+          It will be undefined if the caller fails to specify the
+          EXF_REFCOUNT bit in the EX_DataFields mask.
+
+ [Note 2] This field is the mandatory unique object identfier for all
+          objects on this volume, the value used here may be any arbitrary
+          value as long as it is unique from all other objects on this
+          volume, it may use the object node address, the disk header block
+          number or other such values. (Note: this field is 64 bits wide.)
+          This field will be undefined if you fail to specify the
+          EXF_OBJECTID bit in the EX_DataFields mask.
+
+ [Note 3] Historically, these fields only used the low 16 bits.
+          For extensibility, the size of these are now 32 bit fields.
+          However, for interoperability, it is recommended that values
+          greater than 65535 be avoided where possible so reading only
+          the low 16 bits results in the same value for legacy applications.
+          These fields will be undefined if you fail to specify the
+          EXF_OWNER bit in the EX_DataFields mask.
+          (See extended information relating to the UID/GID fields below.)}
+
+// *********************************************************************
+// Bit mask field values that are passed in the EX_DataFields tag,
+// this determines what data is returned from the ExamineDir() function.
+//
+// The data value returned in the respective fields will be undefined if
+// the mask bit is not specified, NEVER assume otherwise.
+const
+  EXF_DATE       = 1 shl 0;
+  EXF_REFCOUNT   = 1 shl 1;
+  EXF_NAME       = 1 shl 2;
+  EXF_COMMENT    = 1 shl 3;
+  EXF_LINK       = 1 shl 4;
+  EXF_PROTECTION = 1 shl 5;
+  EXF_OWNER      = 1 shl 6;  // both Group and User ID
+  EXF_TYPE       = 1 shl 7;  // MUST be specified for EXD_IS macros
+  EXF_SIZE       = 1 shl 8;
+  EXF_OBJECTID   = 1 shl 9;
+
+  EXF_spare1     = 1 shl 10; // reserved for future EXF_ALL feature
+  EXF_spare2     = 1 shl 11; // reserved for future EXF_ALL feature
+  EXF_spare3     = 1 shl 12; // reserved for future EXF_ALL feature
+  EXF_spare4     = 1 shl 13; // reserved for future EXF_ALL feature
+  EXF_spare5     = 1 shl 14; // reserved for future EXF_ALL feature
+  EXF_spare6     = 1 shl 15; // reserved for future EXF_ALL feature
+
+  EXF_ALL        = $FFFF;    // Return all of the information above
+
+// *********************************************************************
+// Values for ExamineData->Type for checking what kind of object it describes.
+// The lower 8 bits form the unique descriptor value, the upper bits are used
+// as a bitmask. The FSO_TYPE_MASK is used to filter the descriptor value.
+// NOTE: You MUST specify EXF_TYPE in the EX_DataFields tag for these macros
+//       to work otherwise random values will be returned in the 'Type' field.
+
+  FSO_TYPE_MASK      = $FF; // mask for object type descriptors
+
+  FSO_TYPE_SOFTLINK  = 0;   // Object is a softlink
+  FSO_TYPE_FILE      = 1;   // Object is a file
+  FSO_TYPE_DIRECTORY = 2;   // Object is a directory
+  FSO_TYPE_PIPE      = 3;   // Object is a pipe stream
+  FSO_TYPE_SOCKET    = 4;   // Object is a socket stream
+
+  FSO_TYPE_INVALID   = $FE; // Object is unidentifiable or corrupt, you SHOULD never actually see this,
+                            // but the value is reserved here for use by the handler AND DOS to indicate internal errors.
+                            // You MAY also possibly see this value if one were to read the 'Type' member without
+                            // setting the EXF_TYPE bit in EX_DataFields.
+  FSOF_LINK    = 1 shl 8; // Bit set for FFS style hard & soft links
+  FSOF_ALTLINK = 1 shl 9; // Reserved bit for alternate style links, these are currently unimplemented.
+
+// Information relating to the ExamineData; OwnerUID and OwnerGID members.
+  DOS_OWNER_ROOT = 65535;
+  DOS_OWNER_NONE = 0;
+
+// *********************************************************************
+// Definitions for the ExamineData "Protection" bitfield.
+  EXDB_OTR_READ        = 15; // Other: file is readable
+  EXDB_OTR_WRITE       = 14; // Other: file is writable
+  EXDB_OTR_EXECUTE     = 13; // Other: file is executable
+  EXDB_OTR_DELETE      = 12; // Other: file is deleted
+  EXDB_GRP_READ        = 11; // Group: file is readable
+  EXDB_GRP_WRITE       = 10; // Group: file is writable
+  EXDB_GRP_EXECUTE     =  9; // Group: file is executable
+  EXDB_GRP_DELETE      =  8; // Group: file is deleteable
+
+  EXDB_HOLD             = 7; // (H) hold loaded program in cli resident list (v50)
+  EXDB_SCRIPT           = 6; // (S) program is a script (execute) file
+  EXDB_PURE             = 5; // (P) program is reentrant and reexecutable
+  EXDB_ARCHIVE          = 4; // (A) cleared whenever file is changed
+  EXDB_NO_READ          = 3; // (R) NOT readable,
+  EXDB_NO_WRITE         = 2; // (W) NOT writable,
+  EXDB_NO_EXECUTE       = 1; // (E) NOT executable, Used by Shell only
+  EXDB_NO_DELETE        = 0; // (D) NOT deletable,
+
+// Masks for above bits
+  EXDF_OTR_READ    = 1 shl EXDB_OTR_READ;
+  EXDF_OTR_WRITE   = 1 shl EXDB_OTR_WRITE;
+  EXDF_OTR_EXECUTE = 1 shl EXDB_OTR_EXECUTE;
+  EXDF_OTR_DELETE  = 1 shl EXDB_OTR_DELETE;
+  EXDF_GRP_READ    = 1 shl EXDB_GRP_READ;
+  EXDF_GRP_WRITE   = 1 shl EXDB_GRP_WRITE;
+  EXDF_GRP_EXECUTE = 1 shl EXDB_GRP_EXECUTE;
+  EXDF_GRP_DELETE  = 1 shl EXDB_GRP_DELETE;
+
+  EXDF_HOLD        = 1 shl EXDB_HOLD;
+  EXDF_SCRIPT      = 1 shl EXDB_SCRIPT;
+  EXDF_PURE        = 1 shl EXDB_PURE;
+  EXDF_ARCHIVE     = 1 shl EXDB_ARCHIVE;
+  EXDF_NO_READ     = 1 shl EXDB_NO_READ;
+  EXDF_NO_WRITE    = 1 shl EXDB_NO_WRITE;
+  EXDF_NO_EXECUTE  = 1 shl EXDB_NO_EXECUTE;
+  EXDF_NO_DELETE   = 1 shl EXDB_NO_DELETE;
+
+  EXDF_DEFAULT = 0;
+
+{$PACKRECORDS 4}
+type
+// Returned by Examine() and ExInfo(), must be on a 4 byte boundary
+// This structure is obsolete, due to 4 gig file size limits, short string
+// length issues and lack of extensibility.
+// Software should migrate to using the new ExamineDir() and the ExamineObject()
+// functions which use the struct ExamineData.
+//
+// This structure is here because it is nested within other structures and for
+// legacy compatibility reasons, so this definition can't be removed at this time.
+//
+// NOTE: The fib_DOSReserved[8] area is ABSOLUTELY DOS PRIVATE !! - Do not access it.
+//       DOS uses all of this space for context information when emulating the
+//       old V40 functions that require this structure.
+
+  PFileInfoBlock = ^TFileInfoBlock;
+  TFileInfoBlock = record
+    fib_DiskKey: LongWord;     // -- FILESYSTEM PRIVATE !!
+    fib_DirEntryType: LongInt; // Use FIB_IS_ macros to identify object.
+    fib_FileName: array[0..107] of Char; // Null terminated.
+    fib_Protection: LongWord;  // Bit mask of protection, rwxd are 3-0.
+    fib_Obsolete: LongInt;     // obsolete use fib_DirEntryType instead
+    fib_Size: LongWord;        // Byte size of file, only good to 4 gig.
+    fib_NumBlocks: LongWord;   // Number of blocks in file
+    fib_Date: TDateStamp;      // Date file last changed
+    fib_Comment: array[0..79] of Char; // Null terminated comment string.
+    // Note: the following two fields are not supported by all filesystems.
+    //   Should be 0 if not supported
+    fib_OwnerUID: Word;        //
+    fib_OwnerGID: Word;        //
+    fib_Reserved: array [0..7] of Pointer; // DOS Private do not access this
+  end; // FileInfoBlock - 260 bytes
+
+const
+
+{ FIB stands for FileInfoBlock }
+
+{* FIBB are bit definitions, FIBF are field definitions *}
+{* Regular RWED bits are 0 == allowed. *}
+{* NOTE: GRP and OTR RWED permissions are 0 == not allowed! *}
+{* Group and Other permissions are not directly handled by the filesystem *}
+
+    FIBB_OTR_READ       = 15;   {* Other: file is readable *}
+    FIBB_OTR_WRITE      = 14;   {* Other: file is writable *}
+    FIBB_OTR_EXECUTE    = 13;   {* Other: file is executable *}
+    FIBB_OTR_DELETE     = 12;   {* Other: prevent file from being deleted *}
+    FIBB_GRP_READ       = 11;   {* Group: file is readable *}
+    FIBB_GRP_WRITE      = 10;   {* Group: file is writable *}
+    FIBB_GRP_EXECUTE    = 9;    {* Group: file is executable *}
+    FIBB_GRP_DELETE     = 8;    {* Group: prevent file from being deleted *}
+
+    FIBB_SCRIPT         = 6;    { program is a script (execute) file }
+    FIBB_PURE           = 5;    { program is reentrant and rexecutable}
+    FIBB_ARCHIVE        = 4;    { cleared whenever file is changed }
+    FIBB_READ           = 3;    { ignored by old filesystem }
+    FIBB_WRITE          = 2;    { ignored by old filesystem }
+    FIBB_EXECUTE        = 1;    { ignored by system, used by Shell }
+    FIBB_DELETE         = 0;    { prevent file from being deleted }
+
+    FIBF_OTR_READ      = (1 shl FIBB_OTR_READ);
+    FIBF_OTR_WRITE     = (1 shl FIBB_OTR_WRITE);
+    FIBF_OTR_EXECUTE   = (1 shl FIBB_OTR_EXECUTE);
+    FIBF_OTR_DELETE    = (1 shl FIBB_OTR_DELETE);
+    FIBF_GRP_READ      = (1 shl FIBB_GRP_READ);
+    FIBF_GRP_WRITE     = (1 shl FIBB_GRP_WRITE);
+    FIBF_GRP_EXECUTE   = (1 shl FIBB_GRP_EXECUTE);
+    FIBF_GRP_DELETE    = (1 shl FIBB_GRP_DELETE);
+
+    FIBF_SCRIPT         = 64;
+    FIBF_PURE           = 32;
+    FIBF_ARCHIVE        = 16;
+    FIBF_READ           = 8;
+    FIBF_WRITE          = 4;
+    FIBF_EXECUTE        = 2;
+    FIBF_DELETE         = 1;
+
+// Standard maximum length for an error string from fault.  However, most
+// error strings should be kept under 60 characters if possible.  Don't
+// forget space for the header you pass in. *}
+  FAULT_MAX = 82;
+
+type
+// For the old Info() function, the structure must be on a 4 byte boundary.
+// The new V51+ GetDiskInfo() doesn't require special structure alignment.
+// Just use AllocDosObject(DOS_INFO,0); to get the right one every time.
+  PInfoData = ^TInfoData;
+  TInfoData = record
+    id_NumSoftErrors: LongInt;  // number of soft errors on disk
+    id_UnitNumber: LongInt;     // Which unit disk is (was) mounted on
+    id_DiskState: LongInt;      // See defines below
+    id_NumBlocks: LongWord;     // Number of blocks on disk
+    id_NumBlocksUsed: LongWord; // Number of block in use
+    id_BytesPerBlock: LongWord;
+    id_DiskType: LongInt;       // Disk Type code
+    id_VolumeNode: BPTR;        // BCPL pointer to volume node
+    id_InUse: LongInt;          // Flag, zero if not in use
+  end;
+{$PACKRECORDS 2}
+
+const
+// InfoData (ID stands for InfoData)
+// Disk states }
+  ID_WRITE_PROTECTED  = 80; // Disk is write protected
+  ID_VALIDATING       = 81; // Disk is currently being validated
+  ID_VALIDATED        = 82; // Disk is consistent and writeable
+// Disk types for; id_DiskType
+  ID_NO_DISK_PRESENT     = -1;
+  ID_UNREADABLE_DISK     = $42414400; // 'BAD\0'
+  ID_BUSY_DISK           = $42555359; // 'BUSY'
+  ID_SWAP_DISK           = $53574150; // 'SWAP'
+  ID_NOT_REALLY_DOS      = $4E444F53; // 'NDOS'
+  ID_KICKSTART_DISK      = $4B49434B; // 'KICK'
+  ID_CDFS_DISK           = ((Ord('C') shl 24) or (Ord('D') shl 16) or (Ord('0') shl 8) or $01); // CDFileSystem 'CD01'
+
+  ID_DOS_DISK            = $444F5300; // 'DOS\0'
+  ID_FFS_DISK            = $444F5301; // 'DOS\1'
+  ID_INTER_DOS_DISK      = $444F5302; // 'DOS\2'
+  ID_INTER_FFS_DISK      = $444F5303; // 'DOS\3'
+  ID_FASTDIR_DOS_DISK    = $444F5304; // 'DOS\4'
+  ID_FASTDIR_FFS_DISK    = $444F5305; // 'DOS\5'
+  ID_LONGNAME_DOS_DISK   = $444F5306; // 'DOS\6'
+  ID_LONGNAME_FFS_DISK   = $444F5307; // 'DOS\7'
+
+// V53 disk type used for new vector-port based filesystems like RAM: ENV: APPDIR:
+  ID_VP255_DOS_DISK     = $444F5309;  // 'DOS\9'
+  ID_NGFS_DISK          = $4E474653;  //  NGFS
+
+// Special 'disk type' signatures returned by con-handler
+  ID_CON                = $434F4E00;  // 'CON\0'
+  ID_RAWCON             = $52415700;  // 'RAW\0'
+
+// Other known disk types
+  ID_MSDOS_DISK    = (Ord('M') shl 24) or (Ord('S') shl 16) or (Ord('D') shl 8) or $00;
+  ID_MSDOS_DISK_HD = (Ord('M') shl 24) or (Ord('S') shl 16) or (Ord('H') shl 8) or $00;
+  ID_MSDOS_DISK_DS = (Ord('M') shl 24) or (Ord('D') shl 16) or (Ord('D') shl 8) or $00;
+
+// FAT disk types
+  ID_FAT00_DISK = (Ord('F') shl 24) or (Ord('A') shl 16) or (Ord('T') shl 8) or $00;
+  ID_FAT01_DISK = (Ord('F') shl 24) or (Ord('A') shl 16) or (Ord('T') shl 8) or $01;
+  ID_FAT32_DISK = (Ord('F') shl 24) or (Ord('A') shl 16) or (Ord('T') shl 8) or $32;
+
+// FUSE filesystems
+  ID_BOX0_DISK        = $424F5800; //  BOX\0 - BoxFileSystem
+  ID_EXFAT_DISK       = $46415458; //  FATX  - exFATFileSystem
+  ID_EXT2_DISK        = $45585402; //  EXT\2 - FuseExt2FileSystem
+  ID_HFS_DISK         = $48465300; //  HFS\0 - FuseHFS
+  ID_NTFS_DISK        = $4e544653; //  NTFS  - NTFileSystem3G
+
+
+
+
+// Errors from IoErr(), etc.
+  ERROR_INVALID_PACKET_MESSAGE     = 101;
+  ERROR_WRONG_PACKET_RETURNED      = 102;
+  ERROR_NO_FREE_STORE              = 103;
+  ERROR_TASK_TABLE_FULL            = 105;
+  ERROR_BAD_TEMPLATE               = 114;
+  ERROR_BAD_NUMBER                 = 115;
+  ERROR_REQUIRED_ARG_MISSING       = 116;
+  ERROR_KEY_NEEDS_ARG              = 117;
+  ERROR_TOO_MANY_ARGS              = 118;
+  ERROR_UNMATCHED_QUOTES           = 119;
+  ERROR_LINE_TOO_LONG              = 120;
+  ERROR_FILE_NOT_OBJECT            = 121;
+  ERROR_INVALID_RESIDENT_LIBRARY   = 122;
+  ERROR_NO_DEFAULT_DIR             = 201;
+  ERROR_OBJECT_IN_USE              = 202;
+  ERROR_OBJECT_EXISTS              = 203;
+  ERROR_DIR_NOT_FOUND              = 204;
+  ERROR_OBJECT_NOT_FOUND           = 205;
+  ERROR_BAD_STREAM_NAME            = 206;
+  ERROR_OBJECT_TOO_LARGE           = 207;
+  ERROR_ACTION_NOT_KNOWN           = 209;
+  ERROR_INVALID_COMPONENT_NAME     = 210;
+  ERROR_INVALID_LOCK               = 211;
+  ERROR_OBJECT_WRONG_TYPE          = 212;
+  ERROR_DISK_NOT_VALIDATED         = 213;
+  ERROR_DISK_WRITE_PROTECTED       = 214;
+  ERROR_RENAME_ACROSS_DEVICES      = 215;
+  ERROR_DIRECTORY_NOT_EMPTY        = 216;
+  ERROR_TOO_MANY_LEVELS            = 217;
+  ERROR_DEVICE_NOT_MOUNTED         = 218;
+  ERROR_SEEK_ERROR                 = 219;
+  ERROR_COMMENT_TOO_BIG            = 220;
+  ERROR_DISK_FULL                  = 221;
+  ERROR_DELETE_PROTECTED           = 222;
+  ERROR_WRITE_PROTECTED            = 223;
+  ERROR_READ_PROTECTED             = 224;
+  ERROR_NOT_A_DOS_DISK             = 225;
+  ERROR_NO_DISK                    = 226;
+  ERROR_NO_MORE_ENTRIES            = 232;
+// added for 1.4
+  ERROR_IS_SOFT_LINK               = 233;
+  ERROR_OBJECT_LINKED              = 234;
+  ERROR_BAD_HUNK                   = 235;
+  ERROR_NOT_IMPLEMENTED            = 236;
+  ERROR_RECORD_NOT_LOCKED          = 240;
+  ERROR_LOCK_COLLISION             = 241;
+  ERROR_LOCK_TIMEOUT               = 242;
+  ERROR_UNLOCK_ERROR               = 243;
+//
+  ERROR_BUFFER_OVERFLOW            = 303; // User or internal buffer overflow
+  ERROR_BREAK                      = 304; // A break character was received
+  ERROR_NOT_EXECUTABLE             = 305; // A file has E bit cleared
+  ERROR_IS_PIPE                    = 306; // Operation is not permitted on pipes
+  ERROR_BROKEN_PIPE                = 307; // No more data can be read from or written to this pipe
+  ERROR_WOULD_BLOCK                = 308; // Operation cannot complete immediately, as requested
+  ERROR_BAD_SIGNAL_BIT             = 309; // An invalid signal bit number was specified
+//
+  ERROR_UNSUPPORTED_HARDWARE       = 350; // The hardware found is unsupported by software
+// Special error codes that can be set by MountDevice().
+  ERROR_INVALID_DEVICE_TYPE        = 401; // Device to be mounted is neither handler nor file system.
+  ERROR_INVALID_DEVICE_NAME        = 402; // Name of device to be mounted does contain more colon characters than necessary, or in the wrong place
+  ERROR_DEVICE_NAME_TOO_LONG       = 403; // Name of device to be mounted is longer than 255 characters
+  ERROR_INVALID_SECTOR_SIZE        = 404; // Sector size is not a multiple of four
+  ERROR_CONTROL_STRING_TOO_LONG    = 405; // Control string for device to be mounted is longer than 255 characters
+  ERROR_EXEC_DEVICE_NAME_TOO_LONG  = 406; // Exec device driver name for device to be mounted is longer than 255 characters
+  ERROR_HANDLER_STRING_TOO_LONG    = 407; // Name of handler to be mounted is longer than 255 characters
+  ERROR_STARTUP_STRING_TOO_LONG    = 408; // Startup string for device to be mounted is longer than 255 characters
+  ERROR_SIZE_MISSING               = 409; // Number of surfaces, sector size, number of sectors per block or number of sectors per track is zero
+  ERROR_DEVICE_NAME_MISSING        = 410; // No exec device driver name was given
+  ERROR_INVALID_NUMBER_OF_CYLINDERS = 411; // Number of cylinders to use is negative
+  ERROR_HANDLER_CANNOT_BE_STARTED   = 412; // No handler name, segment list or port address was given
+  ERROR_INVALID_GLOBAL_VECTOR       = 413; // Global vector must be one of -2 or -1
+  ERROR_INVALID_TASK_PRIORITY       = 414; // The task priority is not in the range -128..127
+
+// *********************************************************************
+// These are the return codes used by convention by AmigaDOS commands.
+// See FAILAT and IF commands for relevance to EXECUTE files.
+// See RunCommand() and CreateNewProc() for relevance to all DOS processes.
+  RETURN_OK    = 0;  // No problems, success
+  RETURN_WARN  = 5;  // A warning only
+  RETURN_ERROR = 10; // Something wrong
+  RETURN_FAIL  = 20; // Complete or severe failure
+
+// Bit numbers that signal that a user has issued a break
+  SIGBREAKB_CTRL_C = 12;
+  SIGBREAKB_CTRL_D = 13;
+  SIGBREAKB_CTRL_E = 14;
+  SIGBREAKB_CTRL_F = 15;
+// Bit fields that signal that a user has issued a break, See CheckSignal() for examples.
+  SIGBREAKF_CTRL_C = 1 shl SIGBREAKB_CTRL_C;
+  SIGBREAKF_CTRL_D = 1 shl SIGBREAKB_CTRL_D;
+  SIGBREAKF_CTRL_E = 1 shl SIGBREAKB_CTRL_E;
+  SIGBREAKF_CTRL_F = 1 shl SIGBREAKB_CTRL_F;
+// Values returned by SameLock()
+  LOCK_DIFFERENT    =  -1;
+  LOCK_SAME         =  0;
+  LOCK_SAME_HANDLER =  1; // locks are on same volume
+// types for ChangeMode()
+  CHANGE_LOCK = 0;
+  CHANGE_FH   = 1;
+// Mode parameter for DevNameFromLock() and DevNameFromFH()
+  DN_DEVICEONLY = 0;
+  DN_FULLPATH   = 1;
+  DN_ROOTPATH   = 2;
+// Mode flags for GetProcSegList() (v51.88)
+  GPSLF_CLI = 1 shl 1;
+  GPSLF_SEG = 1 shl 2;
+  GPSLF_ENT = 1 shl 3;
+  GPSLF_RUN = 1 shl 4;
+// Values for MakeLink() - DO NOT use random values, new link types will be added in the future that require other values to be used.
+  LINK_HARD = 0;
+  LINK_SOFT = 1;
+// Values returned by ReadItem (and ReadLineItem V50)
+  ITEM_EQUAL    = -2; // "=" Symbol
+  ITEM_ERROR    = -1; // error
+  ITEM_NOTHING  = 0;  // *N, ;, endstreamch
+  ITEM_UNQUOTED = 1;  // unquoted item
+  ITEM_QUOTED   = 2;  // quoted item
+// Types for AllocDosObject/FreeDosObject
+  DOS_FILEHANDLE        = 0;  // Very few people should use this
+  DOS_EXALLCONTROL      = 1;  // Must be used to allocate this! - Obsolete struct
+  DOS_FIB               = 2;  // may be useful - not really, it's obsolete now
+  DOS_STDPKT            = 3;  // for doing packet-level I/O
+  DOS_CLI               = 4;  // for shell-writers, etc
+  DOS_RDARGS            = 5;  // for ReadArgs if you pass it in
+  DOS_ANCHORPATH        = 6;  // for MatchFirst/MatchNext (V50)
+  DOS_INFODATA          = 7;  // for Info() aligned InfoData (V50)
+  DOS_NOTIFYREQUEST     = 8;  // for Notify request functions (V51)
+  DOS_LOCK              = 9;  // for filesystem lock allocations (V51)
+  DOS_FREADLINEDATA     = 10; // for FReadLine() structure. (V51)
+  DOS_EXAMINEDATA       = 11; // for filesystem ExamineData allocations.(V51)
+  DOS_DOSLIST           = 12; // for struct DosList allocations. (V52.16)
+  DOS_VOLUMELIST        = 13; // for struct list with attached nodes. (V53.52)
+  DOS_FSVECTORPORT      = 14; // for filesystem vector port creation. (53.80)
+
+type
+// The following is used by the new V51 tag;  NP_NotifyOnDeathMessage
+// See CreateNewProc() autodoc for more details.
+  PDeathMessage = ^TDeathMessage;
+  TDeathMessage = record
+    dm_Msg: PMessage;       // Embedded exec message structure.
+    dm_ReturnCode: LongInt; // Primary process return code, set by DOS
+    dm_Result2: LongInt;    // The value returned from IoErr(),set by DOS
+  end;
+
+// The following is the data structure to be used for FReadLine()
+// which is allocated by the AllocDosObject() function ONLY.
+  PFReadLineData = ^TFReadLineData;
+  TFReadLineData = record
+    frld_Line: STRPTR;                        // NUL-terminated string
+    frld_LineLength: LongWord;                // what strlen(frld_Line) would return
+    frld_DosPrivate: array[0..7] of LongWord; // -- internal dos.library use only
+  end;
+
+// For use by the V1.4+ DOS functions StrtoDate() and DatetoStr()
+type
+  _PDateTime = ^_TDateTime;
+  _TDateTime = record
+    dat_Stamp: TDateStamp; // DOS DateStamp
+    dat_Format: Byte;      // controls appearance of dat_StrDate
+    dat_Flags: Byte;       // see BITDEF's below
+    dat_StrDay: STRPTR;    // day of the week string
+    dat_StrDate: STRPTR;   // date string
+    dat_StrTime: STRPTR;   // time string
+  end;
+
+// You need this much room for each of the DateTime strings:
+CONST
+  LEN_DATSTRING = 16;
+
+// Flags for dat_Flags
+   DTB_SUBST  = 0; // substitute Today, Tomorrow, etc.
+   DTB_FUTURE = 1; // day of the week is in future
+   DTF_SUBST  = 1 shl DTB_SUBST;
+   DTF_FUTURE = 1 shl DTB_FUTURE;
+
+
+// date format values
+  FORMAT_DOS = 0; // dd-mmm-yy
+  FORMAT_INT = 1; // yy-mm-dd
+  FORMAT_USA = 2; // mm-dd-yy
+  FORMAT_CDN = 3; // dd-mm-yy
+  FORMAT_DEF = 4; // use default format, as defined by locale; if locale not
+                      // available, use FORMAT_DOS instead
+  FORMAT_ISO = 5; // yyyy-mm-dd (ISO 8601) Requires locale V48 or dos V50.36 if locale not available
+  FORMAT_MAX = FORMAT_ISO;
+
+// *********************************************************************
+// This structure is mostly DOS private for MatchXXX() directory scanner.
+Type
+  PAChain = ^TAChain;
+  TAChain = record
+    an_Child: PAChain;
+    an_Parent: PAChain;
+    an_Lock: BPTR;
+    // The remaining members are strictly DOS private.
+    an_Info: TFileInfoBlock;
+    an_Flags: Shortint;
+    an_ExData: PExamineData;
+    an_DevProc: Pointer; // real type PDevProc;
+    an_String: Array[0..0] of Char;
+  end;
+
+// Obsolete definition ==ONLY== for legacy reference, pre V50.76 DOS.
+//  This is what DOS will expect when NOT allocated by AllocDosObject().
+
+  PAnchorPathOld = ^TAnchorPathOld;
+  TAnchorPathOld = record
+    case smallint of
+    0 : (
+      ap_First: PAChain;
+      ap_Last: PAChain;
+     );
+    1 : (
+      ap_Base: PAChain;            // pointer to first anchor
+      ap_Current: PAChain;         // pointer to last anchor
+      ap_BreakBits,                // Bits we want to break on
+      ap_FoundBreak: LongWord;     // Bits we broke on. Also returns ERROR_BREAK
+      ap_Flags: Shortint;          // New use for extra word.
+      ap_Reserved: Shortint;
+      ap_Strlen: Word;             // This is what ap_Length used to be
+      ap_Info: TFileInfoBlock;
+      ap_Buf: array[0..0] of Char; // Buffer for path name, allocated by user !!
+     );
+  end;
+
+// ************************ PATTERN MATCHING ***************************
+{
+  Structure expected by MatchFirst, MatchNext.
+  Allocate this structure ONLY with AllocDosObject() from DOS 50.76+
+  and initialize the ADO_Flags with the appropriate bits as follows:
+
+  Set ADO_Mask, (ap_BreakBits) to the signal bitmask (^CDEF) that you want to
+  take a break on, or 0L, (default) if you don't want to convenience the user.
+
+  If you want to have the FULL PATH NAME of the files you found,
+  allocate an additional buffer space using the tag ADO_Strlen, this will
+  place the buffer in ap_Buffer and the size into ap_Strlen.
+
+  If you don't need the full path name, DO NOT specify the ADO_Strlen tag,
+  this will by default, set ap_Strlen to zero, for no additional buffer space.
+  In this case, the name of the file, and other stats are available in the
+  ap_ExData structure if not NULL, (or old FIB ap_Info struct for legacy apps),
+  Note that the ap_ExData pointer was NULL prior to V54, so you MUST check the
+  pointer before access, when operating with previous dos.library releases.
+  Always use ap_ExData in preference to the old ap_Info data, because only
+  ap_ExData supports 64 bit file sizes and long names > 107 bytes.
+
+  Then call MatchFirst() and then afterwards, MatchNext() with this structure.
+  You should check the return value each time (see below) and take the
+  appropriate action, ultimately calling MatchEnd() when there are
+  no more files and you are done.  You can tell when you are done by
+  checking for the normal AmigaDOS return code ERROR_NO_MORE_ENTRIES.
+
+************************************************************************
+WARNING:  You MUST allocate these with AllocDosObject() from DOS 50.76+
+        MatchXXX() will simply not work if you do not heed this warning.
+************************************************************************}
+
+  PAnchorPath = ^TAnchorPath;
+  TAnchorPath = record       // redefined for dos 50.76+ (2004)
+    ap_Magic: LongInt;       // -- PRIVATE - DOS compatibility
+    case smallint of
+    0 : (
+      ap_First: PAChain;
+      ap_Last: PAChain;
+     );
+    1 : (
+      ap_Base: PAChain;        // Ptr to first anchor
+      ap_Current: PAChain;     // Ptr to current anchor
+      ap_BreakBits: LongWord;  // Bits we want to break on
+      ap_FoundBreak: LongWord; // Bits we broke on.
+      ap_Flags: LongWord;      // The flags bitfield.
+      ap_ExData: PExamineData; // Ptr to ExamineData (or nil)
+      ap_CTXPrivate: APTR;     // -- PRIVATE, DOS use only.
+      ap_Reserved: array[0..1] of LongWord;  // Future use, currently 0
+      ap_Strlen: LongWord;     // Strlen : Size of the buffer -1
+      ap_Buffer: STRPTR;       // Full name, (see ADO_Strlen)
+      ap_Info: PFileInfoBlock; // The old FileInfoBlock space
+      ap_Private1: LongWord;   // --PRIVATE, DOS use only.
+      ap_Private2: LongWord;   // --PRIVATE, DOS use only.
+    );
+  end;
+
+// Flags for AnchorPath->ap_Flags.
+
+const
+  APB_DOWILD       = 0; // Unused
+  APB_ITSWILD      = 1; // Set by MatchFirst, used by MatchNext. Application can test APB_ITSWILD, too
+                        // (means that there's a wildcard in the pattern after calling MatchFirst).
+  APB_DODIR        = 2; // Bit is SET if a DIR node should be entered. Application can RESET this
+                        // bit after MatchFirst/MatchNext to AVOID entering a dir.
+  APB_DIDDIR       = 3; // Bit is SET for an "expired" dir node.
+  APB_NOMEMERR     = 4; // Set on memory error
+  APB_DODOT        = 5; // Unused
+  APB_DirChanged   = 6; // ap_Current->an_Lock changed since last MatchNext call
+  APB_FollowHLinks = 7; // follow hardlinks on DODIR - defaults to not following hardlinks on a DODIR.
+  APB_MultiAssigns = 8; // Set this bit via AllocDosObject() to allow Multi-Assign scanning to be enabled.
+                        // ( NOTE: ONLY AVAILABLE FROM DOS 50.76+ )
+  APF_DOWILD       = 1 shl APB_DOWILD;
+  APF_ITSWILD      = 1 shl APB_ITSWILD;
+  APF_DODIR        = 1 shl APB_DODIR;
+  APF_DIDDIR       = 1 shl APB_DIDDIR;
+  APF_NOMEMERR     = 1 shl APB_NOMEMERR;
+  APF_DODOT        = 1 shl APB_DODOT;
+  APF_DirChanged   = 1 shl APB_DirChanged;
+  APF_FollowHLinks = 1 shl APB_FollowHLinks;
+  APF_MultiAssigns = 1 shl APB_MultiAssigns; // New for V50, See AllocDosObject()
+
+// Flags for AChain->an_Flags; these are private to DOS!
+
+
+  DDB_PatternBit  = 0;
+  DDB_ExaminedBit = 1;
+  DDB_Completed   = 2;
+  DDB_AllBit      = 3;
+  DDB_Assign      = 4;
+  DDB_Device      = 5;
+
+  DDF_Device      = 1 shl DDB_Device;
+  DDF_Assign      = 1 shl DDB_Assign;
+  DDF_AllBit      = 1 shl DDB_AllBit;
+  DDF_Completed   = 1 shl DDB_Completed;
+  DDF_ExaminedBit = 1 shl DDB_ExaminedBit;
+  DDF_PatternBit  = 1 shl DDB_PatternBit;
+
+{
+ * Constants used by wildcard routines, these are the pre-parsed tokens
+ * referred to by pattern match.  It is not necessary for you to do
+ * anything about these, MatchFirst() MatchNext() handle all these for you.
+ }
+
+    P_ANY         =  $80;    { Token for '*' or '#?  }
+    P_SINGLE      =  $81;    { Token for '?' }
+    P_ORSTART     =  $82;    { Token for '(' }
+    P_ORNEXT      =  $83;    { Token for '|' }
+    P_OREND       =  $84;    { Token for ')' }
+    P_NOT         =  $85;    { Token for '~' }
+    P_NOTEND      =  $86;    { Token for }
+    P_NOTCLASS    =  $87;    { Token for '^' }
+    P_CLASS       =  $88;    { Token for '[]' }
+    P_REPBEG      =  $89;    { Token for '[' }
+    P_REPEND      =  $8A;    { Token for ']' }
+    P_STOP        =  $8B;    { token to force end of evaluation }
+
+{ Values for an_Status, NOTE: These are the actual bit numbers }
+
+    COMPLEX_BIT   =  1;       { Parsing complex pattern }
+    EXAMINE_BIT   =  2;       { Searching directory }
+
+{   hunk types }
+     HUNK_UNIT      = 999 ;
+     HUNK_NAME      = 1000;
+     HUNK_CODE      = 1001;
+     HUNK_DATA      = 1002;
+     HUNK_BSS       = 1003;
+     HUNK_RELOC32   = 1004;
+     HUNK_RELOC16   = 1005;
+     HUNK_RELOC8    = 1006;
+     HUNK_EXT       = 1007;
+     HUNK_SYMBOL    = 1008;
+     HUNK_DEBUG     = 1009;
+     HUNK_END       = 1010;
+     HUNK_HEADER    = 1011;
+
+     HUNK_OVERLAY   = 1013;
+     HUNK_BREAK     = 1014;
+
+     HUNK_DREL32    = 1015;
+     HUNK_DREL16    = 1016;
+     HUNK_DREL8     = 1017;
+
+     HUNK_LIB       = 1018;
+     HUNK_INDEX     = 1019;
+
+{   hunk_ext sub-types }
+     EXT_SYMB       = 0  ;     {   symbol table }
+     EXT_DEF        = 1  ;     {   relocatable definition }
+     EXT_ABS        = 2  ;     {   Absolute definition }
+     EXT_RES        = 3  ;     {   no longer supported }
+     EXT_REF32      = 129;     {   32 bit reference to symbol }
+     EXT_COMMON     = 130;     {   32 bit reference to COMMON block }
+     EXT_REF16      = 131;     {   16 bit reference to symbol }
+     EXT_REF8       = 132;     {    8 bit reference to symbol }
+     EXT_DEXT32     = 133;     {   32 bit data releative reference }
+     EXT_DEXT16     = 134;     {   16 bit data releative reference }
+     EXT_DEXT8      = 135;     {    8 bit data releative reference }
+
+
+type
+// All DOS processes have this structure
+  PProcess = ^TProcess;
+  TProcess = record
+    // original definitions from version 1.0 and earlier betas (v30 - 1984)
+    pr_Task: TTask;         // The exec task structure for this process
+    pr_MsgPort: TMsgPort;   // This process' message port structure
+    pr_Size: Word;          // Size of struct from V51.08+, previously 0
+    pr_SegArray: BPTR;      // -- PRIVATE - BPTR to internal process segarray[].
+    pr_StackSize: LongWord; // The running process stack size, in bytes
+    pr_gv: LongInt;         // -- OBSOLETE BCPL value - do not access this.
+    pr_CliNum: LongInt;     // CLI number, for DOS allocated cli processes.
+    pr_sb: BPTR;            // -- OBSOLETE BCPL value - do not access this.
+    pr_Result2: LongInt;    // Secondary result from last call, for IoErr()
+    pr_CurrentDir: BPTR;    // Lock associated with current directory
+    pr_CIS: BPTR;           // Current CLI Input Stream
+    pr_COS: BPTR;           // Current CLI Output Stream
+    pr_ConsoleTask: PMsgPort;     // Console handler process for current window
+    pr_FileSystemTask : PMsgPort; // File handler process for current drive
+    pr_CLI: BPTR;           // BCPL Pointer to struct CommandLineInterface
+    pr_ra: APTR;            // -- OBSOLETE - do not access this.
+    pr_PktWait: APTR;       // Function to be called when awaiting packet
+    pr_WindowPtr: APTR;     // Window for posting error requesters
+
+    // following definitions are new with 2.0 (v36 - 1990)
+    pr_ProgramDir: BPTR;       // Program's home directory lock
+    pr_Flags: LongWord;        // Flags telling dos about this process
+    pr_ExitCode: APTR;         // Code to call on exit of process or nil
+    pr_ExitData: LongInt;      // Passed as an argument to pr_ExitCode.
+    pr_Arguments: STRPTR;      // Arguments passed to the process at start
+    pr_LocalVars: TMinList;    // Local environment variables
+    pr_ShellPrivate: LongWord; // -- PRIVATE - Internal shell use only.
+    pr_CES: BPTR;              // Error stream - if nil, use pr_COS
+
+    // following definitions are new from 4.0 (v50 - Apr,2004)
+    pr_PrData: APTR;          // -- PRIVATE - internal dos access ONLY.
+    pr_CurrentSeg: BPTR;      // Seglist of current running code.(READ ONLY)
+    pr_EmulPrivate: LongWord; // -- PRIVATE - Flags for 68k JIT Emulator.
+    pr_68kPrivate: LongWord;  // -- PRIVATE - 68K control opts, OS access only
+    pr_ParentID: LongWord;    // ID# of parent process, 0 if a task. (READ ONLY)
+    pr_ProcessID: LongWord;   // ID# for this process. (READ ONLY)
+    pr_Reserved4: LongWord;   // -- reserved for dos expansion - leave alone
+    pr_OGLContextData: APTR;  // -- PRIVATE - ogl access only.
+    pr_Reserved5: APTR;       // -- reserved for dos expansion - leave alone.
+    pr_CLibData: APTR;        // -- PRIVATE - clib/newlib use, copied by CNP()
+    pr_Reserved6: APTR;       // -- reserved for dos expansion - leave alone
+
+    // following definitions are new from (v51 - Jan,2006)
+    pr_RestoreList: TMinList;  // -- PRIVATE - used by DOS for process cleanup()
+    pr_DeathSigTask: APTR;     // Process/task to signal when the process ends
+    pr_DeathSigBit: LongWord;  // Signal bit number for pr_DeathSigTask
+    pr_DeathMessage: APTR;     // DeathMessage to ReplyMsg() to when process ends
+    pr_EntryCode: APTR;        // Code to call on startup of process, or nil
+    pr_EntryData: LongInt;     // Passed as an argument to pr_EntryCode func.
+    pr_FinalCode: APTR;        // Code to call on exit of the process, or nil
+    pr_FinalData: LongInt;     // Passed as an argument to pr_FinalCode func.
+    pr_DLNotifyData: LongWord; // -- PRIVATE - dos NotifyDosListChange() data.
+    pr_PLNotifyData: LongWord; // -- PRIVATE - dos NotifyProcListChange() data.
+
+    // following definitions are new from (v52 - Dec,2006)
+    pr_UID: LongWord;      // -- PRIVATE - dos Set/GetOwnerInfo() use only.
+    pr_GID: LongWord;      // -- PRIVATE - dos Set/GetOwnerInfo() use only.
+    pr_Reserved3: LongInt; // -- reserved for dos expansion - leave alone
+    pr_Reserved2: LongInt; // -- reserved for dos expansion - leave alone
+    pr_Reserved1: LongInt; // -- reserved for dos expansion - leave alone
+    pr_Reserved0: LongInt; // -- reserved for dos expansion - leave alone
+  end; // Process - 344 bytes
+
+const
+// Flags for Process->pr_Flags for all DOS processes.
+  PRB_FREESEGLIST       = 0;  // NP_FreeSegList,TRUE sets this bit.
+  PRB_FREECURRDIR       = 1;  // NP_CurrentDir will be UnLocked if set
+  PRB_FREECLI           = 2;  // NP_Cli will be freed if this is set.
+  PRB_CLOSEINPUT        = 3;  // NP_CloseInput,TRUE sets this bit.
+  PRB_CLOSEOUTPUT       = 4;  // NP_CloseOutput,TRUE sets this bit.
+  PRB_FREEARGS_OBSOLETE = 5;  // (V50) obsolete, args copy now on task memlist.
+  PRB_CLOSEERROR        = 6;  // NP_CloseError,TRUE sets this bit. (V51)
+  PRB_LOCKSTACK         = 7;  // NP_LockStack,TRUE sets this bit. (V52.10)
+  PRB_spare08           = 8;
+  PRB_spare09           = 9;
+  PRB_spare10           = 10;
+  PRB_spare11           = 11;
+  PRB_spare12           = 12;
+  PRB_spare13           = 13;
+  PRB_spare14           = 14;
+  PRB_spare15           = 15;
+
+  PRB_spare16           = 16;
+  PRB_spare17           = 17;
+  PRB_spare18           = 18;
+  PRB_spare19           = 19;
+  PRB_spare20           = 20;
+  PRB_spare21           = 21;
+  PRB_spare22           = 22;
+  PRB_spare23           = 23;
+  PRB_CHILDPROCESS      = 24; // (V50) NP_Child,TRUE sets this for a dependant child.
+  PRB_HADCHILDREN       = 25; // (V51) Gets set if this process had created any children.
+  PRB_HASDLNOTIFY       = 26; // (V51) Set when doslist change signal notify is enabled.
+  PRB_HASPLNOTIFY       = 27; // (V51) Set when process list change signal notify is on.
+  PRB_SERVERPROCESS     = 28; // (V53) Set when process is one of the internal dos servers
+  PRB_HANDLERPROCESS    = 29; // (V52) Set to indicate if this is a handler/filesystem process
+  PRB_SHELLPROCESS      = 30; // (V51) Set to indicate if this is a shell handler process
+  PRB_EXTENDED_FLAGS    = 31; // (V51) Reserved for internal dos flags expansion use only.
+// Mask definitions for above bits
+  PRF_FREESEGLIST        = 1 shl PRB_FREESEGLIST;
+  PRF_FREECURRDIR        = 1 shl PRB_FREECURRDIR;
+  PRF_FREECLI            = 1 shl PRB_FREECLI;
+  PRF_CLOSEINPUT         = 1 shl PRB_CLOSEINPUT;
+  PRF_CLOSEOUTPUT        = 1 shl PRB_CLOSEOUTPUT;
+  PRF_FREEARGS_OBSOLETE  = 1 shl PRB_FREEARGS_OBSOLETE;
+  PRF_CLOSEERROR         = 1 shl PRB_CLOSEERROR;
+  PRF_LOCKSTACK          = 1 shl PRB_LOCKSTACK;
+
+  PRF_CHILDPROCESS       = 1 shl PRB_CHILDPROCESS;
+  PRF_HADCHILDREN        = 1 shl PRB_HADCHILDREN;
+  PRF_HASDLNOTIFY        = 1 shl PRB_HASDLNOTIFY;
+  PRF_HASPLNOTIFY        = 1 shl PRB_HASPLNOTIFY;
+  PRF_SERVERPROCESS      = 1 shl PRB_SERVERPROCESS;
+  PRF_HANDLERPROCESS     = 1 shl PRB_HANDLERPROCESS;
+  PRF_SHELLPROCESS       = 1 shl PRB_SHELLPROCESS;
+  PRF_EXTENDED_FLAGS     = 1 shl PRB_EXTENDED_FLAGS;
+
+// The long word address (BPTR) of this structure is returned by
+// Open() and other routines that return a filehandle.
+Type
+  PFileHandle = ^TFileHandle;
+  TFileHandle = record
+    fh_StructSize: Word;     // Size of DOS structure allocation.
+    fh_Flags: Word;          // --Private DOS use only.
+    fh_Interactive: LongInt; // Boolean; True if interactive handle
+    fh_MsgPort: PMsgPort;    // MsgPort of the filesystem/handler.
+    fh_Buf: BPTR;            // --Private Bufferered stream members.
+    fh_Pos: LongInt;
+    fh_End: LongInt;
+    fh_Func1: APTR;          // --Private function pointers to the
+    fh_Func2: APTR;          //   DOS i/o routines.
+    fh_Func3: APTR;
+    fh_Arg1: BPTR;           // --Private, packet handler use.
+    fh_Arg2: APTR;           // --Private, FSVP handler use.
+    fh_OpenerPID: LongWord;  // The process ID of the opener. V52.16
+    fh_Reserved2: LongInt;   // public expansion, leave alone.
+    fh_Reserved1: LongInt;   // public expansion, leave alone.
+    fh_Priv: array[0..17] of LongInt; // --Private, start of the remainder of many more private DOS members.
+  end; // FileHandle - 128 bytes
+
+// This is the standard extension to EXEC Messages used by DOS
+  PDosPacket = ^TDosPacket;
+  TDosPacket = record
+    dp_Link: PMessage;  // EXEC message
+    dp_Port: PMsgPort;  // Reply port for the packet Must be filled in each send.
+    case smallint of
+     0:(
+      dp_Action : LongInt;
+      dp_Status : LongInt;
+      dp_Status2 : LongInt;
+      dp_BufAddr : LongInt;
+     );
+     1:(
+      dp_Type : LongInt;      // See ACTION_... below
+      dp_Res1 : LongInt;      // For file system calls this is the result that would have been returned by the
+                              // function, e.g. Write() returns actual length written
+      dp_Res2 : LongInt;      // For file system calls this is what would have been returned by IoErr()
+      dp_Arg1 : LongInt;
+      dp_Arg2 : LongInt;
+      dp_Arg3 : LongInt;
+      dp_Arg4 : LongInt;
+      dp_Arg5 : LongInt;
+      dp_Arg6 : LongInt;
+      dp_Arg7 : LongInt;
+     );
+  end; // DosPacket - 48 bytes
+
+// A Packet does not require the Message to be before it in memory, but for convenience it is useful to associate the two.
+  PStandardPacket = ^TStandardPacket;
+  TStandardPacket = record
+    sp_Msg: TMessage;
+    sp_Pkt: TDosPacket;
+  end;
+
+{$PACKRECORDS 4}
+// This is the extended 64 bit style EXEC Messages used by DOS. Only dp_Type packets between 8000-8999 range use this structure.
+  PDosPacket64 = ^TDosPacket64;
+  TDosPacket64 = record
+    dp_Link: PMessage;  // EXEC message
+    dp_Port: PMsgPort;  // Reply port for the packet Must be filled in each send.
+    case smallint of
+     0:(
+      dp_Action: LongInt;
+      dp_pad: LongInt;
+      dp_Status2: LongInt;
+      dp_Status: Int64;
+      dp_BufAddr: LongInt;
+     );
+     1:(
+      dp_Type: LongInt; // See ACTION_... below
+      dp_Res0: LongInt; // Special compatibility field. [See below]
+      dp_Res2: LongInt; // This is returned for IoErr()
+      dp_Res1: Int64;   // This is the 64 bit primary result
+      dp_Arg1: LongInt; // 32 bit argument
+      dp_Arg2: Int64;   // 64 bit argument
+      dp_Arg3: LongInt; // 32 bit argument
+      dp_Arg4: LongInt; // 32 bit argument
+      dp_Arg5: Int64;   // 64 bit argument
+     );
+  end; // DosPacket64 - 64 bytes
+  PStandardPacket64 = ^TStandardPacket64;
+  TStandardPacket64 = record
+    sp_Msg: TMessage;
+    sp_Pkt: TDosPacket64;
+  end;
+
+{$PACKRECORDS 2}
+const
+// The DosPacket64 dp_Res0 member initialisation value.
+  DP64_INIT       = -3;
+// Packet types
+  ACTION_NIL                  = 0;
+  ACTION_STARTUP              = 0;
+  ACTION_EVENT                = 6; // INTERNAL for CDFS and CrossDos commodity
+  ACTION_CURRENT_VOLUME       = 7; // DEPRECATED from DOS 53.100+
+  ACTION_LOCATE_OBJECT        = 8;
+  ACTION_RENAME_DISK          = 9;
+  ACTION_FREE_LOCK            = 15;
+  ACTION_DELETE_OBJECT        = 16;
+  ACTION_RENAME_OBJECT        = 17;
+  ACTION_MORE_CACHE           = 18;
+  ACTION_COPY_DIR             = 19;
+  ACTION_WAIT_CHAR            = 20;
+  ACTION_SET_PROTECT          = 21;
+  ACTION_CREATE_DIR           = 22;
+  ACTION_EXAMINE_OBJECT       = 23; // DEPRECATED
+  ACTION_EXAMINE_NEXT         = 24; // DEPRECATED
+  ACTION_DISK_INFO            = 25;
+  ACTION_INFO                 = 26;
+  ACTION_FLUSH                = 27;
+  ACTION_SET_COMMENT          = 28;
+  ACTION_PARENT               = 29;
+  ACTION_TIMER                = 30; // INTERNAL
+  ACTION_INHIBIT              = 31;
+  ACTION_SET_DATE             = 34;
+  ACTION_SAME_LOCK            = 40;
+  ACTION_SAME_FH              = 53; // Added 53.71
+
+  ACTION_READ                 = 82; // 'R'
+  ACTION_WRITE                = 87; // 'W'
+
+  ACTION_SINGLE_CHARACTER_MODE = 994;
+  ACTION_CHANGE_SIGNAL         = 995;
+// Internal packets used by con-handler
+  ACTION_READ_RETURN          = 1001; // INTERNAL
+  ACTION_WRITE_RETURN         = 1002; // INTERNAL
+  ACTION_INT_WRITE_RETURN     = 1003; // INTERNAL
+  ACTION_FINDUPDATE           = 1004; // aka MODE_READWRITE
+  ACTION_FINDINPUT            = 1005; // aka MODE_OLDFILE
+  ACTION_FINDOUTPUT           = 1006; // aka MODE_NEWFILE
+  ACTION_END                  = 1007;
+  ACTION_SEEK                 = 1008; // DEPRECATED
+  ACTION_ICONIFY              = 1009; // INTERNAL
+
+  ACTION_FORMAT         = 1020;
+  ACTION_MAKE_LINK      = 1021;
+  ACTION_WRITE_PROTECT  = 1023;
+  ACTION_READ_SOFT_LINK = 1024;
+  ACTION_FH_FROM_LOCK   = 1026;
+  ACTION_IS_FILESYSTEM  = 1027;
+  ACTION_CHANGE_MODE    = 1028;
+  ACTION_COPY_LOCK_FH   = 1030;
+  ACTION_PARENT_FH      = 1031;
+
+// Added V52.18 - SetOwnerInfo() - replaces old SetOwner() packet 1036.
+  ACTION_SET_OWNER_INFO = 1037;
+// Internal packets used by datatypes.library
+  ACTION_NEWMEMFILE     = 1039; // INTERNAL
+  ACTION_NEWMEMLOCK     = 1040; // INTERNAL
+// New packet types for V50
+  ACTION_WAIT_FOR_DATA     = 1998;
+  ACTION_SET_BLOCKING_MODE = 1999;
+
+// PACKETS 2050-2999 are reserved for use by third party applications.
+
+  ACTION_SHUTDOWN = 3000; // Similar functionality to ACTION_DIE
+  ACTION_COLLECT  = 3001; // controls the relinquishing of active filesystem objects
+// The following are the ACTION_COLLECT object identifiers (in dp_Arg1) to identify the object that is placed in dp_Arg2.
+  ID_COLLECT_LOCK         = 1;
+  ID_COLLECT_FILEHANDLE   = 2;
+  ID_COLLECT_NOTIFICATION = 3;
+
+  ACTION_FILESYSTEM_ATTR = 3005; // Obtain or Set filesystem specific attributes; FileSystemAttr()  51.46
+  ACTION_OBTAIN_CON_INFO = 3006; // Release console information, as obtained through ACTION_OBTAIN_CON_INFO; you must pass the same parameters as with ACTION_OBTAIN_CON_INFO.
+// Packets for ExamineObject() and ExamineDir() functions. 51.104
+  ACTION_EXAMINEDATA     = 3030;
+  ACTION_EXAMINEDATA_FH  = 3031; // added @ 52.30
+  ACTION_EXAMINEDATA_DIR = 3040;
+// DOS will emulate notifications from 52.33+ if you do not support these
+  ACTION_ADD_NOTIFY     = 4097; // optional
+  ACTION_REMOVE_NOTIFY  = 4098; // optional
+  ACTION_SERIALIZE_DISK = 4200; // Tell a file system to serialize the current volume.
+  ACTION_GET_DISK_FSSM  = 4201; // DEPRECATED, Obtain a disk's geometry
+  ACTION_FREE_DISK_FSSM = 4202; // DEPRECATED, Obtain a disk's geometry
+
+// New Packet to control dos.library long path handling code. (@ v53.23)
+  ACTION_INHIBIT_DOS_LONGPATH_HANDLING = 5323;
+
+// 64 Bit ACTION types, ONLY the 8000 series use struct DosPacket64.  51.62
+  ACTION_CHANGE_FILE_POSITION64 = 8001;
+  ACTION_GET_FILE_POSITION64    = 8002;
+  ACTION_CHANGE_FILE_SIZE64     = 8003;
+  ACTION_GET_FILE_SIZE64        = 8004;
+  ACTION_LOCK_RECORD64          = 8010; // added 53.86
+  ACTION_FREE_RECORD64          = 8011; // added 53.86
+
+// 64 bit PACKETS 8500-8999 are reserved for use by third party applications.
+
+// The following were used to convert UID and GID to names and visa-versa
+  ACTION_USERNAME_TO_UID  = 20000;
+  ACTION_GROUPNAME_TO_GID = 20001;
+  ACTION_UID_TO_USERINFO  = 20002;
+  ACTION_GID_TO_GROUPINFO = 20003;
+
+type
+// Data structure used by ACTION_OBTAIN_CON_INFO/ACTION_RELEASE_CON_INFO
+  PConsoleWindowData = ^TConsoleWindowData;
+  TConsoleWindowData = record
+    Reserved: array[0..3] of LongWord; // For use by the console handler
+    ConsoleWindow: APTR;   // real type: PWindow - Pointer to console window; this may be nil for console handlers
+                           // which are not bound to a window, or if that window is currently closed.
+    ConsoleIO: PIORequest; // Pointer to console.device I/O request; this may be nil for console handlers which are not
+                           // bound to a window, or if that window is currently closed.
+    ConsoleType: LongWord; // Identifies the type of console, e.g. ID_RAWCON or ID_CON
+    DOSPrivate: array[0..1] of APTR; // Private fields for use by DOS only
+  end;
+
+// The following are used by the new V50 Address Tracking functions
+  PAddressAndSize = ^TAddressAndSize;
+  TAddressAndSize = record
+    aas_Address: LongWord;
+    aas_Size: LongWord;
+  end;
+
+  PFindTrackedAddressMsg = ^TFindTrackedAddressMsg;
+  TFindTrackedAddressMsg = record
+    ftam_Size: LongInt;
+    ftam_Name: STRPTR;
+    ftam_Date: TDateStamp;
+    ftam_SegList: BPTR;
+    ftam_SegmentNumber: LongWord;
+    ftam_SegmentOffset: LongWord;
+    ftam_ExtraInfo: APTR;
+    ftam_ExtraInfoSize: LongInt;
+    // -- 40 bytes @ V50
+    ftam_AAS: TAddressAndSize;
+    // -- 48 bytes @ 53.118
+  end;
+
+// The following is used by the new V50 pattern functions
+  PCapturedExpression = ^TCapturedExpression;
+  TCapturedExpression = record
+    cape_Next: PCapturedExpression;
+    cape_Match: STRPTR;
+    cape_Start: STRPTR;
+    cape_End: STRPTR;
+    cape_Pool: APTR;   // private
+  end;
+
+// The public structure for PseudoSegLists which are used by RunCommand(), LoadSeg(), Create[new]Proc(), AllocSegList(), etc..
+  PPseudoSegList = ^TPseudoSegList;
+  TPseudoSegList = record
+    ps_Next: BPTR;                // Pointer to next segment. Or 0.
+    ps_Jump: LongWord;            // Internal compatibility magic.
+    ps_Entry: APTR;               // The function entry pointer.
+    ps_Ikey: LongWord;            // Identification key.
+    ps_DosPrivate: LongWord;      // DOS Private use only.
+    ps_Reserved1: LongWord;       // Block alignment - reserved.
+    ps_Reserved2: LongWord;       // Block alignment - reserved.
+    ps_Data: array[0..3] of Byte; // First 4 bytes of data area.
+  end;
+
+// This value is always initialised in the ps_Jump member. (PPC & 68K)
+const
+  PSJUMP_MAGIC   = $4e714ef9; // NOP,JMP - 68k compatibility
+// These are the currently used values for use in the ps_Ikey member.
+  PSIKEY_INIT    = 0; // Set this value for normal native, data or 68k types.  UnLoadSeg() will perform the normal memory freeing on these.
+  PSIKEY_NOFREE  = $80000000; // Set this value if your seglist must not be UnLoadSeg()'ed. Not for internal components, see PSIKEY_NFSYS below.
+  PSIKEY_ELF32   = $7F454C46; //7F 'E' 'L' 'F' This is set EXCLUSIVELY by LoadSeg() for ELF32 executables.
+  PSIKEY_NFSYS   = $FFFFFFFF;
+
+type
+// A structure ONLY for the Dos resident list.  Do NOT allocate these, use AddSegment() and heed the warnings in the autodocs!
+  PDosResidentSeg = ^TDosResidentSeg;
+  TDosResidentSeg = record
+    seg_Next: BPTR;   // BCPL pointer to next DosResidentSeg, or zero
+    seg_UC: LongInt;  // Use Count
+    seg_Seg: BPTR;    // BCPL pointer to seglist of command.
+    seg_Name: array[0..3] of Char; // First 4 chars of BCPL style formatted name
+  end;
+const
+  CMD_SYSTEM   = -1;
+  CMD_INTERNAL = -2;
+  CMD_DISABLED = -999;
+
+
+
+{
+ * A structure for holding error messages - stored as array with error == 0
+ * for the last entry.
+ }
+Type
+       pErrorString = ^tErrorString;
+       tErrorString = record
+        estr_Nums     : Pointer;
+        estr_Strings  : Pointer;
+       END;
+
+
+{ DOS library node structure.
+ * This is the data at positive offsets from the library node.
+ * Negative offsets from the node is the jump table to DOS functions
+ * node = (struct DosLibrary *) OpenLibrary( "dos.library" .. )      }
+
+Type
+
+    pDosLibrary = ^tDosLibrary;
+    tDosLibrary = record
+        dl_lib          : tLibrary;
+        dl_Root         : Pointer;      { Pointer to RootNode, described below }
+        dl_GV           : Pointer;      { Pointer to BCPL global vector       }
+        dl_A2           : LongInt;      { Private register dump of DOS        }
+        dl_A5           : LongInt;
+        dl_A6           : LongInt;
+        dl_Errors       : pErrorString; { pointer to array of error msgs }
+        dl_TimeReq      : pTimeRequest; { private pointer to timer request }
+        dl_UtilityBase  : pLibrary;     { private ptr to utility library }
+        dl_IntuitionBase : pLibrary;
+    end;
+
+    pRootNode = ^tRootNode;
+    tRootNode = record
+        rn_TaskArray    : BPTR;         { [0] is max number of CLI's
+                                          [1] is APTR to process id of CLI 1
+                                          [n] is APTR to process id of CLI n }
+        rn_ConsoleSegment : BPTR;       { SegList for the CLI }
+        rn_Time          : tDateStamp;  { Current time }
+        rn_RestartSeg   : LongInt;      { SegList for the disk validator process }
+        rn_Info         : BPTR;         { Pointer ot the Info structure }
+        rn_FileHandlerSegment : BPTR;   { segment for a file handler }
+        rn_CliList      : tMinList;     { new list of all CLI processes }
+                                        { the first cpl_Array is also rn_TaskArray }
+        rn_BootProc     : PMsgPort;     { private ptr to msgport of boot fs      }
+        rn_ShellSegment : BPTR;         { seglist for Shell (for NewShell)         }
+        rn_Flags        : LongInt;      { dos flags }
+    end;
+
+CONST
+ RNB_WILDSTAR   = 24;
+ RNF_WILDSTAR   = 16777216;
+ RNB_PRIVATE1   = 1;       { private for dos }
+ RNF_PRIVATE1   = 2;
+
+Type
+    pDosInfo = ^tDosInfo;
+    tDosInfo = record
+        case smallint of
+        0 : (
+        di_ResList : BPTR;
+        );
+        1 : (
+        di_McName       : BPTR;          { Network name of this machine; currently 0 }
+        di_DevInfo      : BPTR;          { Device List }
+        di_Devices      : BPTR;          { Currently zero }
+        di_Handlers     : BPTR;          { Currently zero }
+        di_NetHand      : Pointer;       { Network handler processid; currently zero }
+        di_DevLock,                      { do NOT access directly! }
+        di_EntryLock,                    { do NOT access directly! }
+        di_DeleteLock   : tSignalSemaphore; { do NOT access directly! }
+        );
+    end;
+
+{ ONLY to be allocated by DOS! }
+
+       pCliProcList = ^tCliProcList;
+       tCliProcList = record
+        cpl_Node   : tMinNode;
+        cpl_First  : LongInt;      { number of first entry in array }
+        cpl_Array  : Array[0..0] of PMsgPort;
+                             { [0] is max number of CLI's in this entry (n)
+                              * [1] is CPTR to process id of CLI cpl_First
+                              * [n] is CPTR to process id of CLI cpl_First+n-1
+                              }
+       END;
+
+// DOS Processes started from the CLI via RUN or NEWCLI have this additional set of data associated with them
+Type
+  PCommandLineInterface = ^TCommandLineInterface;
+  TCommandLineInterface = record
+    cli_Result2: LongInt;       // Value of IoErr from last command
+    cli_CurrentDirName: BSTR;   // Name of current directory
+    cli_PathList: BPTR;         // Lock associated with command directory
+    cli_ReturnCode: LongInt;    // Return code from last command
+    cli_CommandName: BSTR;      // Name of current command
+    cli_FailLevel: LongInt;     // Fail level (set by FAILAT)
+    cli_Prompt: BSTR;           // Current prompt (set by PROMPT)
+    cli_StandardInput: BPTR;    // Default (terminal) CLI input stream
+    cli_CurrentInput: BPTR;     // Current CLI input stream
+    cli_CommandFile: BSTR;      // BSTR name of EXECUTE command file
+    cli_Interactive: LongInt;   // Boolean; Truth if prompts required
+    cli_Background: LongInt;    // Boolean; Truth if CLI created by 'RUN'
+    cli_CurrentOutput: BPTR;    // Current CLI output
+    cli_DefaultStack: LongWord; // Stack size to be obtained in long words
+    cli_StandardOutput: BPTR;   // Default (terminal) CLI output
+    cli_Module: BPTR;           // SegList of currently loaded command
+  end;
+
+  // VOLUME structure; vn_Type==DLT_VOLUME
+  PVolumeNode = ^TVolumeNode;
+  TVolumeNode = record
+    vn_Next: BPTR;             // BPTR to next entry in the chain
+    vn_Type: LongInt;          // always DLT_VOLUME for dos "volumes"
+    vn_Port: PMsgPort;         // msg port for the handler process
+    vn_Reserved2: LongInt;     // reserved for use by DOS
+    vn_VolumeDate: TDateStamp; // creation date
+    vn_LockList: BPTR;         // unused, leave as 0
+    vn_DOSType: LongInt;       // ie; 'DOS\7' - 32 bit hex dostype = vn_DiskType
+    vn_FSPrivate: LongInt;     // private filesystem use
+    vn_Name: BSTR;             // bstr name
+    vn_StructSize: LongInt;    // FULL size of this structure
+    vn_Reserved: array[0..3] of LongInt; // DOS expansion
+  end;
+
+// DEVICE structure; dn_Type==DLT_DEVICE
+  PDeviceNode = ^TDeviceNode;
+  TDeviceNode = record
+    dn_Next: BPTR;          // BPTR to next entry in the chain
+    dn_Type: LongInt;       // always DLT_DEVICE for dos "devices"
+    dn_Port: PMsgPort;      // msg port to the handler process.
+    dn_Reserved1: LongInt;  // reserved for use by DOS
+    dn_Handler: BSTR;       // BSTR name to loadseg if seglist==0
+    dn_StackSize: LongInt;  // stacksize for the handler process
+    dn_Priority: LongInt;   // task priority when starting task
+    dn_Startup: BPTR;       // startup msg / FileSysStartupMsg
+    dn_SegList: BPTR;       // code to run handler process. if nil then dn_Handler will be loaded
+    dn_GlobalVec: LongInt;  // Global vector locking method key to use when starting the handler proc.
+                            // A value of -1 is used for standard C startup locking method. Only values -1 & -2 are valid now.
+    dn_Name: BSTR;          // BSTR device node name.
+    dn_StructSize: LongInt; // FULL size of this structure.
+    dn_Reserved: array[0..3] of LongInt; // DOS expansion space.
+  end;
+
+  PMultiAssign = ^TMultiAssign; // For normal DLT_LOCK and DLT_NONBINDING(v54) multi-assigns
+  TMultiAssign = record
+    ma_Next: PMultiAssign;      // next MultiAssign in chain, or nil
+    dat: record
+      ma_lock: BPTR;   // for DLT_LOCK multi-assigns
+      ma_name: STRPTR; // for DLT_NONBINDING multi-assigns (v54)
+    end;
+  end;
+
+
+  // ASSIGN struct; DLT_LOCK, DLT_LATE, DLT_NONBINDING
+  PAssignNode = ^TAssignNode;
+  TAssignNode = record
+    an_Next: BPTR;                      // BPTR to next entry in the chain
+    an_Type: LongInt;                   // DLT_LOCK,DLT_LATE,DLT_NONBINDING
+    an_Port: PMsgPort;                  // Ptr to handler process port for DLT_LOCK types.
+    an_Lock: BPTR;                      // Primary lock for DLT_LOCK assignments
+    an_AssignName: STRPTR;              // Primary name for non or late-binding assigns
+    an_MultiAssignList: PMultiAssign;   // Chain of DLT_LOCK multi-assigns
+    an_NBMultiAssignList: PMultiAssign; // Chain of DLT_NONBINDING multi-assigns
+    an_Unused: array[0..2] of LongInt;  // not currently used, leave as 0
+    an_Name: BSTR;                      // BSTR assignment node name
+    an_StructSize: LongInt;             // FULL allocated size of this structure.
+    an_Reserved: array[0..3] of LongInt;// DOS reserved expansion space.
+  end;
+
+       pAssignList = ^tAssignList;
+       tAssignList = record
+        al_Next : pAssignList;
+        al_Lock : BPTR;
+       END;
+
+// COMBINED structure for all types.
+  PDosList = ^TDosList;
+  TDosList = record
+    dol_Next: BPTR;      // bptr to next device on list
+    dol_Type: LongInt;   // see DLT below
+    dol_Port: PMsgPort;  // ptr to handler task
+    case smallint of
+    0:(
+        dol_Device: record
+          dol_Reserved1: LongInt; // Reserved for use by DOS.
+          dol_Handler: BSTR;      // BSTR file name to LoadSeg if dol_Seglist = nil.
+          dol_StackSize: LongInt; // Stacksize to use when starting process.
+          dol_Priority: LongInt;  // Task priority when starting process
+          dol_Startup: BPTR;      // Startup msg: FileSysStartupMsg for disks
+          dol_SegList: BPTR;      // Already loaded seglist for new process.
+          dol_GlobVec: LongInt;   // Global vector locking method key (-1 or -2)
+        end;
+    );
+    1 : (
+        dol_Volume: record
+          dol_Reserved2: LongInt;     // Reserved for use by DOS.
+          dol_VolumeDate: TDateStamp; // creation date
+          dol_LockList: BPTR;         // Unused, leave as 0
+          dol_DiskType: LongInt;      // 'DOS\0' - 32 bit hex identity
+          dol_FSPrivate: LongInt;     // Used privately by filesystems.
+        end;
+    );
+    2 : (
+        dol_Assign       :  record
+          dol_Lock: BPTR;         // Used by DLT_LOCK assign type only.
+          dol_AssignName: STRPTR; // name for non-OR-late-binding assign
+          dol_List: PAssignList;  // for multi-directory assigns (regular)
+          dol_MultiAssignList: PMultiAssign;   // Chain of DLT_LOCK multi-assigns
+          dol_NBMultiAssignList: PMultiAssign; // Chain of DLT_NONBINDING multi-assigns (V54)
+          dol_Unused: array[0..2] of LongInt;  // Not used for assigns, leave as 0
+        END;
+    dol_Name: BSTR;          // BSTR formatted name string
+    dol_StructSize: LongInt; // (See NOTES) FULL allocated size of struct
+    dol_Reserved: array[0..3] of LongInt; // DOS reserved expansion space.
+    );
+   END;
+
+
+{ This structure can take on different values depending on whether it is
+ * a device, an assigned directory, or a volume.  Below is the structure
+ * reflecting volumes only.  Following that is the structure representing
+ * only devices.
+ }
+
+{ structure representing a volume }
+
+    pDeviceList = ^tDeviceList;
+    tDeviceList = record
+        dl_Next         : BPTR;         { bptr to next device list }
+        dl_Type         : LongInt;      { see DLT below }
+        dl_Task         : PMsgPort;     { ptr to handler task }
+        dl_Lock         : BPTR;         { not for volumes }
+        dl_VolumeDate   : tDateStamp;   { creation date }
+        dl_LockList     : BPTR;         { outstanding locks }
+        dl_DiskType     : LongInt;      { 'DOS', etc }
+        dl_unused       : LongInt;
+        dl_Name         : BSTR;         { bptr to bcpl name }
+    end;
+
+{ device structure (same as the DeviceNode structure in filehandler.h) }
+
+    pDevInfo = ^tDevInfo;
+    tDevInfo = record
+        dvi_Next        : BPTR;
+        dvi_Type        : LongInt;
+        dvi_Task        : Pointer;
+        dvi_Lock        : BPTR;
+        dvi_Handler     : BSTR;
+        dvi_StackSize   : LongInt;
+        dvi_Priority    : LongInt;
+        dvi_Startup     : LongInt;
+        dvi_SegList     : BPTR;
+        dvi_GlobVec     : BSTR;
+        dvi_Name        : BSTR;
+    end;
+
+{    structure used for multi-directory assigns. AllocVec()ed. }
+
+
+
+
+
+
+const
+// definitions for dl_Type
+  DLT_DEVICE     = 0;
+  DLT_LOCK       = 1;  // normal assign
+  DLT_VOLUME     = 2;
+  DLT_LATE       = 3;  // late-binding assign
+  DLT_NONBINDING = 4;  // non-binding assign
+  DLT_PRIVATE    = -1; // for internal dos use only
+
+// Flags for Doslist functions
+  LDB_READ    = 0;
+  LDB_WRITE   = 1;
+  LDB_DEVICES = 2;
+  LDB_VOLUMES = 3;
+  LDB_ASSIGNS = 4;
+  LDB_ENTRY   = 5;
+  LDB_DELETE  = 6;
+
+// You MUST specify one of LDF_READ or LDF_WRITE
+  LDF_READ  = 1 shl LDB_READ;
+  LDF_WRITE = 1 shl LDB_WRITE;
+
+// Flags to be passed to LockDosList(), etc
+  LDF_DEVICES = 1 shl LDB_DEVICES;
+  LDF_VOLUMES = 1 shl LDB_VOLUMES;
+  LDF_ASSIGNS = 1 shl LDB_ASSIGNS;
+  LDF_ENTRY   = 1 shl LDB_ENTRY;   // internal
+  LDF_DELETE  = 1 shl LDB_DELETE;  // internal
+
+// Actually all but the internal locking flags
+  LDF_ALL = LDF_DEVICES or LDF_VOLUMES or LDF_ASSIGNS;
+
+// Mode types for NonBlockingModifyDosEntry()   (v51.30)
+
+  NBM_ADDDOSENTRY     = 1 shl 0;
+  NBM_REMDOSENTRY     = 1 shl 1;
+  NBM_RENAMEDOSENTRY  = 1 shl 2;
+  NBM_CHANGESIGNAL    = 1 shl 3;
+  NBM_REMFREEDOSENTRY = 1 shl 4; // added 53.67
+  NBM_DISKINSERTED    = 1 shl 5; // added 53.73
+  NBM_DISKREMOVED     = 1 shl 6; // added 53.73
+
+// A filesystem lock structure, as returned by Lock(), DupLock(), etc.. private
+type
+  PLock = ^TLock;
+  TLock = record
+    fl_Link: BPTR;      // PRIVATE - filesystem use only.
+    fl_Key: LongInt;    // PRIVATE - filesystem use only.
+    fl_Access: LongInt; // PRIVATE - filesystem use only.
+    fl_Port: PMsgPort;  // Handler process message port
+    fl_Volume: BPTR;    // BPTR to DLT_VOLUME DosList entry
+      // -- V51 additions --
+    fl_FSPrivate1: APTR;     // PRIVATE - filesystem use only.    */
+    fl_FSPrivate2: APTR;     // PRIVATE - filesystem use only.    */
+    fl_DOSType: LongWord;    // The DOSType of the filesystem, initialised by AllocDosObject(). */
+    fl_StructSize: LongWord; // Full DOS allocated struct size, initialised by AllocDosObject(). */
+      // -- V53 additions --
+    fl_DosPrivate: LongInt;              // PRIVATE - dos library use only.
+    fl_Reserved: array[0..1] of LongInt; // RESERVED for expansion. V53
+  end;// Filesystem private data usually extends past the end of this definition.
+
+type
+// The Public structure return by GetDeviceProc(), GetDeviceProcFlags()
+  PDevProc = ^TDevProc;
+  TDevProc = record
+    dvp_Port: PMsgPort;  // Handler message port
+    dvp_Lock: BPTR;      // Reference lock (or nil)
+    dvp_Flags: LongWord; // Flags fields.
+  end; // DOS private data extends past the end of this definition.
+
+const
+// Definitions for TDevProc.dvp_Flags;
+  DVPB_UNLOCK      = 0; // For DOS internal use.
+  DVPB_MULTIASSIGN = 1; // The Lock refers to part of a multi-assignment
+// The following flags were added at V53.56 to provide additional functionality for LockTags() and other internal subsystems.
+  DVPB_DEVICE      = 16; // The supplied path is a device relative specification.
+  DVPB_VOLUME      = 17; // The supplied path is a volume relative specification.
+  DVPB_ASSIGNMENT  = 18; // The supplied path is an assignment relative specification.
+  DVPB_PROGDIR     = 19; // The supplied path is a PROGDIR: relative specification.
+  DVPB_CURRDIR     = 20; // The supplied path is a CURRDIR: relative specification.
+  DVPB_ROOTDIR     = 21; // The supplied path is a root directory relative specification.
+  DVPB_CONSOLE     = 23; // The supplied path is a CONSOLE: handler specification.
+  DVPB_FILESYS     = 24; // The supplied path returned the root of the default filesystem.
+// Field definitions for above bits
+  DVPF_UNLOCK      = 1 shl DVPB_UNLOCK;
+  DVPF_MULTIASSIGN = 1 shl DVPB_MULTIASSIGN;
+  DVPF_DEVICE      = 1 shl DVPB_DEVICE;
+  DVPF_VOLUME      = 1 shl DVPB_VOLUME;
+  DVPF_ASSIGNMENT  = 1 shl DVPB_ASSIGNMENT;
+  DVPF_PROGDIR     = 1 shl DVPB_PROGDIR;
+  DVPF_CURRDIR     = 1 shl DVPB_CURRDIR;
+  DVPF_ROOTDIR     = 1 shl DVPB_ROOTDIR;
+  DVPF_CONSOLE     = 1 shl DVPB_CONSOLE;
+  DVPF_FILESYS     = 1 shl DVPB_FILESYS;
+
+// Error report types for ErrorReport()
+  REPORT_STREAM = 0; // a stream
+  REPORT_TASK   = 1; // a process - currently unused
+  REPORT_LOCK   = 2; // a lock
+  REPORT_VOLUME = 3; // a volume node
+  REPORT_INSERT = 4; // "please insert volume..."
+
+// Special error codes for ErrorReport()
+  ABORT_DISK_ERROR = 296; // Read/write error
+  ABORT_BUSY       = 288; // "You MUST replace..."
+
+// Types for initial packets to shells from run/newcli/execute/system. For shell-writers only
+  RUN_EXECUTE       = -1;
+  RUN_SYSTEM        = -2;
+  RUN_SYSTEM_ASYNCH = -3;
+
+{    Types for fib_DirEntryType.  NOTE that both USERDIR and ROOT are      }
+{    directories, and that directory/file checks should use <0 and >=0.    }
+{    This is not necessarily exhaustive!  Some handlers may use other      }
+{    values as needed, though <0 and >=0 should remain as supported as     }
+{    possible.                                                             }
+     ST_ROOT       =  1 ;
+     ST_USERDIR    =  2 ;
+     ST_SOFTLINK   =  3 ;      {    looks like dir, but may point to a file! }
+     ST_LINKDIR    =  4 ;      {    hard link to dir }
+     ST_FILE       =  -3;      {    must be negative for FIB! }
+     ST_LINKFILE   =  -4;      {    hard link to file }
+     ST_PIPEFILE   =  -5;      {    for pipes that support ExamineFH   }
+
+Type
+
+{ a lock structure, as returned by Lock() or DupLock() }
+
+    pFileLock = ^tFileLock;
+    tFileLock = record
+        fl_Link         : BPTR;         { bcpl pointer to next lock }
+        fl_Key          : LongInt;      { disk block number }
+        fl_Access       : LongInt;      { exclusive or shared }
+        fl_Task         : PMsgPort;     { handler task's port }
+        fl_Volume       : BPTR;         { bptr to a DeviceList }
+    end;
+
+
+{  NOTE: V37 dos.library, when doing ExAll() emulation, and V37 filesystems  }
+{  will return an error if passed ED_OWNER.  If you get ERROR_BAD_NUMBER,    }
+{  retry with ED_COMMENT to get everything but owner info.  All filesystems  }
+{  supporting ExAll() must support through ED_COMMENT, and must check Type   }
+{  and return ERROR_BAD_NUMBER if they don't support the type.               }
+
+{   values that can be passed for what data you want from ExAll() }
+{   each higher value includes those below it (numerically)       }
+{   you MUST chose one of these values }
+CONST
+     ED_NAME        = 1;
+     ED_TYPE        = 2;
+     ED_SIZE        = 3;
+     ED_PROTECTION  = 4;
+     ED_DATE        = 5;
+     ED_COMMENT     = 6;
+     ED_OWNER       = 7;
+
+// The ExAll() function and associated structures have been deprecated for V50.
+// Use ExamineDir()/ExamineObject() from V50 onwards.
+
+// Structure in which exall results are returned in.
+//  Note that only the fields asked for will exist!
+type
+  PExAllData = ^TExAllData;
+  TExAllData = record
+    ed_Next: PExAllData;
+    ed_Name: STRPTR;
+    ed_Type: LongInt;
+    ed_Size: LongWord;  // only good to 4gig
+    ed_Prot: LongWord;
+    ed_Days: LongWord;
+    ed_Mins: LongWord;
+    ed_Ticks: LongWord;
+    ed_Comment: STRPTR; // strings will be after last used field
+    ed_OwnerUID: Word;  // new for V39
+    ed_OwnerGID: Word;
+  end;
+
+{ Control structure passed to ExAll.  Unused fields MUST be initialized to 0, expecially eac_LastKey.
+  eac_MatchFunc is a hook (see utility.library documentation for usage)
+  It should return true if the entry is to returned, false if it is to be ignored.
+  This structure MUST be allocated by AllocDosObject()!}
+  PExAllControl = ^TExAllControl;
+  TExAllControl = record
+    eac_Entries: LongWord;   // number of entries returned in buffer
+    eac_LastKey: LongWord;   // Don't touch inbetween linked ExAll calls!
+    eac_MatchString: STRPTR; // wildcard string for pattern match OR nil
+    eac_MatchFunc: PHook;    // optional private wildcard function
+  end;
+
+type
+  pDosEnvec = ^tDosEnvec;
+  tDosEnvec = record
+    de_TableSize: LongWord;      // Size of Environment vector
+    de_SizeBlock: LongWord;      // in longwords: standard value is 128
+    de_SecOrg: LongWord;         // not used; must be 0
+    de_Surfaces: LongWord;       // # of heads (surfaces). drive specific
+    de_SectorPerBlock: LongWord; // not used; must be 1
+    de_BlocksPerTrack: LongWord; // blocks per track. drive specific
+    de_Reserved: LongWord;       // DOS reserved blocks at start of partition.
+    de_PreAlloc: LongWord;       // DOS reserved blocks at end of partition
+    de_Interleave: LongWord;     // usually 0
+    de_LowCyl: LongWord;         // starting cylinder. typically 0
+    de_HighCyl: LongWord;        // max cylinder. drive specific
+    de_NumBuffers: LongWord;     // Initial # DOS of buffers.
+    de_BufMemType: LongWord;     // type of mem to allocate for buffers
+    de_MaxTransfer: LongWord;    // Max number of bytes to transfer at a time
+    de_Mask: LongWord;           // Address Mask to block out certain memory
+    de_BootPri: LongInt;         // Boot priority for autoboot
+    de_DosType: LongWord;        // ASCII (HEX) string showing filesystem type; $444F5300 is old filesystem, $444F5301 is fast file system
+    de_Baud: LongWord;           // Baud rate for serial handler
+    de_Control: LongWord;        // Control smallint for handler/filesystem
+    de_BootBlocks: LongWord;     // Number of blocks containing boot code
+  end;
+
+const
+// The following are the offsets when DosEnvec was accessed as an array of longwords; DE_TABLESIZE is set to the number of fields in the array, minus 1,
+//  that is, NOT including the DE_TABLESIZE field itself. So if de_DosType was the last valid entry, de_TableSize = DE_DOSTYPE.
+
+  DE_TABLESIZE        = 0; // minimum value is 11 (includes NumBuffers)
+  DE_SIZEBLOCK        = 1; // in longwords: standard value is 128
+  DE_SECORG           = 2; // not used; must be 0
+  DE_NUMHEADS         = 3; // # of heads (surfaces). drive specific
+  DE_SECSPERBLK       = 4; // not used; must be 1
+  DE_BLKSPERTRACK     = 5; // sectors per track. drive specific
+  DE_RESERVEDBLKS     = 6; // unavailable blocks at start. usually 2
+  DE_PREFAC           = 7; // not used; must be 0
+  DE_INTERLEAVE       = 8; // usually 0
+  DE_LOWCYL           = 9; // starting cylinder. typically 0
+  DE_UPPERCYL         = 10; // max cylinder.  drive specific
+  DE_NUMBUFFERS       = 11; // starting # of buffers.  typically 5
+  DE_MEMBUFTYPE       = 12; // type of mem to allocate for buffers.
+  DE_BUFMEMTYPE       = 12; //    1 is public, 3 is chip, 5 is fast
+  DE_MAXTRANSFER      = 13; // Max number bytes to transfer at a time
+  DE_MASK             = 14; // Address Mask to block out certain memory
+  DE_BOOTPRI          = 15; // Boot priority for autoboot
+  DE_DOSTYPE          = 16; // ASCII (HEX) string showing filesystem type; $444F5300 is old filesystem, $444F5301 is fast file system
+  DE_BAUD             = 17; // Baud rate for serial handler
+  DE_CONTROL          = 18; // Control word for handler/filesystem
+  DE_BOOTBLOCKS       = 19; // Number of blocks containing boot code
+
+// The file system startup message is linked into a device node's startup
+// field.  It contains a pointer to the above environment, plus the
+// information needed to do an exec OpenDevice().
+type
+  PFileSysStartupMsg = ^TFileSysStartupMsg;
+  TFileSysStartupMsg = record
+    fssm_Unit: LongWord;  // exec unit number for this device
+    fssm_Device: BSTR;    // null terminated bstring to the device name
+    fssm_Environ: BPTR;   // ptr to environment table (see above)
+    fssm_Flags: LongWord; // flags for OpenDevice()
+  end;
+
+// The public portion of the structure used for the new V50 functions;
+// GetDiskFileSystemData() and FreeDiskFileSystemData().
+// Do not depend on the size of this structure to stay constant.
+  PFileSystemData = ^TFileSystemData;
+  TFileSystemData = record
+    fsd_Size: LongWord;                  // the size of this structure
+    fsd_FileSystemName: STRPTR;
+    fsd_DeviceName: STRPTR;
+    fsd_DeviceUnit: LongWord;
+    fsd_DeviceFlags: LongWord;
+    fsd_Environment: PDosEnvec;          // WARNING: See (Note 1) below
+    fsd_DosPrivate: array[0..3] of APTR; // this really is dos private !
+    fsd_Reserved: array[0..3] of APTR;
+  end;
+const
+  // The new V53 struct FileSystemVectorPort includes follow.
+  FS_VECTORPORT_VERSION = 53;
+
+type
+  PFileSystemVectors = ^TFileSystemVectors;
+  TFileSystemVectors = record
+    StructSize: LongWord; // Filesystem must initialise this to; sizeof(struct FileSystemVectors)
+    Version: LongWord;    // Filesystem must initialise this to; FS_VECTORPORT_VERSION
+    FSPrivate: APTR;      // Private field for exclusive use by the filesystem, this is generally used to point to the filesystems private global data structure to
+                          // make it accessible from the vector-port functions. Optionally, the filesystem may just initialise this to zero and then after the AllocDosObject() call, place your required data in there.
+    Reserved: array[0..2] of LongWord; // Filesystems initialise these to 0 - reserved expansion
+    DOSPrivate: APTR;     // Filesystems initialise this  to 0 - private DOS usage
+    // function links
+    DOSEmulatePacket: Pointer;
+    FSLock,
+    FSUnLock,
+    FSDupLock,
+    FSCreateDir,
+    FSParentDir,
+    FSDupLockFromFH,
+    FSOpenFromLock,
+    FSParentOfFH,
+    FSOpen,
+    FSClose,
+    FSDelete,
+    FSRead,
+    FSWrite,
+    FSFlush,
+    FSChangeFilePosition,
+    FSChangeFileSize,
+    FSGetFilePosition,
+    FSGetFileSize,
+    FSChangeLockMode,
+    FSChangeFileMode,
+    FSSetDate,
+    FSSetProtection,
+    FSSetComment,
+    FSSetGroup,
+    FSSetOwner,
+    FSRename,
+    FSCreateSoftLink,
+    FSCreateHardLink,
+    FSReadSoftLink,
+    FSSameLock,
+    FSSameFile,
+    FSFileSystemAttr,
+    FSVolumeInfoData,
+    FSDeviceInfoData,
+    FSReserved1,
+    FSReserved2,
+    FSExamineLock,
+    FSExamineFile,
+    FSExamineDir,
+    FSInhibit,
+    FSWriteProtect,
+    FSFormat,
+    FSSerialize,
+    FSRelabel,
+    FSReserved3,
+    FSAddNotify,
+    FSRemoveNotify,
+    FSLockRecord,
+    FSUnLockRecord: Pointer;
+    //=== End of V53 vectors, - New V54 vectors to be added after this line ===
+    End_Marker: LongInt; // This must always be at vector table end, set to -1
+  end;
+
+  PFileSystemVectorPort = ^TFileSystemVectorPort;
+  TFileSystemVectorPort = record
+    MP: TMsgPort;
+    FSV: TFileSystemVectors;
+  end;
+
+  FSVP = TFileSystemVectorPort; // shortcut
+
+const
+ // The type of device to mount
+  MDT_FileSystem = 0; // A file system, which is associated with a block storage device
+  MDT_Handler    = 1; // Any other kind which does not require a block storage device
+// Control tags which describe the device MountDevice() should mount
+  MD_Dummy           = TAG_USER + 4000;
+  MD_SectorSize      = MD_Dummy + 1;  // Sector size in bytes (ULONG); must be a multiple of 4
+  MD_Surfaces        = MD_Dummy + 2;  // Number of surfaces the file system should use (ULONG)
+  MD_SectorsPerBlock = MD_Dummy + 3;  // Number of sectors that make up a data block (ULONG)
+  MD_SectorsPerTrack = MD_Dummy + 4;  // Number of sectors that make up a track (ULONG)
+  MD_Reserved        = MD_Dummy + 5;  // Number of sectors at the beginning of the partition which should not be touched by the file system (ULONG)
+  MD_PreAlloc        = MD_Dummy + 6;  // Number of sectors at the end of the partition which should not be touched by the file system (ULONG)
+  MD_LowCyl          = MD_Dummy + 7;  // Lowest cylinder number used by the file system (ULONG)
+  MD_HighCyl         = MD_Dummy + 8;  // Highest cylinder number used by the file system (ULONG)
+  MD_NumBuffers      = MD_Dummy + 9;  // Number of data buffers the file system is to use (ULONG)
+  MD_BufMemType      = MD_Dummy + 10; // The type of memory to use for data buffers (ULONG)
+  MD_MaxTransfer     = MD_Dummy + 11; // Maximum number of bytes the device driver can transfer in a single step (ULONG)
+  MD_Mask            = MD_Dummy + 12; // Bit mask which covers the address range which the device driver can access (ULONG)
+  MD_DOSType         = MD_Dummy + 13;  // File system signature, e.g. ID_DOS_DISK (ULONG)
+  MD_Baud            = MD_Dummy + 14;  // Transmission speed (bits/second) to be used by the handler (ULONG)
+  MD_Control         = MD_Dummy + 15;  // Control information for the handler/file system (STRPTR).
+  MD_Device          = MD_Dummy + 16;  // Name of the exec device driver this file system is to use (STRPTR).
+  MD_Unit            = MD_Dummy + 17;  // Exec device driver unit number to be used by this file system (ULONG).
+  MD_Flags           = MD_Dummy + 18;  // Flags to use when the file system opens the exec device driver (ULONG).
+  MD_StackSize       = MD_Dummy + 19;  // Size of the stack to allocate for the file system (ULONG).
+  MD_Priority        = MD_Dummy + 20;  // Priority to start the file system process with (LONG).
+  MD_GlobVec         = MD_Dummy + 21;  // Global vector number (LONG).
+  MD_StartupNumber   = MD_Dummy + 22;  // The number to store as the file system startup data (LONG).
+  MD_StartupString   = MD_Dummy + 23;  // The string to store as the file system startup data (STRPTR).
+  MD_IgnoreFSR       = MD_Dummy + 24;  // Whether the file system parameters should be initialized from the FileSystem.resource or not (BOOL).
+  MD_Activate        = MD_Dummy + 25;  // Whether the file system should be activated immediately after it has been mounted (BOOL).
+  MD_Handler         = MD_Dummy + 26;  // Name of the handler which implements the file system (STRPTR).
+  MD_SegList         = MD_Dummy + 27;  // The segment list which refers to the code which implements the file system (BPTR).
+  MD_Port            = MD_Dummy + 28;  // The port which implements the file system (struct MsgPort *).
+  MD_Entry           = MD_Dummy + 29;  // The function which implements the file system (VOID (*)(VOID)).
+
+
+// Flags for DismountDevice()
+  DMDF_KEEPDEVICE     =  1 shl 0;
+  DMDF_REMOVEDEVICE   =  1 shl 1;
+  DMDF_FORCE_DISMOUNT =  1 shl 2;
+
+const
+// --- NotifyMessage Class
+  NOTIFY_CLASS  =  $40000000;
+// --- NotifyMessage Codes
+  NOTIFY_CODE   =  $1234;
+
+
+// Sent to the application if SEND_MESSAGE is specified.
+
+type
+  PNotifyRequest = ^tNotifyRequest;
+  tNotifyRequest = record
+    nr_Name : STRPTR;       // The name of object for notification
+    nr_FullName: STRPTR;   // PRIVATE: set by dos - don't touch
+    nr_UserData: LongWord; // For the applications use
+    nr_Flags: LongWord;    // Notify method flags NRF_xxx
+    nr_stuff: record
+    case smallint of
+    0: (nr_Msg: record
+        nr_Port: PMsgPort;              // for SEND_MESSAGE
+        nr_MsgPad: array[0..3] of Byte; // Reserved
+     end);
+    1: (nr_Signal : record
+        nr_Task : PTask;                // for SEND_SIGNAL
+        nr_SignalNum : Byte;            // for SEND_SIGNAL
+        nr_SigPad: array[0..2] of Byte; // reserved
+     end);
+     0: (nr_CallHook: record
+        nr_Hook: PHook;                  // for CALL_HOOK
+        nr_HookPad: array[0..3] of Byte; // Reserved
+     end);
+    end;
+    nr_Reserved : array[0..1] of LongWord; // Reserved - leave as 0 for now
+    // internal use by dos and handlers
+    nr_DosPrivate:LongWord;                // PRIVATE: DOS use only. -  V51.30
+    nr_FSPrivate: APTR;                    // PRIVATE: FS/Handler use only. - V51.30
+    nr_MsgCount: LongWord;                 // PRIVATE: # of outstanding msgs
+    nr_Handler: PMsgPort;                  // PRIVATE: handler sent to (for EndNotify)
+    nr_Expansion: array[0..3] of LongWord; // expansion space - added V51.30
+  end;
+
+  PNotifyMessage = ^TNotifyMessage;
+  TNotifyMessage = record
+    nm_ExecMessage: TMessage;
+    nm_Class: LongWord;
+    nm_Code: Word;
+    nm_NReq: PNotifyRequest;  // Don't modify the request while active !
+    nm_DoNotTouch: LongWord;  // Like it says! For use by handlers
+    nm_DoNotTouch2: LongWord; // ditto
+  end;
+
+const
+// Flag bit numbers
+  NRB_SEND_MESSAGE      = 0;
+  NRB_SEND_SIGNAL       = 1;
+  NRB_WAIT_REPLY        = 3;
+  NRB_NOTIFY_INITIAL    = 4;
+  NRB_CALL_HOOK         = 5;
+  NRB_DOS_NOTIFY_ONLY   = 12;
+  NRB_MAGIC             = 31; // PRIVATE - Handler use only.
+
+// --- NotifyRequest Flags ------------------------------------------------
+// Notify Methods - the following three are mutually exclusive
+  NRF_SEND_MESSAGE      = 1 shl NRB_SEND_MESSAGE;
+  NRF_SEND_SIGNAL       = 1 shl NRB_SEND_SIGNAL;
+  NRF_CALL_HOOK         = 1 shl NRB_CALL_HOOK;
+// Do not queue messages for NRF_SEND_MESSAGE method
+  NRF_WAIT_REPLY        = 1 shl NRB_WAIT_REPLY;
+// Always send an initial notification on setup
+  NRF_NOTIFY_INITIAL    = 1 shl NRB_NOTIFY_INITIAL;
+// New flag for V52.33+ DOS, specifying this flag prevents the use  of filesystem supported notification, even if it is available,
+// it forces usage of the dos.library notification function instead. The dos.library notification function supports all three methods with both file and directory monitoring.
+  NRF_DOS_NOTIFY_ONLY   = 1 shl NRB_DOS_NOTIFY_ONLY;
+
+// PRIVATE - Handler use only. Do NOT set or remove NRF_MAGIC yourself.
+  NRF_MAGIC             = 1 shl NRB_MAGIC;
+
+// PRIVATE - Bitmask of flags that are reserved for use by the handler:
+  NR_HANDLER_MASK       = $ffff0000;
+  NR_HANDLER_FLAGS      = NR_HANDLER_MASK;  // old source compatibility
+
+type
+// --- NotifyHook data
+  PNotifyHookMsg = ^TNotifyHookMsg;
+  TNotifyHookMsg = record
+    nhm_Size: LongInt;   // Size of data structure
+    nhm_Action: LongInt; // What happened (see below)
+    nhm_Name: STRPTR;    // The name of the object
+  end;
+
+const
+// nhm_Action types
+  NHM_ACTION_INITIAL = -1; // Initial invocation
+  NHM_ACTION_ADD     = 0;  // Object was added
+  NHM_ACTION_CHANGE  = 1;  // Object has changed
+  NHM_ACTION_DELETE  = 2;  // Object was removed
+
+// A shell search path list component. Do not allocate this yourself!
+type
+  PPathNode = ^TPathNode;
+  TPathNode = record
+    pn_Next: BPTR; // Pointer to next path node
+    pn_Lock: BPTR; // Directory lock
+  end;
+
+// Parameters for use with the AddPathNode() function. Where to add the new node?
+const
+  ADDCMDPATHNODE_HEAD = 0;
+  ADDCMDPATHNODE_TAIL = 1;
+
+// The message passed to hook invoked by the SearchCmdPathList() function.
+type
+  PSearchCmdPathListMsg = ^TSearchCmdPathListMsg;
+  TSearchCmdPathListMsg = record
+    splm_Size: LongInt;
+    splm_Lock: BPTR;
+    splm_Name: STRPTR;
+  end;
+
+{*********************************************************************
+ *
+ * The CSource data structure defines the input source for "ReadItem()"
+ * as well as the ReadArgs call.  It is a publicly defined structure
+ * which may be used by applications which use code that follows the
+ * conventions defined for access.
+ *
+ * When passed to the dos.library functions, the value passed as
+ * struct *CSource is defined as follows:
+ *      if ( CSource == 0)      Use buffered IO "ReadChar()" as data source
+ *      else                    Use CSource for input character stream
+ *
+ * The following two pseudo-code routines define how the CSource structure
+ * is used:
+ *
+ * long CS_ReadChar( struct CSource *CSource )
+ *
+ *      if ( CSource == 0 )     return ReadChar();
+ *      if ( CSource->CurChr >= CSource->Length )       return ENDSTREAMCHAR;
+ *      return CSource->Buffer[ CSource->CurChr++ ];
+ *
+ *
+ * BOOL CS_UnReadChar( struct CSource *CSource )
+ *
+ *      if ( CSource == 0 )     return UnReadChar();
+ *      if ( CSource->CurChr <= 0 )     return FALSE;
+ *      CSource->CurChr--;
+ *      return TRUE;
+ *
+ *
+ * To initialize a struct CSource, you set CSource->CS_Buffer to
+ * a string which is used as the data source, and set CS_Length to
+ * the number of characters in the string.  Normally CS_CurChr should
+ * be initialized to ZERO, or left as it was from prior use as
+ * a CSource.
+ *
+ *********************************************************************}
+
+type
+  PCSource = ^TCSource;
+  TCSource = record
+    CS_Buffer: STRPTR;
+    CS_Length: LongInt;
+    CS_CurChr: LongInt;
+  end;
+
+{   *********************************************************************
+ *
+ * The RDArgs data structure is the input parameter passed to the DOS
+ * ReadArgs() function call.
+ *
+ * The RDA_Source structure is a CSource as defined above;
+ * if RDA_Source.CS_Buffer is non-null, RDA_Source is used as the input
+ * character stream to parse, else the input comes from the buffered STDIN
+ * calls ReadChar/UnReadChar.
+ *
+ * RDA_DAList is a private address which is used internally to track
+ * allocations which are freed by FreeArgs().  This MUST be initialized
+ * to NULL prior to the first call to ReadArgs().
+ *
+ * The RDA_Buffer and RDA_BufSiz fields allow the application to supply
+ * a fixed-size buffer in which to store the parsed data.  This allows
+ * the application to pre-allocate a buffer rather than requiring buffer
+ * space to be allocated.  If either RDA_Buffer or RDA_BufSiz is NULL,
+ * the application has not supplied a buffer.
+ *
+ * RDA_ExtHelp is a text string which will be displayed instead of the
+ * template string, if the user is prompted for input.
+ *
+ * RDA_Flags bits control how ReadArgs() works.  The flag bits are
+ * defined below.  Defaults are initialized to ZERO.
+ *
+ *********************************************************************}
+
+  PRDArgs = ^TRDArgs;
+  TRDArgs = record
+    RDA_Source: TCSource; // Select input source
+    RDA_DAList: LongInt;  // PRIVATE.
+    RDA_Buffer: STRPTR;   // Optional string parsing space.
+    RDA_BufSiz: LongInt;  // Size of RDA_Buffer (0..n)
+    RDA_ExtHelp: STRPTR;  // Optional extended help
+    RDA_Flags: LongInt;   // Flags for any required control
+  end;
+
+const
+  RDAB_STDIN     = 0; // Use "STDIN" rather than "COMMAND LINE"
+  RDAB_NOALLOC   = 1; // If set, do not allocate extra string space.
+  RDAB_NOPROMPT  = 2; // Disable reprompting for string input.
+  RDAF_STDIN     = 1 shl RDAB_STDIN;
+  RDAF_NOALLOC   = 1 shl RDAB_NOALLOC;
+  RDAF_NOPROMPT  = 1 shl RDAB_NOPROMPT;
+
+// Modes for LockRecord/LockRecords()
+  REC_EXCLUSIVE       = 0;
+  REC_EXCLUSIVE_IMMED = 1;
+  REC_SHARED          = 2;
+  REC_SHARED_IMMED    = 3;
+
+  RECF_DOS_METHOD_ONLY = 1 shl 16;
+  REC_MODE_MASK        = $FF;
+
+// Struct to be passed to LockRecords()/UnLockRecords() v53.86+
+// Note: the rec_Size member MUST be set in each struct or it won't work.
+type
+  PRecordLock = ^TRecordLock;
+  TRecordLock = record
+    rec_Size: LongWord;   // This MUST be set to sizeof(struct RecordLock)
+    rec_FH: BPTR;         // filehandle
+    rec_Offset: LongWord; // offset in file
+    rec_Length: LongWord; // length of file record to be locked
+    rec_Mode: LongWord;   // Type of lock
+  end;
+
+// The structure in the pr_LocalVars list. Do NOT allocate yourself, use SetVar()!!! This structure may grow in
+// future releases!  The list should be left in alphabetical order, and may have multiple entries with the same name but different types.
+  PLocalVar = ^TLocalVar;
+  TLocalVar = record
+    lv_Node: TNode;
+    lv_Flags: Word;
+    lv_Value: STRPTR;
+    lv_Len: LongWord;
+  end;
+// The LocalVar->lv_Node.ln_Name points to the name buffer.
+// The LocalVar->lv_Node.ln_Type is used by the system.
+// The LocalVar->lv_Node.ln_Pri is reserved for system use.
+const
+// LocalVar type identifiers:
+  LV_VAR     =   0; // a variable
+  LV_ALIAS   =   1; // an alias
+// bit definitions for LocalVar type:
+  LVB_IGNORE =   7;   // ignore this entry on GetVar, FindVar() etc
+  LV_TYPE_MASK = $FF; // the low 8 flags bits hold the local var type
+
+// bit definitions of flags passed to GetVar()/SetVar()/DeleteVar(), ScanVars() these bit defs are OR'ed with the type. Item will be treated as a single line of text unless BINARY_VAR is specified
+  GVB_GLOBAL_ONLY       = 8;  // only use global vars, no local vars will be accessed.
+  GVB_LOCAL_ONLY        = 9;  // only use local vars, no global vars will be accessed.
+  GVB_BINARY_VAR        = 10; // treat as binary var, don't truncate at a newline or carriage return char.
+  GVB_DONT_NULL_TERM    = 11; // can only be used with GVF_BINARY_VAR do not add a nul-terminator 0 byte at the end of data.
+  GVB_SAVE_VAR          = 12; // only works with GVF_GLOBAL_VAR this is only supported in >= V39 dos.  V37 dos ignores this. this causes SetVar to affect ENVARC: as well as ENV:
+  GVB_SCAN_ENVARC       = 13; // only usefull with GLOBAL vars scan envarc: instead of env: for use in ScanVars() - v50
+  GVB_SCAN_LEVEL        = 14; // for ScanVars() - v53 scan single directory level do not go into further sub directories. - v53
+  GVB_SCAN_TOPLEVEL     = GVB_SCAN_LEVEL;
+  GVB_SCAN_STARTDIR     = 15;
+
+  LVF_IGNORE              = 1 shl LVB_IGNORE;
+  GVF_GLOBAL_ONLY         = 1 shl GVB_GLOBAL_ONLY;
+  GVF_LOCAL_ONLY          = 1 shl GVB_LOCAL_ONLY;
+  GVF_BINARY_VAR          = 1 shl GVB_BINARY_VAR;
+  GVF_DONT_NULL_TERM      = 1 shl GVB_DONT_NULL_TERM;
+  GVF_SAVE_VAR            = 1 shl GVB_SAVE_VAR;
+  GVF_SCAN_ENVARC         = 1 shl GVB_SCAN_ENVARC;
+  GVF_SCAN_LEVEL          = 1 shl GVB_SCAN_LEVEL;
+  GVF_SCAN_STARTDIR       = 1 shl GVB_SCAN_STARTDIR;
+
+const
+//definitions for the (V51.96) GetDiskInfo() call.
+  GDI_Dummy           = TAG_USER + 500;
+  GDI_StringNameInput = GDI_Dummy + 1;  // STRPTR - pointer to a string identifier for the handler.
+  GDI_FileHandleInput = GDI_Dummy + 2;  // BPTR - BCPL pointer to a FileHandle to identify the handler
+  GDI_LockInput       = GDI_Dummy + 3;  // BPTR - BCPL pointer to a Lock to identify the handler.
+  GDI_FileLockInput   = GDI_LockInput;
+  GDI_MsgPortInput    = GDI_Dummy + 4;  // PMsgPort - Pointer to the handlers message port
+  GDI_VolumeRequired  = GDI_Dummy + 10; // LongBool - True for ACTION_INFO, FALSE for ACTION_DISK_INFO
+  GDI_InfoData        = GDI_Dummy + 11; // PInfoData - Pointer to an InfoData structure
+// definitions for the (V53.59) ObtainConsoleDataTags() call.
+  OCD_Dummy           = TAG_USER + 600;
+  OCD_FileHandleInput = OCD_Dummy + 1; // BPTR - BCPL pointer to a FileHandle for a console window.
+  OCD_MsgPortInput    = OCD_Dummy + 2; // PMsgPort - Pointer to a console message port.
+// definitions for the (V50) GetSegListInfo() call
+  GSLI_Dummy         = TAG_USER + 4000;
+  GSLI_NATIVE        = GSLI_Dummy + 1;  // PPPseudoSegList - if PPC executable. this only means it's native and executable, it does NOT imply any particular type.
+  GSLI_Data          = GSLI_Dummy + 2;  // PAPTR - data, if a data-only pseudoseglist.
+  GSLI_68KPS         = GSLI_Dummy + 3;  // PPPseudoSeglist - if 68K pseudoseglist
+  GSLI_ElfHandle     = GSLI_Dummy + 4;  // PPElf32_Handle
+  GSLI_68KHUNK       = GSLI_Dummy + 5;  // PBPTR - seglist, if old 68K HUNK style seglist.
+  GSLI_68KOVLAY      = GSLI_Dummy + 6;  // PBPTR - seglist, if old 68K OVERLAY seglist.
+  GSLI_68KFileSize   = GSLI_Dummy + 7;  // PLongWord - size of the 68K binary load file. 51.58
+  GSLI_68KFileXsum   = GSLI_Dummy + 8;  // PLongWord - 32 bit xsum of the 68K binary load file. 51.58
+  GSLI_HeaderSize    = GSLI_Dummy + 9;  // PLongWord - byte size of the DOS allocated segment header. 51.99
+  GSLI_SegmentSize   = GSLI_Dummy + 10; // PLongWord - byte size of the entire segment allocation.  52.13
+  GSLI_VersionString = GSLI_Dummy + 11; // STRPTR - returns a "$VER:" version string in a seglist. 52.18
+  GSLI_ResidentVersionString = GSLI_Dummy + 12; // STRPTR - returns Resident->rt_IDString version string. 53.21
+  GSLI_ResidentStruct = GSLI_Dummy + 13; // PResident - returns a pointer to a struct Resident. 53.70
+// definitions for the (V50) AddSegmentTagList() call
+  AS_Dummy       = TAG_USER + 3000;
+  AS_SegmentList = AS_Dummy + 1; // Segment list, as returned by the LoadSeg() function
+  AS_Entry       = AS_Dummy + 2; // Address of a function which implements the command
+// definitions for the (V53) LockTagList() call
+  LK_Dummy       = TAG_USER + 5750;
+  LK_Name        = LK_Dummy + 1; // STRPTR - Name of object to lock.
+  LK_Mode        = LK_Dummy + 2; // LongInt - Access mode; SHARED_LOCK or EXCLUSIVE_LOCK
+  LK_InfoMask    = LK_Dummy + 3; // PLongWord - pointer to info mask storage area.
+  LK_SoftLinks   = LK_Dummy + 4; // PLongWord - pointer to softlink count storage area.
+  LK_ResolveSL   = LK_Dummy + 5; // LongInt - Boolean switch to control softlink resolution.
+  LK_ResolveMA   = LK_Dummy + 6; // LongInt - Boolean switch to control multi-assign resolution. 54.21
+
+// definitions for the DosSystem() call.
+  SYS_Dummy              = TAG_USER + 32;
+  SYS_CommandRunMode     = SYS_Dummy + 0; // (LongBool) PRIVATE Internal SHELL tag to identify "run" command.
+  SYS_Input              = SYS_Dummy + 1; // (BPTR) specifies the input filehandle
+  SYS_Output             = SYS_Dummy + 2; // (BPTR) specifies the output filehandle
+  SYS_Asynch             = SYS_Dummy + 3; // (LongBool) run asynch, close input/output on exit(!)
+  SYS_UserShell          = SYS_Dummy + 4; // (LongBool) send to user shell instead of boot shell
+  SYS_CustomShell        = SYS_Dummy + 5; // (STRPTR) send to a specific shell (data is name)
+  SYS_Error              = SYS_Dummy + 6; // (BPTR) specifies the error output filehandle (New for V50)
+  SYS_ExecuteInputStream = SYS_Dummy + 7; // (LongBool) instead of reading the 'command' string parameter, reads commands from the input filehandle instead. (V53.45)
+
+//definitions for the CreateNewProc() call; you MUST specify one of NP_Seglist or NP_Entry. All others are optional.
+  NP_Dummy       = TAG_USER + 1000;
+  NP_Seglist     = NP_Dummy + 1;  // seglist of code to run for the process
+  NP_FreeSeglist = NP_Dummy + 2;  // free seglist on exit - only valid for for NP_Seglist. Default is FALSE.
+  NP_Entry       = NP_Dummy + 3;  // entry point to run
+  NP_Input       = NP_Dummy + 4;  // filehandle - default is DosOpen('NIL:'...)
+  NP_Output      = NP_Dummy + 5;  // filehandle - default is DosOpen('NIL:'...)
+  NP_CloseInput  = NP_Dummy + 6;  // close input filehandle on exit default TRUE
+  NP_CloseOutput = NP_Dummy + 7;  // close output filehandle on exit default TRUE
+  NP_Error       = NP_Dummy + 8;  // filehandle - default is nil V50
+  NP_CloseError  = NP_Dummy + 9;  // close error filehandle on exit default FALSE V50
+  NP_CurrentDir  = NP_Dummy + 10; // lock - default is parent's current dir
+  NP_StackSize   = NP_Dummy + 11; // stacksize for process - default 4000
+  NP_Name        = NP_Dummy + 12; // name for process - default 'New Process'
+  NP_Priority    = NP_Dummy + 13; // priority - default same as parent
+  NP_ConsolePort = NP_Dummy + 14; // consoletask - old compatibility  - default same as parent
+  NP_ConsoleTask = NP_ConsolePort;
+  NP_WindowPtr   = NP_Dummy + 15; // window ptr - default is same as parent
+  NP_ProgramDir  = NP_Dummy + 16; // home program directory - default curr progdir
+  NP_CopyVars    = NP_Dummy + 17; // Boolean to copy local vars - default TRUE
+  NP_Cli         = NP_Dummy + 18; // create cli structure - default FALSE
+  NP_Path        = NP_Dummy + 19; // path - default is copy of parents path only valid if a cli process!
+  NP_CommandName = NP_Dummy + 20; // commandname - valid only for CLI
+  NP_Arguments   = NP_Dummy + 21; // cstring of arguments
+  NP_unused1     = NP_Dummy + 22; // never implemented
+  NP_unused2     = NP_Dummy + 23; // INTERNALLY - used
+  NP_ExitCode    = NP_Dummy + 24; // code to be called on process exit, just before cleanup
+  NP_ExitData    = NP_Dummy + 25; // optional argument for NP_ExitCode function - default 0
+  NP_UserData    = NP_Dummy + 26; // optional value to install into TTask.tc_UserData.
+  NP_Child       = NP_Dummy + 27; // LongBool flag to nominate this new process as a dependant child of the parent. (V50)
+  NP_NotifyOnDeathMessage = NP_Dummy + 28; // PDeathMessage -- (V51.53) Specify an initialised death message structure to ReplyMsg() to,
+                                           // upon death of this process. Defaults to none.
+  NP_NotifyOnDeathSigTask = NP_Dummy + 29; // PTask -- (V51.53) Specify the task or process to signal upon death of this process.
+                                           // Specify NULL for the parent of this child process. Defaults to no signalling, if this tag is not specified
+  NP_NotifyOnDeathSignalBit = NP_Dummy + 30; // A value 0-31 for the signal bit number to send to the task NP_NotifyOnDeathSigTask, upon death of this process. Defaults to SIGB_CHILD if not specified.
+  NP_LocalVars   = NP_Dummy + 31; // STRPTR * -- (V51.70) Paired array of string pointers representing a list of local variables to add to the new process, array must be
+                                  // arranged as;  Name1,Value1, Name2,Value2, Name3,Value3, nil; Default nil
+  NP_EntryCode   = NP_Dummy + 32; // code to be called on process startup, just before internalRunCommand()
+  NP_EntryData   = NP_Dummy + 33; // optional argument for NP_EntryCode function - default 0
+  NP_FinalCode   = NP_Dummy + 34; // code to be called on process exit, just before cleanup
+  NP_FinalData   = NP_Dummy + 35; // optional argument for NP_FinalCode function - default 0
+  NP_LocalAlias  = NP_Dummy + 36; // PSTRPTR -- (added V52.5) Paired array of string pointers to represent a list of local aliases to add to the new process,
+                                  // array must be arranged as; Alias1,Value1, Alias2,Value2, Alias3,Value3, nil; Default nil
+  NP_LockStack   = NP_Dummy + 37; // Boolean tag to cause exec to lock the stack in place, specifying TRUE will prevent the stack frame being swapped out. Default FALSE   (added V52.10)
+  NP_OwnerUID    = NP_Dummy + 38; // LongWord -- (added 52.18) Specify the pr_UID value for the new process.
+  NP_OwnerGID    = NP_Dummy + 39; // LongWord -- (added 52.18) Specify the pr_GID value for the new process.
+
+// tags for AllocDosObject()
+  ADO_Dummy        = TAG_USER + 2000;
+  ADO_TermCharStr  = ADO_Dummy + 0;    // Added for FReadLine() V53.19
+// Obsolete tags +1...+5 have removed
+  ADO_AddedSize    = ADO_Dummy + 6; // Size of additional buffer to allocate over and above the base structure size required by the flag DOS_xxxxx .  (V50)
+  ADO_Strlen       = ADO_AddedSize;
+  ADO_Flags        = ADO_Dummy + 7; // Generic 32 bit flags for those allocations that require initialisation of a specific flags field. (V50)
+  ADO_DOSType      = ADO_Flags;     // alias V51
+  ADO_TermChar     = ADO_Flags;     // alias V51
+  ADO_Type         = ADO_Flags;     // alias V52
+  ADO_Vectors      = ADO_Flags;     // alias V53
+  ADO_Mask         = ADO_Dummy + 8; // Generic 32 bit mask for those allocations that require initialisation of a specific bitmask. (V50)
+  ADO_AddColon     = ADO_Mask;      // alias V53
+  ADO_Name         = ADO_Dummy + 9; // Generic STRPTR Name. (V52)
+  ADO_NotifyName   = ADO_Name;      // alias V52 Name of the volume, directory or file to monitor and produce notification messages for. (V51)
+  ADO_NotifyUserData     = ADO_Dummy + 10; // User data to be stored in a NotifyRequest. (V51)
+  ADO_NotifyMethod       = ADO_Dummy + 11; // Notification method; must be one of NRF_SEND_MESSAGE, NRF_SEND_SIGNAL or NRF_CALL_HOOK. (V51)
+  ADO_NotifyPort         = ADO_Dummy + 12; // MsgPort to send notification messages to; this is used for the NRF_SEND_MESSAGE notification method. (V51)
+  ADO_NotifyTask         = ADO_Dummy + 13; // Task to send a notification signal to; this is used for the NRF_SEND_SIGNAL notification method. (V51)
+  ADO_NotifySignalNumber = ADO_Dummy + 14; // The signal number (0..31) to use when sending a notification signal; this is used for the NRF_SEND_SIGNAL notification method. (V51)
+  ADO_NotifyHook         = ADO_Dummy + 15; // The hook to call when a notification is required; this is used for the NRF_CALL_HOOK method. (V51)
+  ADO_NotifyWaitReply    = ADO_Dummy + 16; // Selects if the further notification messages should be sent unless the last message has been replied. (V51)
+  ADO_NotifyInitial      = ADO_Dummy + 17; // Selects if the notification should be sent immediately after it was requested. (V51)
+  ADO_Size               = ADO_Dummy + 18; // Specify allocation size that is larger than the default. (V51)
+  ADO_DOSMethodOnly      = ADO_Dummy + 19; // Force the dos.library to service the notify request, and exclude the filesystem routines even if they are available. (V52.33)
+  ADO_ExamineData_NameSize = ADO_Dummy + 20; // Selects the size of the name buffer for DOS_EXAMINEDATA. (V51)
+  ADO_ExamineData_CommentSize = ADO_Dummy + 21; // Selects the size of the comment buffer for DOS_EXAMINEDATA (V51)
+  ADO_ExamineData_LinkSize = ADO_Dummy + 22; // Selects the size of the link name buffer for DOS_EXAMINEDATA. (V51)
+  ADO_ExamineDir_Context = ADO_Dummy + 23; // Used by filesystems and DOS to pass an ExamineContext. (V51.104)
+
+// Tags for DosControl()
+  DC_Dummy     = TAG_USER + 5000;
+  DC_WildStarW = DC_Dummy + 1; // (LongInt Boolean) -- Write to the default WildStar switch. Default is FALSE.
+  DC_WildStarR = DC_Dummy + 2; // (PLongInt) -- Obtain the state of WildStar switch.
+  DC_FHBufferW = DC_Dummy + 3; // (LongInt) -- Writes the size in bytes for all FileHandle buffers. The default value for V50 DOS is 8000 bytes.
+  DC_FHBufferR = DC_Dummy + 4; // (PLongInt) -- Obtain the size in bytes for FH Buffers.
+  DC_WarnPostTimeW = DC_Dummy + 5;  // (LongInt) -- Write the number of seconds to post warning for. Default posting time is currently 120 seconds.
+  DC_WarnPostTimeR = DC_Dummy + 6;  // (PLongInt) -- Obtain the value for WarnPostTime.
+  DC_WarnWaitTimeW = DC_Dummy + 7;  // (LongInt) -- Write the number of seconds to wait between warnings. Default wait time is currently 5 seconds.
+  DC_WarnWaitTimeR = DC_Dummy + 8;  // (PLongInt) -- Obtain the value for WarnWaitTime.
+  DC_MinProcStackW = DC_Dummy + 9;  // (LongInt) -- Write the number of bytes to enforce as min proc stack
+  DC_MinProcStackR = DC_Dummy + 10; // (PLongInt) -- Obtain the value for MinProcStack.
+  DC_AssignMountW  = DC_Dummy + 11; // (LongInt) -- Write to the default AssignMount switch.
+  DC_AssignMountR  = DC_Dummy + 12; // (PLongInt) -- Obtain the state of the AssignMount switch.
+  DC_BootCliFontSizeW = DC_Dummy + 13; // (LongInt) -- Write the boot cli font size. TOPAZ_SIXTY or TOPAZ_EIGHTY
+  DC_BootCliFontSizeR = DC_Dummy + 14; // (PLongInt) -- Obtain the size of the boot cli font size.
+  DC_Reload68KApplistW = DC_Dummy + 15; // (LongInt) -- DOSTRUE will cause DEVS:applications.dos config file to reload from disk. 51.58
+  DC_unused1R          = DC_Dummy + 16; // pad tag for DC_Reload68KApplistR slot
+  DC_BootCliCloseGadgetW = DC_Dummy + 17; // (LongInt) -- DOSTRUE will cause the boot cli to have a close gadget. 52.8
+  DC_BootCliCloseGadgetR = DC_Dummy + 18; // (PLongInt) -- Obtain the state of the boot cli close gadget switch. 52.8
+  DC_LocaleBaseW = DC_Dummy + 19; // (PLocaleBase) -- Write the locale base pointer for DOS to access. V54
+  DC_LocaleBaseR = DC_Dummy + 20; // (PPLocaleBase) -- Obtain the locale base pointer value from DOS. V54
+
+// Tags for ReadLineItem()
+  RLI_Dummy           = TAG_USER + 5500;
+  RLI_FileHandleInput = RLI_Dummy + 1;  // (BPTR) -- Read with FGetC() from this filehandle. Default is FGetC(Input());
+  RLI_CSourceInput    = RLI_Dummy + 2;  // (PCSource) -- Read from this CSource stream. Default is FGetC(Input());
+  RLI_EscapeChars     = RLI_Dummy + 10; // (STRPTR) -- Nul-terminated string of one or more characters to be recognised as escape characters.
+                                        // This may be an empty string '' or nil, for none. Defaults to '*'.
+  RLI_MultiLine       = RLI_Dummy + 11; // (LongInt; boolean) -- Enable Multi-line processing. Defaults to FALSE.
+  RLI_CommentChars    = RLI_Dummy + 12; // (STRPTR) -- Nul-terminated string of one or more characters to be used as a comment marker.
+                                        // This may be an empty string '' or nil, for none. Defaults to ''.
+  RLI_Substitute_N    = RLI_Dummy + 13; // (LongInt; boolean) -- Substitute quoted escaped 'N' to the hex char $0a.
+                                        // Only works when RLI_EscapeChars is not "" or nil. Defaults to TRUE.
+  RLI_Substitute_E    = RLI_Dummy + 14; // (LongInt; boolean) -- Substitute quoted escaped 'E' to the hex
+                                        // char $1b. Only works when RLI_EscapeChars is not '' or nil. Defaults to TRUE.
+// Tags for SetFileHandleAttr()
+  FH_Dummy      = TAG_USER + 6000;
+
+  FH_BufferSize = FH_Dummy + 1;
+  FH_UserBuffer = FH_Dummy + 2;
+  FH_BufferMode = FH_Dummy + 3;
+  FH_Locking    = FH_Dummy + 4;
+  FH_EndStream  = FH_Dummy + 5;
+
+// Tags for SetOwnerInfo(), GetOwnerInfo().
+  OI_Dummy           = TAG_USER + 6200;
+
+  OI_StringNameInput = OI_Dummy + 1;  // (STRPTR) -- Pointer to a string identifying a filesystem object. This tag is mutually exclusive with OI_Process.
+  OI_StringName      = OI_StringNameInput;
+  OI_ProcessInput    = OI_Dummy + 2;  // (PProcess) -- Pointer to a process structure, or nil for this process, to identify a process. This tag is mutually exclusive with OI_StringName.
+  OI_Process         = OI_ProcessInput;
+  OI_OwnerUID        = OI_Dummy + 10; // GetOwnerInfo() -- Pointer to a LongInt sized storage area. Returns the value of the objects UID field.
+                                      // SetOwnerInfo() -- LongInt value. Sets the value of an objects UID field.
+  OI_OwnerGID        = OI_Dummy + 11; // GetOwnerInfo() -- Pointer to a LongInt sized storage area. Returns the value of the objects GID field.
+                                      // SetOwnerInfo() -- LongInt value. Sets the value of an objects GID field.
+// Tags for TimedDosRequester()
+  TDR_Dummy      = TAG_USER + 3500;
+
+  TDR_IDCMP_Ptr  = TDR_Dummy + 1; // (PLongInt) -- [OPTIONAL] Pointer to a longword initialised with the IDCMP flags that you want to terminate the requester on. (Default nil)
+  TDR_Timeout    = TDR_Dummy + 2; // (LongInt) -- [OPTIONAL] Value in seconds to wait before requester will close without intervention.  A timeout will only occur with values > 0.
+                                 // It is recommended that timouts less than 10 seconds be avoided whenever possible, to be user-friendly. (Default; 0)
+  TDR_Window     = TDR_Dummy + 3; // (PWindow) -- [OPTIONAL] A pointer to an (over-riding) reference window pointer. Normally, you would not need to specify this tag.
+  TDR_EasyStruct = TDR_Dummy + 4; // (PEasyStruct) [OPTIONAL] -- Pointer to your own private struct EasyStruct that has already been initialised.   (Default; internally allocated)
+  TDR_FormatString = TDR_Dummy + 5; // (STRPTR) [OPTIONAL] -- The format string using RawDoFmt style specifiers that match the number of argument array entries.
+                                    // If this tag is present, it will override a formatstring that may have already been supplied with a private TDR_EasyStruct.
+  TDR_TitleString  = TDR_Dummy + 6; // (STRPTR) [OPTIONAL] -- The title string for the requester. If this tag is present, it will override a title string that may have already been supplied with a private TDR_EasyStruct.
+  TDR_GadgetString = TDR_Dummy + 7; // (STRPTR) [OPTIONAL] -- The string spec for the gadgets/text for the requester. If this tag is present, it will override a Gadget string that may have been supplied with a private TDR_EasyStruct.
+  TDR_ImageType    = TDR_Dummy + 8; // (LongInt) -- The visual style of this request. This argument has currently no effect before IPrefs is running, but should always
+                                    // be specified to indicate the style of request this is directedfor.   (Default; TDRIMAGE_DEFAULT) The values for this tag are defined below.
+  TDRIMAGE_DEFAULT    = 0;
+  TDRIMAGE_INFO       = 1;
+  TDRIMAGE_WARNING    = 2;
+  TDRIMAGE_ERROR      = 3;
+  TDRIMAGE_QUESTION   = 4;
+  TDRIMAGE_INSERTDISK = 5;
+
+  TDR_ArgArray = TDR_Dummy + 9;  // (APTR) [OPTIONAL] -- A pointer to a completely initialised argument array with the number of entries that correspond to the RawDoFmt() format specifiers.
+                                 // Do not use this tag if you want to specify up to the first 10 arguments individually with the following TDR_Arg# tags.
+  TDR_Inactive = TDR_Dummy + 10; // (LongInt; Boolean) -- Boolean value to specify the requester should not be activated to avoid its stealing the users input focus.
+                                 // You should set this to TRUE when the gadgets of your requester contain keyboard shortcuts and its possible that the user is
+                                 // currently typing text in another application (otherwise the user could answer the requester by accident). This tag has
+                                 // currently no effect before IPrefs is running, keyboard shortcuts also won't work before either.  (Default; FALSE)
+  TDR_CharSet  = TDR_Dummy + 11; // (LongWord) -- Character set for the requester's text and gadgets. Defaults to 0, meaning the charset of the screen font which
+                                 // will be the current system default charset in most cases. This tag has currently no effect before IPrefs is running.
+                                 // The tag value is based on the IANA MIBenum value for charsets. See the autodoc for diskfont.library/ObtainCharsetInfo().
+                                 // TDR_CharSet should be set by localized applications that want to display localized requesters, they tell locale.library in
+                                 // OpenCatalog() that it shall not convert the catalog charset to current system default charset and use the value of
+                                 // Catalog->cat_CodeSet for the TDR_CharSet.    (Default; 0)
+  TDR_NonBlocking = TDR_Dummy + 12; // (LongInt; Boolean) -- [OPTIONAL] switch to prevent this function from attempting any disk based I/O whatsoever.
+                                    // This makes the function safe to call at any time from handlers and filesystems and in some cases performing dospacket I/O from a task context.
+                                    // This tag will effectively bypass the use of any reaction components that may cause blocking issues and re-apply the original dos.library
+                                    // code that only calls the intuition library EasyRequest() function, as if it was never patched by "IPrefs". (Default; FALSE)
+  TDR_Arg1  = TDR_Dummy+20;
+  TDR_Arg2  = TDR_Dummy+21;
+  TDR_Arg3  = TDR_Dummy+22;
+  TDR_Arg4  = TDR_Dummy+23;
+  TDR_Arg5  = TDR_Dummy+24;
+  TDR_Arg6  = TDR_Dummy+25;
+  TDR_Arg7  = TDR_Dummy+26;
+  TDR_Arg8  = TDR_Dummy+27;
+  TDR_Arg9  = TDR_Dummy+28;
+  TDR_Arg10 = TDR_Dummy+29;
+
+// Tags for FileSystemAttr()
+  FSA_Dummy                    = TAG_USER + 9000;
+  FSA_StringNameInput          = FSA_Dummy + 1; // (STRPTR) -- Identify the filesystem by this name reference.
+  FSA_FileHandleInput          = FSA_Dummy + 2; // (BPTR) -- Identify the filesystem by this FileHandle.
+  FSA_LockInput                = FSA_Dummy + 3; // (BPTR) -- Identify the filesystem by this Lock.
+  FSA_FileLockInput            = FSA_LockInput;
+  FSA_MsgPortInput             = FSA_Dummy + 4;  // (PMsgPort)  Identify the filesystem by this message port. NOTE: This tag was added in dos.library 51.96
+  FSA_MaxFileNameLengthR       = FSA_Dummy + 10; // (PLongWord) -- Obtain the maximum filename length. (including \0)
+  FSA_MaxFileNameLengthW       = FSA_Dummy + 11; // (LongWord) -- Set the maximum filename length. (including \0)
+  FSA_VersionNumberR           = FSA_Dummy + 12; // (PLongWord) -- Obtain the version/rev number for the filesystem.
+  FSA_DOSTypeR                 = FSA_Dummy + 13; // (PLongWord) -- Obtain the dostype identifier for the filesystem.
+  FSA_ActivityFlushTimeoutR    = FSA_Dummy + 14; // (PLongWord) -- Obtain the mS (1000th second) before a flush while active occurs.
+  FSA_ActivityFlushTimeoutW    = FSA_Dummy + 15; // (LongWord) -- Set the mS (1000th second) before a flush while active occurs.
+  FSA_InactivityFlushTimeoutR  = FSA_Dummy + 16; // (PLongWord) -- Obtain the mS (1000th second) before a flush when inactive occurs.
+  FSA_InactivityFlushTimeoutW  = FSA_Dummy + 17; // (LongWord) -- Set the mS (1000th second) before a flush when inactive occurs.
+  FSA_MaxRecycledEntriesR      = FSA_Dummy + 18; // (PLongWord) -- Obtain the number of recycled entries supported.
+  FSA_MaxRecycledEntriesW      = FSA_Dummy + 19; // (LongWord) -- Set the number of recycled entries supported.
+  FSA_HasRecycledEntriesR      = FSA_Dummy + 20; // (PLongWord) -- Obtain boolean value if the filesystem supports recycled entries.
+  FSA_VersionStringR           = FSA_Dummy + 21; // (STRPTR) -- Obtain a copy of the version string for the filesystem.
+  FSA_VersionStringR_BufSize   = FSA_Dummy + 22; // (LongWord) -- Sub tag to specify the length of the space provided for FSA_VersionStringR.
+  FSA_VersionStringR_Len       = FSA_VersionStringR_BufSize;  // temp compatibility
+
+// Common tags for ExamineObject() and ExamineDir().
+  EX_Dummy           = TAG_USER + 6500;
+  EX_StringNameInput = EX_Dummy + 1; // (STRPTR) -- Pointer to a nul-terminated string name, to specify the filesystem object required. This may be relative to the current directory an assignment
+  EX_StringName      = EX_Dummy + 1; //   or an absolute path.  DOS will internally perform a Lock() on the string provided, it will also Unlock() it again for you. Failure will occur if the object is already exclusively locked.
+
+  EX_FileHandleInput = EX_Dummy + 2; // (BPTR) -- BCPL pointer to a FileHandle. Identify the parent directory from the stream pointed to by an open FileHandle.  DOS determins the parent directory of the
+  EX_FileHandle      = EX_Dummy + 2; //   file by calling ParentOfFH() internally. The internal lock is UnLock'ed when the caller invokes ReleaseDirContext().
+
+  EX_LockInput       = EX_Dummy + 3; // (BPTR) -- BCPL pointer to a Lock.
+  EX_FileLockInput   = EX_Dummy + 3; //   Identify the filesystem object by this associated Lock.
+  EX_DirLockInput    = EX_Dummy + 3; //   This lock is always passed directly throught to the filesystem.
+  EX_FileLock        = EX_Dummy + 3;
+  EX_DirLock         = EX_Dummy + 3;
+
+ //The following are specific only for use with ObtainDirContext() when preparing a context for ExamineDir()
+   EX_DataFields     = EX_Dummy + 10; // (LongWord) -- A bitmask to indicate which additional items of data are to be filled in your ExamineData structure, by the filesystem.
+   EX_MatchFunc      = EX_Dummy + 11; // (PHook) -- Pointer to a custom Hook structure which has the h_Entry function pointer set to a filtering function. (Default = nil) for the internal filter to be used instead.
+   EX_MatchString    = EX_Dummy + 12; // (STRPTR) -- A pointer to a pre-parsed pattern string. (Default=NULL) If this field is NULL then all entries will be returned from the internal filter function.
+   EX_DoCurrentDir   = EX_Dummy + 13; // (BOOLEAN) -- Set TRUE if you wish DOS to make the reference to the specified directory the current directory.
+                                      // This will allow for recursive directory scans to nominate the sub-directory by name, without having to specifying the full path. (Default=FALSE)
+   EX_ResetContext   = EX_Dummy + 14; // (APTR) -- Pointer to a previous context for which a change of any parameter/s are required.  By passing in a previous context via this tag, the resources already allocated for the old context and
+                                      // ExamineData nodes will be reused.  All necessary filesystem context information will also be reset to allow a new scan to begin again. (Default = nil)
+
+function DosObtain(): LongWord; syscall IDos 60;
+function DosRelease(): LongWord; syscall IDos 64;
+procedure DosExpunge(); syscall IDos 68;
+function DosClone(): PInterface; syscall IDos 72;
+function DosOpen(const Name: STRPTR; AccessMode: LongInt): BPTR; syscall IDos 76;
+procedure DOSClose(File_: BPTR); syscall IDos 80;
+function DosRead(File_: BPTR; Buffer: APTR; Length: LongInt): LongInt; syscall IDos 84;
+function DosWrite(File_: BPTR; Buffer: APTR; Length: LongInt): LongInt; syscall IDos 88;
+function DosInput: BPTR; syscall IDos 92;
+function DosOutput: BPTR; syscall IDos 96;
+function DosSeek(File_: BPTR; Position: LongInt; Offset: LongInt): LongInt; syscall IDos 100;
+function DosDeleteFile(const Name: STRPTR) : LongBool; overload; syscall IDos 104;  // compatibility to older platforms
+function DosDelete(const Name: STRPTR) : LongBool; overload; syscall IDos 104;
+function DosRename(const OldName: STRPTR; const NewName: STRPTR): LongBool; syscall IDos 108;
+function Lock(const Name: STRPTR; Type_: LongInt): BPTR; syscall IDos 112;
+procedure UnLock(Lock: BPTR); syscall IDos 116;
+function DupLock(Lock: BPTR): BPTR; syscall IDos 120;
+function Examine(Lock: BPTR; FileInfoBlock: PFileInfoBlock): LongBool; syscall IDos 124;
+function ExNext(Lock: BPTR; FileInfoBlock: PFileInfoBlock): LongBool; syscall IDos 128;
+function Info(Lock: BPTR; ParameterBlock: PInfoData): LongBool; syscall IDos 132;
+function CreateDir(const Name: STRPTR) : BPTR; syscall IDos 136;
+function CurrentDir(Lock: BPTR): BPTR; syscall IDos 140; // compatibility to older platforms
+function SetCurrentDir(Lock: BPTR): BPTR; syscall IDos 140;
+function IoErr: LongInt; syscall IDos 144;
+function CreateProc(const Name: STRPTR; Pri: LongInt; SegList: BPTR; StackSize: LongInt): PMsgPort; syscall IDos 148;
+// obsolete - procedure DosExit(ReturnCode: LongInt); syscall IDos 152;
+// obsolete - function LoadSeg(const Name: STRPTR): LongInt; syscall IDos 156;
+procedure UnLoadSeg(Seglist: BPTR); syscall IDos 160;
+// private - function DoPkt32(Port: PMsgPort; Action, Arg1, Arg2, Arg3, Arg4, Arg5, ): LongInt; syscall IDos 164;
+function LoadSeg(const Name: STRPTR): LongInt; syscall IDos 168;
+function DeviceProc(const Name: STRPTR): PMsgPort; syscall IDos 172;
+function SetComment(const Name: STRPTR; const Comment: STRPTR): LongBool; syscall IDos 176;
+function SetProtection(const Name: STRPTR; Protect: LongInt): LongBool; syscall IDos 180;
+function DateStamp(Date: PDateStamp): PDateStamp; syscall IDos 184;
+procedure DosDelay(TimeOut: LongInt); syscall IDos 188;
+function WaitForChar(File_: BPTR; TimeOut: LongInt): LongBool; syscall IDos 192;
+function ParentDir(Lock: BPTR): BPTR; syscall IDos 196;
+function IsInteractive(File_: BPTR): LongBool; syscall IDos 200;
+function Execute(const String_: STRPTR; File_: BPTR; File2: BPTR): LongBool; syscall IDos 204;
+function AllocDosObject(Type_: LongWord; const Tags: PTagItem): APTR; syscall IDos 208;
+function AllocDosObjectTagList(Type_: LongWord; const Tags: PTagItem): APTR; syscall IDos 212;
+// 216 AllocDosObjectTags
+procedure FreeDosObject(Type_: LongWord; Ptr: APTR); syscall IDos 220;
+function DoPkt(Port: PMsgPort; Action, Arg1, Arg2, Arg3, Arg4, Arg5: LongInt): LongInt; syscall IDos 224;
+function DoPkt0(Port: PMsgPort; Action: LongInt): LongInt; syscall IDos 228;
+function DoPkt1(Port: PMsgPort; Action, Arg1: LongInt): LongInt; syscall IDos 232;
+function DoPkt2(Port: PMsgPort; Action, Arg1, Arg2: LongInt): LongInt; syscall IDos 236;
+function DoPkt3(Port: PMsgPort; Action, Arg1, Arg2, Arg3: LongInt): LongInt; syscall IDos 240;
+function DoPkt4(Port: PMsgPort; Action, Arg1, Arg2, Arg3, Arg4: LongInt): LongInt; syscall IDos 244;
+procedure SendPkt(Dp: PDosPacket; Port: PMsgPort; ReplyPort: PMsgPort); syscall IDos 248;
+function WaitPkt: PDosPacket; syscall IDos 252;
+procedure ReplyPkt(Dp: PDosPacket; Res1, Res2: LongInt); syscall IDos 256;
+// 260 Reserved
+// obsolete LockRecord 264
+function LockRecords(RecArray: PRecordLock; TimeOut: LongWord): LongBool; syscall IDos 268;
+// obsolete UnLockRecord 272
+function UnLockRecords(RecArray: PRecordLock): LongBool; syscall IDos 276;
+function SelectInput(Fh: BPTR): BPTR; syscall IDos 280;
+function SelectOutput(Fh: BPTR): BPTR; syscall IDos 284;
+function FGetC(Fh: BPTR): LongInt; syscall IDos 288;
+function FPutC(Fh: BPTR; Ch: LongInt): LongInt; syscall IDos 292;
+function UnGetC(Fh: BPTR; Character: LongInt): LongInt; syscall IDos 296;
+function FRead(Fh: BPTR; Block: APTR; BlockLen: LongWord; Number: LongWord): LongWord; syscall IDos 300;
+function FWrite(Fh: BPTR; Block: APTR; BlockLen: LongWord; Number: LongWord): LongWord; syscall IDos 304;
+function FGets(Fh: BPTR; Buf: STRPTR; BufLen: LongWord): STRPTR; syscall IDos 308;
+function FPuts(Fh: BPTR; const Str: STRPTR): LongInt; syscall IDos 312;
+// obsolete VFWritef 316
+// obsolete FWritef 320
+function VFPrintf(Fh: BPTR; const Format: STRPTR; const ArgArray: APTR): LongInt; syscall IDos 324;
+// 328 FPrintf
+function DosFlush(Fh: BPTR): LongBool; syscall IDos 332; // compatibility to older platforms
+function FFlush(Fh: BPTR): LongBool; syscall IDos 332;
+function SetVBuf(Fh: BPTR; Buff: STRPTR; Type_: LongInt; Size: LongInt): LongBool; syscall IDos 336;
+function DupLockFromFH(Fh: BPTR): BPTR; syscall IDos 340;
+function OpenFromLock(Lock: BPTR): BPTR; syscall IDos 344;
+function ParentOfFH(Fh: BPTR): BPTR; syscall IDos 348;
+function ExamineFH(Fh: BPTR; Fib: PFileInfoBlock): LongBool; syscall IDos 352;
+function SetDate(const Name: STRPTR; const Date: PDateStamp): LongBool; syscall IDos 356;
+function NameFromLock(Lock: BPTR; Buffer: STRPTR; Len: LongInt): LongBool; syscall IDos 360;
+function NameFromFH(Fh: BPTR; Buffer: STRPTR; Len: LongInt): LongBool; syscall IDos 364;
+function SplitName(const Name: STRPTR; Seperator: LongWord; Buf: STRPTR; OldPos: LongInt; Size: LongInt): LongInt; syscall IDos 368;
+function SameLock(Lock1, Lock2: BPTR): LongInt; syscall IDos 372;
+function SetMode(Fh: BPTR; Mode: LongInt): LongBool; syscall IDos 376;
+function ExAll(Lock: BPTR; Buffer: PExAllData; Size, Data: LongInt; Control: PExAllControl): LongBool; syscall IDos 380;
+function ReadSoftLink(Port: PMsgPort; Lock: BPTR; const Path: STRPTR; Size: LongWord): LongInt; syscall IDos 384;
+function MakeLink(const Name: STRPTR; Dest: APTR; soft: LongInt): LongBool; syscall IDos 388;
+function ChangeMode(Type_ : LongInt; Fh: BPTR; NewMode: LongInt): LongBool; syscall IDos 392;
+function SetFileSize(Fh: BPTR; Pos: LongInt; Mode: LongInt): LongBool; syscall IDos 396;
+function SetIoErr(Result: LongInt): LongInt; syscall IDos 400;
+function Fault(Code: LongInt; const Header: STRPTR; Buffer: STRPTR; Len: LongInt): LongBool; syscall IDos 404;
+function PrintFault(Code: LongInt; const Header: STRPTR): LongBool; syscall IDos 408;
+function ErrorReport(Code, Type_: LongInt; Arg1: LongWord; Device: PMsgPort): LongBool; syscall IDos 412;
+// private Requester 416
+function Cli: PCommandLineInterface; syscall IDos 420;
+function CreateNewProc(const Tags: PTagItem): PProcess; syscall IDos 424;
+function CreateNewProcTagList(const Tags: PTagItem): PProcess; syscall IDos 428;
+// 432 CreateNewProcTags
+function RunCommand(Seg: BPTR; Stack: LongWord; const ParamPtr: STRPTR; ParamLen: LongInt): LongInt; syscall IDos 436;
+function GetConsolePort(): PMsgPort; syscall IDos 440;
+function SetConsolePort(const Port: PMsgPort): PMsgPort; syscall IDos 444;
+function GetFileSysPort(): PMsgPort; syscall IDos 448;
+function SetFileSysPort(const Port: PMsgPort): PMsgPort; syscall IDos 452;
+function GetArgStr: STRPTR; syscall IDos 456;
+function SetArgStr(const String_: STRPTR): STRPTR; syscall IDos 460;
+function FindCliProc(Num: LongWord): PProcess; syscall IDos 464;
+function MaxCli: LongWord; syscall IDos 468;
+function SetCliCurrentDirName(const Name: STRPTR): LongInt; syscall IDos 472;
+function GetCliCurrentDirName(Buf: STRPTR; Len: LongInt): LongInt; syscall IDos 476;
+function SetCliProgramName(const Name: STRPTR): LongInt; syscall IDos 480;
+function GetCliProgramName(Buf: STRPTR; Len: LongInt): LongInt; syscall IDos 484;
+function SetCliPrompt(const Name: STRPTR): LongInt; syscall IDos 488;
+function GetCliPrompt(Buf: STRPTR; Len: LongInt): LongInt; syscall IDos 492;
+function SetProgramDir(Lock: BPTR): BPTR; syscall IDos 496;
+function GetProgramDir(): BPTR; syscall IDos 500;
+function SystemTagList(const Command: STRPTR; const Tags: PTagItem): LongInt; syscall IDos 504;
+function DosSystem(const Command: STRPTR; const Tags: PTagItem): LongInt; syscall IDos 508;
+// 512 SystemTags
+function AssignLock(const Name: STRPTR; Lock: BPTR): LongBool; syscall IDos 516;
+function AssignLate(const Name: STRPTR; const Path: STRPTR): LongBool; syscall IDos 520;
+function AssignPath(const Name: STRPTR; const Path: STRPTR) : LongBool; syscall IDos 524;
+function AssignAdd(const Name: STRPTR; Lock: BPTR): LongBool; syscall IDos 528;
+function RemAssignList(const Name: STRPTR; Lock: BPTR): LongBool; syscall IDos 532;
+function GetDeviceProc(const Name: STRPTR; Dp: PDevProc): pDevProc; syscall IDos 536;
+procedure FreeDeviceProc(Dp: PDevProc); syscall IDos 540;
+function LockDosList(Flags: LongWord): PDosList; syscall IDos 544;
+procedure UnLockDosList(Flags: LongWord); syscall IDos 548;
+function AttemptLockDosList(Flags: LongWord): PDosList; syscall IDos 552;
+function RemDosEntry(DList: PDosList): LongBool; syscall IDos 556;
+function AddDosEntry(DList: PDosList): LongBool; syscall IDos 560;
+function FindDosEntry(const DList: PDosList; const Name: STRPTR; Flags: LongWord): PDosList; syscall IDos 564;
+function NextDosEntry(const DList: PDosList; Flags: LongWord) : PDosList; syscall IDos 568;
+function MakeDosEntry(const Name: STRPTR; Type_: LongInt): PDosList; syscall IDos 572;
+procedure FreeDosEntry(DList: PDosList); syscall IDos 576;
+function IsFileSystem(const Name: STRPTR): LongBool; syscall IDos 580;
+function Format(const Filesystem: STRPTR; const VolumeName: STRPTR; DosType: LongWord): LongBool; syscall IDos 584;
+function Relabel(const Drive: STRPTR; const NewName: STRPTR): LongBool; syscall IDos 588;
+function Inhibit(const Name: STRPTR; OnOff: LongInt): LongBool; syscall IDos 592;
+function AddBuffers(const Name: STRPTR; Number: LongInt): LongBool; syscall IDos 596;
+function CompareDates(const Date1: PDateStamp; const Date2: PDateStamp): LongInt; syscall IDos 600;
+function DosDateToStr(DateTime: _PDateTime): LongBool; syscall IDos 604;
+function DosStrToDate(DateTime: _PDateTime): LongBool; syscall IDos 608;
+// obsolete InternalLoadSeg 612
+// obsolete InternalUnLoadSeg 616
+// obsolete NewLoadSeg 620
+// obsolete NewLoadSegTagList 624
+// obsolete NewLoadSegTags 628
+function AddSegment(const Name: STRPTR; Seg: BPTR; Type_: LongInt): LongBool; syscall IDos 632;
+function FindSegment(const Name: STRPTR; const Seg: PDosResidentSeg; Sys: LongInt): PDosResidentSeg; syscall IDos 636;
+function RemSegment(Seg: PDosResidentSeg): LongBool; syscall IDos 640;
+function CheckSignal(Mask: LongWord): LongWord; syscall IDos 644;
+function ReadArgs(const ArgTemplate: STRPTR; Array_: PLongInt; Args: PRDArgs): PRDArgs; syscall IDos 648;
+function FindArg(const KeyWord: STRPTR; const ArgTemplate: STRPTR): LongInt; syscall IDos 652;
+function ReadItem(const Name: STRPTR; MaxChars: LongInt; CSource: PCSource): LongInt; syscall IDos 656;
+function StrToLong(const String_: STRPTR; var Value: LongInt): LongInt; syscall IDos 660;
+function MatchFirst(const Pat: STRPTR; Anchor: PAnchorPath): LongInt; syscall IDos 664;
+function MatchNext(Anchor: PAnchorPath): LongInt; syscall IDos 668;
+procedure MatchEnd(Anchor: PAnchorPath); syscall IDos 672;
+function ParsePattern(const Pat: STRPTR; Buf: STRPTR; BufLen: LongInt): LongInt; syscall IDos 676;
+function MatchPattern(const Pat: STRPTR; Str: STRPTR): LongBool; syscall IDos 680;
+// 684 reserved
+procedure FreeArgs(Args: PRDArgs); syscall IDos 688;
+// 692 reserved
+function FilePart(const Path: STRPTR): STRPTR; syscall IDos 696;
+function PathPart(const Path: STRPTR): STRPTR; syscall IDos 700;
+function AddPart(DestDirName: STRPTR; const FileName: STRPTR; Size: LongWord): LongBool; syscall IDos 704;
+function StartNotify(Notify: PNotifyRequest): LongBool; syscall IDos 708;
+procedure EndNotify(Notify: PNotifyRequest); syscall IDos 712;
+function SetVar(const Name: STRPTR; Buffer: STRPTR; Size: LongInt; Flags: LongWord): LongBool; syscall IDos 716;
+function GetVar(const Name: STRPTR; Buffer: STRPTR; Size: LongInt; Flags: LongInt): LongInt; syscall IDos 720;
+function DeleteVar(const Name: STRPTR; Flags: LongWord): LongBool; syscall IDos 724;
+function FindVar(const Name: STRPTR; Type_: LongWord): PLocalVar; syscall IDos 728;
+// private CLIInit 732
+function CliInitNewcli(Dp: PDosPacket): LongInt; syscall IDos 736;
+function CliInitRun(Dp: PDosPacket): LongInt; syscall IDos 740;
+function WriteChars(const Buf: STRPTR; BufLen: LongWord): LongInt; syscall IDos 744;
+function PutStr(const Str: STRPTR): LongBool; syscall IDos 748;
+function VPrintf(const Format: STRPTR; const ArgArray: PLongInt): LongInt; syscall IDos 752;
+// 756 Printf
+// 760 reserved
+function ParsePatternNoCase(const Pat: STRPTR; Buf: STRPTR; BufLen: LongInt): LongInt; syscall IDos 764;
+function MatchPatternNoCase(const Pat: STRPTR; Str: STRPTR): LongBool; syscall IDos 768;
+// private DosGetString 772
+function SameDevice(Lock1, Lock2: BPTR): LongBool; syscall IDos 776;
+procedure ExAllEnd(Lock: BPTR; Buffer: PExAllData; Size, data: LongInt; Control: PExAllControl); syscall IDos 780;
+function SetOwner(const Name: STRPTR; OwnerInfo: LongInt): LongBool; syscall IDos 784;
+function GetEntryData(): LongInt; syscall IDos 788;
+function ReadLineItem(Buffer: STRPTR; MaxChars: LongInt; TagList: PTagItem): LongInt; syscall IDos 792;
+// 796 ReadLineItemTags
+// private InternalRunCommand 800
+function GetCurrentDir(): BPTR; syscall IDos 804;
+function NonBlockingModifyDosEntry(Dl: PDosList; Mode: LongInt; Arg1, Arg2: APTR): LongInt; syscall IDos 808;
+function SecondsToDateStamp(Seconds: LongWord; Ds: PDateStamp): PDateStamp; syscall IDos 812;
+function DateStampToSeconds(const Ds: PDateStamp): LongWord; syscall IDos 816;
+function FixDateStamp(Ds: PDateStamp): LongInt; syscall IDos 820;
+function AddDates(To_: PDateStamp; const From_: PDateStamp): LongInt; syscall IDos 824;
+function SubtractDates(To_: PDateStamp; const From_: PDateStamp): LongInt; syscall IDos 828;
+function AddSegmentTagList(const Name: STRPTR; Type_: LongInt; const Tags: PTagItem): LongInt; syscall IDos 832;
+function ParseCapturePattern(const Pat: STRPTR; Dst: STRPTR; Length: LongInt; CaseSen: LongInt): LongInt; syscall IDos 836;
+function CapturePattern(const Pat: STRPTR; const Str: STRPTR; CaseSen: LongInt; var Cap: PCapturedExpression): LongInt; syscall IDos 840;
+procedure ReleaseCapturedExpressions(First: PCapturedExpression); syscall IDos 844;
+procedure FindTrackedAddress(const Address: APTR; Hook: PHook); syscall IDos 848;
+function TrackAddressList(const Name: STRPTR; Segment: BPTR; const ExtraInfo: APTR; ExtraInfoSize: LongInt; const Aas: PAddressAndSize; NumPairs: LongInt): LongInt; syscall IDos 852;
+function TrackSegmentList(const Name: STRPTR; Segment: BPTR; const ExtraInfo: APTR; ExtraInfoSize: LongInt): LongInt; syscall IDos 856;
+procedure UnTrackAddress(Address: APTR); syscall IDos 860;
+procedure UnTrackSegmentList(Segment: BPTR); syscall IDos 864;
+function GetExitData(): LongInt; syscall IDos 868;
+function PutErrStr(const str: STRPTR): LongInt; syscall IDos 872;
+function ErrorOutput(): BPTR; syscall IDos 876;
+function SelectErrorOutput(Fh: BPTR): BPTR; syscall IDos 880;
+function MountDevice(const Name: STRPTR; Type_: LongInt; Tags: PTagItem): LongInt; syscall IDos 884;
+// 888 MountDeviceTags
+function SetProcWindow(const Win: APTR): APTR; syscall IDos 892;
+function FindSegmentStackSize(Segment: BPTR): LongWord; syscall IDos 896;
+function CalculateSegmentChecksum(Segment: BPTR): LongWord; syscall IDos 900;
+function AllocSegList(const Entry: APTR; const Data: APTR; DataLen: LongWord; IdentKey: LongWord): BPTR; syscall IDos 904;
+function GetSegListInfo(SegList: BPTR; const Tags: PTagItem): LongInt; syscall IDos 908;
+// 912 GetSegListInfoTags
+function AddSegListTail(BSegList: BPTR; BSegNew: BPTR): LongInt; syscall IDos 916;
+function DevNameFromLock(Lock: BPTR; Buffer: STRPTR; BufLen: LongInt; Mode: LongInt): LongInt; syscall IDos 920;
+function GetProcMsgPort(const Proc: PProcess): PMsgPort; syscall IDos 924;
+function WaitForData(Stream: BPTR; DataDirection: LongInt; TimeOut: LongInt): LongInt; syscall IDos 928;
+function SetBlockingMode(Stream: BPTR; NewBlocking: LongInt): LongInt; syscall IDos 932;
+function SetCurrentCmdPathList(Pn: PPathNode): PPathNode; syscall IDos 936;
+function AllocateCmdPathList(FirstLock: BPTR): PPathNode; syscall IDos 940;
+procedure FreeCmdPathList(Pn: PPathNode); syscall IDos 944;
+function RemoveCmdPathNode(Pn: PPathNode; Lock: BPTR): PPathNode; syscall IDos 948;
+function AddCmdPathNode(Pn: PPathNode; Lock: BPTR; Where: LongInt): PPathNode; syscall IDos 952;
+function SearchCmdPathList(Pn: PPathNode; h: PHook; const Name: STRPTR; const Tags: PTagItem): LongInt; syscall IDos 956;
+// 960 SearchCmdPathListTags
+function ScanVars(Hook: PHook; Flags: LongWord; const UserData: APTR): LongInt; syscall IDos 964;
+function GetProcSegList(const Proc: PProcess; Flags: LongWord): BPTR; syscall IDos 968;
+function HexToLong(const String_: STRPTR; ValuePtr: PLongWord): LongInt; syscall IDos 972;
+function GetDeviceProcFlags(const Name: STRPTR; Odp: PDevProc; Flags: LongWord): PDevProc; syscall IDos 976;
+function DosControl(const Tags: PTagItem): LongInt; syscall IDos 980;
+// 984 DosControlTags
+function CreateDirTree(const Name: STRPTR): BPTR; syscall IDos 988;
+function NotifyVar(const Name: STRPTR; Hook: PHook; Flags: LongInt; const UserData: APTR): LongInt; syscall IDos 992;
+function GetDiskFileSystemData(const Name: STRPTR): PFileSystemData; syscall IDos 996;
+procedure FreeDiskFileSystemData(Fsd: PFileSystemData); syscall IDos 1000;
+function FOpen(const Name: STRPTR; Mode: LongInt; BufSize: LongInt): BPTR; syscall IDos 1004;
+function FClose(Scb: BPTR): LongInt; syscall IDos 1008;
+function FOpenFromLock(Lock: BPTR; BufSize: LongInt): BPTR; syscall IDos 1012;
+// 1016 reserved
+function TimedDosRequester(const Tags: PTagITem): LongInt; syscall IDos 1020;
+// 1024 TimedDosRequesterTags
+function RenameDosEntry(const DList: PDosList; const NewName: STRPTR): LongInt; syscall IDos 1028;
+function DismountDevice(const Name: STRPTR; Flags: LongWord; Reserved: APTR): LongInt; syscall IDos 1032;
+function DupFileHandle(Scb: BPTR): BPTR; syscall IDos 1036;
+function DevNameFromFH(Scb: BPTR; Buffer: STRPTR; BufLen: LongInt; Mode: LongInt): LongInt; syscall IDos 1040;
+function AssignAddToList(const Name: STRPTR; Lock: BPTR; EndPos: LongInt): LongInt; syscall IDos 1044;
+function SetFileHandleAttr(Fh: BPTR; const Tags: PTagItem): LongInt; syscall IDos 1048;
+// 1052 SetFileHandleAttrTags
+function FileSystemAttr(const Tags: PTagItem): LongInt; syscall IDos 1056;
+// 1060 FileSystemAttrTags
+function FReadLine(Fh: BPTR; Frld: PFReadLineData): LongInt; syscall IDos 1064;
+function CopyStringBSTRToC(BSrc: BSTR; Dst: STRPTR; Size: LongWord): LongWord; syscall IDos 1068;
+function CopyStringCToBSTR(const Src: STRPTR; BDest: BSTR; Size: LongWord): LongWord; syscall IDos 1072;
+function GetFilePosition(Fh: BPTR): Int64; syscall IDos 1076;
+function ChangeFilePosition(Fh: BPTR; Position: Int64; Offset: LongInt): LongInt; syscall IDos 1080;
+function ChangeFileSize(Fh: BPTR; Pos: Int64; Mode: LongInt): LongInt; syscall IDos 1084;
+function GetFileSize(Fh: BPTR): Int64; syscall IDos 1088;
+// 1092 reserved
+// 1096 Private DoPkt64
+// 1100 reserved
+// 1104 reserved
+// 1108 reserved
+function ProcessScan(Hook: PHook; const UserData: APTR; Reserved: LongWord): LongInt; syscall IDos 1112;
+function NotifyDosListChange(Process: PProcess; SignalNum, Reserved: LongWord): LongInt; syscall IDos 1116;
+function NotifyProcListChange(Process: PProcess; SignalNum, Reserved: LongWord): LongInt; syscall IDos 1120;
+function GetDiskInfo(const Tags: PTagItem): LongInt; syscall IDos 1124;
+// 1128 GetDiskInfoTags
+function WriteProtectVolume(const Name: STRPTR; OnOff: LongInt; PassKey: LongWord; Reserved: LongWord): LongInt; syscall IDos 1132;
+function ExamineObject(const CTags: PTagItem): PExamineData; syscall IDos 1136;
+// 1140 ExamineObjectTags
+function ExamineDir(Context: APTR): PExamineData; syscall IDos 1144;
+function ObtainDirContext(const CTags: PTagItem): APTR; syscall IDos 1148;
+// 1152 ObtainDirContextTags
+procedure ReleaseDirContext(Contx: APTR); syscall IDos 1156;
+function GetOwnerInfo(const Tags: PTagItem): APTR; syscall IDos 1160;
+// 1164 GetOwnerInfoTags
+function SetOwnerInfo(const Tags: PTagItem): LongInt; syscall IDos 1168;
+// 1172 SetOwnerInfoTags
+function LockTagList(const Tags: PTagItem): BPTR; syscall IDos 1176;
+// 1180 LockTags
+function GetPID(Process: PProcess): LongWord; syscall IDos 1184;
+function FlushVolume(const Name: STRPTR): LongInt; syscall IDos 1188;
+// 1192 obsolete ConsoleData
+// 1196 obsolete ConsoleDataTags
+procedure ReleaseConsoleData(Data: PConsoleWindowData); syscall IDos 1200;
+function Serialize(const Name: STRPTR): LongInt; syscall IDos 1204;
+function NameFromPort(Port: PMsgPort; Buffer: STRPTR; BufLen: LongInt; AddColon: LongInt): LongInt; syscall IDos 1208;
+function DevNameFromPort(Port: PMsgPort; Buffer: STRPTR; BufLen: LongInt; AddColon: LongInt): LongInt; syscall IDos 1212;
+function SameFH(Scb1, Scb2: BPTR): LongInt; syscall IDos 1216;
+function LockRecord(Fh: BPTR; Offset, Length: Int64; Mode: LongWord; TimeOut: LongWord): LongBool; syscall IDos 1220;
+function UnLockRecord(Fh: BPTR; Offset, Length: Int64): LongBool; syscall IDos 1224;
+function IsFileSystemPort(Port: PMsgPort): LongBool; syscall IDos 1228;
+function InhibitPort(Port: PMsgPort; State: LongInt): LongBool; syscall IDos 1232;
+function FormatPort(Port: PMsgPort; const VolumeName: STRPTR; DosType: LongInt): LongBool; syscall IDos 1236;
+function SerializePort(Port: PMsgPort): LongBool; syscall IDos 1240;
+function FlushVolumePort(Port: PMsgPort): LongBool; syscall IDos 1244;
+function FileHandleScan(const Hook: PHook; const UserData: APTR; Reserved: LongWord): LongInt; syscall IDos 1248;
+function GetFileSystemVectorPort(Port: PMsgPort; MinVersion: LongWord): PFileSystemVectorPort; syscall IDos 1252;
+function ResolvePath(Port: PMsgPort; const Path: STRPTR; InLock: BPTR; Out_: STRPTR; OutLen: LongWord; var OutDir: BPTR; var SLCount: LongWord): LongInt; syscall IDos 1256;
+function WriteProtectVolumePort(Port: PMsgPort; OnOff: LongInt; PassKey: LongWord; Reserved: LongInt): LongInt; syscall IDos 1260;
+// 1264 - 1280 Reserved
+
+
+function BADDR(bval :BPTR): POINTER;
+function MKBADDR(adr: Pointer): BPTR;
+
+// var args version
+function AllocDosObjectTags(type_ : LongWord; Const argv : Array of PtrUInt) : POINTER;
+function CreateNewProcTags(Const argv : Array of PtrUInt) : pProcess;
+function SystemTags(command : PChar; Const argv : Array of PtrUInt) : LongInt;
+
+
+
+implementation
+
+
+function BADDR(bval : BPTR): POINTER; inline;
+BEGIN
+  BADDR := POINTER( bval shl 2);
+END;
+
+function MKBADDR(adr : POINTER): BPTR; inline;
+BEGIN
+  MKBADDR := BPTR(LongWord(adr) shr 2);
+END;
+
+function AllocDosObjectTags(type_ : LongWord; Const argv : Array of PtrUInt) : POINTER;
+begin
+  AllocDosObjectTags := AllocDosObjectTagList(type_, @argv);
+end;
+
+function CreateNewProcTags(Const argv : Array of PtrUInt) : pProcess;
+begin
+  CreateNewProcTags := CreateNewProcTagList(@argv);
+end;
+
+function SystemTags(command : PChar; Const argv : Array of PtrUInt) : LongInt;
+begin
+  SystemTags := SystemTagList(command, @argv);
+end;
+
+end.
+
+

packages/os4units/src/exec.pas

@@ -2,7 +2,7 @@
     This file is part of the Free Pascal run time library.
     Copyright (c) 2016 by Free Pascal development team
 
-    exec.library functions
+    exec.library functions for Amiga OS 4.x
 
     See the file COPYING.FPC, included in this distribution,
     for details about the copyright.
@@ -25,11 +25,12 @@ interface
 
 type
   STRPTR   = PChar;
+  PSTRPTR  = PPChar;
   ULONG    = Longword;
   LONG     = LongInt;
   APTR     = Pointer;
-  BPTR     = LongInt;
-  BSTR     = LongInt;
+  BPTR     = LongInt; // Long word (BCPL) pointer
+  BSTR     = LongInt; // Long word pointer to BCPL string
   BOOL     = SmallInt;
   UWORD    = Word;
   WORDBITS = Word;
@@ -114,14 +115,14 @@ const
 const
 // differentiates user tags from control tags
  TAG_USER = $80000000;    // differentiates user tags from system tags
-Type
+type
   Tag = LongWord;
   PTag = ^Tag;
 
   PTagItem = ^TTagItem;
   TTagItem = record
-   ti_Tag: Tag;
-   ti_Data: LongWord;
+    ti_Tag: Tag;        // identifies the type of data
+    ti_Data: LongWord;  // type-specific data
   end;
   PPTagItem = ^PTagItem;
 
@@ -1742,10 +1743,10 @@ const
 
 //**********************************************************************
 
-function Obtain(): LongWord; syscall IExec 60;
-function Release(): LongWord; syscall IExec 64;
-procedure Expunge(); syscall IExec 68;
-function Clone(): PInterface; syscall IExec 72;
+function ExecObtain(): LongWord; syscall IExec 60;
+function ExecRelease(): LongWord; syscall IExec 64;
+procedure ExecExpunge(); syscall IExec 68;
+function ExecClone(): PInterface; syscall IExec 72;
 procedure AddHead(List: PList; Node: PNode); syscall IExec 76;
 procedure AddMemHandler(MemHand: PInterrupt); syscall IExec 80;
 procedure AddMemList(Size: LongWord; Attributes: LongWord; Pri: LongInt; Base: APTR; const Name: PChar); syscall IExec 84;

packages/os4units/src/timer.pas

@@ -0,0 +1,86 @@
+{
+    This file is part of the Free Pascal run time library.
+    Copyright (c) 2016 by Free Pascal development team
+
+    dos.library functions for Amiga OS 4.x
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ **********************************************************************}
+{$PACKRECORDS 2}
+
+unit timer;
+
+interface
+
+uses
+  exec;
+
+const
+// unit defintions
+// enTimerUnits
+  UNIT_MICROHZ    = 0; // 1/1000000 second granularity
+  UNIT_VBLANK     = 1; // 1/60 second granularity
+  UNIT_ECLOCK     = 2; // system dependant number of ticks/second
+  UNIT_WAITUNTIL  = 3; // wait until a certain point of time
+  UNIT_WAITECLOCK = 4; // wait until a certain point of time (in EClock ticks)
+  UNIT_ENTROPY    = 5; // Read entropy data
+
+  TIMERNAME : PChar   = 'timer.device';
+
+type
+  PTimeVal = ^TTimeVal;
+  TTimeVal = record
+    tv_secs: LongWord;
+    tv_micro: LongWord;
+  end;
+
+  PTimeRequest = ^TTimeRequest;
+  TTimeRequest = record
+    tr_node: TIORequest;
+    tr_time: TTimeVal;
+  end;
+
+  PEClockVal = ^TEClockVal;
+  TEClockVal = record
+    ev_hi: LongWord;
+    ev_lo: LongWord;
+  end;
+
+const
+// enTimerCmd
+  TR_ADDREQUEST = CMD_NONSTD;
+  TR_GETSYSTIME = CMD_NONSTD + 1;
+  TR_SETSYSTIME = CMD_NONSTD + 2;
+
+{ To use any of the routines below, TimerBase must be set to point
+  to the timer.device, either by calling CreateTimer or by pulling
+  the device pointer from a valid TimeRequest, and get the
+  Interface i.e.
+    TimerBase := TimeRequest.io_Device;
+    ITimer := GetInterface(TimerBase, 'main', 1, nil);
+  _after_ you have called OpenDevice on the timer.}
+var
+  TimerBase: Pointer = nil;
+  ITimer: Pointer = nil;
+
+function TimerObtain(): LongWord; syscall ITimer 60;
+function TimerRelease(): LongWord; syscall ITimer 64;
+procedure TimerExpunge(); syscall ITimer 68;
+function TimerClone(): PInterface; syscall ITimer 72;
+procedure AddTime(Dest: PTimeVal; Src: PTimeVal); syscall TimerBase 76;
+function CmpTime(Dest: PTimeVal; Src: PTimeVal): LongInt; syscall TimerBase 80;
+procedure SubTime(Dest: PTimeVal; Src: PTimeVal); syscall TimerBase 84;
+function ReadEClock(Dest: PEClockVal): LongWord; syscall TimerBase 88;
+procedure GetSysTime(Dest: PTimeVal); syscall TimerBase 92;
+procedure GetUpTime(Dest: PTimeVal); syscall TimerBase 96;
+procedure MicroDelay(MicroSeconds: LongWord); syscall TimerBase 100;
+
+implementation
+
+end.

packages/os4units/src/utility.pas

@@ -0,0 +1,389 @@
+{
+    This file is part of the Free Pascal run time library.
+    Copyright (c) 2016 by Free Pascal development team
+
+    utility.library functions for Amiga OS 4.x
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ **********************************************************************}
+
+
+{$PACKRECORDS 2}
+
+unit utility;
+
+interface
+
+uses
+  exec;
+
+type
+  PClockData = ^TClockData;
+  TClockData = record
+    sec: Word;   // 0..59
+    min: Word;   // 0..59
+    hour: Word;  // 0..23
+    mday: Word;  // 1..31
+    month: Word; // 1..12
+    year: Word;  // 1978..
+    wday: Word;  // 0..6; 0 = Sunday
+  end;
+
+// PHook/THook relocated to Exec
+
+// Namespace definitions
+type
+// The named object structure
+  PNamedObject = ^TNamedObject;
+  TNamedObject = record
+    no_Object: APTR;  // Your pointer, for whatever you want
+  end;
+
+const
+// Tags for AllocNamedObject()
+
+// enAllocNamedObjectTags
+  ANO_NameSpace  = 4000; // Tag to define namespace
+  ANO_UserSpace  = 4001; // tag to define userspace
+  ANO_Priority   = 4002; // tag to define priority
+  ANO_Flags      = 4003; // tag to define flags
+
+// Flags for tag ANO_Flags
+// enANOFlagBits
+  NSB_NODUPS     = 0;
+  NSB_CASE       = 1;
+// enANOFlags
+  NSF_NODUPS     = 1 shl NSB_NODUPS; // Default allow duplicates
+  NSF_CASE       = 1 shl NSB_CASE;   // Default to caseless...
+
+
+   {    Control attributes for Pack/UnpackStructureTags() }
+
+
+{ PackTable definition:
+ *
+ * The PackTable is a simple array of LONGWORDS that are evaluated by
+ * PackStructureTags() and UnpackStructureTags().
+ *
+ * The table contains compressed information such as the tag offset from
+ * the base tag. The tag offset has a limited range so the base tag is
+ * defined in the first longword.
+ *
+ * After the first longword, the fields look as follows:
+ *
+ *      +--------- 1 = signed, 0 = unsigned (for bits, 1=inverted boolean)
+ *      |
+ *      |  +------ 00 = Pack/Unpack, 10 = Pack, 01 = Unpack, 11 = special
+ *      | / \
+ *      | | |  +-- 00 = Byte, 01 = Integer, 10 = Long, 11 = Bit
+ *      | | | / \
+ *      | | | | | /----- For bit operations: 1 = TAG_EXISTS is TRUE
+ *      | | | | | |
+ *      | | | | | | /-------------------- Tag offset from base tag value
+ *      | | | | | | |                 \
+ *      m n n o o p q q q q q q q q q q r r r s s s s s s s s s s s s s
+ *                                      \   | |               |
+ *      Bit offset (for bit operations) ----/ |               |
+ *                                            \                       |
+ *      Offset into data structure -----------------------------------/
+ *
+ * A -1 longword signifies that the next longword will be a new base tag
+ *
+ * A 0 longword signifies that it is the end of the pack table.
+ *
+ * What this implies is that there are only 13-bits of address offset
+ * and 10 bits for tag offsets from the base tag.  For most uses this
+ * should be enough, but when this is not, either multiple pack tables
+ * or a pack table with extra base tags would be able to do the trick.
+ * The goal here was to make the tables small and yet flexible enough to
+ * handle most cases.
+ }
+
+const
+  PSTB_SIGNED = 31;
+  PSTB_UNPACK = 30; // Note that these are active low...
+  PSTB_PACK   = 29; // Note that these are active low...
+  PSTB_EXISTS = 26; // Tag exists bit true flag hack...
+
+  PSTF_SIGNED = 1 shl PSTB_SIGNED;
+  PSTF_UNPACK = 1 shl PSTB_UNPACK;
+  PSTF_PACK   = 1 shl PSTB_PACK;
+
+  PSTF_EXISTS = 1 shl PSTB_EXISTS;
+
+
+// *********************************************************************
+
+ PKCTRL_PACKUNPACK = $00000000;
+ PKCTRL_PACKONLY   = $40000000;
+ PKCTRL_UNPACKONLY = $20000000;
+
+ PKCTRL_BYTE       = $80000000;
+ PKCTRL_WORD       = $88000000;
+ PKCTRL_LONG       = $90000000;
+
+ PKCTRL_UBYTE      = $00000000;
+ PKCTRL_UWORD      = $08000000;
+ PKCTRL_ULONG      = $10000000;
+
+ PKCTRL_BIT        = $18000000;
+ PKCTRL_FLIPBIT    = $98000000;
+
+
+// *********************************************************************
+// Tags are a general mechanism of extensible data arrays for parameter
+// specification and property inquiry. In practice, tags are used in arrays,
+// or chain of arrays.
+
+// PTagItem/TTagItem/TAG relocated to Exec
+
+// constants for Tag.ti_Tag, control tag values
+const
+  TAG_DONE   = 0; // terminates array of TagItems. ti_Data unused
+  TAG_END    = 0; // synonym for TAG_DONE
+  TAG_IGNORE = 1; // ignore this item, not end of array
+  TAG_MORE   = 2; // ti_Data is pointer to another array of TagItems note that this tag terminates the current array
+  TAG_SKIP   = 3; // skip this and the next ti_Data items
+
+// differentiates user tags from control tags
+  TAG_USER = $80000000;    { differentiates user tags from system tags}
+
+{ If the TAG_USER bit is set in a tag number, it tells utility.library that
+  the tag is not a control tag (like TAG_DONE, TAG_IGNORE, TAG_MORE) and is
+  instead an application tag. "USER" means a client of utility.library in
+  general, including system code like Intuition or ASL, it has nothing to do
+  with user code.}
+
+// Tag filter logic specifiers for use with FilterTagItems()
+// enTagLogic
+  TAGFILTER_AND = 0; // exclude everything but filter hits
+  TAGFILTER_NOT = 1; // exclude only filter hits
+
+// Mapping types for use with MapTags()
+// enTagMap
+ MAP_REMOVE_NOT_FOUND = 0; // remove tags that aren't in mapList
+ MAP_KEEP_NOT_FOUND   = 1; // keep tags that aren't in mapList
+
+type
+  PUtilityBase = ^TUtilityBase;
+  TUtilityBase = record
+    ub_LibNode: TLibrary;
+    ub_Language: Byte;    // Private, for lowlevel.library
+    ub_Reserved: Byte;
+  end;
+
+//**********************************************************************
+// Flags used by the UTF-8 functions. */
+const
+  UTF_INVALID_SUBST_FFFD = 1 shl 0;
+  //  Do not abort decoding when an invalid UTF-8 sequence is encountered,
+  //  instead, substitute the invalid byte sequence with the special
+  //  $FFFD character. (inverse ? on square background)
+
+type
+// *********************************************************************
+// Lists with probabilistic balancing
+  PSkipList = ^TSkipList;
+  TSkipList = record
+    sl_Error: LongInt; // If an insertion fails, here is why
+  end;
+
+  PSkipNode = ^TSkipNode;
+  TSkipNode = record
+    sn_Reserved: APTR;
+    sn_Key: APTR;      // Unique key associated with this node
+  end;
+
+// *********************************************************************
+// Self-organizing binary trees
+  PSplayTree = ^TSplayTree;
+  TSplayTree = record
+    st_Error: LongInt; // If an insertion fails, here is why
+  end;
+
+  PSplayNode = ^TSplayNode;
+  TSplayNode = record
+    sn_UserData: APTR; // Points to user data area for this node
+  end;
+
+const
+// *********************************************************************
+// Error codes that may be returned by the insertion functions.
+// enErrorCodes
+  INSERTNODE_OUT_OF_MEMORY = 1; // Not enough memory
+  INSERTNODE_DUPLICATE_KEY = 2; // Key is not unique
+  INSERTNODE_TOO_SHORT     = 3; // Node size must be at least as large as sizeof(TSkipNode)
+
+// *********************************************************************
+// Context information to be passed around between the different SHA-1
+//   calculation routines. When the digest has been calculated, you fill
+//   find it stored in the 'mdsha_Code' member (all 160 bits of it).
+type
+  PMessageDigest_SHA = ^TMessageDigest_SHA;
+  TMessageDigest_SHA = record
+    mdsha_Code: array[0..19] of Byte;
+    mdsha_Reserved: array[0..327] of Byte;
+  end;
+
+  PRandomState = ^TRandomState;
+  TRandomState = record
+    rs_High: LongInt;
+    rs_Low: LongInt;
+  end;
+
+var
+  UtilityBase: pUtilityBase;
+
+function UtilityObtain(): LongWord; syscall IUtility 60;
+function UtilityRelease(): LongWord; syscall IUtility 64;
+procedure UtilityExpunge(); syscall IUtility 68;
+function UtilityClone(): PInterface; syscall IUtility 72;
+function AllocateTagItems(NumTags: LongWord): PTagItem; syscall IUtility 76;
+procedure ApplyTagChanges(List: PTagItem; const ChangeList: PTagItem); syscall IUtility 80;
+function CloneTagItems(const Original: PTagItem): PTagItem; syscall IUtility 84;
+procedure FilterTagChanges(Changelist: PTagItem; OriginalList: PTagItem; Apply: LongWord); syscall IUtility 88;
+function FilterTagItems(Taglist: PTagItem; const FilterArray: PLongWord; Logic: LongWord): LongWord; syscall IUtility 92;
+function FindTagItem(TagValue: Tag; const TagList: PTagItem): PTagItem; syscall IUtility 96;
+procedure FreeTagItems(TagList: PTagItem); syscall IUtility 100;
+function GetTagData(TagValue: Tag; DefaultValue: LongWord; const TagList: PTagItem): LongWord; syscall IUtility 104;
+procedure MapTags(TagList: PTagItem; const Maplist: PTagItem; MapType: LongWord); syscall IUtility 108;
+function NextTagItem(ItemPtr: PPTagItem): PTagItem; overload; syscall IUtility 112;
+function NextTagItem(var Item: PTagItem): PTagItem; overload; syscall IUtility 112;
+function PackBoolTags(InitialFlags: LongWord; const TagList: PTagItem; const Boolmap: PTagItem) : LongWord; syscall IUtility 116;
+procedure RefreshTagItemClones(Clone: PTagItem; const OriginalTagItems : PTagItem); syscall IUtility 120;
+function TagInArray(TagValue: Tag; const TagArray: PLongWord): LongBool; syscall IUtility 124;
+function CallHookPkt(Hook: PHook; Obj: APTR; Message_: APTR): LongWord; syscall IUtility 128;
+// 132 CallHook
+function AddNamedObject(NameSpace: PNamedObject; Obj: PNamedObject): LongBool; syscall IUtility 136;
+function AllocNamedObjectA(const Name: STRPTR; const TagList: PTagItem): PNamedObject; syscall IUtility 140;
+// 144 AllocNamedObject
+function AttemptRemNamedObject(Obj: PNamedObject): LongInt; syscall IUtility 148;
+function FindNamedObject(NameSpace: PNamedObject; const Name: STRPTR; PreviousObject: PNamedObject): PNamedObject; syscall IUtility 152;
+procedure FreeNamedObject(Obj: PNamedObject); syscall IUtility 156;
+function NamedObjectName(Obj: PNamedObject): STRPTR; syscall IUtility 160;
+procedure ReleaseNamedObject(Obj: PNamedObject); syscall IUtility 164;
+procedure RemNamedObject(Obj: PNamedObject; Message_: PMessage); syscall IUtility 168;
+procedure Amiga2Date(DateAmiga: LongWord; Cd: PClockData); syscall IUtility 172;
+function CheckDate(const Date: PClockData): LongWord; syscall IUtility 176;
+function Date2Amiga(const Date: PClockData): LongWord; syscall IUtility 180;
+function CreateSkipList(Hook: PHook; MaxLevels: LongInt): PSkipList; syscall IUtility 184;
+procedure DeleteSkipList(SkipList: PSkipList); syscall IUtility 188;
+function FindSkipNode(SkipList: PSkipList; Key: APTR): PSkipList; syscall IUtility 192;
+function GetFirstSkipNode(SkipList: PSkipList): PSkipList; syscall IUtility 196;
+function GetNextSkipNode(SkipList: PSkipList): PSkipList; syscall IUtility 200;
+function InsertSkipNode(SkipList: PSkipList): PSkipList; syscall IUtility 204;
+function RemoveSkipNode(SkipList: PSkipList; Key: APTR): LongBool; syscall IUtility 208;
+function CreateSplayTree(CompareHook: PHook): PSplayTree; syscall IUtility 212;
+procedure DeleteSplayTree(SplayTree: PSplayTree); syscall IUtility 216;
+function FindSplayNode(SplayTree: PSplayTree; Key: APTR): PSplayTree; syscall IUtility 220;
+function InsertSplayNode(SplayTree: PSplayTree; Key: APTR; DateSize: LongWord): PSplayTree; syscall IUtility 224;
+function RemoveSplayNode(SplayTree: PSplayTree; Key: APTR): PSplayTree; syscall IUtility 228;
+function FindNameNC(List: PList; const Name: PChar): PNode; syscall IUtility 232;
+function GetUniqueID : LongWord; syscall IUtility 236;
+procedure MessageDigest_SHA_Final(SHAs: PMessageDigest_SHA); syscall IUtility 240;
+procedure MessageDigest_SHA_Init(SHAs: PMessageDigest_SHA); syscall IUtility 244;
+procedure MessageDigest_SHA_Update(SHAs: PMessageDigest_SHA; Data: APTR; NumBytes: LongInt); syscall IUtility 248;
+function PackStructureTags(Pack: APTR; const PackTable: PLongWord; const TagList: PTagItem): LongWord; syscall IUtility 252;
+function UnpackStructureTags(const Pack: APTR; const PackTable: PLongWord; TagList: PTagItem): LongWord; syscall IUtility 256;
+function Random(State: PRandomState): LongWord; syscall IUtility 260;
+function SetMem(Destination: APTR; FillChar: Byte; Length: LongInt): APTR; syscall IUtility 264;
+function Stricmp(const S1: STRPTR; const S2: STRPTR): LongInt; syscall IUtility 268;
+function Strlcpy(Dst: STRPTR; const Src: STRPTR; Size: LongInt): LongInt; syscall IUtility 272;
+function Strlcat(Dst: STRPTR; const Src: STRPTR; Size: LongInt): LongInt; syscall IUtility 276;
+function Strnicmp(const S1: STRPTR; const S2: STRPTR; n: LongInt): LongInt; syscall IUtility 280;
+function ToLower(c: Char): LongWord; syscall IUtility 284;
+function ToUpper(c: Char): LongWord; syscall IUtility 288;
+function VASPrintf(const Fmt: STRPTR; Args: APTR): STRPTR; syscall IUtility 292;
+// 296 ASPrintf
+function VSNPrintf(Buffer: STRPTR; BufferSize: LongInt; const Fmt: STRPTR; Args: APTR): STRPTR; syscall IUtility 300;
+// 304 SNPrintf
+procedure ClearMem(Destination: APTR; Size: LongWord); syscall IUtility 308;
+procedure MoveMem(const Source: APTR; Destination: APTR; Size: LongWord); syscall IUtility 312;
+function Strlen(const String_: STRPTR): LongWord; syscall IUtility 316;
+function UTF8toUCS4(const UTF8Source: STRPTR; UCS4Destination: PLongInt; UCS4DestinationSize: LongInt; Flags: LongWord): LongInt; syscall IUtility 320;
+function UCS4toUTF8(const UCS4Source: PLongInt; UTF8Destination: STRPTR;  UTF8DestinationSize: LongInt; Flags: LongWord): LongInt; syscall IUtility 324;
+function UTF8Strnicmp(const UTF8String1: STRPTR; const UTF8String2: STRPTR; MaxUCSchars: LongInt): LongInt; syscall IUtility 328;
+function UTF8Stricmp(const UTF8String1: STRPTR; const UTF8String2: STRPTR): LongInt; syscall IUtility 332;
+function UTF8Count(const UTF8String: STRPTR; Validate: LongInt): LongInt; syscall IUtility 336;
+function UCS4Count(const UCS4String: PLongInt; Validate: LongInt): LongInt; syscall IUtility 340;
+function UTF8Encode(UCS4: LongInt; Buffer: STRPTR; BufSize: LongInt; Flags: LongWord): LongInt; syscall IUtility 344;
+function UTF8Decode(const UTF8PPTR: PSTRPTR; Flags: LongWord): LongInt; syscall IUtility 348;
+function UCS4ToLower(UCS4In: LongInt): LongInt; syscall IUtility 352;
+function UCS4ToUpper(UCS4In: LongInt): LongInt; syscall IUtility 356;
+function UCS4Valid(UCS4: LongInt): LongInt; syscall IUtility 360;
+
+
+function AllocNamedObject(Name: STRPTR; const Tags: array of PtrUInt): PNamedObject; inline;
+
+function TAG_(value: pointer): PtrUInt; overload; inline;
+function TAG_(value: PChar): PtrUInt; overload; inline;
+function TAG_(value: boolean): PtrUInt; overload; inline;
+function TAG_(value: integer): PtrUInt; overload; inline;
+
+function AsTag(value: pointer): PtrUInt; overload; inline;
+function AsTag(value: PChar): PtrUInt; overload; inline;
+function AsTag(value: boolean): PtrUInt; overload; inline;
+function AsTag(value: integer): PtrUInt; overload; inline;
+
+implementation
+
+function AllocNamedObject(Name: STRPTR; const Tags: array of PtrUInt): PNamedObject; inline;
+begin
+  AllocNamedObject := AllocNamedObjectA(Name, @Tags);
+end;
+
+function TAG_(value: pointer): PtrUInt; inline;
+begin
+  TAG_:=PtrUInt(value);
+end;
+
+function TAG_(value: PChar): PtrUInt; inline;
+begin
+  TAG_:=PtrUInt(value);
+end;
+
+function TAG_(value: boolean): PtrUInt; inline;
+begin
+  if value then
+    TAG_ := LTrue
+  else
+    TAG_ := LFalse;
+end;
+
+function TAG_(value: integer): PtrUInt; inline;
+begin
+  TAG_:=PtrUInt(value);
+end;
+
+function AsTag(value: pointer): PtrUInt; inline;
+begin
+  AsTag:=PtrUInt(value);
+end;
+
+function AsTag(value: PChar): PtrUInt; inline;
+begin
+  AsTag:=PtrUInt(value);
+end;
+
+function AsTag(value: boolean): PtrUInt; inline;
+begin
+  if value then
+    AsTag := LTrue
+  else
+    AsTag := LFalse;
+end;
+
+function AsTag(value: integer): PtrUInt; inline;
+begin
+  AsTag:=PtrUInt(value);
+end;
+
+initialization
+  UtilityBase := _UtilityBase;
+end.