DEFINITION MODULE SPL;

(************************************************************************
  OS/2 2.0 interface for Presentation Manager
           Spooler constants, types and function declarations.

  Copyright (c) 1992-1994 by Juergen Neuhoff
*************************************************************************)

(*$XL+       Modula-2 language extensions: '_' allowed for symbol names *)
(*$CDECL+    C-style procedures                                         *)
(*$A         default alignment for record fields                        *)

IMPORT SYSTEM;
FROM   OS2DEF  IMPORT TYPEPREFIX, LHANDLE, PSZ, HWND, HDC, PDRIVDATA, HFILE;

CONST (* Names of various OS2SYS.INI spooler variables *)
  SPL_INI_SPOOLER          = "PM_SPOOLER";
  SPL_INI_QUEUE            = "PM_SPOOLER_QUEUE";
  SPL_INI_PRINTER          = "PM_SPOOLER_PRINTER";
  SPL_INI_PRINTERDESCR     = "PM_SPOOLER_PRINTER_DESCR";
  SPL_INI_QUEUEDESCR       = "PM_SPOOLER_QUEUE_DESCR";
  SPL_INI_QUEUEDD          = "PM_SPOOLER_QUEUE_DD";
  SPL_INI_QUEUEDDDATA      = "PM_SPOOLER_QUEUE_DDDATA";

CONST (* General SPL return values *)
  SPL_ERROR                = 0;
  SPL_OK                   = 1;

TYPE (* handle to a spool file *)
   HSPL                    = LHANDLE;          (* hspl *)

TYPE (* Used in recording of PM_Q_STD data via SplStdxxx calls *)
   HSTD                    = LHANDLE;    (* hstd *)
   PHSTD                   = POINTER TO HSTD;

TYPE (* spooler manager open data *)
  QMOPENDATA               = PSZ;
  PQMOPENDATA              = POINTER TO PSZ;   (* pqmdop *)

CONST (* control codes for SplQpControl *)
  SPLC_ABORT               = 1;
  SPLC_PAUSE               = 2;
  SPLC_CONTINUE            = 3;

CONST
  (* flag defines for optional SplQpQueryFlags           *)
  (* set this to allow spooler to bypass Queue Processor *)
  (* for PM_Q_RAW jobs.  This allows print while a job   *)
  (* is still spooling.                                  *)
  QP_RAWDATA_BYPASS        = 00000001H;

TYPE (* handle to a spooler queue processor *)
  HPROC                    = LHANDLE;         (* hproc *)

TYPE (* spooler processor open data *)
  QPOPENDATA               = PSZ;
  PQPOPENDATA              = POINTER TO PSZ;  (* pqpdop *)

(**************************************************************************
  API's exported by Queue Processor DLL's.

  Note: OS/2 2.0 can be extended by Spooler Queue Processor.
        This Modula-2 compiler can be used to create it.

        Writing such a Queue Processor DLL requires:
        - SplQp... functions must be made public to the operating
          system by placing their headers in a definition module
          and their code an an implementation module.
        - Insert (*$DLL *)    at the beginning of definition module
        - Insert (*$CDECL+ *) at the begiining of implementation module

       The API for the spooler procedures looks like this:

    PROCEDURE SplQpOpen
    ( DataCount                : LONGINT;
      VAR QPDataIn             : QPOPENDATA
    )                          : HPROC;

    PROCEDURE SplQpPrint
    ( ProcHandle               : HPROC;
      FileName                 : ARRAY OF CHAR
    )                          : BOOLEAN;

    PROCEDURE SplQpClose
    ( ProcHandle               : HPROC
    )                          : BOOLEAN;

    PROCEDURE SplQpControl
    ( ProcHandle               : HPROC;
      Code                     : LONGINT
    )                          : BOOLEAN;

    PROCEDURE SplQpQueryDt
    ( VAR DataType             : LONGINT;
      VAR DataTypes            : PSZ
    )                          : BOOLEAN;

    PROCEDURE SplQpInstall
    ( WinHandle                : HWND
    )                          : BOOLEAN;

    (* The next API is optionally exported by Queue Processors *)
    (* The flags may be set to QP_RAWDATA_BYPASS to allow the  *)
    (* spooler to print the job while spooling, bypassing this *)
    (* queue processor                                         *)

    PROCEDURE SplQpQueryFlags
    ( VAR Flags                : LONGCARD
    )                          : BOOLEAN;

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


(*************************************************************************
* There are two definitions governing the QpOpen data block :-
* 1) the original  QPOPENDATA, which is used as
*    an array of PSZ and has a list of associated QPDAT defines
*    for accessing elements of the array. This has been extended
*    from 6 to 12 elements. The last element is a numeric type
*    and cannot satisfactorily be accessed via array indexing.
*
* 2) a new SQPOPENDATA structure (see below)
*
* The old defn has been retained to support existing QProcs.
*
*************************************************************************)

CONST (* Definition for elements within the PQPOPENDATA block *)
  QPDAT_ADDRESS      =  0;
  QPDAT_DRIVER_NAME  =  1;
  QPDAT_DRIVER_DATA  =  2;
  QPDAT_DATA_TYPE    =  3;
  QPDAT_COMMENT      =  4;
  QPDAT_PROC_PARAMS  =  5;
  QPDAT_SPL_PARAMS   =  6;     (* SplQmOpen Spooler params **       *)
  QPDAT_NET_PARAMS   =  7;     (* SplQmOpen Network params **       *)
  QPDAT_DOC_NAME     =  8;     (* SplQmStartDoc name       **       *)
  QPDAT_QUEUE_NAME   =  9;     (* Queue name for job       **       *)
  QPDAT_TOKEN        = 10;     (* SplQmOpen token name     **       *)
  QPDAT_JOBID        = 11;     (* SQM job identity         **       *)

