(* Release 3.10 *)
(*-------------------------------------------------------------------------*
*                                                                          *
*  DOS.DEF - Modula-2 OS/2 API Dos...  API interface                       *
*                                                                          *
*  COPYRIGHT (C) 1989..1992 Clarion Software Corporation.                  *
*  All Rights Reserved                                                     *
*                                                                          *
*--------------------------------------------------------------------------*)

(*# call(o_a_size => off,
         o_a_copy=>off,
         result_optional=>on,
         reg_saved => (bx, cx, dx, si, di, es, ds, st1, st2),
         reg_param => (),
         seg_name => none,
         near_call => off,
         ds_eq_ss => off) *)
(*# module(implementation=>off, init_code => off) *)
(*# name(prefix => os2_lib) *)
(*# data(near_ptr => off) *)
DEFINITION MODULE Dos;

(**)
(**--- OS/2 Kernel Dos calls -----------------------------------------------*)
(**)

(**)
(*--- Conditional sections, set to TRUE if required ------------------------*)
(**)

CONST
  i_PROCESS         = TRUE;     (* Threads & Processes *)
  i_INFOSEG         = TRUE;     (* Info Segment *)
  i_FILEMGR         = TRUE;     (* File Manager *)
  i_MEMMGR          = TRUE;     (* Memory Manager *)
  i_SEMAPHORE       = TRUE;     (* Semaphores *)
  i_DATETIME        = TRUE;     (* Date & Time *)
  i_MODULEMGR       = TRUE;     (* Module Manager *)
  i_RESOURCE        = TRUE;     (* Resource Manager *)
  i_NLS             = TRUE;     (* National Language Support *)
  i_SIGNAL          = TRUE;     (* Signal Manager *)
  i_MONITOR         = TRUE;     (* Device monitors *)
  i_QUEUES          = TRUE;     (* Pipes and queues *)
  i_MISC            = TRUE;     (* Miscellaneous dos services *)
  i_SESSION         = TRUE;     (* Session Manager *)
  i_DEVICE          = TRUE;     (* Device support *)
  i_NMPIPES         = TRUE;     (* Named pipes *)
  i_FONT            = TRUE;     (* Font support *)

TYPE
  HSEM        = FarADDRESS;     (* Used in more than one section *)
  Os2ProcType = PROCEDURE();

(**)
(**--Dos General Services--------------------------------------------------*)
(**)
PROCEDURE Beep(frqncy,duratn:CARDINAL) : CARDINAL;
PROCEDURE Exit(action,result:CARDINAL);
CONST
  EXIT_THREAD        = 0;  EXIT_PROCESS       = 1;

(**)
(*--Process routines-------------------------------------------------------*)
(**)
(*%T i_PROCESS *)

TYPE
  PIDINFO = RECORD
              pid : CARDINAL;
              tid : CARDINAL;
              pidParent : CARDINAL;
            END;
(*# save *)
(*# call(reg_saved => (ds,si,di,st1,st2),
         near_call=>off) *)
  THREAD     = PROCEDURE ();
  EXITLIST   = PROCEDURE (CARDINAL);
(*# restore *)

PROCEDURE CreateThread(paddr:THREAD; VAR thread:CARDINAL; staddr:FarADDRESS) : CARDINAL;
PROCEDURE ResumeThread(thread:CARDINAL) : CARDINAL;
PROCEDURE SuspendThread(thread:CARDINAL) : CARDINAL;

(* Values/types for DosCWait and DosExecPgm *)
CONST
  DCWA_PROCESS       = 0;  DCWA_PROCESSTREE   = 1;
  DCWW_WAIT          = 0;  DCWW_NOWAIT        = 1;

TYPE
  RESULTCODES = RECORD
                  codeTerminate : CARDINAL;
                  codeResult : CARDINAL;
                END;
PROCEDURE CWait(action,wait:CARDINAL; VAR tcodes:RESULTCODES; VAR procadd:CARDINAL; process:CARDINAL) : CARDINAL;
PROCEDURE Sleep(time:LONGCARD) : CARDINAL;
PROCEDURE EnterCritSec();
PROCEDURE ExitCritSec();

CONST
(* codeTerminate values *)
  TC_EXIT            = 0;  TC_HARDERROR       = 1;
  TC_TRAP            = 2;  TC_KILLPROCESS     = 3;
(*DosExitList functions *)
  EXLST_ADD          = 1;  EXLST_REMOVE       = 2;  EXLST_EXIT         = 3;
PROCEDURE ExitList(fcncode:CARDINAL; rtnaddr:EXITLIST) : CARDINAL;

PROCEDURE ExecPgm(   VAR buff:ARRAY OF CHAR; buflen:INTEGER;
                     eflag:CARDINAL; args:ARRAY OF CHAR;
                     environ:ARRAY OF CHAR; VAR result:RESULTCODES;
                     pgmfile:ARRAY OF CHAR) : CARDINAL;

CONST (* ExecPgm functions *)
  EXEC_SYNC          = 0;  EXEC_ASYNC         = 1;
  EXEC_ASYNCRESULT   = 2;  EXEC_TRACE         = 3;
  EXEC_BACKGROUND    = 4;  EXEC_LOAD          = 5;

PROCEDURE GetPID(VAR parea:PIDINFO);
PROCEDURE GetPPid(ChildId: CARDINAL; VAR ParentId: CARDINAL): CARDINAL;
PROCEDURE GetPrty(scope:CARDINAL; VAR prty:CARDINAL; procid:CARDINAL) : CARDINAL;
PROCEDURE SetPrty(scope,class:CARDINAL; delta:INTEGER; procid:CARDINAL) : CARDINAL;

CONST (* Priority scopes, classes & deltas *)
  PRTYS_PROCESS      = 0;  PRTYS_PROCESSTREE  = 1;  PRTYS_THREAD       = 2;
  PRTYC_NOCHANGE     = 0;  PRTYC_IDLETIME     = 1;
  PRTYC_REGULAR      = 2;  PRTYC_TIMECRITICAL = 3;
  PRTYC_FOREGROUNDSERVER = 4;
  PRTYD_MINIMUM = -31;
  PRTYD_MAXIMUM = 31;

PROCEDURE KillProcess(action,procid:CARDINAL) : CARDINAL;
CONST (* Values for DosKillProcess *)
  DKP_PROCESSTREE    = 0;  DKP_PROCESS        = 1;

(*%E *)
(**)
(*-- Dos Info Segment support ----------------------------------------------*)
(**)
(*%T i_INFOSEG *)

TYPE
(* Global info seg *)
  GINFOSEG = RECORD
               time               : LONGCARD;
               msecs              : LONGCARD;
               hour               : SHORTCARD;
               minutes            : SHORTCARD;
               seconds            : SHORTCARD;
               hundredths         : SHORTCARD;
               timezone           : CARDINAL;
               usecTimerInterval  : CARDINAL;
               day                : SHORTCARD;
               month              : SHORTCARD;
               year               : CARDINAL;
               weekday            : SHORTCARD;
               majorVersion       : SHORTCARD;
               minorVersion       : SHORTCARD;
               revisionLetter     : SHORTCARD;
               current            : SHORTCARD;
               gMax               : SHORTCARD;
               hugeShift          : SHORTCARD;
               protectModeOnly    : BOOLEAN;
               pidForeground      : CARDINAL;
               dynamicSched       : BOOLEAN;
               secMaxWait         : SHORTCARD;
               msecMinSlice       : CARDINAL;
               msecMaxSlice       : CARDINAL;
               bootdrive          : CARDINAL;
               amecRAS            : ARRAY [0..31] OF SHORTCARD;
               windowableVioMax   : SHORTCARD;
               PMMax              : SHORTCARD;
             END;
  PGINFOSEG = POINTER TO GINFOSEG;
  (* Local Info Seg *)
  LINFOSEG = RECORD
               pidCurrent     : CARDINAL;
               pidParent      : CARDINAL;
               prtyCurrent    : CARDINAL;
               tidCurrent     : CARDINAL;
               sgCurrent      : CARDINAL;
               rfProcStatus   : SHORTCARD;
               dummy1         : SHORTCARD;
               foreground     : CARDINAL;
               typeProcess    : SHORTCARD;
               dummy2         : SHORTCARD;
               selEnvironment : CARDINAL;
               offCmdLine     : CARDINAL;
               dataSegment    : CARDINAL;
               stack          : CARDINAL;
               cbHeap         : CARDINAL;
               hmod           : CARDINAL;
               selDS          : CARDINAL;
             END;
  PLINFOSEG = POINTER TO LINFOSEG;

CONST
(* Values for local typeProcess field *)
  PT_FULLSCREEN     = 0;      (* Full screen app.          *)
  PT_REALMODE       = 1;      (* Real mode process         *)
  PT_WINDOWABLEVIO  = 2;      (* VIO windowable app.       *)
  PT_PM             = 3;      (* Presentation Manager app. *)
  PT_DETACHED       = 4;      (* Detached app.             *)

(* Values for local rfProgStatus field *)
  PS_EXITLIST       = 1;      (* Thread is in exitlist routine *)

PROCEDURE GetInfoSeg(VAR global,local:CARDINAL);

(*%E *)
(**)
(*-- File Manager support ------------------------------------------------*)
(**)
(*%T i_FILEMGR *)

CONST
(* DosChgFilePtr() file position codes *)

  FILE_BEGIN      = 00H;  (* Move relative to beginning of file     *)
  FILE_CURRENT    = 01H;  (* Move relative to current fptr position *)
  FILE_END        = 02H;  (* Move relative to end of file           *)

(* DosFindFirst/Next Directory handle types *)

  HDIR_SYSTEM  = 1;       (* Use system handle (1)         *)
  HDIR_CREATE  = 0FFFFH;  (* Allocate a new, unused handle *)

(* DosCopy control bits; may be or'ed together *)
  DCPY_EXISTING   = 01H;         (* Copy even if target exists *)
  DCPY_APPEND     = 02H;         (* Append to existing file,   *)
                                 (* do not replace             *)

(* Dosopen/DosQFHandState/DosQueryFileInfo et al file attributes; also *)
(* known as Dso File Mode bits... *)

  FILE_NORMAL     = 00H;
  FILE_READONLY   = 01H;
  FILE_HIDDEN     = 02H;
  FILE_SYSTEM     = 04H;
  FILE_DIRECTORY  = 010H;
  FILE_ARCHIVED   = 020H;

(* DosOpen() actions *)

  FILE_EXISTED    = 01H;
  FILE_CREATED    = 02H;
  FILE_TRUNCATED  = 03H;

(* DosOpen() open flags *)

  FILE_OPEN       = 01H;
  FILE_TRUNCATE   = 02H;
  FILE_CREATE     = 010H;

(*     this nibble applies if file already exists                xxxx *)

  OPEN_ACTION_FAIL_IF_EXISTS     = 00H;  (* ---- ---- ---- 0000 *)
  OPEN_ACTION_OPEN_IF_EXISTS     = 01H;  (* ---- ---- ---- 0001 *)
  OPEN_ACTION_REPLACE_IF_EXISTS  = 02H;  (* ---- ---- ---- 0010 *)

(*     this nibble applies if file does not exist           xxxx      *)

  OPEN_ACTION_FAIL_IF_NEW        = 00H;  (* ---- ---- 0000 ---- *)
  OPEN_ACTION_CREATE_IF_NEW      = 010H;  (* ---- ---- 0001 ---- *)

(* DosOpen/DosSetFHandState flags *)

  OPEN_ACCESS_READONLY        = 00H;    (* ---- ---- ---- -000 *)
  OPEN_ACCESS_WRITEONLY       = 01H;    (* ---- ---- ---- -001 *)
  OPEN_ACCESS_READWRITE       = 02H;    (* ---- ---- ---- -010 *)
  OPEN_SHARE_DENYREADWRITE    = 010H;   (* ---- ---- -001 ---- *)
  OPEN_SHARE_DENYWRITE        = 020H;   (* ---- ---- -010 ---- *)
  OPEN_SHARE_DENYREAD         = 030H;   (* ---- ---- -011 ---- *)
  OPEN_SHARE_DENYNONE         = 040H;   (* ---- ---- -100 ---- *)
  OPEN_FLAGS_NOINHERIT        = 080H;   (* ---- ---- 1--- ---- *)
  OPEN_FLAGS_NO_LOCALITY      = 000H;   (* ---- -000 ---- ---- *)
  OPEN_FLAGS_SEQUENTIAL       = 0100H;  (* ---- -001 ---- ---- *)
  OPEN_FLAGS_RANDOM           = 0200H;  (* ---- -010 ---- ---- *)
  OPEN_FLAGS_RANDOMSEQUENTIAL = 0300H;  (* ---- -011 ---- ---- *)
  OPEN_FLAGS_NO_CACHE         = 01000H; (* ---1 ---- ---- ---- *)
  OPEN_FLAGS_FAIL_ON_ERROR    = 02000H; (* --1- ---- ---- ---- *)
  OPEN_FLAGS_WRITE_THROUGH    = 04000H; (* -1-- ---- ---- ---- *)
  OPEN_FLAGS_DASD             = 08000H; (* 1--- ---- ---- ---- *)

(* DosSearchPath() constants *)

  SEARCH_PATH            = 00H;
  SEARCH_CUR_DIRECTORY   = 01H;
  SEARCH_ENVIRONMENT     = 02H;
  SEARCH_IGNORENETERRS   = 04H;

(* File IO command words *)
  FIO_LOCK        = 0;       (* Lock Files          *)
  FIO_UNLOCK      = 1;       (* Unlock Files        *)
  FIO_SEEK        = 2;       (* Seek (set file ptr) *)
  FIO_READ        = 3;       (* File Read           *)
  FIO_WRITE       = 4;       (* File Write          *)

(* Lock Sharing Modes *)
  FIO_NOSHARE     = 0;       (* None      *)
  FIO_SHAREREAD   = 1;       (* Read-Only *)

TYPE
  FIOLOCKCMD = RECORD                (* FLC  FileLockCmd prefix *)
                 Cmd    : CARDINAL;  (* Cmd = FIO_LOCK           *)
                 LockCnt: CARDINAL;  (* Lock records that follow *)
                 TimeOut: LONGCARD;  (* in Msec                  *)
               END;

  FIOLOCKREC = RECORD                (* FLR FileLockRecord              *)
                 fShare: CARDINAL;   (* FIO_NOSHARE or FIO_SHAREREAD    *)
                 Start: LONGCARD;    (* Starting offset for lock region *)
                 Length: LONGCARD;   (* Length of lock region           *)
               END;

  FIOUNLOCKCMD = RECORD                 (* FUC FileUnlockCmd prefix   *)
                   Cmd: CARDINAL;       (* Cmd = FIO_UNLOCK           *)
                   UnlockCnt: CARDINAL; (* Unlock records that follow *)
                 END;


  FIOUNLOCKREC = RECORD                 (* FUR FileUnlockRecord              *)
                   Start: LONGCARD;     (* Starting offset for unlock region *)
                   Length: LONGCARD;    (* Length of unlock region           *)
                 END;

  FIOSEEKCMD = RECORD                   (* Seek command structure             *)
                 Cmd: CARDINAL;         (* Cmd = FIO_SEEK                     *)
                 Method: CARDINAL;      (* One of : FPM_BEGINNING,            *)
                                        (* FPM_CURRENT,or FPM_END             *)
                 Distance: LONGCARD;    (* Byte offset for seek               *)
                 NewPosition: LONGCARD; (* Bytes from start of file after     *)
                                        (* seek                               *)
               END;

  FIOREADWRITE = RECORD                 (* RWC Read&Write command structure *)
                   Cmd: CARDINAL;       (* Cmd = FIO_READ or FIO_WRITE      *)
                   pBuffer: FarADDRESS; (* Pointer to data buffer           *)
                   BufferLen: CARDINAL; (* Bytes in buffer or max size      *)
                   ActualLen: CARDINAL; (* Bytes actually read/written      *)
                 END;

(************************************************************
EA Info Levels & Find First/Next
=========================================
API's: DosFindFirst, DosQueryFileInfo, DosQueryPathInfo, DosSetFileInfo,
       DosSetPathInfo
************************************************************)

CONST
(* File info levels: All listed API's *)
  FIL_STANDARD          = 1;      (* Info level 1, standard file info *)
  FIL_QUERYEASIZE       = 2;      (* Level 2, return Full EA size     *)
  FIL_QUERYEASFROMLIST  = 3;      (* Level 3, return requested EA's   *)

(* File info levels: Dos...PathInfo only *)
  FIL_QUERYFULLNAME     = 5;      (* Level 5, return fully qualified  *)
                                        (* name of file                     *)
  FIL_NAMEISVALID       = 6;      (* Level 6, check validity of file/path
                                           name for this FSD                *)



(* DosFindNotifyFirst() *)
  FNOTIL_STANDARD = 1;    (* Find-Notify Info level 1: Return
                                   standard directory change info *)


(* DosFsAttach() *)
(* Attact or detach *)
  FSATTACH     = 0;      (* Attach file server *)
  FSDETACH     = 1;      (* Detach file server *)


(* DosFsCtl() *)
(* Routing type *)
  FSCTL_HANDLE   = 1;    (* File Handle directs req routing *)
  FSCTL_PATHNAME = 2;    (* Path Name directs req routing   *)
  FSCTL_FSDNAME  = 3;    (* FSD Name directs req routing    *)


(* DosQueryFSAttach() *)
(* Information level types (defines method of query) *)
  FSAIL_QUERYNAME = 1;       (* Return data for a Drive or Device *)
  FSAIL_DEVNUMBER = 2;       (* Return data for Ordinal Device #  *)
  FSAIL_DRVNUMBER = 3;       (* Return data for Ordinal Drive #   *)

(* Item types (from data structure item "iType") *)
  FSAT_CHARDEV   = 1;       (* Resident character device    *)
  FSAT_PSEUDODEV = 2;       (* Pusedu-character device      *)
  FSAT_LOCALDRV  = 3;       (* Local drive                  *)
  FSAT_REMOTEDRV = 4;       (* Remote drive attached to FSD *)

(***********
File System Drive Information&gml DosQueryFSInfo DosSetFSInfo
***********)

(* FS Drive Info Levels *)
  FSIL_ALLOC     = 1;       (* Drive allocation info (Query only) *)
  FSIL_VOLSER    = 2;       (* Drive Volum/Serial info            *)

(* DosQueryFHType() *)
(* Handle classes (low 8 bits of Handle Type) *)
  FHT_DISKFILE    = 00H;          (* Disk file handle        *)
  FHT_CHRDEV      = 01H;          (* Character device handle *)
  FHT_PIPE        = 02H;          (* Pipe handle             *)

(* Handle bits (high 8 bits of Handle Type) *)
  FHB_DSKREMOTE        = 08000H;  (* Remote disk             *)
  FHB_CHRDEVREMOTE     = 08000H;  (* Remote character device *)
  FHB_PIPEREMOTE       = 08000H;  (* Remote pipe             *)

TYPE
  HFILE = CARDINAL;
  FDATE = CARDINAL;
  FTIME = CARDINAL;

  FILEFINDBUF = RECORD
                  fdateCreation   : FDATE;
                  ftimeCreation   : FTIME;
                  fdateLastAccess : FDATE;
                  ftimeLastAccess : FTIME;
                  fdateLastWrite  : FDATE;
                  ftimeLastWrite  : FTIME;
                  fileSize        : LONGCARD;
                  fileAlloc       : LONGCARD;
                  attrFile        : CARDINAL;
                  cname           : SHORTCARD;
                  name            : ARRAY [0..12] OF CHAR;
                END;

  FILEFINDBUF2= RECORD
                  fdateCreation   : FDATE;
                  ftimeCreation   : FTIME;
                  fdateLastAccess : FDATE;
                  ftimeLastAccess : FTIME;
                  fdateLastWrite  : FDATE;
                  ftimeLastWrite  : FTIME;
                  fileSize        : LONGCARD;
                  fileAlloc       : LONGCARD;
                  attrFile        : CARDINAL;
                  cbList          : LONGCARD;
                  cname           : SHORTCARD;
                  name            : ARRAY [0..12] OF CHAR;
                END;

(* extended attribute structures *)

  GEA = RECORD
          cbName: SHORTCARD;          (* name length not including NULL *)
          Name: ARRAY [0..0] OF CHAR; (* attribute name                 *)
        END;

  GEALIST = RECORD
              cbList: LONGCARD; (* total bytes of structure including full list *)
              list: ARRAY [0..0] OF GEA;  (* variable length GEA structures               *)
            END;

  FEA = RECORD
          fea: SHORTCARD;    (* flags                          *)
          cbName: SHORTCARD; (* name length not including NULL *)
          cbValue: CARDINAL; (* value length                   *)
        END;


(* flags for _FEA.fea *)
CONST
  FEA_NEEDEA = 080H;     (* need EA bit *)

TYPE
  FEALIST = RECORD
              cbList: LONGCARD; (* total bytes of structure including full list *)
              list: ARRAY [0..0] OF FEA;  (* variable length FEA structures     *)
            END;

  EAOP = RECORD
           GEAList: FarADDRESS;     (* general EA list *)
           FEAList: FarADDRESS;     (* full EA list    *)
           Error: LONGCARD;
         END;

(*
 * Equates for the types of EAs that follow the convention that we have
 * established.
 *
 * Values 0xFFFE thru 0x8000 are reserved.
 * Values 00 thru 0x7fff are user definable.
 *)

CONST
  EAT_BINARY   = 0FFFEH; (* length preceeded binary            *)
  EAT_ASCII    = 0FFFDH; (* length preceeded ASCII             *)
  EAT_BITMAP   = 0FFFBH; (* length preceeded bitmap            *)
  EAT_METAFILE = 0FFFAH; (* length preceeded metafile          *)
  EAT_ICON     = 0FFF9H; (* length preceeded icon              *)
  EAT_EA       = 0FFEEH; (* length preceeded ASCII ext. attr.  *)
                         (* name of associated data (#include) *)
  EAT_MVMT     = 0FFDFH; (* multi-valued, multi-typed field    *)
  EAT_MVST     = 0FFDEH; (* multi-valued, single-typed field   *)
  EAT_ASN1     = 0FFDDH; (* ASN.1 field                        *)

PROCEDURE Open(name:ARRAY OF CHAR; VAR handle:HFILE; VAR action:CARDINAL; size:LONGCARD;
               attrib,flag,mode:CARDINAL; rsrvd:LONGCARD) : CARDINAL;
PROCEDURE Open2(name:ARRAY OF CHAR; VAR handle:HFILE; VAR action:CARDINAL; size:LONGCARD;
                attrib,flag:CARDINAL;mode:LONGCARD; VAR EA: EAOP; rsrvd:LONGCARD) : CARDINAL;
PROCEDURE Close(handle:HFILE) : CARDINAL;
PROCEDURE Read(handle:HFILE; buffer:FarADDRESS; bufflng:CARDINAL; VAR read:CARDINAL) : CARDINAL;
PROCEDURE Write(handle:HFILE;buffer:FarADDRESS; bufflng:CARDINAL; VAR write:CARDINAL) : CARDINAL;
PROCEDURE Shutdown(rsrvd:LONGCARD): CARDINAL;

TYPE
  FILESTATUS = RECORD
                 fdateCreation   : FDATE;
                 ftimeCreation   : FTIME;
                 fdateLastAccess : FDATE;
                 ftimeLastAccess : FTIME;
                 fdateLastWrite  : FDATE;
                 ftimeLastWrite  : FTIME;
                 fileSize        : LONGCARD;
                 fileAlloc       : LONGCARD;
                 attrFile        : CARDINAL;
               END;

  FILESTATUS2 = RECORD
                  fdateCreation   : FDATE;
                  ftimeCreation   : FTIME;
                  fdateLastAccess : FDATE;
                  ftimeLastAccess : FTIME;
                  fdateLastWrite  : FDATE;
                  ftimeLastWrite  : FTIME;
                  fileSize        : LONGCARD;
                  fileAlloc       : LONGCARD;
                  attrFile        : CARDINAL;
                  ListSize        : LONGCARD;
               END;

  FSALLOCATE = RECORD
                 idFileSystem : LONGCARD;
                 sectorUnit   : LONGCARD;
                 unit         : LONGCARD;
                 unitAvail    : LONGCARD;
                 sector       : CARDINAL;
               END;

  VOLUMELABEL = RECORD
                  count: SHORTCARD;
                  VolLabel: ARRAY [0..11] OF CHAR;
                END;

  FSINFO = RECORD
             fdateCreation: FTIME;
             ftimeCreation: FTIME;
             vol: VOLUMELABEL;
           END;

  FILELOCK = RECORD
               Offset : LONGINT;
               Range  : LONGINT;
             END;

  LOCKRANGE  = RECORD
                 pos,len   : LONGCARD;
               END ;

  HDIR = CARDINAL;

CONST
(* HANDTYPE values *)
  HANDTYPE_FILE    = 00H;
  HANDTYPE_DEVICE  = 01H;
  HANDTYPE_PIPE    = 02H;
  HANDTYPE_NETWORK = 08000H;

PROCEDURE Delete(path:ARRAY OF CHAR; rsrvd:LONGCARD) : CARDINAL;
PROCEDURE DupHandle(ohandle :HFILE; VAR nhandle:HFILE) : CARDINAL;
PROCEDURE QFHandState(handle :HFILE; VAR state:CARDINAL) : CARDINAL;
PROCEDURE SetFHandState(handle :HFILE; state:CARDINAL) : CARDINAL;
PROCEDURE QHandType(handle :HFILE; VAR type,flag:CARDINAL) : CARDINAL;
PROCEDURE ReadAsync(handle :HFILE; ramsem : HSEM; VAR result:CARDINAL; buffer:FarADDRESS; bufflng:CARDINAL;
                    VAR bytread:CARDINAL) : CARDINAL;
PROCEDURE WriteAsync(handle :HFILE; ramsem : HSEM; VAR result:CARDINAL; buffer:FarADDRESS; bufflng:CARDINAL;
                     VAR bytwrt:CARDINAL) : CARDINAL;
PROCEDURE FindFirst(file:ARRAY OF CHAR; VAR handle:HDIR; attrib:CARDINAL; VAR result:FILEFINDBUF;
                    reslng:CARDINAL; VAR count:CARDINAL; rsrvd:LONGCARD) : CARDINAL;
PROCEDURE FindFirst2(file:ARRAY OF CHAR; VAR handle:HDIR; attrib:CARDINAL; result: FarADDRESS;
                     reslng:CARDINAL; VAR count:CARDINAL; InfoLevel: CARDINAL; rsrvd:LONGCARD) : CARDINAL;
PROCEDURE FindNext(handle:HDIR; VAR result:FILEFINDBUF; reslng:CARDINAL;
                   VAR count:CARDINAL) : CARDINAL;
PROCEDURE FindClose(handle:HDIR) : CARDINAL;

PROCEDURE FindNotifyFirst (Path:ARRAY OF CHAR; VAR h:HDIR; Attr:CARDINAL;
                           Buf:FarADDRESS; BufSize:CARDINAL; VAR Chg:CARDINAL;
                           InfoLevel:CARDINAL; TimeOut: LONGCARD; resvd: LONGCARD): CARDINAL;
PROCEDURE FindNotifyNext (h:HDIR; Buf:FarADDRESS; BufSize:CARDINAL; VAR Chg:CARDINAL;
                          TimeOut:LONGCARD): CARDINAL;
PROCEDURE FindNotifyClose (h:HDIR): CARDINAL;

PROCEDURE FSAttach (Dev,FSD:ARRAY OF CHAR; Data:FarADDRESS; Datasize:CARDINAL;
                    Op:CARDINAL; resvd:LONGCARD): CARDINAL;
PROCEDURE QFSAttach (Dev:ARRAY OF CHAR; ord:CARDINAL; InfoLevel:CARDINAL;
                     AttBuf:FarADDRESS; VAR BufSize:CARDINAL; resvd:LONGCARD): CARDINAL;
PROCEDURE FSCtl (date:FarADDRESS; Datamax:CARDINAL; VAR datalen:CARDINAL;
                 Parms:FarADDRESS; Parmmax:CARDINAL; VAR parmlen:CARDINAL;
                 fcode:CARDINAL; h:HFILE; Route:CARDINAL; resvd:LONGCARD): CARDINAL;

PROCEDURE NewSize(handle:HFILE; size:LONGCARD) : CARDINAL;
PROCEDURE BufReset(handle:HFILE) : CARDINAL;
PROCEDURE ChgFilePtr(handle:HFILE; distance:LONGINT; method:CARDINAL;
                     VAR newloc:LONGCARD) : CARDINAL;
PROCEDURE FileLocks(handle:HFILE; VAR unlock,lock:LOCKRANGE) : CARDINAL;
PROCEDURE Move(oldnam,newnam:ARRAY OF CHAR; rsrvd:LONGCARD) : CARDINAL;
PROCEDURE Copy(srcnam,dstnam:ARRAY OF CHAR; mode:CARDINAL; rsrvd:LONGCARD) : CARDINAL;
PROCEDURE EditName(Level: CARDINAL; Erc,Edit: ARRAY OF CHAR; VAR Dst: ARRAY OF CHAR;
                    DstSize: CARDINAL): CARDINAL;
PROCEDURE FileIO(h:HFILE; Cmd:FarADDRESS; CmdLen:CARDINAL; VAR error:LONGINT):CARDINAL;
PROCEDURE MkDir(name:ARRAY OF CHAR; rsrvd:LONGCARD) : CARDINAL;
PROCEDURE MkDir2(name:ARRAY OF CHAR; Buf:FarADDRESS; rsrvd:LONGCARD) : CARDINAL;
PROCEDURE RmDir(name:ARRAY OF CHAR; rsrvd:LONGCARD) : CARDINAL;
PROCEDURE SelectDisk(drive:CARDINAL) : CARDINAL;
PROCEDURE QCurDisk(VAR drive:CARDINAL; VAR map:LONGCARD) : CARDINAL;
PROCEDURE ChDir(dirnam:ARRAY OF CHAR; rsrvd:LONGCARD) : CARDINAL;
PROCEDURE QCurDir(drive:CARDINAL; buffer:FarADDRESS; VAR length:CARDINAL) : CARDINAL;
PROCEDURE QFSInfo(drive,level:CARDINAL; buffer:FarADDRESS; bufflng:CARDINAL) : CARDINAL;

(* N.B. Misspeled version for compatibility with older programs only *)
PROCEDURE QFsInfo(drive,level:CARDINAL; buffer:FarADDRESS; bufflng:CARDINAL) : CARDINAL;

PROCEDURE SetFSInfo(drive,level:CARDINAL; buffer:FarADDRESS; size:CARDINAL) : CARDINAL;
PROCEDURE QVerify(VAR verify:CARDINAL) : CARDINAL;
PROCEDURE SetVerify(verify:CARDINAL) : CARDINAL;
PROCEDURE SetMaxFH(handles:CARDINAL) : CARDINAL;
PROCEDURE QFileInfo(drive,level:CARDINAL; buffer:FarADDRESS; bufflng:CARDINAL) : CARDINAL;
PROCEDURE SetFileInfo(drive,level:CARDINAL; buffer:FarADDRESS; bufflng:CARDINAL) : CARDINAL;
PROCEDURE QPathInfo(Path:ARRAY OF CHAR; InfoLevel:CARDINAL; InfoBuf:FarADDRESS;
                    BufSize:CARDINAL; resvd:LONGCARD):CARDINAL;
PROCEDURE SetPathInfo(Path:ARRAY OF CHAR; InfoLevel:CARDINAL; InfoBuf:FarADDRESS;
                      BufSize:CARDINAL; Flags:CARDINAL; resvd:LONGCARD):CARDINAL;
PROCEDURE QFileMode(name:ARRAY OF CHAR; VAR attrib:CARDINAL; rsrvd:LONGCARD) : CARDINAL;
PROCEDURE SetFileMode(name:ARRAY OF CHAR; attrib:CARDINAL; rsrvd:LONGCARD) : CARDINAL;
PROCEDURE EnumAttribute(Type:CARDINAL; buf:FarADDRESS; Start:LONGCARD;
                        buf1:FarADDRESS; buf1size:LONGCARD; VAR entries:LONGCARD;
                        infolevel:CARDINAL; resvd:CARDINAL):CARDINAL;

(* level 1 info returned from DosEnumAttribute *)
TYPE
  DENA1 = RECORD
            reserved: SHORTCARD;          (* 0                             *)
            cbName: SHORTCARD;            (* length of name exculding NULL *)
            cbValue: CARDINAL;            (* length of value               *)
            Name: ARRAY [0..0] OF CHAR;   (* variable length asciiz name   *)
          END;

(*%E *)
(**)
(*-- Memory Manager support ----------------------------------------------*)
(**)
(*%T i_MEMMGR *)

PROCEDURE AllocSeg(size:CARDINAL; VAR select:CARDINAL; aflag:CARDINAL) : CARDINAL;
PROCEDURE ReallocSeg(size,select:CARDINAL) : CARDINAL;
PROCEDURE FreeSeg(select:CARDINAL) : CARDINAL;
PROCEDURE GiveSeg(handle,procid:CARDINAL; VAR receive:CARDINAL) : CARDINAL;
PROCEDURE GetSeg(select:CARDINAL) : CARDINAL;
PROCEDURE SizeSeg(select:CARDINAL; VAR size:LONGCARD) : CARDINAL;

CONST
(* Segment attribute flags *)
  SEG_NONSHARED   = 00H;
  SEG_GIVEABLE    = 01H;
  SEG_GETTABLE    = 02H;
  SEG_DISCARDABLE = 04H;

PROCEDURE AllocHuge(numseg,size:CARDINAL; VAR select:CARDINAL; maxseg,share:CARDINAL) : CARDINAL;
PROCEDURE ReallocHuge(numseg,size,select:CARDINAL) : CARDINAL;
PROCEDURE GetHugeShift(VAR shift:CARDINAL);
PROCEDURE AllocShrSeg(size:CARDINAL; name:ARRAY OF CHAR; VAR select:CARDINAL) : CARDINAL;
PROCEDURE LockSeg(select:CARDINAL) : CARDINAL;
PROCEDURE UnlockSeg(select:CARDINAL) : CARDINAL;
PROCEDURE GetShrSeg(name:ARRAY OF CHAR; VAR select:CARDINAL) : CARDINAL;
PROCEDURE MemAvail(VAR size:LONGCARD) : CARDINAL;
PROCEDURE CreateCSAlias(datasel:CARDINAL; VAR codesel:CARDINAL) : CARDINAL;
PROCEDURE SubAlloc(segment:CARDINAL; VAR block:CARDINAL; size:CARDINAL) : CARDINAL;
PROCEDURE SubFree(segment,block,size:CARDINAL) : CARDINAL;
PROCEDURE SubSet(segment,flag,size:CARDINAL) : CARDINAL;

(*%E *)
(**)
(*-- Semaphore support ----------------------------------------------------*)
(**)
(*%T i_SEMAPHORE *)

CONST
  SEM_INDEFINITE_WAIT = -1;   SEM_IMMEDIATE_RETURN = 0;
  CSEM_PRIVATE        = 0;    CSEM_PUBLIC          = 1;

PROCEDURE SemClear(handle:HSEM) : CARDINAL;
PROCEDURE SemSet(handle:HSEM) : CARDINAL;
PROCEDURE SemWait(handle:HSEM; timeout:LONGINT) : CARDINAL;
PROCEDURE SemSetWait(handle:HSEM; timeout:LONGINT) : CARDINAL;
PROCEDURE SemRequest(handle:HSEM; timeout:LONGINT) : CARDINAL;
PROCEDURE CreateSem(excl:CARDINAL; VAR handle:HSEM; name:ARRAY OF CHAR) : CARDINAL;
PROCEDURE OpenSem(VAR handle:HSEM; name:ARRAY OF CHAR) : CARDINAL;
PROCEDURE CloseSem(handle:HSEM) : CARDINAL;

TYPE
  MUXSEM = RECORD
             zero : CARDINAL;
             sem  : HSEM;
           END;
  MUXSEMLIST = RECORD
                 cmxs : CARDINAL;
                 amxs : ARRAY [0..15] OF MUXSEM;
               END;
  DOSFSRSEM  = RECORD
                 len       : CARDINAL;
                 pid,tid   : CARDINAL;
                 use       : CARDINAL;
                 client    : CARDINAL;
                 ramsem    : HSEM;
               END;

PROCEDURE MuxSemWait(VAR index:CARDINAL; list:FarADDRESS; timeout:LONGINT) : CARDINAL;
PROCEDURE FSRamSemRequest(VAR s:DOSFSRSEM; to:LONGINT) : CARDINAL;
PROCEDURE FSRamSemClear(VAR s:DOSFSRSEM) : CARDINAL;

(*%E *)
(**)
(*-- Time support ---------------------------------------------------------*)
(**)
(*%T i_DATETIME *)

TYPE
  DATETIME = RECORD
               hours      : SHORTCARD;
               minutes    : SHORTCARD;
               seconds    : SHORTCARD;
               hundredths : SHORTCARD;
               day        : SHORTCARD;
               month      : SHORTCARD;
               year       : CARDINAL;
               timezone   : INTEGER;
               weekday    : SHORTCARD;
             END;

PROCEDURE GetDateTime(VAR data:DATETIME) : CARDINAL;
PROCEDURE SetDateTime(VAR data:DATETIME) : CARDINAL;

TYPE
  HTIMER   = CARDINAL;

PROCEDURE TimerAsync(interval:LONGCARD; semaphore:HSEM; VAR handle:HTIMER) : CARDINAL;
PROCEDURE TimerStart(interval:LONGCARD; semaphore:HSEM; VAR handle:HTIMER) : CARDINAL;
PROCEDURE TimerStop(handle:HTIMER) : CARDINAL;

(*%E *)
(**)
(*-- Module Manager -------------------------------------------------------*)
(**)
(*%T i_MODULEMGR *)

PROCEDURE LoadModule(buffaddr:FarADDRESS; bufflen:CARDINAL; name:ARRAY OF CHAR; VAR handle:CARDINAL) : CARDINAL;
PROCEDURE FreeModule(handle:CARDINAL) : CARDINAL;
PROCEDURE GetProcAddr(handle:CARDINAL; name:ARRAY OF CHAR; VAR addr: Os2ProcType) : CARDINAL;
PROCEDURE GetModHandle(name:ARRAY OF CHAR; VAR handle:CARDINAL) : CARDINAL;
PROCEDURE GetModName(handle,bufflng:CARDINAL; VAR buffer:ARRAY OF CHAR) : CARDINAL;

(*%E *)
(**)
(*-- Resource support -----------------------------------------------------*)
(**)
(*%T i_RESOURCE *)

CONST
  RT_POINTER = 1;  RT_BITMAP    = 2;  RT_MENU         = 3;  RT_DIALOG     = 4;
  RT_STRING  = 5;  RT_FONTDIR   = 6;  RT_FONT         = 7;  RT_ACCELTABLE = 8;
  RT_RCDATA  = 9;  RT_MESSAGE   = 10; RT_DLGINCLUDE   = 11; RT_VKEYTBL    = 12;
  RT_KEYTBL  = 13; RT_CHARTBL   = 14; RT_DISPLAYINFO  = 15; RT_FKASHORT   = 16;
  RT_FKALONG = 17; RT_HELPTABLE = 18; RT_HELPSUBTABLE = 19; RT_FDDIR      = 20;
  RT_FD      = 21; RT_MAX       = 22;

PROCEDURE GetResource(m:CARDINAL; t,n:CARDINAL; VAR sel:CARDINAL):CARDINAL;
PROCEDURE GetResource2(m:CARDINAL; t,n:CARDINAL; VAR data: FarADDRESS):CARDINAL;
PROCEDURE FreeResource(pData: FarADDRESS): CARDINAL;

(*%E*)
(**)
(**--- National Language Support -------------------------------------------*)
(**)
(*%T i_NLS*)

TYPE
  COUNTRYCODE = RECORD
                  country  : CARDINAL;
                  codepage : CARDINAL;
                END;
  COUNTRYINFO = RECORD
                  country            : CARDINAL;
                  codepage           : CARDINAL;
                  dateFmt            : CARDINAL;
                  currency           : ARRAY [0..4] OF CHAR;
                  thousandsSeparator : ARRAY [0..1] OF CHAR;
                  decimal            : ARRAY [0..1] OF CHAR;
                  dateSeparator      : ARRAY [0..1] OF CHAR;
                  timeSeparator      : ARRAY [0..1] OF CHAR;
                  currencyFmt        : SHORTCARD;
                  decimalPlace       : SHORTCARD;
                  timeFmt            : SHORTCARD;
                  reserved1          : ARRAY [0..1] OF CARDINAL;
                  dataSeparator      : ARRAY [0..1] OF CHAR;
                  reserved2          : ARRAY [0..4] OF CARDINAL;
                END;

PROCEDURE GetCtryInfo(length:CARDINAL; VAR cntry:COUNTRYCODE; VAR buffer:COUNTRYINFO; VAR retlngth:CARDINAL) : CARDINAL;
PROCEDURE GetDBCSEv(length:CARDINAL; VAR cntry:COUNTRYCODE; buffer:FarADDRESS) : CARDINAL;
PROCEDURE CaseMap(length:CARDINAL; VAR cntry:COUNTRYCODE; binstrg:FarADDRESS) : CARDINAL;
PROCEDURE GetCollate(length:CARDINAL; VAR cntry:COUNTRYCODE; buffer:FarADDRESS; VAR rlng:CARDINAL) : CARDINAL;
PROCEDURE GetCp(length:CARDINAL; VAR cplist,rlng:CARDINAL) : CARDINAL;
PROCEDURE SetCp(cpage,rsrvd:CARDINAL) : CARDINAL;
PROCEDURE SetProcCp(cpage,rsrvd:CARDINAL) : CARDINAL;

(*%E*)
(**)
(**--- Signal manager -----------------------------------------------------*)
(**)
(*%T i_SIGNAL *)

CONST
(* Signal Numbers for DosSetSigHandler  *)
  SIG_CTRLC          = 1;  SIG_BROKENPIPE     = 2;  SIG_KILLPROCESS    = 3;
  SIG_CTRLBREAK      = 4;  SIG_PFLG_A         = 5;  SIG_PFLG_B         = 6;
  SIG_PFLG_C         = 7;  SIG_CSIGNALS       = 8;
(* Flag Numbers for DosFlagProcess      *)
  PFLG_A             = 0;  PFLG_B             = 1;  PFLG_C             = 2;
(* Signal actions *)
  SIGA_KILL          = 0;  SIGA_IGNORE        = 1;  SIGA_ACCEPT        = 2;
  SIGA_ERROR         = 3;  SIGA_ACKNOWLEDGE   = 4;
(* DosHoldSignal constants *)
  HLDSIG_ENABLE      = 0;  HLDSIG_DISABLE     = 1;
(* DosFlagProcess codes *)
  FLGP_SUBTREE       = 0;  FLGP_PID           = 1;

(*# save *)
(*# call(reg_saved => (ds,si,di,st1,st2),
         near_call=>off) *)
TYPE
  SIGHANDLER = PROCEDURE (CARDINAL,CARDINAL);
(*# restore *)

PROCEDURE SetSigHandler(raddr:SIGHANDLER; VAR paddr:SIGHANDLER; VAR paction:CARDINAL; action,signbr:CARDINAL) : CARDINAL;
PROCEDURE FlagProcess(procid,action,flagnum,flagarg:CARDINAL) : CARDINAL;
PROCEDURE HoldSignal(action:CARDINAL) : CARDINAL;
PROCEDURE SendSignal(pid,signum:CARDINAL) : CARDINAL;

(*%E*)
(**)
(**--- Device Monitors -----------------------------------------------------*)
(**)
(*%T i_MONITOR*)

TYPE
  HMONITOR = CARDINAL;

PROCEDURE MonOpen(name:ARRAY OF CHAR; VAR handle:HMONITOR) : CARDINAL;
PROCEDURE MonClose(handle:HMONITOR) : CARDINAL;
PROCEDURE MonReg(handle:HMONITOR; buffi,buffo : FarADDRESS;flag,indx:CARDINAL) : CARDINAL;
PROCEDURE MonRead(inbuffs :FarADDRESS; wait:CARDINAL; doffs:FarADDRESS;  VAR bytcnt:CARDINAL) : CARDINAL;
PROCEDURE MonWrite(inbuffs :FarADDRESS; doffs:FarADDRESS;  bytcnt :CARDINAL) : CARDINAL;

(*%E*)
(**)
(**--- Pipe and Queue support ---------------------------------------------*)
(**)
(*%T i_QUEUES *)

TYPE
  HQUEUE = CARDINAL;
  QINFO  = RECORD
             pid       : CARDINAL;
             app       : CARDINAL;
           END ;

CONST
(* Values for CreateQueue *)
  QUE_FIFO = 0; QUE_LIFO = 1; QUE_PRIORITY = 2;

PROCEDURE MakePipe(VAR rhandle,whandle:CARDINAL; size:CARDINAL) : CARDINAL;
PROCEDURE CloseQueue(handle:HQUEUE) : CARDINAL;
PROCEDURE CreateQueue(VAR handle:HQUEUE; priority:CARDINAL; name:ARRAY OF CHAR) : CARDINAL;
PROCEDURE OpenQueue(VAR owner:CARDINAL; VAR handle:HQUEUE; name:ARRAY OF CHAR) : CARDINAL;
PROCEDURE PeekQueue(handle:HQUEUE;VAR rqst:QINFO; VAR lng:CARDINAL; VAR addr:FarADDRESS;
                       VAR code: CARDINAL; wait :CARDINAL; VAR prty: CARDINAL; sem: HSEM ) : CARDINAL ;
PROCEDURE PurgeQueue(handle:HQUEUE) : CARDINAL;
PROCEDURE QueryQueue(handle:HQUEUE; VAR number:CARDINAL) : CARDINAL;
PROCEDURE ReadQueue(handle:HQUEUE;VAR rqst:QINFO; VAR lng:CARDINAL; VAR addr:FarADDRESS;
                       code,wait :CARDINAL; VAR prty: CARDINAL; sem: HSEM ) : CARDINAL ;
PROCEDURE WriteQueue(handle:HQUEUE;rqst,length:CARDINAL; data :FarADDRESS;prty:CARDINAL) : CARDINAL ;

(*%E*)
(**)
(**--- Miscellanous Dos services ------------------------------------------*)
(**)
(*%T i_MISC *)

PROCEDURE Error(flag:CARDINAL) : CARDINAL;
PROCEDURE SetVec(vector:CARDINAL; routin: Os2ProcType; VAR prev: Os2ProcType) : CARDINAL;
PROCEDURE GetMessage(vartab:FarADDRESS; varcnt:CARDINAL; VAR data:ARRAY OF CHAR; length:CARDINAL;
                        msgnbr:CARDINAL; msgfile:ARRAY OF CHAR; VAR msglng:CARDINAL) : CARDINAL;
PROCEDURE ErrClass(ecode:CARDINAL; VAR eclass,action,locus:CARDINAL);
PROCEDURE InsMessage(table:FarADDRESS;count:CARDINAL;input:FarADDRESS;
                        inlength:CARDINAL; data:FarADDRESS ;
                        length:CARDINAL; VAR mlength:CARDINAL) : CARDINAL;
PROCEDURE PutMessage(handle:HFILE; length:CARDINAL; buffer:ARRAY OF CHAR) : CARDINAL;
PROCEDURE PTrace(b : FarADDRESS):CARDINAL;

CONST
  (* definition for DOSQSYSINFO *)
  Q_MAX_PATH_LENGTH = 0;     (* index for query max path length *)
PROCEDURE QSysInfo (index:CARDINAL; Buf:FarADDRESS; bufsize:CARDINAL):CARDINAL;

PROCEDURE GetEnv(VAR environ,cmdoff:CARDINAL) : CARDINAL;
PROCEDURE ScanEnv(environ:ARRAY OF CHAR; VAR cmdoff:FarADDRESS) : CARDINAL;
PROCEDURE SearchPath(cntrl:CARDINAL; path:ARRAY OF CHAR;
                        file:ARRAY OF CHAR; rbuff:FarADDRESS ; buflen:CARDINAL) : CARDINAL;
PROCEDURE GetVersion(VAR vnumber:CARDINAL);
PROCEDURE GetMachineMode(VAR mode:CARDINAL);
(*%E*)
(**)
(**--- Session Manager Routines --------------------------------------------*)
(**)
(*%T i_SESSION*)

TYPE
  STARTDATA = RECORD
                length      : CARDINAL;
                related     : CARDINAL;
                fgBg        : CARDINAL;
                traceOpt    : CARDINAL;
                pgmTitle    : FarADDRESS;
                pgmName     : FarADDRESS;
                pgmInputs   : FarADDRESS;
                termQ       : FarADDRESS;
                env         : FarADDRESS;
                inherit     : CARDINAL;
                sesstype    : CARDINAL;
                iconfile    : FarADDRESS;
                pgmhandle   : FarADDRESS;
                pgmcontrol  : CARDINAL;
                initX,initY : CARDINAL;
                initXsize   : CARDINAL;
                initYsize   : CARDINAL;
              END;

  STATUSDATA = RECORD
                 length    : CARDINAL;
                 selectInd : CARDINAL;
                 bondInd   : CARDINAL;
               END;

  REGISTERDATA = RECORD
                   Length: CARDINAL;     (* length of this data structure *)
                   NotifType: CARDINAL;  (* type of notification          *)
                   DDName: FarADDRESS;   (* pointer to device driver name *)
                 END;

CONST
  STARTDATASIZE0     = VSIZE(STARTDATA.termQ); (* Size for V1.0 *)

PROCEDURE StartSession(VAR sdata:STARTDATA; VAR sessid,pid:CARDINAL) : CARDINAL;
PROCEDURE SetSession(sessid:CARDINAL; VAR status:STATUSDATA) : CARDINAL;
PROCEDURE SelectSession(sessid:CARDINAL; rsrvd:LONGCARD) : CARDINAL;
PROCEDURE StopSession(target,sessid:CARDINAL; rsrvd:LONGCARD) : CARDINAL;
PROCEDURE SmRegisterDD(VAR rdata: REGISTERDATA) : CARDINAL;
PROCEDURE QAppType(n:ARRAY OF CHAR; VAR t:CARDINAL) : CARDINAL;


(*%E*)
(**)
(**--- Device Support -----------------------------------------------------*)
(**)
(*%T i_DEVICE*)

PROCEDURE DevConfig(device:FarADDRESS; item,rsrvd:CARDINAL) : CARDINAL;
PROCEDURE DevIOCtl(data:FarADDRESS; parms:FarADDRESS; functn,categry,device:CARDINAL) : CARDINAL;
PROCEDURE DevIOCtl2(data:FarADDRESS; datalen:CARDINAL;
                    parms:FarADDRESS; parmlen:CARDINAL; functn,categry,device:CARDINAL) : CARDINAL;
PROCEDURE CLIAccess();
PROCEDURE PortAccess(rsrvd,type,first,last:CARDINAL) : CARDINAL;
PROCEDURE PhysicalDisk(func:CARDINAL; buff:FarADDRESS;blng:CARDINAL; parms:FarADDRESS; plng:CARDINAL) : CARDINAL;
PROCEDURE CallBack (p : Os2ProcType);
PROCEDURE R2StackRealloc(ns:CARDINAL):CARDINAL;

(*%E*)
(**)
(**--- Dos Named Pipes -----------------------------------------------------*)
(**)
(*%T i_NMPIPES*)

TYPE
  HPIPE = CARDINAL;
  AVAILBUF = RECORD buffered,curmsg : CARDINAL END;

PROCEDURE CallNmPipe(fn:ARRAY OF CHAR; ib:ARRAY OF BYTE; il:CARDINAL; VAR ob:ARRAY OF BYTE; ol:CARDINAL; VAR r:CARDINAL; to:LONGCARD) : CARDINAL;
PROCEDURE ConnectNmPipe(p:HPIPE) : CARDINAL;
PROCEDURE DisConnectNmPipe(p:HPIPE) : CARDINAL;
PROCEDURE MakeNmPipe(fn:ARRAY OF CHAR; VAR p:HPIPE; om,pm,obs,ibs:CARDINAL; to:LONGCARD) : CARDINAL;
PROCEDURE PeekNmPipe(p:HPIPE; VAR ob:ARRAY OF BYTE; bl:CARDINAL; VAR r:CARDINAL; VAR a:AVAILBUF; VAR ps:CARDINAL) : CARDINAL;
PROCEDURE QNmPHandState(p:HPIPE; VAR ps:CARDINAL) : CARDINAL;
PROCEDURE QNmPipeInfo(p:HPIPE; il:CARDINAL; VAR ib:ARRAY OF BYTE; ibs:CARDINAL) : CARDINAL;
PROCEDURE QNmPipeSemState(s:HSEM; VAR ib:ARRAY OF BYTE; ibs:CARDINAL) : CARDINAL;
PROCEDURE SetNmPHandState(p:HPIPE; s:CARDINAL) : CARDINAL;
PROCEDURE SetNmPipeSem(p:HPIPE; s:HSEM; kh:CARDINAL) : CARDINAL;
PROCEDURE TransactNmPipe(p:HPIPE; ib:ARRAY OF BYTE; ibl:CARDINAL; VAR ob:ARRAY OF BYTE; obl:CARDINAL; VAR r:CARDINAL) : CARDINAL;
PROCEDURE WaitNmPipe(n:ARRAY OF CHAR; to:LONGCARD) : CARDINAL;

(* Data structures and constants used with named pipes *)

TYPE
  npi_data1 = RECORD                     (* PipeInfo data block (returned, level 1) *)
                npi_obuflen : CARDINAL;  (* length of outgoing I/O buffer *)
                npi_ibuflen : CARDINAL;  (* length of incoming I/O buffer *)
                npi_maxicnt : SHORTCARD; (* maximum number of instances   *)
                npi_curicnt : SHORTCARD; (* current number of instances   *)
                npi_namlen  : SHORTCARD; (* length of pipe name           *)
                npi_name    : ARRAY[0..0] OF CHAR;   (* start of name     *)
              END;

  npss = RECORD                      (* QNmPipeSemState information record *)
           npss_status : SHORTCARD;  (* type of record, 0=EOI, 1=read ok, 2 = write ok, 3 = pipe closed    *)
           npss_flag   : SHORTCARD;  (* additional info, 01=waiting thread *)
           npss_key    : CARDINAL;   (* user's key value                   *)
           npss_avail  : CARDINAL;   (* available data/space if status=1/2 *)
         END;

CONST
(* values in npss_status *)
  NPSS_EOI    = 0;              (* End Of Information    *)
  NPSS_RDATA  = 1;              (* read data available   *)
  NPSS_WSPACE = 2;              (* write space available *)
  NPSS_CLOSE  = 3;              (* pipe in CLOSING state *)

(* values in npss_flag *)
  NPSS_WAIT   = 01H;              (* waiting thread on other end of pipe *)

(* defined bits in pipe mode *)
  NP_NBLK     = 08000H;           (* non-blocking read/write *)
  NP_SERVER   = 04000H;           (* set if server end       *)
  NP_WMESG    = 00400H;           (* write messages          *)
  NP_RMESG    = 00100H;           (* read as messages        *)
  NP_ICOUNT   = 000FFH;           (* instance count field    *)

(* Values for named pipe state *)

  NP_DISCONNECTED = 1;    (* after pipe creation or Disconnect *)
  NP_LISTENING    = 2;    (* after DosNmPipeConnect            *)
  NP_CONNECTED    = 3;    (* after Client open                 *)
  NP_CLOSING      = 4;    (* after Client or Server close      *)

(*%E*)
(**)
(**--- Dos Font Support ----------------------------------------------------*)
(**)
(*%T i_FONT*)
TYPE
  HSPL = FarADDRESS;

PROCEDURE PFSActivate(s:HSPL; VAR w:LONGCARD; n:ARRAY OF CHAR; c,i,f:CARDINAL; z:LONGCARD) : CARDINAL;
PROCEDURE PFSCloseUser(n:ARRAY OF CHAR; f:CARDINAL; z:LONGCARD) : CARDINAL;
PROCEDURE PFSInit(pl:ARRAY OF CARDINAL; fn,pt1,pt2:ARRAY OF CHAR; i:CARDINAL; z:LONGCARD) : CARDINAL;
PROCEDURE PFSQueryAct(n:ARRAY OF CHAR; VAR c,i:CARDINAL; f:CARDINAL; z:LONGCARD) : CARDINAL;
PROCEDURE PFSVerifyFont(n:ARRAY OF CHAR; c,i:CARDINAL; z:LONGCARD) : CARDINAL;

(*%E*)

VAR
  NULL [0:0] : BYTE ; (* equivalent of NIL for VAR params *)

END Dos.