TYPE
  SQPOPENDATA              = RECORD (* SplQpOpenData *)
    CASE                     : TYPEPREFIX OF
    | TRUE                   :
      pszLogAddress          : PSZ;
      pszDriverName          : PSZ;
      pdriv                  : PDRIVDATA;
      pszDataType            : PSZ;
      pszComment             : PSZ;
      pszProcParams          : PSZ;
      pszSpoolParams         : PSZ;
      pszNetworkParams       : PSZ;
      pszDocName             : PSZ;
      pszQueueName           : PSZ;
      pszToken               : PSZ;
      idJobId                : CARDINAL;
    | FALSE                  :
      LogAddress             : PSZ;
      DriverName             : PSZ;
      DriverData             : PDRIVDATA;
      DataType               : PSZ;
      Comment                : PSZ;
      ProcParams             : PSZ;
      SpoolParams            : PSZ;
      NetworkParams          : PSZ;
      DocName                : PSZ;
      QueueName              : PSZ;
      Token                  : PSZ;
      JobId                  : CARDINAL;
    END;                     END;
  PSQPOPENDATA             = POINTER TO SQPOPENDATA;

CONST (* Error information for SplMessageBox *)
  SPLINFO_QPERROR          = 0001H;
  SPLINFO_DDERROR          = 0002H;
  SPLINFO_SPLERROR         = 0004H;
  SPLINFO_OTHERERROR       = 0080H;
  SPLINFO_INFORMATION      = 0100H;
  SPLINFO_WARNING          = 0200H;
  SPLINFO_ERROR            = 0400H;
  SPLINFO_SEVERE           = 0800H;
  SPLINFO_USERINTREQD      = 1000H;

CONST (* Error Data for SplMessageBox *)
  SPLDATA_PRINTERJAM       = 0001H;
  SPLDATA_FORMCHGREQD      = 0002H;
  SPLDATA_CARTCHGREQD      = 0004H;
  SPLDATA_PENCHGREQD       = 0008H;
  SPLDATA_DATAERROR        = 0010H;
  SPLDATA_UNEXPECTERROR    = 0020H;
  SPLDATA_OTHER            = 8000H;

CONST (* return code for fSplStdQueryLength *)
  SSQL_ERROR               = -1;

TYPE
  SPLERR                   = LONGCARD;

CONST (* length for character arrays in structs (excluding zero terminator) *)
  CNLEN                    = 15; (* Computer name length      *)
  UNLEN                    = 20; (* Maximum user name length  *)
  QNLEN                    = 12; (* Queue name maximum length *)
  PDLEN                    =  8; (* Print destination length  *)
  DTLEN                    =  9; (* Spool file data type      *)
                                 (* e.g. PM_Q_STD,PM_Q_RAW    *)
  QP_DATATYPE_SIZE         = 15; (* returned by SplQpQueryDt  *)
  DRIV_DEVICENAME_SIZE     = 31; (* see DRIVDATA struc        *)
  DRIV_NAME_SIZE           =  8; (* name of device driver     *)
  PRINTERNAME_SIZE         = 32; (* max printer name length   *)
  FORMNAME_SIZE            = 31; (* max form name length      *)
  MAXCOMMENTSZ             = 48; (* queue comment length      *)

TYPE
  DRIVPROPS                = RECORD   (* dprop *)
    CASE                     : TYPEPREFIX OF
    | TRUE                   :
      pszKeyName             : PSZ;
      cbBuf                  : LONGCARD;
      pBuf                   : SYSTEM.ADDRESS;
    | FALSE                  :
      KeyName                : PSZ;
      BufSize                : LONGCARD;
      Buf                    : SYSTEM.ADDRESS;
    END;                     END;
  PDRIVPROPS               = POINTER TO DRIVPROPS;
  NPDRIVPROPS              = POINTER TO DRIVPROPS;

TYPE
  PRJINFO                  = RECORD   (* prj1 *)
    CASE                     : TYPEPREFIX OF
    | TRUE                   :
      uJobId                 : CARDINAL;
      szUserName             : ARRAY [0..UNLEN] OF CHAR;
      pad_1                  : CHAR;
      szNotifyName           : ARRAY [0..CNLEN] OF CHAR;
      szDataType             : ARRAY [0..DTLEN] OF CHAR;
      pszParms               : PSZ;
      uPosition              : CARDINAL;
      fsStatus               : CARDINAL;
      pszStatus              : PSZ;
      ulSubmitted            : LONGCARD;
      ulSize                 : LONGCARD;
      pszComment             : PSZ;
    | FALSE                  :
      JobId                  : CARDINAL;
      UserName               : ARRAY [0..UNLEN] OF CHAR;
      Pad_1                  : CHAR;
      NotifyName             : ARRAY [0..CNLEN] OF CHAR;
      DataType               : ARRAY [0..DTLEN] OF CHAR;
      Parms                  : PSZ;
      Position               : CARDINAL;
      StatusFlag             : CARDINAL;
      StatusStr              : PSZ;
      Submitted              : LONGCARD;
      Size                   : LONGCARD;
      Comment                : PSZ;
    END;                     END;
  PPRJINFO                 = POINTER TO PRJINFO;
  NPPRJINFO                = POINTER TO PRJINFO;

TYPE
  PRJINFO2                 = RECORD   (* prj2 *)
    CASE                     : TYPEPREFIX OF
    | TRUE                   :
      uJobId                 : CARDINAL;
      uPriority              : CARDINAL;
      pszUserName            : PSZ;
      uPosition              : CARDINAL;
      fsStatus               : CARDINAL;
      ulSubmitted            : LONGCARD;
      ulSize                 : LONGCARD;
      pszComment             : PSZ;
      pszDocument            : PSZ;
    | FALSE                  :
      JobId                  : CARDINAL;
      Priority               : CARDINAL;
      UserName               : PSZ;
      Position               : CARDINAL;
      Status                 : CARDINAL;
      Submitted              : LONGCARD;
      Size                   : LONGCARD;
      Comment                : PSZ;
      Document               : PSZ;
    END;                     END;
  PPRJINFO2                = POINTER TO PRJINFO2;
  NPPRJINFO2               = POINTER TO PRJINFO2;

TYPE
  PRJINFO3                 = RECORD   (* prj *)
    CASE                     : TYPEPREFIX OF
    | TRUE                   :
      uJobId                 : CARDINAL;
      uPriority              : CARDINAL;
      pszUserName            : PSZ;
      uPosition              : CARDINAL;
      fsStatus               : CARDINAL;
      ulSubmitted            : LONGCARD;
      ulSize                 : LONGCARD;
      pszComment             : PSZ;
      pszDocument            : PSZ;
      pszNotifyName          : PSZ;
      pszDataType            : PSZ;
      pszParms               : PSZ;
      pszStatus              : PSZ;
      pszQueue               : PSZ;
      pszQProcName           : PSZ;
      pszQProcParms          : PSZ;
      pszDriverName          : PSZ;
      pDriverData            : PDRIVDATA;
      pszPrinterName         : PSZ;
    | FALSE                  :
      JobId                  : CARDINAL;
      Priority               : CARDINAL;
      UserName               : PSZ;
      Position               : CARDINAL;
      Status                 : CARDINAL;
      Submitted              : LONGCARD;
      Size                   : LONGCARD;
      Comment                : PSZ;
      Document               : PSZ;
      NotifyName             : PSZ;
      DataType               : PSZ;
      Parms                  : PSZ;
      StatusStr              : PSZ;
      Queue                  : PSZ;
      QProcName              : PSZ;
      QProcParms             : PSZ;
      DriverName             : PSZ;
      DriverData             : PDRIVDATA;
      PrinterName            : PSZ;
    END;                     END;
  PPRJINFO3                = POINTER TO PRJINFO3;
  NPPRJINFO3               = POINTER TO PRJINFO3;

TYPE
  PRDINFO                  = RECORD    (* prd1 *)
    CASE                     : TYPEPREFIX OF
    | TRUE                   :
      szName                 : ARRAY [0..PDLEN] OF CHAR;
      pad_1                  : ARRAY [0..2] OF SYSTEM.BYTE;
      szUserName             : ARRAY [0..UNLEN] OF CHAR;
      uJobId                 : CARDINAL;
      fsStatus               : CARDINAL;
      pszStatus              : PSZ;
      time                   : CARDINAL;
    | FALSE                  :
      Name                   : ARRAY [0..PDLEN] OF CHAR;
      Pad_1                  : ARRAY [0..2] OF SYSTEM.BYTE;
      UserName               : ARRAY [0..UNLEN] OF CHAR;
      JobId                  : CARDINAL;
      StatusFlag             : CARDINAL;
      StatusStr              : PSZ;
      Time                   : CARDINAL;
    END;                     END;
  PPRDINFO                 = POINTER TO PRDINFO;
  NPPRDINFO                = POINTER TO PRDINFO;

TYPE
  PRDINFO3                 = RECORD    (* prd *)
    CASE                     : TYPEPREFIX OF
    | TRUE                   :
      pszPrinterName         : PSZ;
      pszUserName            : PSZ;
      pszLogAddr             : PSZ;
      uJobId                 : CARDINAL;
      fsStatus               : CARDINAL;
      pszStatus              : PSZ;
      pszComment             : PSZ;
      pszDrivers             : PSZ;
      time                   : CARDINAL;
      usTimeOut              : CARDINAL;
    | FALSE                  :
      PrinterName            : PSZ;
      UserName               : PSZ;
      LogAddr                : PSZ;
      JobId                  : CARDINAL;
      StatusFlag             : CARDINAL;
      StatusStr              : PSZ;
      Comment                : PSZ;
      Drivers                : PSZ;
      Time                   : CARDINAL;
      TimeOut                : CARDINAL;
    END;                     END;
  PPRDINFO3                = POINTER TO PRDINFO3;
  NPPRDINFO3               = POINTER TO PRDINFO3;

TYPE
  PRQINFO                  = RECORD    (* prq1 *)
    CASE                     : TYPEPREFIX OF
    | TRUE                   :
      szName                 : ARRAY [0..QNLEN] OF CHAR;
      pad_1                  : CHAR;
      uPriority              : CARDINAL;
      uStartTime             : CARDINAL;
      uUntilTime             : CARDINAL;
      pszSepFile             : PSZ;
      pszPrProc              : PSZ;
      pszDestinations        : PSZ;
      pszParms               : PSZ;
      pszComment             : PSZ;
      fsStatus               : CARDINAL;
      cJobs                  : CARDINAL;
    | FALSE                  :
      Name                   : ARRAY [0..QNLEN] OF CHAR;
      Pad_1                  : CHAR;
      Priority               : CARDINAL;
      StartTime              : CARDINAL;
      UntilTime              : CARDINAL;
      SepFile                : PSZ;
      PrProc                 : PSZ;
      Destinations           : PSZ;
      Parms                  : PSZ;
      Comment                : PSZ;
      Status                 : CARDINAL;
      Jobs                   : CARDINAL;
    END;                     END;
  PPRQINFO                 = POINTER TO PRQINFO;
  NPPRQINFO                = POINTER TO PRQINFO;

TYPE
  PRQINFO3                 = RECORD  (* prq *)
    CASE                     : TYPEPREFIX OF
    | TRUE                   :
      pszName                : PSZ;
      uPriority              : CARDINAL;
      uStartTime             : CARDINAL;
      uUntilTime             : CARDINAL;
      fsType                 : CARDINAL;
      pszSepFile             : PSZ;
      pszPrProc              : PSZ;
      pszParms               : PSZ;
      pszComment             : PSZ;
      fsStatus               : CARDINAL;
      cJobs                  : CARDINAL;
      pszPrinters            : PSZ;
      pszDriverName          : PSZ;
      pDriverData            : PDRIVDATA;
    | FALSE                  :
      Name                   : PSZ;
      Priority               : CARDINAL;
      StartTime              : CARDINAL;
      UntilTime              : CARDINAL;
      Type                   : CARDINAL;
      SepFile                : PSZ;
      PrProc                 : PSZ;
      Parms                  : PSZ;
      Comment                : PSZ;
      Status                 : CARDINAL;
      Jobs                   : CARDINAL;
      Printers               : PSZ;
      DriverName             : PSZ;
      DriverData             : PDRIVDATA;
    END;                     END;
  PPRQINFO3                = POINTER TO PRQINFO3;
  NPPRQINFO3               = POINTER TO PRQINFO3;

TYPE
  PRQINFO6                 = RECORD  (* prq6 *)
    CASE                     : TYPEPREFIX OF
    | TRUE                   :
      pszName                : PSZ;
      uPriority              : CARDINAL;
      uStartTime             : CARDINAL;
      uUntilTime             : CARDINAL;
      fsType                 : CARDINAL;
      pszSepFile             : PSZ;
      pszPrProc              : PSZ;
      pszParms               : PSZ;
      pszComment             : PSZ;
      fsStatus               : CARDINAL;
      cJobs                  : CARDINAL;
      pszPrinters            : PSZ;
      pszDriverName          : PSZ;
      pDriverData            : PDRIVDATA;
      pszRemoteComputerName  : PSZ;
      pszRemoteQueueName     : PSZ;
    | FALSE                  :
      Name                   : PSZ;
      Priority               : CARDINAL;
      StartTime              : CARDINAL;
      UntilTime              : CARDINAL;
      Type                   : CARDINAL;
      SepFile                : PSZ;
      PrProc                 : PSZ;
      Parms                  : PSZ;
      Comment                : PSZ;
      Status                 : CARDINAL;
      Jobs                   : CARDINAL;
      Printers               : PSZ;
      DriverName             : PSZ;
      DriverData             : PDRIVDATA;
      RemoteComputerName     : PSZ;
      RemoteQueueName        : PSZ;
    END;                     END;
  PPRQINFO6                = POINTER TO PRQINFO6;
  NPPRQINFO6               = POINTER TO PRQINFO6;

TYPE (* structure for DosPrintJobGetId *)
  PRIDINFO                 = RECORD    (* prjid *)
    CASE                     : TYPEPREFIX OF
    | TRUE                   :
      uJobId                 : CARDINAL;
      szComputerName         : ARRAY [0..CNLEN] OF CHAR;
      szQueueName            : ARRAY [0..QNLEN] OF CHAR;
      pad_1                  : CHAR;
    | FALSE                  :
      JobId                  : CARDINAL;
      ComputerName           : ARRAY [0..CNLEN] OF CHAR;
      QueueName              : ARRAY [0..QNLEN] OF CHAR;
      Pad_1                  : CHAR;
    END;                     END;
  PPRIDINFO                = POINTER TO PRIDINFO;
  NPPRIDINFO               = POINTER TO PRIDINFO;

TYPE (* structure for DosPrintDriverEnum *)
  PRDRIVINFO     = RECORD   (* prdid *)
    CASE           : TYPEPREFIX OF
    | TRUE         :
      szDrivName   : ARRAY [0..DRIV_NAME_SIZE+1+DRIV_DEVICENAME_SIZE] OF CHAR;
    | FALSE        :
      DrivName     : ARRAY [0..DRIV_NAME_SIZE+1+DRIV_DEVICENAME_SIZE] OF CHAR;
    END;           END;
  PPRDRIVINFO    = POINTER TO PRDRIVINFO;
  NPPRDRIVINFO   = POINTER TO PRDRIVINFO;

TYPE (* structure for DosPrintQProcessorEnum *)
  PRQPROCINFO    = RECORD     (* prqp *)
    CASE           : TYPEPREFIX OF
    | TRUE         :
      szQProcName  : ARRAY [0..QNLEN] OF CHAR;
    | FALSE        :
      QProcName    : ARRAY [0..QNLEN] OF CHAR;
    END;           END;
  PPRQPROCINFO   = POINTER TO PRQPROCINFO;
  NPPRQPROCINFO  = POINTER TO PRQPROCINFO;

TYPE (* structure for DosPrintPortEnum Level 0 *)
  PRPORTINFO     = RECORD     (* prpo *)
    CASE           : TYPEPREFIX OF
    | TRUE         :
      szPortName   : ARRAY [0..PDLEN] OF CHAR;
    | FALSE        :
      PortName     : ARRAY [0..PDLEN] OF CHAR;
    END;           END;
  PPRPORTINFO    = POINTER TO PRPORTINFO;
  NPPRPORTINFO   = POINTER TO PRPORTINFO;

TYPE (* structure for DosPrintPortEnum Level 1 *)
  PRPORTINFO1                  = RECORD    (* prpo1 *)
    CASE                         : TYPEPREFIX OF
    | TRUE                       :
      pszPortName                : PSZ;
      pszPortDriverName          : PSZ;
      pszPortDriverPathName      : PSZ;
    | FALSE                      :
      PortName                   : PSZ;
      PortDriverName             : PSZ;
      PortDriverPathName         : PSZ;
    END;                         END;
  PPRPORTINFO1                 = POINTER TO PRPORTINFO1;
  NPPRPORTINFO1                = POINTER TO PRPORTINFO1;

CONST (* Values for parmnum in DosPrintQSetInfo/SplSetQueue  *)
  PRQ_PRIORITY_PARMNUM         =  2;
  PRQ_STARTTIME_PARMNUM        =  3;
  PRQ_UNTILTIME_PARMNUM        =  4;
  PRQ_SEPARATOR_PARMNUM        =  5;
  PRQ_PROCESSOR_PARMNUM        =  6;
  PRQ_DESTINATIONS_PARMNUM     =  7;
  PRQ_PARMS_PARMNUM            =  8;
  PRQ_COMMENT_PARMNUM          =  9;
  PRQ_TYPE_PARMNUM             = 10;
  PRQ_PRINTERS_PARMNUM         = 12;
  PRQ_DRIVERNAME_PARMNUM       = 13;
  PRQ_DRIVERDATA_PARMNUM       = 14;
  PRQ_REMOTE_COMPUTER_PARMNUM  = 15;
  PRQ_REMOTE_QUEUE_PARMNUM     = 16;
  PRQ_MAXPARMNUM               = 16;

CONST (* Print Queue Priority *)
  PRQ_MAX_PRIORITY             = 1;       (* highest priority *)
  PRQ_DEF_PRIORITY             = 5;
  PRQ_MIN_PRIORITY             = 9;       (* lowest priority  *)
  PRQ_NO_PRIORITY              = 0;

CONST (* Print queue status bitmask and values for level 1 *)
  PRQ_STATUS_MASK              = 3;
  PRQ_ACTIVE                   = 0;
  PRQ_PAUSED                   = 1;       (* queue is held    *)
  PRQ_ERROR                    = 2;
  PRQ_PENDING                  = 3;       (* pending deletion *)

CONST (* Print queue status bits for level 3 *)
  PRQ3_PAUSED                  = 1H;      (* queue is held    *)
  PRQ3_PENDING                 = 2H;      (* pending deletion *)

CONST (* Print queue type bits for level 3 *)
  PRQ3_TYPE_RAW                = 0001H;   (* spools printer-specific data *)
  PRQ3_TYPE_BYPASS             = 0002H;   (* allow print while spooling   *)

CONST (* Values for parmnum in DosPrintJobSetInfo/SplSetJob *)
  PRJ_NOTIFYNAME_PARMNUM       =  3;
  PRJ_DATATYPE_PARMNUM         =  4;
  PRJ_PARMS_PARMNUM            =  5;
  PRJ_POSITION_PARMNUM         =  6;
  PRJ_JOBFILEINUSE_PARMNUM     =  7;
  PRJ_COMMENT_PARMNUM          = 11;
  PRJ_DOCUMENT_PARMNUM         = 12;
  PRJ_STATUSCOMMENT_PARMNUM    = 13;
  PRJ_PRIORITY_PARMNUM         = 14;
  PRJ_PROCPARMS_PARMNUM        = 16;
  PRJ_DRIVERDATA_PARMNUM       = 18;
  PRJ_MAXPARMNUM               = 18;

CONST (* Bitmap masks for status field of PRJINFO. *)
      (* 2-7 bits also used in device status *)
  PRJ_QSTATUS                  = 0003H;    (* Bits 0,1  *)
  PRJ_DEVSTATUS                = 0FFCH;    (* 2-11 bits *)
  PRJ_COMPLETE                 = 0004H;    (* Bit 2     *)
  PRJ_INTERV                   = 0008H;    (* Bit 3     *)
  PRJ_ERROR                    = 0010H;    (* Bit 4     *)
  PRJ_DESTOFFLINE              = 0020H;    (* Bit 5     *)
  PRJ_DESTPAUSED               = 0040H;    (* Bit 6     *)
  PRJ_NOTIFY                   = 0080H;    (* Bit 7     *)
  PRJ_DESTNOPAPER              = 0100H;    (* Bit 8     *)
  PRJ_DESTFORMCHG              = 0200H;    (* BIT 9     *)
  PRJ_DESTCRTCHG               = 0400H;    (* BIT 10    *)
  PRJ_DESTPENCHG               = 0800H;    (* BIT 11    *)
  PRJ_JOBFILEINUSE             = 4000H;    (* Bit 14    *)
  PRJ_DELETED                  = 8000H;    (* Bit 15    *)

CONST (* Values of PRJ_QSTATUS bits in fsStatus field of PRJINFO. *)
  PRJ_QS_QUEUED                = 0;
  PRJ_QS_PAUSED                = 1;
  PRJ_QS_SPOOLING              = 2;
  PRJ_QS_PRINTING              = 3;

CONST (* Print Job Priority *)
  PRJ_MAX_PRIORITY             = 99;          (* lowest priority  *)
  PRJ_MIN_PRIORITY             =  1;          (* highest priority *)
  PRJ_NO_PRIORITY              =  0;

CONST (* Bitmap masks for status field of PRDINFO. *)
  PRD_STATUS_MASK              = 0003H;       (* Bits 0,1 *)
  PRD_DEVSTATUS                = 0FFCH;       (* 2-11 bits *)

CONST (* Values of PRD_STATUS_MASK bits in fsStatus field of PRDINFO. *)
  PRD_ACTIVE                   = 0;
  PRD_PAUSED                   = 1;

CONST (* Control codes used in DosPrintDestControl/SplControlDevice *)
  PRD_DELETE                   = 0;
  PRD_PAUSE                    = 1;
  PRD_CONT                     = 2;
  PRD_RESTART                  = 3;

CONST (* Values for parmnum in DosPrintDestSetInfo/SplSetDevice *)
  PRD_LOGADDR_PARMNUM          =  3;
  PRD_COMMENT_PARMNUM          =  7;
  PRD_DRIVERS_PARMNUM          =  8;
  PRD_TIMEOUT_PARMNUM          = 10;

TYPE (* structure for SplEnumPrinter *)
  PRINTERINFO                  = RECORD   (* prtin *)
    CASE                         : TYPEPREFIX OF
    | TRUE                       :
      flType                     : LONGCARD;
      pszComputerName            : PSZ;
      pszPrintDestinationName    : PSZ;
      pszDescription             : PSZ;
      pszLocalName               : PSZ;
    | FALSE                      :
      Type                       : LONGCARD;
      ComputerName               : PSZ;
      PrintDestinationName       : PSZ;
      Description                : PSZ;
      LocalName                  : PSZ;
    END;                         END;
  PPRINTERINFO                 = POINTER TO PRINTERINFO;

CONST (* Flags for flType in  PRINTERINFO and SplEnumPrinter *)
  SPL_PR_QUEUE                 = 00000001H; (* include queues *)
  SPL_PR_DIRECT_DEVICE         = 00000002H; (* unattached devices *)
  SPL_PR_QUEUED_DEVICE         = 00000004H; (* queued devices *)
  SPL_PR_LOCAL_ONLY            = 00000100H; (* exclude remote queues *)


(*** Spooler API functions *)

PROCEDURE SplQmOpen
( Token                        : ARRAY OF CHAR;
  Count                        : LONGINT;
  Data                         : PQMOPENDATA
)                              : HSPL;

PROCEDURE SplQmStartDoc
( SpoolHandle                  : HSPL;
  DocName                      : ARRAY OF CHAR
)                              : BOOLEAN;

PROCEDURE SplQmWrite
( SpoolHandle                  : HSPL;
  Count                        : LONGINT;
  VAR Data                     : ARRAY OF SYSTEM.BYTE
)                              : BOOLEAN;

PROCEDURE SplQmEndDoc
( SpoolHandle                  : HSPL
)                              : BOOLEAN;

PROCEDURE SplQmClose
( SpoolHandle                  : HSPL
)                              : BOOLEAN;

PROCEDURE SplQmAbort
( SpoolHandle                  : HSPL
)                              : BOOLEAN;

PROCEDURE SplQmAbortDoc
( SpoolHandle                  : HSPL
)                              : BOOLEAN;

PROCEDURE SplMessageBox
( VAR LogAddrStr               : ARRAY OF CHAR;
  ErrInfoFlags                 : LONGCARD;
  ErrDataFlags                 : LONGCARD;
  VAR Text                     : ARRAY OF CHAR;
  VAR Caption                  : ARRAY OF CHAR;
  WindowId                     : LONGCARD;
  Style                        : LONGCARD
)                              : LONGCARD;


(*** Direct Device File System Interface *)

PROCEDURE PrtOpen
( DeviceName                   : ARRAY OF CHAR;
  VAR Device                   : HFILE;
  VAR ActionTaken              : LONGCARD;
  FileSize                     : LONGCARD;
  FileAttr                     : LONGCARD;
  OpenFlag                     : LONGCARD;
  OpenMode                     : LONGCARD;
  Reserved                     : LONGCARD
)                              : LONGCARD;

PROCEDURE PrtClose
( Device                       : HFILE
)                              : LONGCARD;

PROCEDURE PrtWrite
( Device                       : HFILE;
  VAR Data                     : ARRAY OF SYSTEM.BYTE;
  DataSize                     : LONGCARD;
  VAR WrittenSize              : LONGCARD
)                              : LONGCARD;

PROCEDURE PrtDevIOCtl
( VAR Data                     : ARRAY OF SYSTEM.BYTE;
  VAR Parms                    : ARRAY OF SYSTEM.BYTE;
  Function                     : LONGCARD;
  Category                     : LONGCARD;
  Device                       : LONGCARD
)                              : LONGCARD;

PROCEDURE PrtAbort
( Device                       : LONGCARD
);


(*** further Spooler API functions *)

PROCEDURE SplStdOpen
( DevHandle                    : HDC
)                              : BOOLEAN;

PROCEDURE SplStdClose
( DevHandle                    : HDC
)                              : BOOLEAN;

PROCEDURE SplStdStart
( DevHandle                    : HDC
)                              : BOOLEAN;

PROCEDURE SplStdStop
( DevHandle                    : HDC
)                              : HSTD;

PROCEDURE SplStdDelete
( MetaFile                     : HSTD
)                              : BOOLEAN;

PROCEDURE SplStdGetBits
( MetaFile                     : HSTD;
  DataOffset                   : LONGINT;
  DataSize                     : LONGINT;
  VAR Data                     : ARRAY OF SYSTEM.BYTE
)                              : BOOLEAN;

PROCEDURE SplStdQueryLength
( MetaFile                     : HSTD
)                              : LONGINT;

PROCEDURE SplCreateDevice      (* DosPrintDestAdd *)
( ComputerName                 : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD
)                              : SPLERR;

PROCEDURE SplControlDevice     (* DosPrintDestControl *)
( ComputerName                 : ARRAY OF CHAR;
  PortName                     : ARRAY OF CHAR;
  Control                      : LONGCARD
)                              : SPLERR;

PROCEDURE SplDeleteDevice      (* DosPrintDestDel *)
( ComputerName                 : ARRAY OF CHAR;
  PrintDeviceName              : ARRAY OF CHAR
)                              : SPLERR;

PROCEDURE SplEnumDevice        (* DosPrintDestEnum *)
( ComputerName                 : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  VAR ReturnedEntries          : LONGCARD;
  VAR TotalEntries             : LONGCARD;
  VAR NeededSize               : LONGCARD;
  Reserved                     : SYSTEM.ADDRESS
)                              : SPLERR;

PROCEDURE SplQueryDevice       (* DosPrintDestGetInfo *)
( ComputerName                 : ARRAY OF CHAR;
  PrintDeviceName              : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  VAR NeededSize               : LONGCARD
)                              : SPLERR;

PROCEDURE SplSetDevice         (* DosPrintDestSetInfo *)
( ComputerName                 : ARRAY OF CHAR;
  PrintDeviceName              : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  ParmNum                      : LONGCARD
)                              : SPLERR;

PROCEDURE SplReleaseJob        (* DosPrintJobContinue *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR;
  Job                          : LONGCARD
)                              : SPLERR;

PROCEDURE SplDeleteJob         (* DosPrintJobDel *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR;
  Job                          : LONGCARD
)                              : SPLERR;

PROCEDURE SplEnumJob           (* DosPrintJobEnum *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  VAR ReturnedEntries          : LONGCARD;
  VAR TotalEntries             : LONGCARD;
  VAR NeededSize               : LONGCARD;
  Reserved                     : SYSTEM.ADDRESS
)                              : SPLERR;

PROCEDURE SplQueryJob          (* DosPrintJobGetInfo *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR;
  Job                          : LONGCARD;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  VAR NeededSize               : LONGCARD
)                              : SPLERR;

PROCEDURE SplHoldJob           (* DosPrintJobPause *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR;
  Job                          : LONGCARD
)                              : SPLERR;

PROCEDURE SplSetJob            (* DosPrintJobSetInfo *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR;
  Job                          : LONGCARD;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  ParmNum                      : LONGCARD
)                              : SPLERR;

PROCEDURE SplCreateQueue       (* DosPrintQAdd *)
( ComputerName                 : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD
)                              : SPLERR;

PROCEDURE SplReleaseQueue      (* DosPrintQContinue *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR
)                              : SPLERR;

PROCEDURE SplDeleteQueue       (* DosPrintQDel *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR
)                              : SPLERR;

PROCEDURE SplEnumQueue         (* DosPrintQEnum *)
( ComputerName                 : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  VAR ReturnedEntries          : LONGCARD;
  VAR TotalEntries             : LONGCARD;
  VAR NeededSize               : LONGCARD;
  Reserved                     : SYSTEM.ADDRESS
)                              : SPLERR;

PROCEDURE SplQueryQueue        (* DosPrintQGetInfo *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  VAR NeededSize               : LONGCARD
)                              : SPLERR;

PROCEDURE SplHoldQueue         (* DosPrintQPause *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR
)                              : SPLERR;

PROCEDURE SplPurgeQueue        (* DosPrintQPurge *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR
)                              : SPLERR;

PROCEDURE SplSetQueue          (* DosPrintQSetInfo *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  ParmNum                      : LONGCARD
)                              : SPLERR;

PROCEDURE SplEnumDriver        (* DosPrintDriverEnum *)
( ComputerName                 : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  VAR ReturnedEntries          : LONGCARD;
  VAR TotalEntries             : LONGCARD;
  VAR NeededSize               : LONGCARD;
  Reserved                     : SYSTEM.ADDRESS
)                              : SPLERR;

PROCEDURE SplEnumPort          (* DosPrintPortEnum *)
( ComputerName                 : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  VAR ReturnedEntries          : LONGCARD;
  VAR TotalEntries             : LONGCARD;
  VAR NeededSize               : LONGCARD;
  Reserved                     : SYSTEM.ADDRESS
)                              : SPLERR;

PROCEDURE SplEnumQueueProcessor (* DosPrintQProcessorEnum *)
( ComputerName                 : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  VAR ReturnedEntries          : LONGCARD;
  VAR TotalEntries             : LONGCARD;
  VAR NeededSize               : LONGCARD;
  Reserved                     : SYSTEM.ADDRESS
)                              : SPLERR;

PROCEDURE SplEnumPrinter
( ComputerName                 : ARRAY OF CHAR;
  Level                        : LONGCARD;
  Type                         : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  VAR ReturnedEntries          : LONGCARD;
  VAR TotalEntries             : LONGCARD;
  VAR NeededSize               : LONGCARD;
  Reserved                     : SYSTEM.ADDRESS
)                              : SPLERR;

PROCEDURE SplCopyJob
( SrcComputerName              : ARRAY OF CHAR;
  SrcQueueName                 : ARRAY OF CHAR;
  SrcJob                       : LONGCARD;
  TrgComputerName              : ARRAY OF CHAR;
  TrgQueueName                 : ARRAY OF CHAR;
  VAR TrgJob                   : LONGCARD
)                              : SPLERR;


(**** DosPrint... mapped to Spl... functions by SPL.LIB import library *)

PROCEDURE DosPrintDestAdd      (* SplCreateDevice *)
( ComputerName                 : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD
)                              : SPLERR;

PROCEDURE DosPrintDestControl  (* SplControlDevice *)
( ComputerName                 : ARRAY OF CHAR;
  PortName                     : ARRAY OF CHAR;
  Control                      : LONGCARD
)                              : SPLERR;

PROCEDURE DosPrintDestDel      (* SplDeleteDevice *)
( ComputerName                 : ARRAY OF CHAR;
  PrintDeviceName              : ARRAY OF CHAR
)                              : SPLERR;

PROCEDURE DosPrintDestEnum     (* SplEnumDevice *)
( ComputerName                 : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  VAR ReturnedEntries          : LONGCARD;
  VAR TotalEntries             : LONGCARD;
  VAR NeededSize               : LONGCARD;
  Reserved                     : SYSTEM.ADDRESS
)                              : SPLERR;

PROCEDURE DosPrintDestGetInfo  (* SplQueryDevice *)
( ComputerName                 : ARRAY OF CHAR;
  PrintDeviceName              : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  VAR NeededSize               : LONGCARD
)                              : SPLERR;

PROCEDURE DosPrintDestSetInfo  (* SplSetDevice *)
( ComputerName                 : ARRAY OF CHAR;
  PrintDeviceName              : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  ParmNum                      : LONGCARD
)                              : SPLERR;

PROCEDURE DosPrintJobContinue  (* SplReleaseJob *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR;
  Job                          : LONGCARD
)                              : SPLERR;

PROCEDURE DosPrintJobDel       (* SplDeleteJob *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR;
  Job                          : LONGCARD
)                              : SPLERR;

PROCEDURE DosPrintJobEnum      (* SplEnumJob *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  VAR ReturnedEntries          : LONGCARD;
  VAR TotalEntries             : LONGCARD;
  VAR NeededSize               : LONGCARD;
  Reserved                     : SYSTEM.ADDRESS
)                              : SPLERR;

PROCEDURE DosPrintJobGetInfo   (* SplQueryJob *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR;
  Job                          : LONGCARD;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  VAR NeededSize               : LONGCARD
)                              : SPLERR;

PROCEDURE DosPrintJobPause     (* SplHoldJob *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR;
  Job                          : LONGCARD
)                              : SPLERR;

PROCEDURE DosPrintJobSetInfo   (* SplSetJob *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR;
  Job                          : LONGCARD;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  ParmNum                      : LONGCARD
)                              : SPLERR;

PROCEDURE DosPrintQAdd         (* SplCreateQueue *)
( ComputerName                 : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD
)                              : SPLERR;

PROCEDURE DosPrintQContinue    (* SplReleaseQueue *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR
)                              : SPLERR;

PROCEDURE DosPrintQDel         (* SplDeleteQueue *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR
)                              : SPLERR;

PROCEDURE DosPrintQEnum        (* SplEnumQueue *)
( ComputerName                 : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  VAR ReturnedEntries          : LONGCARD;
  VAR TotalEntries             : LONGCARD;
  VAR NeededSize               : LONGCARD;
  Reserved                     : SYSTEM.ADDRESS
)                              : SPLERR;

PROCEDURE DosPrintQGetInfo     (* SplQueryQueue *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  VAR NeededSize               : LONGCARD
)                              : SPLERR;

PROCEDURE DosPrintQPause       (* SplHoldQueue *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR
)                              : SPLERR;

PROCEDURE DosPrintQPurge       (* SplPurgeQueue *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR
)                              : SPLERR;

PROCEDURE DosPrintQSetInfo     (* SplSetQueue *)
( ComputerName                 : ARRAY OF CHAR;
  QueueName                    : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  ParmNum                      : LONGCARD
)                              : SPLERR;

PROCEDURE DosPrintDriverEnum   (* SplEnumDriver *)
( ComputerName                 : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  VAR ReturnedEntries          : LONGCARD;
  VAR TotalEntries             : LONGCARD;
  VAR NeededSize               : LONGCARD;
  Reserved                     : SYSTEM.ADDRESS
)                              : SPLERR;

PROCEDURE DosPrintPortEnum     (* SplEnumPort *)
( ComputerName                 : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  VAR ReturnedEntries          : LONGCARD;
  VAR TotalEntries             : LONGCARD;
  VAR NeededSize               : LONGCARD;
  Reserved                     : SYSTEM.ADDRESS
)                              : SPLERR;

PROCEDURE DosPrintQProcessorEnum (* SplEnumQueueProcessor *)
( ComputerName                 : ARRAY OF CHAR;
  Level                        : LONGCARD;
  VAR Buffer                   : ARRAY OF SYSTEM.BYTE;
  BufferSize                   : LONGCARD;
  VAR ReturnedEntries          : LONGCARD;
  VAR TotalEntries             : LONGCARD;
  VAR NeededSize               : LONGCARD;
  Reserved                     : SYSTEM.ADDRESS
)                              : SPLERR;

END SPL.
