home *** CD-ROM | disk | FTP | other *** search
/ Datatid 1999 #6 / Datatid_1999-06.iso / internet / Tango352Promo / P.SQL / PTKPKG.1 / SQLAPID.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1997-01-03  |  103.9 KB  |  3,181 lines
  1. {*************************************************************************
  2. **
  3. **  Copyright 1982-1997 Pervasive Software Inc. All Rights Reserved
  4. **
  5. *************************************************************************}
  6. {************************************************************************
  7.    SQLAPID.PAS
  8.       This unit contains the Turbo Pascal function prototypes, function
  9.       definitions, constant definitions, and datatype definitions for
  10.       Scalable SQL v3.x, including the Historical APIs and the
  11.       SQL-Level APIs.
  12.  
  13.       Two $defines control whether the code for the Historical APIs
  14.       and/or the SQL-Level API's are generated in the SQLAPID.TPU file.
  15.       If you do not need one of these sets of APIs, comment out the
  16.       appropriate define.
  17.  
  18.          SQL_SQL_FUNCTIONS .......... SQL-Level APIs
  19.          SQL_HISTORICAL_FUNCTIONS ... Historical APIs
  20.  
  21.       The 5.x verion of the Turbo Pascal IDE has problems loading
  22.       large modules; you will need to use the command line compiler
  23.       to create the SQLAPID.TPU. E.G., "TPC SQLAPID". You can use
  24.       the 6.x IDE to compile the interface.
  25. ************************************************************************}
  26. UNIT  sqlapid;
  27.  
  28. {$DEFINE SQL_HISTORICAL_FUNCTIONS}
  29. {$DEFINE SQL_SQL_FUNCTIONS}
  30.  
  31. {***********************************************************************
  32.    PASCAL INTERFACE SECTION
  33. ************************************************************************}
  34. INTERFACE
  35. USES DOS;
  36.  
  37. {***********************************************************************
  38.    SESSION MANAGEMENT PRIMITIVES
  39.       The following primitives are required by applications which
  40.       want to use multiple SQL logins:
  41.          xGetSessionID
  42.          xPutSessionID
  43. ************************************************************************}
  44.    FUNCTION xGetSessionID(
  45.                VAR session : INTEGER ) : INTEGER;
  46.  
  47.    FUNCTION xPutSessionID(
  48.                session : INTEGER ) : INTEGER;
  49.  
  50. {***********************************************************************
  51.    Named Database Functions
  52.       SQLGetCountDatabaseNames
  53.       SQLGetDatabaseNames
  54.       SQLUnloadDBNames
  55. ************************************************************************}
  56. FUNCTION SQLGetCountDatabaseNames(
  57.            VAR iCount : INTEGER ) : INTEGER;
  58.  
  59. FUNCTION SQLGetDatabaseNames(
  60.            VAR iBufLen  : INTEGER;
  61.            VAR bDataBuf : CHAR ) : INTEGER;
  62.  
  63. FUNCTION SQLUnloadDBNAMES(
  64.            iReserved : INTEGER ) : INTEGER;
  65.  
  66. {************************************************************************
  67.    Interface Module Internal Functions
  68.  ************************************************************************}
  69.    PROCEDURE callsql (VAR SQLPARMS);
  70.    PROCEDURE PrimitiveCall;
  71.    FUNCTION  PrimitivesManagerLoaded: BOOLEAN;
  72.  
  73. {$IFDEF SQL_SQL_FUNCTIONS}
  74. {************************************************************************
  75.    Interface Module SQL-Level Internal Functions
  76.  ************************************************************************}
  77.    PROCEDURE SQLLevelCall;
  78.    FUNCTION  SQLManagerLoaded : BOOLEAN;
  79.  
  80. {***********************************************************************
  81.    SQL-LEVEL FUNCTIONS
  82.       XQLCursor     XQLFetch    XQLSPUtility   XQLVersion
  83.       XQLCompile    XQLFormat   XQLStatus      XQLConvert
  84.       XQLDescribe   XQLFree     XQLStop        XQLValidate
  85.       XQLExec       XQLLogin    XQLSubst       XQLMask
  86.                     XQLLogout
  87. ***********************************************************************}
  88.    FUNCTION XQLCursor(
  89.                VAR CURSOR : INTEGER ) : INTEGER;
  90.  
  91.    FUNCTION XQLCompile(
  92.                CURSOR    : INTEGER;
  93.            VAR LEN       : INTEGER;
  94.            VAR STMNT )   : INTEGER;
  95.  
  96.    FUNCTION XQLDescribe(
  97.                CURSOR  : INTEGER;
  98.                POS     : INTEGER;
  99.            VAR DTYPE   : INTEGER;
  100.            VAR SIZE    : INTEGER;
  101.            VAR DEC     : INTEGER;
  102.            VAR DSIZE   : INTEGER;
  103.            VAR NLENGTH : INTEGER;
  104.            VAR NAME    : CHAR ) : INTEGER;
  105.  
  106.    FUNCTION XQLExec(
  107.                CURSOR : INTEGER ) : INTEGER;
  108.  
  109.    FUNCTION XQLFetch(
  110.                CURSOR : INTEGER;
  111.                OP     : INTEGER;
  112.            VAR DLEN   : INTEGER;
  113.            VAR BUF;
  114.            VAR SEL    : LONGINT;
  115.                ASCII  : INTEGER;
  116.                SPACES : INTEGER ) : INTEGER;
  117.  
  118.    FUNCTION XQLFormat(
  119.                CURSOR : INTEGER;
  120.                POS    : INTEGER;
  121.                LENGTH : INTEGER;
  122.            VAR MASKBUF ) : INTEGER;
  123.  
  124.    FUNCTION XQLFree(
  125.                CURSOR : INTEGER ) : INTEGER;
  126.  
  127.    FUNCTION XQLLogin(
  128.                VAR USERID;
  129.                VAR PSWDNAME;
  130.                VAR DD;
  131.                VAR DATAPATH;
  132.                VAR SRES;
  133.                    iFeaturesUsed : INTEGER ) : INTEGER;
  134.  
  135.    FUNCTION XQLLogout : INTEGER;
  136.  
  137.    FUNCTION XQLSPUtility(
  138.                CURSOR    : INTEGER;
  139.                OPTION    : INTEGER;
  140.            VAR STMNTCNT  : INTEGER;
  141.            VAR STMNTEXEC : INTEGER;
  142.            VAR BUFLEN    : INTEGER;
  143.            VAR STATBUF ) : INTEGER;
  144.  
  145.    FUNCTION XQLStatus(
  146.                CURSOR : INTEGER;
  147.                OPTION : INTEGER;
  148.            VAR STATBUF ) : INTEGER;
  149.  
  150.    FUNCTION XQLStop : INTEGER;
  151.  
  152.    FUNCTION XQLSubst(
  153.                CURSOR  : INTEGER;
  154.                SCOUNT  : INTEGER;
  155.                NAMELEN : INTEGER;
  156.            VAR VARNAME;
  157.                TEXTLEN : INTEGER;
  158.            VAR VARTEXT ) : INTEGER;
  159.  
  160.    FUNCTION XQLVersion(
  161.                VAR VBUFFER ) : INTEGER;
  162.  
  163.    FUNCTION XQLConvert(
  164.                OPTION : INTEGER;
  165.                DTYPE  : INTEGER;
  166.                SIZE   : INTEGER;
  167.                DEC    : INTEGER;
  168.                DSIZE  : INTEGER;
  169.            VAR VALUE;
  170.            VAR RETVALUE;
  171.            VAR MASK;
  172.                JUST : INTEGER ) : INTEGER;
  173.  
  174.    FUNCTION XQLValidate(
  175.                VAR COUNT : INTEGER;
  176.                VAR FIELDNAME;
  177.                    BUFLEN : INTEGER;
  178.                VAR DATA ) : INTEGER;
  179.  
  180.    FUNCTION XQLMask(
  181.                OPTION : INTEGER;
  182.                DTYPE  : INTEGER;
  183.                SIZE   : INTEGER;
  184.                DEC    : INTEGER;
  185.            VAR MLEN   : INTEGER;
  186.            VAR MASK ) : INTEGER;
  187.  
  188. {$ENDIF} {SQL-Level APIs}
  189.  
  190. {$IFDEF SQL_HISTORICAL_FUNCTIONS}
  191. {***********************************************************************
  192.    HISTORICAL RELATIONAL PRIMITIVES
  193.       The following functions will be phased out over time.  They
  194.       are included here to support existing applications.  New applications
  195.       should not use these functions.
  196.  
  197.       xCompute    xOrder         xDD            xAccess
  198.       xDescribe   xRemall        xDDAttr        xPassword
  199.       xMovefld    xRemove        xDDModify      xSecurity
  200.       xFetch      xReset         xDDCreate      xUser
  201.       xField      xRestrict      xDDDrop        xChar
  202.       xFree       xStop          xDDField       xVersion
  203.       xInsert     xTrans         xDDFile        xStatus
  204.       xJoin       xStore         xDDIndex       xConvert
  205.       xLogin      xRecall        xDDPath        xValidate
  206.       xLogout     xUpdate        xDDView        xMask
  207.       xNew        xUpdall
  208. ***********************************************************************}
  209.    FUNCTION xCompute(
  210.                VHANDLE   : INTEGER;
  211.            VAR FNAME;
  212.                DATA_TYPE : INTEGER;
  213.                DATA_SIZE : INTEGER;
  214.                DEC       : INTEGER;
  215.            VAR ELEN      : INTEGER;
  216.            VAR EBUF )    : INTEGER;
  217.  
  218.    FUNCTION xDescribe(
  219.                VHANDLE : INTEGER;
  220.                SUBF    : INTEGER;
  221.            VAR DLEN    : INTEGER;
  222.                POS     : INTEGER;
  223.            VAR CNT     : INTEGER;
  224.            VAR BUF )   : INTEGER;
  225.  
  226.    FUNCTION xMovefld(
  227.                VHANDLE : INTEGER;
  228.                FPOS    : INTEGER;
  229.                TPOS    : INTEGER ) : INTEGER;
  230.  
  231.    FUNCTION xFetch(
  232.                VHANDLE : INTEGER;
  233.            VAR DLEN    : INTEGER;
  234.                FETCH_OP: INTEGER;
  235.            VAR SELCNT  : LONGINT;
  236.            VAR REJCNT  : LONGINT;
  237.            VAR BUF )   : INTEGER;
  238.  
  239.    FUNCTION xField(
  240.                VHANDLE : INTEGER;
  241.                SUBF    : INTEGER;
  242.                POS     : INTEGER;
  243.            VAR CNT     : INTEGER;
  244.            VAR BUF )   : INTEGER;
  245.  
  246.    FUNCTION xFree(
  247.                VHANDLE : INTEGER) : INTEGER;
  248.  
  249.    FUNCTION xInsert(
  250.                VHANDLE  : INTEGER;
  251.            VAR COUNT    : INTEGER;
  252.            VAR FILES;
  253.            VAR EDITCNT  : LONGINT;
  254.            VAR BUFFER ) : INTEGER;
  255.  
  256.    FUNCTION xJoin(
  257.                VHANDLE  : INTEGER;
  258.            VAR NEWFILE;
  259.            VAR OWNERNAME;
  260.                JTYPE    : INTEGER;
  261.                VCOUNT   : INTEGER;
  262.            VAR VNAMES;
  263.                NCOUNT   : INTEGER;
  264.            VAR NNAMES ) : INTEGER;
  265.  
  266.    FUNCTION xLogin(
  267.            VAR USERID;
  268.            VAR PASSWORD;
  269.            VAR DPATH;
  270.            VAR FPATH;
  271.            VAR SRES;
  272.                iFeaturesUsed : INTEGER ) : INTEGER;
  273.  
  274.    FUNCTION xLogout : INTEGER;
  275.  
  276.    FUNCTION xNew(
  277.            VAR VHANDLE : INTEGER;
  278.            VAR FNAME;
  279.            VAR OWNERNAME;
  280.                MODE : INTEGER ) : INTEGER;
  281.  
  282.    FUNCTION xOrder(
  283.                VHANDLE : INTEGER;
  284.                CNT     : INTEGER;
  285.            VAR BUF )   : INTEGER;
  286.  
  287.    FUNCTION xRemall(
  288.                VHANDLE : INTEGER;
  289.            VAR COUNT   : INTEGER;
  290.            VAR FILES;
  291.                ROP     : INTEGER;
  292.            VAR SELCNT  : LONGINT;
  293.                REJCNT  : LONGINT ) : INTEGER;
  294.  
  295.    FUNCTION xRemove(
  296.                VHANDLE : INTEGER;
  297.            VAR COUNT   : INTEGER;
  298.            VAR FILES;
  299.            VAR EDITCNT : LONGINT ) : INTEGER;
  300.  
  301.    FUNCTION xReset(
  302.            VAR SRESERVED ) : INTEGER;
  303.  
  304.    FUNCTION xRestrict(
  305.                VHANDLE : INTEGER;
  306.                NEW_EXP : INTEGER;
  307.            VAR ELEN    : INTEGER;
  308.            VAR EBUF )  : INTEGER;
  309.  
  310.    FUNCTION xStop : INTEGER;
  311.  
  312.    FUNCTION xTrans(
  313.                OPERATION : INTEGER ) : INTEGER;
  314.  
  315.    FUNCTION xStore(
  316.                VHANDLE : INTEGER;
  317.            VAR VNAME;
  318.                BLEN    : INTEGER;
  319.            VAR VBUF )  : INTEGER;
  320.  
  321.    FUNCTION xRecall(
  322.            VAR VHANDLE : INTEGER;
  323.            VAR VNAME;
  324.                ONUM    : INTEGER;
  325.            VAR OLST;
  326.                MODE    : INTEGER;
  327.            VAR BLEN    : INTEGER;
  328.            VAR VBUF )  : INTEGER;
  329.  
  330.    FUNCTION xUpdate(
  331.                VHANDLE  : INTEGER;
  332.            VAR COUNT    : INTEGER;
  333.            VAR FILES;
  334.            VAR EDITCNT  : LONGINT;
  335.            VAR BUFFER ) : INTEGER;
  336.  
  337.    FUNCTION xUpdall(
  338.                VHANDLE   : INTEGER;
  339.            VAR UPDCOUNT  : INTEGER;
  340.            VAR FILES;
  341.                UOP       : INTEGER;
  342.            VAR SELCNT    : LONGINT;
  343.            VAR REJCNT    : LONGINT;
  344.                COLCNT    : INTEGER;
  345.            VAR RESULT;
  346.            VAR COMPARE ) : INTEGER;
  347.  
  348.    FUNCTION xDD(
  349.            VAR DIRPATH;
  350.            FNCTION : INTEGER ) : INTEGER;
  351.  
  352.    FUNCTION xDDAttr(
  353.                OPTION    : INTEGER;
  354.             VAR FLDNAME;
  355.                 ATTRIB   : INTEGER;
  356.             VAR BSIZE    : INTEGER;
  357.             VAR ABUF )   : INTEGER;
  358.  
  359.    FUNCTION xDDModify(
  360.                OPTION      : INTEGER;
  361.            VAR FNAME;
  362.                CREATE_FILE : INTEGER;
  363.            VAR PATH;
  364.            VAR OWNERNAME;
  365.                OACC        : INTEGER;
  366.                FLDCOUNT    : INTEGER;
  367.            VAR FLDLIST;
  368.                KEYCOUNT    : INTEGER;
  369.            VAR KLIST )     : INTEGER;
  370.  
  371.    FUNCTION xDDCreate(
  372.                OPTION      : INTEGER;
  373.            VAR FNAME;
  374.                CREATE_FILE : INTEGER;
  375.            VAR PATH;
  376.            VAR OWNERNAME;
  377.                OACC        : INTEGER;
  378.                FLDCOUNT    : INTEGER;
  379.            VAR FLDLIST;
  380.                KEYCOUNT    : INTEGER;
  381.            VAR KLIST;
  382.                BLEN        : INTEGER;
  383.            VAR CRPARMS )   : INTEGER;
  384.  
  385.    FUNCTION xDDDrop(
  386.            VAR FILENAME;
  387.                FILETYPE   : INTEGER;
  388.                DELETEPATH : INTEGER ) : INTEGER;
  389.  
  390.     FUNCTION xDDField(
  391.                 OPTION : INTEGER;
  392.             VAR FCOUNT : INTEGER;
  393.             VAR FBUF;
  394.             VAR BLEN   : INTEGER;
  395.             VAR OBUF ) : INTEGER;
  396.  
  397.    FUNCTION xDDFile(
  398.                OPTION : INTEGER;
  399.            VAR FCOUNT : INTEGER;
  400.            VAR FBUF;
  401.            VAR BLEN   : INTEGER;
  402.            VAR OBUF ) : INTEGER;
  403.  
  404.    FUNCTION xDDIndex(
  405.                OPTION : INTEGER;
  406.            VAR FCOUNT : INTEGER;
  407.            VAR FBUF;
  408.            VAR BLEN   : INTEGER;
  409.            VAR OBUF ) : INTEGER;
  410.  
  411.    FUNCTION xDDPath(
  412.                DIRTYPE    : INTEGER;
  413.            VAR PATHNAME ) : INTEGER;
  414.  
  415.    FUNCTION xDDView(
  416.            VAR FCOUNT : INTEGER;
  417.            VAR VNAME;
  418.            VAR BLEN   : INTEGER;
  419.            VAR OBUF ) : INTEGER;
  420.  
  421.    FUNCTION xAccess(
  422.            VAR MASTERPSWD;
  423.            VAR UNAME;
  424.                OPTION      : INTEGER;
  425.                ARIGHTS     : INTEGER;
  426.            VAR FNAME;
  427.            VAR FCOUNT      : INTEGER;
  428.            VAR FIELDNAME;
  429.            VAR BLEN        : INTEGER;
  430.            VAR OBUF )      : INTEGER;
  431.  
  432.    FUNCTION xPassword(
  433.            VAR UNAME;
  434.            VAR PASSWORD ) : INTEGER;
  435.  
  436.    FUNCTION xSecurity(
  437.            VAR MPSWD;
  438.            FLAG : INTEGER ) : INTEGER;
  439.  
  440.    FUNCTION xUser(
  441.            VAR MASTERPSWD;
  442.                OPTION      : INTEGER;
  443.            VAR UNAME;
  444.            VAR PASSWORD;
  445.                UGRIGHTS    : INTEGER;
  446.            VAR FCOUNT      : INTEGER;
  447.            VAR BLEN        : INTEGER;
  448.            VAR UBUF )      : INTEGER;
  449.  
  450.    FUNCTION xChar(
  451.                CHARFCN  : INTEGER;
  452.                CHARTYPE : INTEGER;
  453.            VAR VALUE    : CHAR ) : INTEGER;
  454.  
  455.    FUNCTION xVersion(
  456.            VAR BUFFER ) : INTEGER;
  457.  
  458.    FUNCTION xStatus(
  459.                VHANDLE   : INTEGER;
  460.                SUBFUNC   : INTEGER;
  461.            VAR LEN       : INTEGER;
  462.            VAR STATBUF ) : INTEGER;
  463.  
  464.    FUNCTION xConvert(
  465.                OPTION     : INTEGER;
  466.                DTYPE      : INTEGER;
  467.                SIZE       : INTEGER;
  468.                DEC        : INTEGER;
  469.                DSIZE      : INTEGER;
  470.            VAR VALUE;
  471.            VAR RETVALUE;
  472.            VAR MASK;
  473.                JUST       : INTEGER ) : INTEGER;
  474.  
  475.    FUNCTION xValidate(
  476.            VAR COUNT       : INTEGER;
  477.            VAR FIELDNAME;
  478.                BUFLEN      : INTEGER;
  479.            VAR DATA )      : INTEGER;
  480.  
  481.    FUNCTION xMask(
  482.                OPTION : INTEGER;
  483.                DTYPE  : INTEGER;
  484.                SIZE   : INTEGER;
  485.                DEC    : INTEGER;
  486.            VAR MLEN   : INTEGER;
  487.            VAR MASK ) : INTEGER;
  488.  
  489. {$ENDIF} {Historical APIs}
  490.  
  491.  
  492. {************************************************************************
  493.                              CONSTANTS
  494.  ************************************************************************}
  495. CONST
  496. {************************************************************************
  497.     Miscellaneous Constants
  498.  ************************************************************************}
  499.   SessID    : INTEGER = -1;      {  session identifier for Scalable SQL  }
  500.   VSet      : BOOLEAN = false;   {  flag set to true if checked version  }
  501.  
  502. {************************************************************************
  503.      Error codes
  504.  ************************************************************************}
  505.   PRIMITIVES_NOT_LOADED_ERR  = 200;   {  Relational Primitives Manager not loaded }
  506.   SQL_MANAGER_NOT_LOADED_ERR = 802;   {  SQL Manager program not started }
  507.   SQL_INT                    = $7B;   {  Scalable SQL interrupt vector  }
  508.   SQL_VECTOR                 = $00BC; {  offset for interrupt  }
  509.   SQL_OFFSET                 = $0033; {  Scalable SQL offset within segment  }
  510.   InvSQLLevelFcn             = 503;
  511.   InvPrimitiveFcn            = 201;
  512.   NOT_LOGGED                 = 287;
  513.   InvFcn                     = -1;
  514.  
  515. {$IFDEF SQL_HISTORICAL_FUNCTIONS}
  516. {************************************************************************
  517.      Historical Relational Primitives Function Numbers
  518.  ************************************************************************}
  519.  
  520.   tLogInFcn    =  0;
  521.   tLogOutFcn   =  1;
  522.   tNewFcn      =  2;
  523.   tFreeFcn     =  3;
  524.   tMoveFldFcn  =  4;
  525.   tFieldFcn    =  5;
  526.   tDescribeFcn =  6;
  527.   tFetchFcn    =  7;
  528.   tComputeFcn  =  8;
  529.   tOrderFcn    =  9;
  530.   tRestrictFcn = 10;
  531.   tJoinFcn     = 11;
  532.   tInsertFcn   = 12;
  533.   tUpdateFcn   = 13;
  534.   tUpdallFcn   = 14;
  535.   tRemoveFcn   = 15;
  536.   tRemallFcn   = 16;
  537.   tResetFcn    = 17;
  538.   tTrans       = 18;
  539.   tStatFcn     = 19;
  540.   tDDCreFcn    = 20;
  541.   tStoreFcn    = 21;
  542.   tRecallFcn   = 22;
  543.   tStopFcn     = 23;
  544.   tDDFileFcn   = 24;
  545.   tDDFieldFcn  = 25;
  546.   tDDIndexFcn  = 26;
  547.   tDDModFcn    = 27;
  548.   tDDViewFcn   = 28;
  549.   tDDDrpFcn    = 29;
  550.   tDDPathFcn   = 30;
  551.   tDDAttrFcn   = 31;
  552.   tDDFcn       = 32;
  553.   tSecurFcn    = 33;
  554.   tUserFcn     = 34;
  555.   tAccessFcn   = 35;
  556.   tPswdFcn     = 36;
  557.   tCharFcn     = 37;
  558.   tVersionFcn  = 38;
  559.   tConvertFcn  = 39;
  560.   tValidFcn    = 40;
  561.   tMaskFcn     = 41;
  562. {$ENDIF} {Historical Relational Primitive APIs}
  563.  
  564. {$IFDEF SQL_SQL_FUNCTIONS}
  565. {************************************************************************
  566.      SQL-Level Function Numbers
  567.  ************************************************************************}
  568.   lLogInFcn    = 0;
  569.   lLogOutFcn   = 1;
  570.   lCursorFcn   = 2;
  571.   lCompFcn     = 3;
  572.   lFormatFcn   = 4;
  573.   lFetchFcn    = 5;
  574.   lDescribeFcn = 6;
  575.   lSubstFcn    = 7;
  576.   lExecFcn     = 8;
  577.   lFreeFcn     = 9;
  578.   lStatFcn     = 10;
  579.   lStopFcn     = 11;
  580.   lVersFcn     = 12;
  581.   lConvFcn     = 13;
  582.   lValFcn      = 14;
  583.   lMaskFcn     = 15;
  584.   lSPUtilFcn   = 16;
  585. {$ENDIF} {SQL-Level Function numbers}
  586.  
  587.  
  588. {************************************************************************
  589.                              DATA TYPES
  590.  ************************************************************************}
  591. TYPE
  592. {************************************************************************
  593.    Miscellaneous Data Types
  594.  ************************************************************************}
  595.     REGISTERS = RECORD
  596.                   case INTEGER of
  597.                   1: (AX,BX,CX,DX,BP,SI,DI,DS,ES,Flags : INTEGER);
  598.                   2: (AL,AH,BL,BH,CL,CH,DL,DH          : BYTE);
  599.                 END;
  600.  
  601.     ADDR = RECORD
  602.              OffSet, Seg : WORD;
  603.            END;
  604.  
  605. {***************************************************************************
  606.     Named Database Structure Definitions
  607. ***************************************************************************}
  608.    DBNGETCNT = RECORD
  609.          XQL_ID    : ARRAY[0..3] OF CHAR;
  610.          fcn       : WORD;
  611.          cursorid  : WORD;
  612.          stat      : INTEGER;
  613.          sessionid : INTEGER;
  614.          count     : INTEGER;
  615.    END;
  616.  
  617.    DBNGETNAME = RECORD
  618.          XQL_ID    : ARRAY[0..3] OF CHAR;
  619.          fcn       : WORD;
  620.          cursorid  : WORD;
  621.          stat      : INTEGER;
  622.          sessionid : INTEGER;
  623.          bufLen    : INTEGER;
  624.          buffer    : ADDR;
  625.    END;
  626.  
  627.    DBNUNLOAD = RECORD
  628.          XQL_ID    : ARRAY[0..3] OF CHAR;
  629.          fcn       : WORD;
  630.          cursorid  : WORD;
  631.          stat      : INTEGER;
  632.          sessionid : INTEGER;
  633.          reserved  : INTEGER;
  634.    END;
  635.  
  636.    { Protected Mode switch parameter block }
  637.    pmswParmBlock = RECORD
  638.        sign  : ARRAY[0..3] OF CHAR;
  639.        flags : LONGINT;
  640.        func  : LONGINT;
  641.        stat  : LONGINT;
  642.        len   : LONGINT;
  643.        data  : ADDR;
  644.    END;
  645.  
  646.  
  647. {$IFDEF SQL_HISTORICAL_FUNCTIONS }
  648. {************************************************************************
  649.   Historical Relational Primitive Data Types
  650.  ************************************************************************}
  651.     RPFUNC =    (RP_LOGIN,    RP_NEW,    RP_COMPUTE,  RP_DDMOD,
  652.                  RP_DESCRIBE, RP_EDIT,   RP_FETCH,    RP_FIELD,
  653.                  RP_JOIN,     RP_ORDER,  RP_MOVEFLD,  RP_REMALL,
  654.                  RP_RESTRICT, RP_RESET,  RP_STORE,    RP_RECALL,
  655.                  RP_UPDALL,   RP_TRANS,  RP_DD,       RP_DDATTR,
  656.                  RP_DDCRE,    RP_DDFCN,  RP_DDDROP,   RP_DDPATH,
  657.                  RP_DDVIEW,   RP_SECURE, RP_USER,     RP_ACCESS,
  658.                  RP_PASSWORD, RP_CHAR,   RP_VERSION,  RP_CONVERT,
  659.                  RP_MASK,     RP_VALIDATE, RP_STATUS,   RP_LOAD);
  660.  
  661.  
  662.     RP_TCOMPUTE =  RECORD                   {             xCompute    }
  663.                         fldname : ADDR;
  664.                         fldtype : INTEGER;
  665.                         fldsize : INTEGER;
  666.                         flddec  : INTEGER;
  667.                         explen  : INTEGER;
  668.                         expbuf  : ADDR;
  669.                 END;
  670.  
  671.     RP_TDESCRIBE = RECORD                   {             xDescribe   }
  672.                         option      : INTEGER;
  673.                         desclen     : INTEGER;
  674.                         position    : INTEGER;
  675.                         count       : INTEGER;
  676.                         desclist    : ADDR;
  677.                 END;
  678.  
  679.     RP_TNEW =      RECORD                  {              xNew        }
  680.                         filename : ADDR;
  681.                         owner    : ADDR;
  682.                         openmode : INTEGER;
  683.                 END;
  684.  
  685.     RP_TFIELD =    RECORD                  {              xField      }
  686.                         option      : INTEGER;
  687.                         position    : INTEGER;
  688.                         count       : INTEGER;
  689.                         fldlist     : ADDR;
  690.                 END;
  691.  
  692.     RP_TMOVEFLD =  RECORD                  {              xMovefld    }
  693.                         frompos : INTEGER;
  694.                         topos   : INTEGER;
  695.                 END;
  696.                                              {              xDelete     }
  697.                                              {              xInsert     }
  698.     RP_TEDIT =     RECORD                  {              xUpdate     }
  699.                         filecount : INTEGER;
  700.                         filelist  : ADDR;
  701.                         cnt       : LONGINT;
  702.                         buf       : ADDR;
  703.                 END;
  704.  
  705.     RP_TFETCH =    RECORD                  {              xFetch      }
  706.                         datalen      : INTEGER;
  707.                         op           : INTEGER;
  708.                         select       : LONGINT;
  709.                         reject       : LONGINT;
  710.                         databuf      : ADDR;
  711.                 END;
  712.  
  713.     RP_TJOIN =     RECORD                  {              xJoin       }
  714.                         filename : ADDR;
  715.                         owner    : ADDR;
  716.                         joinType : INTEGER;
  717.                         pCount   : INTEGER;
  718.                         pNames   : ADDR;
  719.                         sCount   : INTEGER;
  720.                         sNames   : ADDR;
  721.                 END;
  722.  
  723.     RP_TLOGIN =    RECORD                  {              xLogin      }
  724.                         username   : ADDR;
  725.                         pswd       : ADDR;
  726.                         dictionary : ADDR;
  727.                         filepath   : ADDR;
  728.                         sreserved  : ADDR;
  729.                         iFeaturesUsedx : INTEGER;
  730.                 END;
  731.  
  732.     RP_TORDER =    RECORD                  {              xOrder      }
  733.                         count   : INTEGER;
  734.                         fldlist : ADDR;
  735.                 END;
  736.  
  737.     RP_TREMALL =   RECORD                  {              xRemall     }
  738.                         filecount    : INTEGER;
  739.                         filelist     : ADDR;
  740.                         op           : INTEGER;
  741.                         select       : LONGINT;
  742.                         reject       : LONGINT;
  743.                 END;
  744.  
  745.     RP_TRESTRICT = RECORD                  {              xRestrict   }
  746.                         newexp : INTEGER;{  new | extended restriction  }
  747.                         explen : INTEGER;
  748.                         expbuf : ADDR;
  749.                 END;
  750.  
  751.     RP_TSTORE =    RECORD                  {              xStore      }
  752.                         StoreName : ADDR;
  753.                         BufLen    : INTEGER;
  754.                         Buf       : ADDR;
  755.                 END;
  756.  
  757.     RP_TRECALL =   RECORD                  {              xRecall     }
  758.                         RecallName : ADDR;
  759.                         ownernum   : INTEGER;
  760.                         ownerlst   : ADDR;
  761.                         openmode   : INTEGER;
  762.                         buflen     : INTEGER;
  763.                         buf        : ADDR;
  764.                 END;
  765.  
  766.     RP_TRESET =    RECORD                  {              xReset      }
  767.                         sreserved : ADDR;
  768.                 END;
  769.  
  770.     RP_TUPDALL =   RECORD                  {              xUpdall     }
  771.                         filecount    : INTEGER;
  772.                         filelist     : ADDR;
  773.                         op           : INTEGER;
  774.                         select       : LONGINT;
  775.                         reject       : LONGINT;
  776.                         count        : INTEGER;
  777.                         res          : ADDR;
  778.                         comp         : ADDR;
  779.                 END;
  780.     RP_TTRANS  =   RECORD                  {              xTrans      }
  781.                         option  : INTEGER;
  782.                 END;
  783.  
  784. { **************      Dictionary Primitives           ***************** }
  785.  
  786.     RP_TDD =       RECORD                  {              xDD         }
  787.                         dirpath  : ADDR;
  788.                         fnction : INTEGER;
  789.                 END;
  790.  
  791.     RP_TDDATTR =   RECORD                  {              xDDAttr     }
  792.                         subfunct   : INTEGER;
  793.                         fieldname  : ADDR;                                       {  field name  }
  794.                         attr       : INTEGER;
  795.                         bufsize    : INTEGER;
  796.                         attrbuf    : ADDR;        {  attributes buffer  }
  797.                 END;
  798.     RP_TDDCRE =    RECORD                  {              xDDModify   }
  799.                         subfunct  : INTEGER;
  800.                         filename  : ADDR;
  801.                         create    : INTEGER;
  802.                         pathname  : ADDR;
  803.                         owner     : ADDR;
  804.                         oaccess   : INTEGER;  {  owner access restrict  }
  805.                         fcount    : INTEGER;
  806.                         fieldlist : ADDR;
  807.                         kcount    : INTEGER;
  808.                         keylist   : ADDR;
  809.                         buflen    : INTEGER;
  810.                         creparms  : ADDR;
  811.                 END;
  812.  
  813.     RP_TDDMOD =    RECORD                  {              xDDModify   }
  814.                         subfunct  : INTEGER;
  815.                         filename  : ADDR;
  816.                         create    : INTEGER;
  817.                         pathname  : ADDR;
  818.                         owner     : ADDR;
  819.                         oaccess   : INTEGER;  {  owner access restrict  }
  820.                         fcount    : INTEGER;
  821.                         fieldlist : ADDR;
  822.                         kcount    : INTEGER;
  823.                         keylist   : ADDR;
  824.                 END;
  825.  
  826.     RP_TDDDROP =   RECORD                  {              xDDDrop     }
  827.                         filename   : ADDR;
  828.                         filetype   : INTEGER;
  829.                         deletepath : INTEGER;
  830.                 END;
  831.  
  832.     RP_TDDFCN =    RECORD                 { xDDField/xDDFile/xDDIndex }
  833.                         rtype    : INTEGER;
  834.                         count    : INTEGER;
  835.                         namebuf  : ADDR;
  836.                         buflen   : INTEGER;
  837.                         outbuf   : ADDR;
  838.                 END;
  839.  
  840.     RP_TDDPATH =   RECORD                  {              xDDPath     }
  841.                         dirtype  : INTEGER;
  842.                         pathname : ADDR;
  843.                 END;
  844.  
  845.     RP_TDDVIEW =   RECORD                  {              xDDView     }
  846.                         count    : INTEGER;
  847.                         viewname : ADDR;
  848.                         buflen   : INTEGER;
  849.                         outbuf   : ADDR;
  850.                 END;
  851.  
  852. { **************        Security  Primitives          ***************** }
  853.  
  854.     RP_TSECURE =   RECORD                  {              xSecurity   }
  855.                         mpswd        : ADDR;        {  master password  }
  856.                         securityflag : INTEGER;
  857.                 END;
  858.  
  859.     RP_TUSER =     RECORD                  {              xUser       }
  860.                         mpswd    : ADDR;
  861.                         subfcn   : INTEGER;     {  add, modify, remove  }
  862.                         username : ADDR;
  863.                         pswd     : ADDR;
  864.                         grights  : INTEGER;          {  global rights   }
  865.                         count    : INTEGER;
  866.                         buflen   : INTEGER;
  867.                         userbuf  : ADDR;
  868.                 END;
  869.  
  870.     RP_TACCESS =   RECORD                  {              xAccess     }
  871.                         mpswd    : ADDR;
  872.                         username : ADDR;
  873.                         subfcn   : INTEGER;  {  grant, deny, return     }
  874.                         rights   : INTEGER;
  875.                         filename : ADDR;
  876.                         count    : INTEGER;       {  field list count   }
  877.                         name     : ADDR;          {  field list names   }
  878.                         buflen   : INTEGER;       {  max buffer length  }
  879.                         outbuf   : ADDR;          {  output buffer      }
  880.                 END;
  881.  
  882.     RP_TPASSWORD = RECORD                  {              xPassword   }
  883.                         user : ADDR;                {  user name        }
  884.                         pswd : ADDR;                {  password         }
  885.                 END;
  886.  
  887.  
  888. { **************     Miscellaneous Primitives         ***************** }
  889.  
  890.     RP_TCHAR =     RECORD                  {              xChar       }
  891.                         charFcn   : INTEGER;
  892.                         charType  : INTEGER;
  893.                         charValue : INTEGER;
  894.                 END;
  895.  
  896.     RP_TVERSION =  RECORD                  {              xVersion    }
  897.                         buffer : ADDR;
  898.                 END;
  899.  
  900.     RP_TCONVERT =  RECORD                  {              xConvert    }
  901.                         convFcn   : INTEGER;
  902.                         convType  : INTEGER;
  903.                         convSize  : INTEGER;
  904.                         convDec   : INTEGER;
  905.                         convDSize : INTEGER;
  906.                         convVal   : ADDR;
  907.                         convRet   : ADDR;
  908.                         convMask  : ADDR;
  909.                         convJust  : INTEGER;
  910.                END;
  911.  
  912.     RP_TMASK   =  RECORD                              {         xMask  }
  913.                         maskFcn   : INTEGER;
  914.                         maskType  : INTEGER;
  915.                         maskSize  : INTEGER;
  916.                         maskDec   : INTEGER;
  917.                         maskLen   : INTEGER;
  918.                         maskVal   : ADDR;
  919.                END;
  920.  
  921.     RP_TVALIDATE = RECORD
  922.                         valCount  : INTEGER;
  923.                         valField  : ADDR;
  924.                         valBufLen : INTEGER;
  925.                         valData   : ADDR;
  926.                END;
  927.  
  928.     RP_TSTATUS    = RECORD
  929.                         option     : INTEGER;
  930.                         buflen     : INTEGER;
  931.                         buf        : ADDR;
  932.                END;
  933.  
  934.     RP_BTRIEVE  = RECORD
  935.                         dumy1     : INTEGER;
  936.                         btrop     : INTEGER;
  937.                         dumy2     : INTEGER;
  938.                         dumy3     : INTEGER;
  939.                         dumy4     : INTEGER;
  940.                         btrstat   : ADDR;
  941.                  END;
  942.  
  943.     RP_STRUC =     RECORD        { structure passed to Scalable SQL }
  944.                                  { for Relational Primitive APIs}
  945.                         SQL_ID    : ARRAY[0..3] OF CHAR;
  946.                         fcn       : INTEGER;
  947.                         handle    : INTEGER;
  948.                         stat      : INTEGER;
  949.  
  950.                         sessionid : INTEGER;
  951.                         case RPFUNC of
  952.                                 RP_LOGIN   : (tloginData  : RP_TLOGIN);
  953.                                 RP_NEW     : (tnewData    : RP_TNEW);
  954.                                 RP_COMPUTE : (tcompData   : RP_TCOMPUTE);
  955.                                 RP_DDCRE   : (tcreData    : RP_TDDCRE);
  956.                                 RP_DDMOD   : (tmodData    : RP_TDDMOD);
  957.                                 RP_DESCRIBE: (tdescData   : RP_TDESCRIBE);
  958.                                 RP_EDIT    : (teditData   : RP_TEDIT);
  959.                                 RP_FETCH   : (tfetchData  : RP_TFETCH);
  960.                                 RP_FIELD   : (tfldData    : RP_TFIELD);
  961.                                 RP_JOIN    : (tjoinData   : RP_TJOIN);
  962.                                 RP_ORDER   : (tordData    : RP_TORDER);
  963.                                 RP_MOVEFLD : (tmovData    : RP_TMOVEFLD);
  964.                                 RP_REMALL  : (tremallData : RP_TREMALL);
  965.                                 RP_RESTRICT: (trestData   : RP_TRESTRICT);
  966.                                 RP_RESET   : (tresetData  : RP_TRESET);
  967.                                 RP_STORE   : (tstoreData  : RP_TSTORE);
  968.                                 RP_RECALL  : (trecallData : RP_TRECALL);
  969.                                 RP_UPDALL  : (tupdallData : RP_TUPDALL);
  970.                                 RP_TRANS   : (ttransData  : RP_TTRANS);
  971.                                 RP_DD      : (tddData     : RP_TDD);
  972.                                 RP_DDATTR  : (tddattrData : RP_TDDATTR);
  973.                                 RP_DDFCN   : (tddfcnData  : RP_TDDFCN);
  974.                                 RP_DDDROP  : (tdddropData : RP_TDDDROP);
  975.                                 RP_DDPATH  : (tddpathData : RP_TDDPATH);
  976.                                 RP_DDVIEW  : (tddviewData : RP_TDDVIEW);
  977.                                 RP_SECURE  : (tsecureData : RP_TSECURE);
  978.                                 RP_USER    : (tuserData   : RP_TUSER);
  979.                                 RP_ACCESS  : (taccessData : RP_TACCESS);
  980.                                 RP_PASSWORD: (tpswdData   : RP_TPASSWORD);
  981.                                 RP_CHAR    : (tcharData   : RP_TCHAR);
  982.                                 RP_VERSION : (tversionData: RP_TVERSION);
  983.                                 RP_CONVERT : (tconvertData: RP_TCONVERT);
  984.                                 RP_MASK    : (tmaskData   : RP_TMASK);
  985.                                 RP_VALIDATE: (tvalidData  : RP_TVALIDATE);
  986.                                 RP_STATUS  : (tstatData   : RP_TSTATUS);
  987.                                 RP_LOAD    : (txData      : RP_BTRIEVE);
  988.                 END;
  989.  
  990. {$ENDIF} {Historical Relational Primitive Data Types}
  991.  
  992. {$IFDEF SQL_SQL_FUNCTIONS}
  993. {************************************************************************
  994.   SQL-Level Data Types
  995.  ************************************************************************}
  996.  
  997.    { SQL-Level functions }
  998.    SQLFUNC =    (SQL_LOGIN,        SQL_COMPILE,   SQL_FORMAT,
  999.                  SQL_FETCH,        SQL_DESCRIBE,  SQL_SUBST,
  1000.                  SQL_STATUS,       SQL_VERSION,   SQL_CONVERT,
  1001.                  SQL_VALIDATE,     SQL_MASK,      SQL_UTIL,
  1002.                  SQL_LOAD);
  1003.  
  1004.   T_XLOGIN     = RECORD
  1005.                  username   : ADDR;
  1006.                  pswd       : ADDR;
  1007.                  dictionary : ADDR;
  1008.                  filepath   : ADDR;
  1009.                  sreserved  : ADDR;
  1010.                  iFeaturesUsedx  : INTEGER;
  1011.                END;
  1012.  
  1013.   T_XCOMPILE   = RECORD
  1014.                  length    : INTEGER;
  1015.                  statement : ADDR;
  1016.                END;
  1017.  
  1018.   T_XDESCRIB   = RECORD                         {             XQLDescribe }
  1019.                  position  : INTEGER;
  1020.                  datatype  : INTEGER;
  1021.                  datasize  : INTEGER;
  1022.                  deccount  : INTEGER;
  1023.                  dsize     : INTEGER;
  1024.                  namelength: INTEGER;
  1025.                  namebuf   : ADDR;
  1026.                END;
  1027.  
  1028.   T_XFETCH     = RECORD
  1029.                  operation   : INTEGER;
  1030.                  datalen     : INTEGER;
  1031.                  databuf     : ADDR;
  1032.                  select      : LONGINT;
  1033.                  ASCIIFlag   : INTEGER;
  1034.                  spacing     : INTEGER;
  1035.                END;
  1036.  
  1037.   T_XFORMAT    = RECORD
  1038.                  position  : INTEGER;
  1039.                  masklen   : INTEGER;
  1040.                  mask      : ADDR;
  1041.                END;
  1042.  
  1043.   T_XSTATUS    = RECORD
  1044.                  subfunction: INTEGER;
  1045.                  buf        : ADDR;
  1046.                END;
  1047.  
  1048.   T_XSUBST     = RECORD
  1049.                  count      : INTEGER;
  1050.                  nlen       : INTEGER;
  1051.                  vname      : ADDR;
  1052.                  tlen       : INTEGER;
  1053.                  vtext      : ADDR;
  1054.                END;
  1055.  
  1056.   T_XVERSION   = RECORD
  1057.                  buffer     : ADDR;
  1058.                END;
  1059.  
  1060.   T_XCONVERT =  RECORD                 {              xConvert    }
  1061.                  convFcn   : INTEGER;
  1062.                  convType  : INTEGER;
  1063.                  convSize  : INTEGER;
  1064.                  convDec   : INTEGER;
  1065.                  convDSize : INTEGER;
  1066.                  convVal   : ADDR;
  1067.                  convRet   : ADDR;
  1068.                  convMask  : ADDR;
  1069.                  convJust  : INTEGER;
  1070.               END;
  1071.  
  1072.  T_XMASK   =  RECORD                              {         xMask  }
  1073.                  maskOption: INTEGER;
  1074.                  maskType  : INTEGER;
  1075.                  maskSize  : INTEGER;
  1076.                  maskDec   : INTEGER;
  1077.                  maskLen   : INTEGER;
  1078.                  maskVal   : ADDR;
  1079.             END;
  1080.  
  1081.  T_XVALIDATE = RECORD
  1082.                  valCount  : INTEGER;
  1083.                  valField  : ADDR;
  1084.                  valBufLen : INTEGER;
  1085.                  valData   : ADDR;
  1086.             END;
  1087.  
  1088.  T_XUTIL   =  RECORD                              {         XQLSPUtility  }
  1089.                  utilOption    : INTEGER;
  1090.                  utilStmntCnt  : INTEGER;
  1091.                  utilStmntExec : INTEGER;
  1092.                  utilBufLen    : INTEGER;
  1093.                  utilStatBuf   : ADDR;
  1094.             END;
  1095.  
  1096.  T_XBTRIEVE  = RECORD
  1097.                  dumy1     : INTEGER;
  1098.                  btrop     : INTEGER;
  1099.                  dumy2     : INTEGER;
  1100.                  dumy3     : INTEGER;
  1101.                  dumy4     : INTEGER;
  1102.                  btrstat   : ADDR;
  1103.             END;
  1104.  
  1105.   SQL_STRUC  = RECORD                { structure passed to Scalable SQL
  1106.                                         for SQL-Level APIs}
  1107.                   SQL_ID     : ARRAY[0..3] OF CHAR;
  1108.                   fcn        : INTEGER;
  1109.                   cursorid   : INTEGER;
  1110.                   stat       : INTEGER;
  1111.                   sessionid  : INTEGER;
  1112.                   case SQLFUNC of
  1113.                           SQL_LOGIN     : (tlData  : T_XLOGIN);
  1114.                           SQL_COMPILE   : (tcData  : T_XCOMPILE);
  1115.                           SQL_FETCH     : (tfData  : T_XFETCH);
  1116.                           SQL_DESCRIBE  : (tdData  : T_XDESCRIB);
  1117.                           SQL_FORMAT    : (tfmData : T_XFORMAT);
  1118.                           SQL_STATUS    : (tstData : T_XSTATUS);
  1119.                           SQL_SUBST     : (tsData  : T_XSUBST);
  1120.                           SQL_VERSION   : (tvData  : T_XVERSION);
  1121.                           SQL_CONVERT   : (tcoData : T_XCONVERT);
  1122.                           SQL_VALIDATE  : (tvaData : T_XVALIDATE);
  1123.                           SQL_MASK      : (tmData  : T_XMASK);
  1124.                           SQL_UTIL      : (tuData  : T_XUTIL);
  1125.                           SQL_LOAD      : (txData  : T_XBTRIEVE);
  1126.                 END;
  1127.  
  1128. {$ENDIF} {SQL-Level Types}
  1129.  
  1130. {************************************************************************
  1131.    INTERFACE VARIABLES
  1132.  ************************************************************************}
  1133. VAR
  1134. {$IFDEF SQL_HISTORICAL_FUNCTIONS}
  1135.   RP_PARMS  : RP_STRUC;
  1136. {$ENDIF}
  1137.  
  1138. {$IFDEF SQL_SQL_FUNCTIONS}
  1139.   SQL_PARMS : SQL_STRUC;
  1140. {$ENDIF}
  1141.  
  1142.   REGS      : DOS.REGISTERS;
  1143.   SQLCODE   : INTEGER;
  1144.  
  1145. {************************************************************************
  1146.    IMPLEMENTATION
  1147.  ************************************************************************}
  1148. IMPLEMENTATION
  1149.  
  1150. {***********************************************************************
  1151.    Named Database Functions
  1152.       SQLGetCountDatabaseNames
  1153.       SQLGetDatabaseNames
  1154.       SQLUnloadDBNames
  1155. ************************************************************************}
  1156. { CallPMSW() is a support function for the Named Database APIs. }
  1157. FUNCTION CallPMSW(
  1158.            VAR pb : pmswParmBlock ) : INTEGER;
  1159. var
  1160.    stat  : INTEGER;
  1161.  
  1162. begin
  1163.    stat := 0;
  1164.  
  1165.    regs.AX := $3500 + SQL_INT;
  1166.    MsDOS( regs );
  1167.    if (regs.BX <> SQL_OFFSET) then
  1168.       begin
  1169.         SQLCODE := SQL_MANAGER_NOT_LOADED_ERR;
  1170.         stat := SQLCODE;
  1171.       end;
  1172.  
  1173.    if ( stat = 0 ) then
  1174.       begin
  1175.           regs.DX := Ofs ( pb );
  1176.           regs.DS := Seg( pb );
  1177.           Intr( SQL_INT, regs );
  1178.       end;
  1179.  
  1180.    CallPMSW := stat;
  1181. end;
  1182.  
  1183. FUNCTION SQLGetCountDatabaseNames(
  1184.            VAR iCount : INTEGER ) : INTEGER;
  1185. VAR
  1186.    stat  : INTEGER;
  1187.    dbnpb : DBNGETCNT;
  1188.    pb    : pmswParmBlock;
  1189.  
  1190. begin
  1191.    stat := 0;
  1192.  
  1193.    dbnpb.XQL_ID[ 0 ] := 'D';
  1194.    dbnpb.XQL_ID[ 1 ] := 'B';
  1195.    dbnpb.XQL_ID[ 2 ] := 'N';
  1196.    dbnpb.XQL_ID[ 3 ] := 'M';
  1197.    dbnpb.fcn         := 2;
  1198.    dbnpb.count       := iCount;
  1199.  
  1200.    pb.sign[ 0 ]   := 'P';
  1201.    pb.sign[ 1 ]   := 'M';
  1202.    pb.sign[ 2 ]   := 'S';
  1203.    pb.sign[ 3 ]   := 'W';
  1204.    pb.flags       := 0;
  1205.    pb.func        := 768;
  1206.    pb.len         := sizeof( dbnpb );
  1207.    pb.data.Seg    := Seg( dbnpb );
  1208.    pb.data.Offset := Ofs( dbnpb );
  1209.  
  1210.    stat := CallPMSW( pb );
  1211.  
  1212.    iCount := dbnpb.count;
  1213.  
  1214.    if ( stat = 0 ) then
  1215.       stat := dbnpb.stat;
  1216.  
  1217.    SQLGetCountDatabaseNames := stat;
  1218. end;
  1219.  
  1220. FUNCTION SQLGetDatabaseNames(
  1221.            VAR iBufLen  : INTEGER;
  1222.            VAR bDataBuf : CHAR ) : INTEGER;
  1223. var
  1224.    stat  : INTEGER;
  1225.    dbnpb : DBNGETNAME;
  1226.    pb    : pmswParmBlock;
  1227.  
  1228. begin
  1229.    stat := 0;
  1230.  
  1231.    dbnpb.XQL_ID[ 0 ] := 'D';
  1232.    dbnpb.XQL_ID[ 1 ] := 'B';
  1233.    dbnpb.XQL_ID[ 2 ] := 'N';
  1234.    dbnpb.XQL_ID[ 3 ] := 'M';
  1235.    dbnpb.fcn         := 4;
  1236.  
  1237.    dbnpb.bufLen        := iBufLen;
  1238.    dbnpb.buffer.Seg    := Seg( bDataBuf );
  1239.    dbnpb.buffer.Offset := Ofs( bDataBuf );
  1240.  
  1241.    pb.sign[ 0 ]   := 'P';
  1242.    pb.sign[ 1 ]   := 'M';
  1243.    pb.sign[ 2 ]   := 'S';
  1244.    pb.sign[ 3 ]   := 'W';
  1245.    pb.flags       := 0;
  1246.    pb.func        := 768;
  1247.    pb.len         := sizeof( dbnpb );
  1248.    pb.data.Seg    := Seg( dbnpb );
  1249.    pb.data.Offset := Ofs( dbnpb );
  1250.  
  1251.    stat := CallPMSW( pb );
  1252.  
  1253.    iBufLen := dbnpb.bufLen;
  1254.  
  1255.    if ( stat = 0 ) then
  1256.        stat := dbnpb.stat;
  1257.  
  1258.    SQLGetDatabaseNames := stat;
  1259. end;
  1260.  
  1261. FUNCTION SQLUnloadDBNAMES(
  1262.            iReserved : INTEGER ) : INTEGER;
  1263. var
  1264.    stat  : INTEGER;
  1265.    dbnpb : DBNUNLOAD;
  1266.    pb    : pmswParmBlock;
  1267.  
  1268. begin
  1269.    stat := 0;
  1270.  
  1271.    dbnpb.XQL_ID[ 0 ] := 'D';
  1272.    dbnpb.XQL_ID[ 1 ] := 'B';
  1273.    dbnpb.XQL_ID[ 2 ] := 'N';
  1274.    dbnpb.XQL_ID[ 3 ] := 'M';
  1275.    dbnpb.fcn         := 7;
  1276.  
  1277.    dbnpb.reserved := 0;
  1278.  
  1279.    pb.sign[ 0 ]   := 'P';
  1280.    pb.sign[ 1 ]   := 'M';
  1281.    pb.sign[ 2 ]   := 'S';
  1282.    pb.sign[ 3 ]   := 'W';
  1283.    pb.flags       := 0;
  1284.    pb.func        := 768;
  1285.    pb.len         := sizeof( dbnpb );
  1286.    pb.data.Seg    := Seg( dbnpb );
  1287.    pb.data.Offset := Ofs( dbnpb );
  1288.  
  1289.    stat := CallPMSW( pb );
  1290.  
  1291.    if ( stat = 0 ) then
  1292.        stat := dbnpb.stat;
  1293.  
  1294.    SQLUnloadDBNAMES := stat;
  1295. end;
  1296.  
  1297.  
  1298. FUNCTION xGetSessionID(
  1299.             VAR session : INTEGER ) : INTEGER;
  1300. begin
  1301.   session := SessID;
  1302.   if (SessID = -1) then
  1303.     xGetSessionID := NOT_LOGGED
  1304.   else
  1305.     xGetSessionID := 0;
  1306. end;
  1307.  
  1308.  
  1309. FUNCTION xPutSessionID(
  1310.             session : INTEGER ) : INTEGER;
  1311. begin
  1312.   SessID := session;
  1313.   xPutSessionID := 0;
  1314. end;
  1315.  
  1316. PROCEDURE callsql(
  1317.              VAR SQLPARMS );
  1318. begin
  1319.   regs.DX := Ofs(SQLPARMS);
  1320.   regs.ES := Seg(SQLPARMS);
  1321.   regs.DS := regs.ES;
  1322.   Intr (SQL_INT, regs);
  1323. end;
  1324.  
  1325. PROCEDURE PrimitiveCall;
  1326. begin
  1327.   RP_PARMS.SQL_ID[0] := 'X';
  1328.   RP_PARMS.SQL_ID[1] := 'Q';
  1329.   RP_PARMS.SQL_ID[2] := 'L';
  1330.   RP_PARMS.SQL_ID[3] := 'P';
  1331.   RP_PARMS.sessionid  := SessID;
  1332.   callsql (RP_PARMS);
  1333. end;
  1334.  
  1335. FUNCTION PrimitivesManagerLoaded : BOOLEAN;
  1336. var
  1337.   bstat              : INTEGER;
  1338.  
  1339. begin
  1340.  
  1341.   SQLCODE := 0;
  1342.   RP_PARMS.stat := -1;
  1343.   RP_PARMS.fcn  := InvFcn;
  1344.   regs.AX := $3500 + SQL_INT;
  1345.   MsDOS (regs);
  1346.   if ( regs.BX <> SQL_OFFSET ) then
  1347.     SQLCODE := PRIMITIVES_NOT_LOADED_ERR
  1348.   else
  1349.     begin
  1350.       with RP_PARMS, txData do
  1351.        begin
  1352.           btrop          := -1;
  1353.           btrstat.Seg    := Seg (bstat);
  1354.           btrstat.OffSet := Ofs (bstat);
  1355.           PrimitiveCall;
  1356.        end;
  1357.  
  1358.       if ((RP_PARMS.stat <> InvSQLLevelFcn) and
  1359.               (RP_PARMS.stat <> InvPrimitiveFcn)) then
  1360.         SQLCODE := PRIMITIVES_NOT_LOADED_ERR
  1361.       else
  1362.         begin
  1363.           if (not VSet) then
  1364.             begin
  1365.               VSet := true;
  1366.             end;
  1367.         end;
  1368.     end;
  1369.   RP_PARMS.stat := SQLCODE;
  1370.   if SQLCODE = 0
  1371.   then  PrimitivesManagerLoaded := True
  1372.   else  PrimitivesManagerLoaded := False;
  1373. end;
  1374.  
  1375. {$IFDEF SQL_SQL_FUNCTIONS}
  1376. {************************************************************************
  1377.    SQL-Level Function Definitions
  1378.  ************************************************************************}
  1379. {*************************************************************************}
  1380. {   SQLLevelCall                                                          }
  1381. {    Send parameter block to Scalable SQL                                 }
  1382. {*************************************************************************}
  1383. PROCEDURE SQLLevelCall;
  1384. begin
  1385.                  { set up Scalable SQL signature for SQL-Level Functions   }
  1386.   SQL_PARMS.SQL_ID[0] := 'X';
  1387.   SQL_PARMS.SQL_ID[1] := 'Q';
  1388.   SQL_PARMS.SQL_ID[2] := 'L';
  1389.   SQL_PARMS.SQL_ID[3] := 'M';
  1390.   SQL_PARMS.sessionid  := SessID;
  1391.   callsql (SQL_PARMS);
  1392. end;
  1393.  
  1394. {*************************************************************************}
  1395. {                                                                         }
  1396. {  SQLManagerLoaded                                                          }
  1397. {    Check if Scalable SQL is loaded.                                     }
  1398. {                                                                         }
  1399. {*************************************************************************}
  1400. FUNCTION SQLManagerLoaded : BOOLEAN;
  1401. var
  1402.   bstat              : INTEGER;
  1403.  
  1404. begin
  1405.   SQLCODE := 0;
  1406.   SQL_PARMS.stat := -1;
  1407.   SQL_PARMS.fcn  := InvFcn;
  1408.   regs.AX := $3500 + SQL_INT;
  1409.   MsDOS (regs);
  1410.   if (regs.BX <> SQL_OFFSET) then
  1411.     SQLCODE := SQL_MANAGER_NOT_LOADED_ERR
  1412.   else
  1413.     begin
  1414.       with SQL_PARMS, txData do
  1415.        begin
  1416.           btrop         := -1;
  1417.           btrstat.Seg   := Seg (bstat);
  1418.           btrstat.OffSet   := Ofs(bstat);
  1419.           SQLLevelCall;
  1420.        end;
  1421.  
  1422.       if (SQL_PARMS.stat <> InvSQLLevelFcn) then
  1423.         SQLCODE := SQL_MANAGER_NOT_LOADED_ERR
  1424.       else
  1425.         begin
  1426.           if (not VSet) then   { check Version (Network, Multi, Single) }
  1427.             begin
  1428.               VSet := true;
  1429.             end;
  1430.         end;
  1431.     end;
  1432.   SQL_PARMS.stat := SQLCODE;
  1433.   if SQLCODE = 0
  1434.   then  SQLManagerLoaded := True
  1435.   else  SQLManagerLoaded := False;
  1436. end;
  1437.  
  1438.  
  1439. FUNCTION XQLCompile (CURSOR : INTEGER; { cursor id returned from XQLCursor }
  1440.                      VAR LEN    : INTEGER; { length of SQL statement           }
  1441.                      VAR STMNT)
  1442.                     : INTEGER;
  1443. begin
  1444.  if (SQLManagerLoaded) then
  1445.   begin
  1446.     with SQL_PARMS, tcData do
  1447.      begin
  1448.         fcn           := lCompFcn;
  1449.         cursorid      := CURSOR;
  1450.         length        := LEN;
  1451.         statement.Seg := Seg (STMNT);
  1452.         statement.OffSet := Ofs(STMNT);
  1453.  
  1454.         SQLLevelCall;
  1455.  
  1456.         LEN := length;
  1457.         SQLCODE := stat;
  1458.      end;
  1459.   end;
  1460.  XQLCompile := SQLCODE;
  1461. end;    { XQLCompile }
  1462.  
  1463. FUNCTION XQLCursor(
  1464.             VAR CURSOR : INTEGER ) : INTEGER;
  1465. begin
  1466.   if (SQLManagerLoaded) then
  1467.     begin
  1468.       SQL_PARMS.fcn := lCursorFcn;
  1469.       SQL_PARMS.cursorid := -1;
  1470.  
  1471.       SQLLevelCall;
  1472.  
  1473.       CURSOR := SQL_PARMS.cursorid;
  1474.       SQLCODE := SQL_PARMS.stat;
  1475.     end;
  1476.   XQLCursor := SQLCODE;
  1477. end; {XQLCursor }
  1478.  
  1479.    FUNCTION XQLDescribe(
  1480.                CURSOR  : INTEGER;
  1481.                POS     : INTEGER;
  1482.            VAR DTYPE   : INTEGER;
  1483.            VAR SIZE    : INTEGER;
  1484.            VAR DEC     : INTEGER;
  1485.            VAR DSIZE   : INTEGER;
  1486.            VAR NLENGTH : INTEGER;
  1487.            VAR NAME    : CHAR ) : INTEGER;
  1488. begin
  1489.   if (SQLManagerLoaded) then
  1490.     begin
  1491.       {                                                                 }
  1492.       { Set up parameters for Scalable SQL request.                     }
  1493.       {                                                                 }
  1494.       with SQL_PARMS, tdData do
  1495.        begin
  1496.          fcn               := lDescribeFcn;
  1497.          cursorid          := CURSOR;
  1498.          position          := POS;
  1499.          namelength        := NLENGTH;
  1500.          namebuf.Seg       := Seg(NAME);
  1501.          namebuf.OffSet    := Ofs(NAME);
  1502.  
  1503.          SQLLevelCall;
  1504.  
  1505.          DTYPE   := datatype;
  1506.          SIZE    := datasize;
  1507.          DEC     := deccount;
  1508.          DSIZE   := dsize;
  1509.          NLENGTH := namelength;
  1510.          SQLCODE := stat;
  1511.        end;
  1512.     end;
  1513.   XQLDescribe := SQLCODE;
  1514. end;  { XQLDescribe }
  1515.  
  1516.  
  1517. FUNCTION XQLExec (CURSOR : INTEGER) : INTEGER;
  1518. begin
  1519.   if (SQLManagerLoaded) then
  1520.     begin
  1521.       SQL_PARMS.fcn    := lExecFcn;
  1522.       SQL_PARMS.cursorid := CURSOR;
  1523.  
  1524.       SQLLevelCall;
  1525.  
  1526.       SQLCODE := SQL_PARMS.stat;
  1527.     end;
  1528.   XQLExec := SQLCODE;
  1529. end;  { XQLExec }
  1530.  
  1531. FUNCTION XQLFetch     (CURSOR,
  1532.                        OP      : INTEGER;
  1533.                    VAR DLEN    : INTEGER;
  1534.                    VAR BUF;
  1535.                    VAR SEL     : LONGINT;
  1536.                        ASCII,
  1537.                        SPACES  : INTEGER)
  1538.                   : INTEGER;
  1539. begin
  1540.   if (SQLManagerLoaded) then
  1541.     begin
  1542.       {                                                                 }
  1543.       { Set up parameters for Scalable SQL request.                     }
  1544.       {                                                                 }
  1545.       with SQL_PARMS, tfData do
  1546.        begin
  1547.          fcn := lFetchFcn;
  1548.          cursorid := CURSOR;
  1549.          datalen := DLEN;
  1550.          operation := OP;
  1551.          databuf.Seg := Seg (BUF);
  1552.          databuf.OffSet := Ofs(BUF);
  1553.          select := SEL;
  1554.          ASCIIFlag := ASCII;
  1555.          spacing := spaces;
  1556.  
  1557.          SQLLevelCall;
  1558.  
  1559.          DLEN  := datalen;
  1560.          SEL := select;
  1561.          SQLCODE := stat;
  1562.        end;
  1563.     end;
  1564.   XQLFETCH := SQLCODE;
  1565. end;   { XQLFetch }
  1566.  
  1567. FUNCTION XQLFormat (CURSOR,
  1568.                     POS,
  1569.                     LENGTH  : INTEGER;
  1570.                     VAR MASKBUF)
  1571.                    : INTEGER;
  1572. begin
  1573.   if (SQLManagerLoaded) then
  1574.     begin
  1575.       {                                                                 }
  1576.       { Set up parameters for Scalable SQL request.                     }
  1577.       {                                                                 }
  1578.       with SQL_PARMS, tfmData do
  1579.         begin
  1580.           fcn      := lFormatFcn;
  1581.           cursorid := CURSOR;
  1582.           position := POS;
  1583.           masklen  := LENGTH;
  1584.           mask.Seg := Seg (MASKBUF);
  1585.           mask.OffSet := Ofs(MASKBUF);
  1586.  
  1587.           SQLLevelCall;
  1588.  
  1589.           SQLCODE := stat;
  1590.         end;
  1591.     end;
  1592.   XQLFormat := SQLCODE;
  1593. end;  { XQLFormat }
  1594.  
  1595.  
  1596. FUNCTION XQLFree (CURSOR : INTEGER) : INTEGER;
  1597. begin
  1598.   if (SQLManagerLoaded) then
  1599.     begin
  1600.       SQL_PARMS.fcn   := lFreeFcn;
  1601.       SQL_PARMS.cursorid := CURSOR;
  1602.  
  1603.       SQLLevelCall;
  1604.  
  1605.       SQLCODE := SQL_PARMS.stat;
  1606.     end;
  1607.   XQLFree := SQLCODE;
  1608. end;  { XQLFree }
  1609.  
  1610. FUNCTION XQLLogin (VAR USERID,       { User name       }
  1611.                       PSWDNAME,      { User password   }
  1612.                       DD,            { Dictionary path }
  1613.                       DATAPATH,      { Data file path  }
  1614.                       SRES;          { reserved        }
  1615.                       iFeaturesUsed : INTEGER) : INTEGER;
  1616. begin
  1617.   if (SQLManagerLoaded) then
  1618.     begin
  1619.       with SQL_PARMS, tlData do
  1620.         begin
  1621.           fcn := lLogInFcn;
  1622.           cursorid := 0;
  1623.           username.Seg := Seg (USERID);
  1624.           username.OffSet := Ofs(USERID);
  1625.           pswd.Seg := Seg (PSWDNAME);
  1626.           pswd.OffSet := Ofs(PSWDNAME);
  1627.           dictionary.Seg := Seg (DD);
  1628.           dictionary.OffSet := Ofs(DD);
  1629.           filepath.Seg := Seg (DATAPATH);
  1630.           filepath.OffSet := Ofs(DATAPATH);
  1631.           sreserved.Seg := Seg (SRES);
  1632.           sreserved.OffSet := Ofs(SRES);
  1633.           iFeaturesUsedx := iFeaturesUsed;
  1634.  
  1635.           SQLLevelCall;
  1636.  
  1637.          if (stat = 0) then
  1638.            SessID := sessionid;
  1639.          SQLCODE := stat;
  1640.        end;
  1641.     end;
  1642.    XQLLogin := SQLCODE;
  1643. end;  { XQLLogin }
  1644.  
  1645. FUNCTION XQLLogout : INTEGER;
  1646. begin
  1647.   if (SQLManagerLoaded) then
  1648.     begin
  1649.       SQL_PARMS.fcn    := lLogOutFcn;
  1650.  
  1651.       SQLLevelCall;
  1652.  
  1653.       SQLCODE := SQL_PARMS.stat;
  1654.     end;
  1655.   XQLLogout := SQLCODE;
  1656. end;    { XQLLogout }
  1657.  
  1658. FUNCTION XQLStatus (CURSOR,
  1659.                     OPTION  : INTEGER;
  1660.                     VAR STATBUF)
  1661.                    : INTEGER;
  1662. begin
  1663.   if (SQLManagerLoaded) then
  1664.     begin
  1665.       with SQL_PARMS, tstData do
  1666.         begin
  1667.           fcn := lStatFcn;
  1668.           cursorid := CURSOR;
  1669.           subfunction := OPTION;
  1670.           buf.Seg := Seg (STATBUF);
  1671.           buf.OffSet := Ofs(STATBUF);
  1672.  
  1673.           SQLLevelCall;
  1674.  
  1675.           SQLCODE := stat;
  1676.         end;
  1677.     end;
  1678.   XQLStatus := SQLCODE;
  1679. end;  { XQLStatus }
  1680.  
  1681. FUNCTION XQLStop : INTEGER;
  1682. begin
  1683.   if (SQLManagerLoaded) then
  1684.     begin
  1685.       SQL_PARMS.fcn    := lStopFcn;
  1686.  
  1687.       SQLLevelCall;
  1688.  
  1689.       SQLCODE := SQL_PARMS.stat;
  1690.     end;
  1691.   XQLStop := SQLCODE;
  1692. end;  { XQLStop }
  1693.  
  1694.  
  1695. FUNCTION XQLSubst (        CURSOR,
  1696.                            SCOUNT,
  1697.                            NAMELEN : INTEGER;
  1698.                     VAR    VARNAME;
  1699.                            TEXTLEN : INTEGER;
  1700.                     VAR    VARTEXT)
  1701.                   : INTEGER;
  1702. begin
  1703.   if (SQLManagerLoaded) then
  1704.     begin
  1705.       with SQL_PARMS, tsData do
  1706.         begin
  1707.           fcn       := lSubstFcn;
  1708.           cursorid  := CURSOR;
  1709.           count     := SCOUNT;
  1710.           nlen      := NAMELEN;
  1711.           vname.Seg := Seg (VARNAME);
  1712.           vname.OffSet := Ofs(VARNAME);
  1713.           tlen      := TEXTLEN;
  1714.           vtext.Seg := Seg (VARTEXT);
  1715.           vtext.OffSet := Ofs(VARTEXT);
  1716.  
  1717.           SQLLevelCall;
  1718.  
  1719.           SQLCODE := stat;
  1720.         end;
  1721.     end;
  1722.   XQLSubst := SQLCODE;
  1723. end;    { XQLSubst }
  1724.  
  1725. FUNCTION XQLVersion (VAR VBUFFER) : INTEGER;
  1726. begin
  1727.  if (SQLManagerLoaded) then
  1728.    begin
  1729.      with SQL_PARMS, tvData do
  1730.        begin
  1731.          fcn        := lVersFcn;
  1732.          buffer.Seg := Seg (VBUFFER);
  1733.          buffer.OffSet := Ofs(VBUFFER);
  1734.  
  1735.          SQLLevelCall;
  1736.  
  1737.          SQLCODE := stat;
  1738.        end;
  1739.    end;
  1740.   XQLVersion := SQLCODE;
  1741. end;    { XQLVersion }
  1742.  
  1743.  
  1744. FUNCTION XQLConvert (   OPTION,               { 0=>Format, 1=>Unformat    }
  1745.                         DTYPE,                { Data Type for value       }
  1746.                         SIZE,                 { Internal size of value    }
  1747.                         DEC,                  { Decimal places            }
  1748.                         DSIZE    : INTEGER;   { Display size              }
  1749.                     VAR VALUE;                { Value to convert          }
  1750.                     VAR RETVALUE;             { Converted value on return }
  1751.                     VAR MASK;                 { Display mask              }
  1752.                         JUST     : INTEGER)   { Justification             }
  1753.                     : INTEGER;
  1754. begin
  1755.   if (SQLManagerLoaded) then
  1756.     begin
  1757.       {                                                                 }
  1758.       { Set up parameters for Scalable SQL request.                     }
  1759.       {                                                                 }
  1760.  
  1761.       with SQL_PARMS, tcoData do
  1762.         begin
  1763.           fcn          := lConvFcn;
  1764.           convFcn      := OPTION;
  1765.           convType     := DTYPE;
  1766.           convSize     := SIZE;
  1767.           convDec      := DEC;
  1768.           convDSize    := DSIZE;
  1769.           convVal.Seg  := Seg(VALUE);
  1770.           convVal.OffSet  := Ofs(VALUE);
  1771.           convRet.Seg  := Seg(RETVALUE);
  1772.           convRet.OffSet  := Ofs(RETVALUE);
  1773.           convMask.Seg := Seg(MASK);
  1774.           convMask.OffSet := Ofs(MASK);
  1775.           convJust     := JUST;
  1776.  
  1777.           SQLLevelCall;
  1778.  
  1779.         end;
  1780.     end;
  1781.   XQLConvert := SQL_PARMS.stat;
  1782. end;    {  XQLConvert    }
  1783.  
  1784. FUNCTION XQLMask    (   OPTION,               { 0=>Validate, 1=>Default   }
  1785.                         DTYPE,                { Data Type for value       }
  1786.                         SIZE,                 { Internal size of value    }
  1787.                         DEC      : INTEGER;   { Decimal places            }
  1788.                     VAR MLEN     : INTEGER;   { Mask length               }
  1789.                     VAR MASK)                 { Mask value                }
  1790.                     : INTEGER;
  1791. begin
  1792.   if (SQLManagerLoaded) then
  1793.     begin
  1794.  
  1795.       {                                                                 }
  1796.       { Set up parameters for Scalable SQL request.                     }
  1797.       {                                                                 }
  1798.  
  1799.       with SQL_PARMS, tmData do
  1800.         begin
  1801.           fcn         := lMaskFcn;
  1802.           maskOption  := OPTION;
  1803.           maskType    := DTYPE;
  1804.           maskSize    := SIZE;
  1805.           maskDec     := DEC;
  1806.           maskLen     := MLEN;
  1807.           maskVal.Seg := Seg(MASK);
  1808.           maskVal.OffSet := Ofs(MASK);
  1809.  
  1810.           SQLLevelCall;
  1811.  
  1812.           MLEN := maskLen;
  1813.  
  1814.         end;
  1815.     end;
  1816.   XQLMask := SQL_PARMS.stat;
  1817. end;    {  XQLMask    }
  1818.  
  1819.  
  1820. FUNCTION XQLValidate    ( VAR COUNT    : INTEGER;
  1821.                           VAR FIELDNAME;
  1822.                               BUFLEN   : INTEGER;
  1823.                           VAR DATA)
  1824.                                  : INTEGER;
  1825. begin
  1826.   if (SQLManagerLoaded) then
  1827.     begin
  1828.  
  1829.       {                                                                 }
  1830.       { Set up parameters for Scalable SQL request.                     }
  1831.       {                                                                 }
  1832.  
  1833.       with SQL_PARMS, tvaData do
  1834.         begin
  1835.           fcn         := lValFcn;
  1836.           valCount    := COUNT;
  1837.           valField.Seg := Seg(FIELDNAME);
  1838.           valField.OffSet := Ofs(FIELDNAME);
  1839.           valBufLen    := BUFLEN;
  1840.           valData.Seg  := Seg (DATA);
  1841.           valData.OffSet  := Ofs(DATA);
  1842.           SQLLevelCall;
  1843.           COUNT   := valCount;
  1844.  
  1845.         end;
  1846.     end;
  1847.   XQLValidate := SQL_PARMS.stat;
  1848. end;    {  XQLValidate }
  1849.  
  1850. FUNCTION XQLSPUtility (   CURSOR,
  1851.                           OPTION : INTEGER;
  1852.                       VAR STMNTCNT,
  1853.                           STMNTEXEC : INTEGER;
  1854.                       VAR BUFLEN   : INTEGER;   { Buffer length             }
  1855.                       VAR STATBUF)              { Status buffer             }
  1856.                     : INTEGER;
  1857. begin
  1858.   if (SQLManagerLoaded) then
  1859.     begin
  1860.  
  1861.       {                                                                 }
  1862.       { Set up parameters for Scalable SQL request.                     }
  1863.       {                                                                 }
  1864.       with SQL_PARMS, tuData do
  1865.         begin
  1866.           fcn           := lSPUtilFcn;
  1867.           cursorid      := CURSOR;
  1868.           utilOption    := OPTION;
  1869.           utilStmntCnt  := STMNTCNT;
  1870.           utilStmntExec := STMNTEXEC;
  1871.           utilBufLen    := BUFLEN;
  1872.           utilStatBuf.Seg := Seg(STATBUF);
  1873.           utilStatBuf.OffSet := Ofs(STATBUF);
  1874.  
  1875.           SQLLevelCall;
  1876.  
  1877.           STMNTCNT := utilStmntCnt;
  1878.           STMNTEXEC := utilStmntExec;
  1879.           BUFLEN := utilBufLen;
  1880.  
  1881.  
  1882.         end;
  1883.     end;
  1884.   XQLSPUtility := SQL_PARMS.stat;
  1885. end;    {  XQLSPUtility   }
  1886.  
  1887. {$ENDIF} {SQL-Level Function Definitions}
  1888.  
  1889. {$IFDEF SQL_HISTORICAL_FUNCTIONS }
  1890. {************************************************************************
  1891.    Historical APIs
  1892.  ************************************************************************}
  1893. {************************************************************************
  1894.   Dictionary Definition Function Prototypes
  1895.  ************************************************************************}
  1896. FUNCTION xDictionary ( FNCTN,
  1897.                        OPTION      : INTEGER;
  1898.                    VAR FCOUNT      : INTEGER;
  1899.                    VAR FBUF;
  1900.                    VAR BLEN        : INTEGER;
  1901.                        VAR OBUF )  : INTEGER;
  1902.  
  1903. begin
  1904.   if (PrimitivesManagerLoaded) then
  1905.     begin
  1906.  
  1907.       {                                                                 }
  1908.       { Set up parameters for NetWare SQL request.                      }
  1909.       {                                                                 }
  1910.  
  1911.       with RP_PARMS, tddfcnData do
  1912.         begin
  1913.           fcn         := FNCTN;
  1914.           handle      := 0;
  1915.           rtype       := OPTION;
  1916.           count       := FCOUNT;
  1917.           namebuf.Seg := Seg(FBUF);
  1918.           namebuf.OffSet := Ofs(FBUF);
  1919.           buflen      := BLEN;
  1920.           outbuf.Seg  := Seg(OBUF);
  1921.           outbuf.OffSet  := Ofs(OBUF);
  1922.  
  1923.           PrimitiveCall;
  1924.  
  1925.           if (stat >= 0) then
  1926.             begin
  1927.               FCOUNT := count;
  1928.               BLEN   := buflen;
  1929.             end;
  1930.         end;
  1931.     end;
  1932.   xDictionary := RP_PARMS.stat;
  1933. end;
  1934.  
  1935. FUNCTION xDDFile (      OPTION      : INTEGER;
  1936.                     VAR FCOUNT      : INTEGER;{ Number of fields moved  }
  1937.                     VAR FBUF;                 { length of field buffer  }
  1938.                     VAR BLEN        : INTEGER;{ file names and info     }
  1939.                     VAR OBUF)                 { output buffer           }
  1940.                  : INTEGER;
  1941. begin
  1942.   xDDFile := xDictionary (tDDFileFcn, OPTION, FCOUNT, FBUF, BLEN, OBUF);
  1943. end;    {  xDDFile    }
  1944.  
  1945. FUNCTION xDDField (     OPTION      : INTEGER;
  1946.                     VAR FCOUNT      : INTEGER; { Number of fields moved }
  1947.                     VAR FBUF;                  { field names and info   }
  1948.                     VAR BLEN        : INTEGER; { length of field buffer }
  1949.                     VAR OBUF)
  1950.                   : INTEGER;
  1951. begin
  1952.   xDDField := xDictionary (tDDFieldFcn, OPTION, FCOUNT, FBUF, BLEN, OBUF);
  1953. end;    {  xDDField   }
  1954.  
  1955. FUNCTION xDDIndex (     OPTION      : INTEGER; { option                 }
  1956.                     VAR FCOUNT      : INTEGER; { Number of fields       }
  1957.                     VAR FBUF;                  { field names            }
  1958.                     VAR BLEN        : INTEGER; { output buffer length   }
  1959.                     VAR OBUF)                  { output buffer          }
  1960.                   : INTEGER;
  1961. begin
  1962.   xDDIndex := xDictionary (tDDIndexFcn, OPTION, FCOUNT, FBUF, BLEN, OBUF);
  1963. end;    {  xDDIndex   }
  1964.  
  1965. FUNCTION xDDCreate (    OPTION      : INTEGER;
  1966.                     VAR FNAME;
  1967.                         CREATE_FILE : INTEGER;
  1968.                     VAR PATH,
  1969.                         OWNERNAME;
  1970.                         OACC,
  1971.                         FLDCOUNT    : INTEGER;
  1972.                     VAR FLDLIST;
  1973.                         KEYCOUNT    : INTEGER;
  1974.                     VAR KLIST;
  1975.                         BLEN        : INTEGER;
  1976.                     VAR CRPARMS)
  1977.                   : INTEGER;
  1978. begin
  1979.   if (PrimitivesManagerLoaded) then
  1980.     begin
  1981.  
  1982.       {                                                                 }
  1983.       { Set up parameters for Scalable SQL request.                     }
  1984.       {                                                                 }
  1985.  
  1986.       with RP_PARMS, tcreData do
  1987.         begin
  1988.           fcn           := tDDCreFcn;
  1989.           subfunct      := OPTION;
  1990.           filename.Seg  := Seg(FNAME);
  1991.           filename.OffSet  := Ofs(FNAME);
  1992.           create        := CREATE_FILE;
  1993.           pathname.Seg  := Seg(PATH);
  1994.           pathname.OffSet  := Ofs(PATH);
  1995.           owner.Seg     := Seg(OWNERNAME);
  1996.           owner.OffSet     := Ofs(OWNERNAME);
  1997.           oaccess       := OACC;
  1998.           fieldlist.Seg := Seg(FLDLIST);
  1999.           fieldlist.OffSet := Ofs(FLDLIST);
  2000.           keylist.Seg   := Seg(KLIST);
  2001.           keylist.OffSet   := Ofs(KLIST);
  2002.           fcount        := FLDCOUNT;
  2003.           kcount        := KEYCOUNT;
  2004.           buflen        := BLEN;
  2005.           creparms.Seg  := Seg(CRPARMS);
  2006.           creparms.OffSet  := Ofs(CRPARMS);
  2007.  
  2008.           PrimitiveCall;
  2009.         end;
  2010.     end;
  2011.   xDDCreate := RP_PARMS.stat;
  2012. end;     {  xDDCreate   }
  2013.  
  2014. FUNCTION xDDModify (    OPTION      : INTEGER;
  2015.                     VAR FNAME;
  2016.                         CREATE_FILE : INTEGER;
  2017.                     VAR PATH,
  2018.                         OWNERNAME;
  2019.                         OACC,
  2020.                         FLDCOUNT    : INTEGER;
  2021.                     VAR FLDLIST;
  2022.                         KEYCOUNT    : INTEGER;
  2023.                     VAR KLIST)
  2024.                    : INTEGER;
  2025. begin
  2026.   if (PrimitivesManagerLoaded) then
  2027.     begin
  2028.  
  2029.       {                                                                 }
  2030.       { Set up parameters for Scalable SQL request.                     }
  2031.       {                                                                 }
  2032.  
  2033.       with RP_PARMS, tmodData do
  2034.         begin
  2035.           fcn           := tDDModFcn;
  2036.           subfunct      := OPTION;
  2037.           filename.Seg  := Seg(FNAME);
  2038.           filename.OffSet  := Ofs(FNAME);
  2039.           create        := CREATE_FILE;
  2040.           pathname.Seg  := Seg(PATH);
  2041.           pathname.OffSet  := Ofs(PATH);
  2042.           owner.Seg     := Seg(OWNERNAME);
  2043.           owner.OffSet     := Ofs(OWNERNAME);
  2044.           oaccess       := OACC;
  2045.           fieldlist.Seg := Seg(FLDLIST);
  2046.           fieldlist.OffSet := Ofs(FLDLIST);
  2047.           keylist.Seg   := Seg(KLIST);
  2048.           keylist.OffSet   := Ofs(KLIST);
  2049.           fcount        := FLDCOUNT;
  2050.           kcount        := KEYCOUNT;
  2051.  
  2052.           PrimitiveCall;
  2053.         end;
  2054.     end;
  2055.   xDDModify := RP_PARMS.stat;
  2056. end;     {  xDDModify   }
  2057.  
  2058. FUNCTION xDDDrop (  VAR FILENAME;
  2059.                         FILETYPE,
  2060.                         DELETEPATH : INTEGER)
  2061.                  : INTEGER;
  2062. begin
  2063.   if (PrimitivesManagerLoaded) then
  2064.     begin
  2065.  
  2066.       {                                                                 }
  2067.       { Set up parameters for Scalable SQL request.                     }
  2068.       {                                                                 }
  2069.  
  2070.       RP_PARMS.fcn                      := tDDDrpFcn;
  2071.       RP_PARMS.tdddropData.filename.Seg := Seg(FILENAME);
  2072.       RP_PARMS.tdddropData.filename.OffSet := Ofs(FILENAME);
  2073.       RP_PARMS.tdddropData.filetype     := FILETYPE;
  2074.       RP_PARMS.tdddropData.deletepath   := DELETEPATH;
  2075.  
  2076.       PrimitiveCall;
  2077.     end;
  2078.   xDDDrop := RP_PARMS.stat;
  2079. end;     {  xDDDrop     }
  2080.  
  2081. FUNCTION xDDPath (      DIRTYPE  : INTEGER;
  2082.                     VAR PATHNAME)
  2083.                  : INTEGER;
  2084. begin
  2085.   if (PrimitivesManagerLoaded) then
  2086.     begin
  2087.  
  2088.       {                                                                 }
  2089.       { Set up parameters for Scalable SQL request.                     }
  2090.       {                                                                 }
  2091.  
  2092.       RP_PARMS.fcn                      := tDDPathFcn;
  2093.       RP_PARMS.tddpathData.dirtype      := DIRTYPE;
  2094.       RP_PARMS.tddpathData.pathname.Seg := Seg(PATHNAME);
  2095.       RP_PARMS.tddpathData.pathname.OffSet := Ofs(PATHNAME);
  2096.  
  2097.       PrimitiveCall;
  2098.     end;
  2099.   xDDPath := RP_PARMS.stat;
  2100. end;     {  xDDPath     }
  2101.  
  2102. FUNCTION xDDAttr (      OPTION      : INTEGER;
  2103.                     VAR FLDNAME;
  2104.                         ATTRIB      : INTEGER;
  2105.                     VAR BSIZE       : INTEGER;
  2106.                     VAR ABUF)
  2107.                  : INTEGER;
  2108. begin
  2109.   if (PrimitivesManagerLoaded) then
  2110.     begin
  2111.  
  2112.       {                                                                 }
  2113.       { Set up parameters for Scalable SQL request.                     }
  2114.       {                                                                 }
  2115.  
  2116.       with RP_PARMS, tddattrData do
  2117.         begin
  2118.           fcn           := tDDAttrFcn;
  2119.           handle        := 0;
  2120.           subfunct      := OPTION;
  2121.           fieldname.Seg := Seg(FLDNAME);
  2122.           fieldname.OffSet := Ofs(FLDNAME);
  2123.           attr          := ATTRIB;
  2124.           bufsize       := BSIZE;
  2125.           attrbuf.Seg   := Seg(ABUF);
  2126.           attrbuf.OffSet   := Ofs(ABUF);
  2127.  
  2128.           PrimitiveCall;
  2129.  
  2130.           BSIZE := bufsize;
  2131.         end;
  2132.     end;
  2133.   xDDAttr := RP_PARMS.stat;
  2134. end;     {  xDDAttr    }
  2135.  
  2136. FUNCTION xDD (   VAR DIRPATH;
  2137.                      FNCTION : INTEGER)
  2138.              : INTEGER;
  2139. begin
  2140.   if (PrimitivesManagerLoaded) then
  2141.     begin
  2142.  
  2143.       {                                                                 }
  2144.       { Set up parameters for Scalable SQL request.                     }
  2145.       {                                                                 }
  2146.  
  2147.       RP_PARMS.fcn                     := tDDFcn;
  2148.       RP_PARMS.tddData.dirpath.Seg     := Seg(DIRPATH);
  2149.       RP_PARMS.tddData.dirpath.OffSet     := Ofs(DIRPATH);
  2150.       RP_PARMS.tddData.fnction         := FNCTION;
  2151.  
  2152.       PrimitiveCall;
  2153.  
  2154.     end;
  2155.   xDD := RP_PARMS.stat;
  2156. end;     {  xDD         }
  2157.  
  2158. FUNCTION xDDView (  VAR FCOUNT : INTEGER;
  2159.                     VAR VNAME;
  2160.                     VAR BLEN   : INTEGER;
  2161.                     VAR OBUF)
  2162.                  : INTEGER;
  2163. begin
  2164.   if (PrimitivesManagerLoaded) then
  2165.     begin
  2166.  
  2167.       {                                                                 }
  2168.       { Set up parameters for Scalable SQL request.                     }
  2169.       {                                                                 }
  2170.  
  2171.       with RP_PARMS, tddviewData do
  2172.         begin
  2173.           fcn          := tDDViewFcn;
  2174.           handle       := 0;
  2175.           count        := FCOUNT;
  2176.           viewname.Seg := Seg(VNAME);
  2177.           viewname.OffSet := Ofs(VNAME);
  2178.           buflen       := BLEN;
  2179.           outbuf.Seg   := Seg(OBUF);
  2180.           outbuf.OffSet   := Ofs(OBUF);
  2181.  
  2182.           PrimitiveCall;
  2183.  
  2184.           if (stat >= 0) then
  2185.             begin
  2186.               FCOUNT := count;
  2187.               BLEN := buflen;
  2188.             end;
  2189.         end;
  2190.     end;
  2191.   xDDView := RP_PARMS.stat;
  2192. end;    {  xDDView    }
  2193.  
  2194. {************************************************************************
  2195.                       Security Primitives
  2196.  ************************************************************************}
  2197.  
  2198. FUNCTION xSecurity (VAR MPSWD;
  2199.                         FLAG  : INTEGER)
  2200.                    : INTEGER;
  2201. begin
  2202.   if (PrimitivesManagerLoaded) then
  2203.     begin
  2204.  
  2205.       {                                                                 }
  2206.       { Set up parameters for Scalable SQL request.                     }
  2207.       {                                                                 }
  2208.  
  2209.       RP_PARMS.fcn                      := tSecurFcn;
  2210.       RP_PARMS.handle                   := 0;
  2211.       RP_PARMS.tsecureData.mpswd.Seg    := Seg(MPSWD);
  2212.       RP_PARMS.tsecureData.mpswd.OffSet    := Ofs(MPSWD);
  2213.       RP_PARMS.tsecureData.securityflag := FLAG;
  2214.  
  2215.       PrimitiveCall;
  2216.     end;
  2217.   xSecurity := RP_PARMS.stat;
  2218. end;     {  xSecurity  }
  2219.  
  2220. FUNCTION xUser (VAR MASTERPSWD;
  2221.                     OPTION      : INTEGER;
  2222.                 VAR UNAME,
  2223.                     PASSWORD;
  2224.                     UGRIGHTS    : INTEGER;
  2225.                 VAR FCOUNT,
  2226.                     BLEN        : INTEGER;
  2227.                 VAR UBUF)
  2228.                : INTEGER;
  2229. begin
  2230.   if (PrimitivesManagerLoaded) then
  2231.     begin
  2232.  
  2233.       {                                                                 }
  2234.       { Set up parameters for Scalable SQL request.                     }
  2235.       {                                                                 }
  2236.  
  2237.       with RP_PARMS, tuserData do
  2238.         begin
  2239.           fcn          := tUserFcn;
  2240.           handle       := 0;
  2241.           mpswd.Seg    := Seg(MASTERPSWD);
  2242.           mpswd.OffSet    := Ofs(MASTERPSWD);
  2243.           subfcn       := OPTION;
  2244.           username.Seg := Seg(UNAME);
  2245.           username.OffSet := Ofs(UNAME);
  2246.           pswd.Seg     := Seg(PASSWORD);
  2247.           pswd.OffSet     := Ofs(PASSWORD);
  2248.           grights      := UGRIGHTS;
  2249.           count        := FCOUNT;
  2250.           buflen       := BLEN;
  2251.           userbuf.Seg  := Seg(UBUF);
  2252.           userbuf.OffSet  := Ofs(UBUF);
  2253.  
  2254.           PrimitiveCall;
  2255.  
  2256.           FCOUNT  := count;
  2257.           BLEN    := buflen;
  2258.         end;
  2259.     end;
  2260.   xUser := RP_PARMS.stat;
  2261. end;     {  xUser    }
  2262.  
  2263. FUNCTION xAccess (  VAR MASTERPSWD,
  2264.                         UNAME;
  2265.                         OPTION,
  2266.                         ARIGHTS      : INTEGER;
  2267.                     VAR FNAME;
  2268.                     VAR FCOUNT      : INTEGER;
  2269.                     VAR FIELDNAME;
  2270.                     VAR BLEN        : INTEGER;
  2271.                     VAR OBUF)
  2272.                  : INTEGER;
  2273. begin
  2274.   if (PrimitivesManagerLoaded) then
  2275.     begin
  2276.  
  2277.       {                                                                 }
  2278.       { Set up parameters for Scalable SQL request.                     }
  2279.       {                                                                 }
  2280.  
  2281.       with RP_PARMS, taccessData do
  2282.         begin
  2283.           fcn          := tAccessFcn;
  2284.           handle       := 0;
  2285.           mpswd.Seg    := Seg(MASTERPSWD);
  2286.           mpswd.OffSet    := Ofs(MASTERPSWD);
  2287.           username.Seg := Seg(UNAME);
  2288.           username.OffSet := Ofs(UNAME);
  2289.           subfcn       := OPTION;
  2290.           rights       := ARIGHTS;
  2291.           filename.Seg := Seg(FNAME);
  2292.           filename.OffSet := Ofs(FNAME);
  2293.           count        := FCOUNT;
  2294.           name.Seg     := Seg(FIELDNAME);
  2295.           name.OffSet     := Ofs(FIELDNAME);
  2296.           buflen       := BLEN;
  2297.           outbuf.Seg   := Seg(OBUF);
  2298.           outbuf.OffSet   := Ofs(OBUF);
  2299.  
  2300.           PrimitiveCall;
  2301.  
  2302.           if (stat = 0) then
  2303.             begin
  2304.               FCOUNT := count;
  2305.               BLEN   := buflen;
  2306.             end;
  2307.         end;
  2308.     end;
  2309.   xAccess := RP_PARMS.stat;
  2310. end;     {  xAccess    }
  2311.  
  2312. FUNCTION xPassword (VAR UNAME,
  2313.                         PASSWORD)
  2314.                    : INTEGER;
  2315. begin
  2316.   if (PrimitivesManagerLoaded) then
  2317.     begin
  2318.  
  2319.       {                                                                 }
  2320.       { Set up parameters for Scalable SQL request.                     }
  2321.       {                                                                 }
  2322.  
  2323.       with RP_PARMS, tpswdData do
  2324.         begin
  2325.           fcn      := tPswdFcn;
  2326.           handle   := 0;
  2327.           user.Seg := Seg(UNAME);
  2328.           user.OffSet := Ofs(UNAME);
  2329.           pswd.Seg := Seg(PASSWORD);
  2330.           pswd.OffSet := Ofs(PASSWORD);
  2331.  
  2332.           PrimitiveCall;
  2333.         end;
  2334.     end;
  2335.   xPassword := RP_PARMS.stat;
  2336. end;     {  xPassword  }
  2337.  
  2338. {************************************************************************
  2339.                       Miscellaneous Primitives
  2340.  ************************************************************************}
  2341.  
  2342. FUNCTION xChar(
  2343.             CHARFCN  : INTEGER;
  2344.             CHARTYPE : INTEGER;
  2345.         VAR VALUE    : CHAR ) : INTEGER;
  2346. begin
  2347.   if (PrimitivesManagerLoaded) then
  2348.     begin
  2349.  
  2350.       {                                                                 }
  2351.       { Set up parameters for Scalable SQL request.                     }
  2352.       {                                                                 }
  2353.  
  2354.       RP_PARMS.fcn                 := tCharFcn;
  2355.       RP_PARMS.tcharData.charFcn   := CHARFCN;
  2356.       RP_PARMS.tcharData.charType  := CHARTYPE;
  2357.       RP_PARMS.tcharData.charValue := ORD (VALUE);
  2358.  
  2359.       PrimitiveCall;
  2360.     end;
  2361.   xChar := RP_PARMS.stat;
  2362. end;    {  xChar    }
  2363.  
  2364. FUNCTION xVersion  (VAR BUFFER) : INTEGER;
  2365. begin
  2366.   if (PrimitivesManagerLoaded) then
  2367.     begin
  2368.  
  2369.       {                                                                 }
  2370.       { Set up parameters for Scalable SQL request.                     }
  2371.       {                                                                 }
  2372.  
  2373.       RP_PARMS.fcn                     := tVersionFcn;
  2374.       RP_PARMS.tversionData.buffer.Seg := Seg(BUFFER);
  2375.       RP_PARMS.tversionData.buffer.OffSet := Ofs(BUFFER);
  2376.  
  2377.       PrimitiveCall;
  2378.     end;
  2379.   xVersion := RP_PARMS.stat;
  2380. end;    {  xVersion    }
  2381.  
  2382.  
  2383. FUNCTION xConvert (     OPTION,               { 0=>Format, 1=>Unformat    }
  2384.                         DTYPE,                { Data Type for value       }
  2385.                         SIZE,                 { Internal size of value    }
  2386.                         DEC,                  { Decimal places            }
  2387.                         DSIZE    : INTEGER;   { Display size              }
  2388.                     VAR VALUE;                { Value to convert          }
  2389.                     VAR RETVALUE;             { Converted value on return }
  2390.                     VAR MASK;                 { Display mask              }
  2391.                         JUST     : INTEGER)   { Justification             }
  2392.                     : INTEGER;
  2393. begin
  2394.   if (PrimitivesManagerLoaded) then
  2395.     begin
  2396.  
  2397.       {                                                                 }
  2398.       { Set up parameters for Scalable SQL request.                     }
  2399.       {                                                                 }
  2400.  
  2401.       with RP_PARMS, tconvertData do
  2402.         begin
  2403.           fcn         := tConvertFcn;
  2404.           convFcn     := OPTION;
  2405.           convType    := DTYPE;
  2406.           convSize    := SIZE;
  2407.           convDec     := DEC;
  2408.           convDSize   := DSIZE;
  2409.           convVal.Seg := Seg(VALUE);
  2410.           convVal.OffSet := Ofs(VALUE);
  2411.           convRet.Seg := Seg(RETVALUE);
  2412.           convRet.OffSet := Ofs(RETVALUE);
  2413.           convMask.Seg := Seg (MASK);
  2414.           convMask.OffSet := Ofs(MASK);
  2415.           convJust     := JUST;
  2416.           PrimitiveCall;
  2417.  
  2418.         end;
  2419.     end;
  2420.   xConvert := RP_PARMS.stat;
  2421. end;    {  xConvert    }
  2422.  
  2423. FUNCTION xMask    (     OPTION,               { 0=>Validate, 1=>Default   }
  2424.                         DTYPE,                { Data Type for value       }
  2425.                         SIZE,                 { Internal size of value    }
  2426.                         DEC      : INTEGER;   { Decimal places            }
  2427.                     VAR MLEN     : INTEGER;   { Mask length               }
  2428.                     VAR MASK)                 { Mask value                }
  2429.                     : INTEGER;
  2430. begin
  2431.   if (PrimitivesManagerLoaded) then
  2432.     begin
  2433.  
  2434.       {                                                                 }
  2435.       { Set up parameters for Scalable SQL request.                     }
  2436.       {                                                                 }
  2437.  
  2438.       with RP_PARMS, tmaskData do
  2439.         begin
  2440.           fcn         := tMaskFcn;
  2441.           maskFcn     := OPTION;
  2442.           maskType    := DTYPE;
  2443.           maskSize    := SIZE;
  2444.           maskDec     := DEC;
  2445.           maskLen     := MLEN;
  2446.           maskVal.Seg := Seg(MASK);
  2447.           maskVal.OffSet := Ofs(MASK);
  2448.  
  2449.           PrimitiveCall;
  2450.  
  2451.           MLEN := maskLen;
  2452.  
  2453.         end;
  2454.     end;
  2455.   xMask := RP_PARMS.stat;
  2456. end;    {  xMask    }
  2457.  
  2458.  
  2459. FUNCTION xValidate  ( VAR COUNT    : INTEGER;
  2460.                     VAR FIELDNAME;
  2461.                         BUFLEN     : INTEGER;
  2462.                     VAR DATA)
  2463.                     : INTEGER;
  2464. begin
  2465.   if (PrimitivesManagerLoaded) then
  2466.     begin
  2467.  
  2468.       {                                                                 }
  2469.       { Set up parameters for Scalable SQL request.                     }
  2470.       {                                                                 }
  2471.  
  2472.       with RP_PARMS, tvalidData do
  2473.         begin
  2474.           fcn         := tValidFcn;
  2475.           valCount    := COUNT;
  2476.           valField.Seg := Seg(FIELDNAME);
  2477.           valField.OffSet := Ofs(FIELDNAME);
  2478.           valBufLen    := BUFLEN;
  2479.           valData.Seg  := Seg (DATA);
  2480.           valData.OffSet  := Ofs (DATA);
  2481.           PrimitiveCall;
  2482.           COUNT := valCount;
  2483.  
  2484.         end;
  2485.     end;
  2486.   xValidate := RP_PARMS.stat;
  2487. end;    {  xValidate }
  2488.  
  2489. {************************************************************************
  2490.                         Data Manipulation Primitives
  2491.  ************************************************************************}
  2492. FUNCTION xLogin (   VAR USERID,              { user name                }
  2493.                         PASSWORD,            { user password            }
  2494.                         DPATH,               { dictionary directory     }
  2495.                         FPATH,               { file path directory      }
  2496.                         SRES;                { reserved variable        }
  2497.                         iFeaturesUsed : INTEGER) : INTEGER;
  2498. begin
  2499.   if (PrimitivesManagerLoaded) then
  2500.     begin
  2501.  
  2502.       {                                                                 }
  2503.       { Set up parameters for Scalable SQL request.                     }
  2504.       {                                                                 }
  2505.  
  2506.       with RP_PARMS, tloginData do
  2507.         begin
  2508.           fcn            := tLogInFcn;
  2509.           handle         := 0;
  2510.           username.Seg   := Seg(USERID);
  2511.           username.OffSet   := Ofs(USERID);
  2512.           pswd.Seg       := Seg(PASSWORD);
  2513.           pswd.OffSet       := Ofs(PASSWORD);
  2514.           dictionary.Seg := Seg(DPATH);
  2515.           dictionary.OffSet := Ofs(DPATH);
  2516.           filepath.Seg   := Seg(FPATH);
  2517.           filepath.OffSet   := Ofs(FPATH);
  2518.           sreserved.Seg  := Seg(SRES);
  2519.           sreserved.OffSet  := Ofs(SRES);
  2520.           iFeaturesUsedx    := iFeaturesUsed;
  2521.  
  2522.           PrimitiveCall;
  2523.  
  2524.           if (stat = 0) then
  2525.             SessID := sessionid;
  2526.         end;
  2527.     end;
  2528.   xLogin := RP_PARMS.stat;
  2529. end;     {  xLogin  }
  2530.  
  2531. FUNCTION xLogout : INTEGER;
  2532. begin
  2533.   if (PrimitivesManagerLoaded) then
  2534.     begin
  2535.  
  2536.       {                                                                 }
  2537.       { Set up parameters for Scalable SQL request.                     }
  2538.       {                                                                 }
  2539.  
  2540.       RP_PARMS.fcn    := tLogOutFcn;
  2541.       RP_PARMS.handle := 0;
  2542.  
  2543.       PrimitiveCall;
  2544.  
  2545.     end;
  2546.   xLogout := RP_PARMS.stat;
  2547. end;    {  xLogout  }
  2548.  
  2549. FUNCTION xNew ( VAR VHANDLE  : INTEGER;                 {  view handle  }
  2550.                 VAR FNAME,                       { Dictionary file name }
  2551.                     OWNERNAME;                     { Btrieve owner name }
  2552.                     MODE : INTEGER)                 { btrieve open mode }
  2553.               : INTEGER;
  2554. begin
  2555.   if (PrimitivesManagerLoaded) then
  2556.     begin
  2557.  
  2558.       {                                                                 }
  2559.       { Set up parameters for Scalable SQL request.                     }
  2560.       {                                                                 }
  2561.  
  2562.       with RP_PARMS, tnewData do
  2563.         begin
  2564.           fcn          := tNewFcn;
  2565.           handle       := VHANDLE;
  2566.           filename.Seg := Seg(FNAME);
  2567.           filename.OffSet := Ofs(FNAME);
  2568.           owner.Seg    := Seg(OWNERNAME);
  2569.           owner.OffSet    := Ofs(OWNERNAME);
  2570.           openmode     := MODE;
  2571.  
  2572.           PrimitiveCall;
  2573.  
  2574.           if (stat = 0) then
  2575.             VHANDLE := handle;
  2576.         end;
  2577.     end;
  2578.   xNew := RP_PARMS.stat;
  2579. end;     {  xNew  }
  2580.  
  2581. FUNCTION xFree (VHANDLE : INTEGER)                         { view handle }
  2582.                : INTEGER;
  2583. begin
  2584.   if (PrimitivesManagerLoaded) then
  2585.     begin
  2586.  
  2587.       {                                                                 }
  2588.       { Set up parameters for Scalable SQL request.                     }
  2589.       {                                                                 }
  2590.  
  2591.       RP_PARMS.fcn    := tFreeFcn;
  2592.       RP_PARMS.handle := VHANDLE;
  2593.  
  2594.       PrimitiveCall;
  2595.  
  2596.     end;
  2597.   xFree := RP_PARMS.stat;
  2598. end;    {  xFree   }
  2599.  
  2600. FUNCTION xField (       VHANDLE,               { view handle            }
  2601.                         SUBF,                  { ADD/DELETE field       }
  2602.                         POS     : INTEGER;     { field position in list }
  2603.                     VAR CNT     : INTEGER;     { # of fields in buffer  }
  2604.                     VAR BUF)                   { field name buffer      }
  2605.                     : INTEGER;
  2606. begin
  2607.   if (PrimitivesManagerLoaded) then
  2608.     begin
  2609.  
  2610.       {                                                                 }
  2611.       { Set up parameters for Scalable SQL request.                     }
  2612.       {                                                                 }
  2613.  
  2614.       with RP_PARMS, tfldData do
  2615.         begin
  2616.           fcn         := tFieldFcn;
  2617.           handle      := VHANDLE;
  2618.           option      := SUBF;
  2619.           position    := POS;
  2620.           count       := CNT;
  2621.           fldlist.Seg := Seg(BUF);
  2622.           fldlist.OffSet := Ofs(BUF);
  2623.  
  2624.           PrimitiveCall;
  2625.  
  2626.           if (stat >= 0) then
  2627.             CNT := count;
  2628.         end;
  2629.     end;
  2630.   xField := RP_PARMS.stat;
  2631. end;    {  xField    }
  2632.  
  2633. FUNCTION xMovefld (     VHANDLE,               { view handle            }
  2634.                         FPOS,                  { current field position }
  2635.                         TPOS    : INTEGER)     { new field position     }
  2636.                   : INTEGER;
  2637. begin
  2638.   if (PrimitivesManagerLoaded) then
  2639.     begin
  2640.  
  2641.       {                                                                 }
  2642.       { Set up parameters for Scalable SQL request.                     }
  2643.       {                                                                 }
  2644.  
  2645.       with RP_PARMS, tmovData do
  2646.         begin
  2647.           fcn     := tMoveFldFcn;
  2648.           handle  := VHANDLE;
  2649.           frompos := FPOS;
  2650.           topos   := TPOS;
  2651.  
  2652.           PrimitiveCall;
  2653.         end;
  2654.     end;
  2655.   xMovefld := RP_PARMS.stat;
  2656. end;    {  xMovefld   }
  2657.  
  2658. FUNCTION xDescribe (        VHANDLE : INTEGER; { view handle             }
  2659.                             SUBF    : INTEGER; { option                  }
  2660.                         VAR DLEN    : INTEGER; { description buffer len  }
  2661.                             POS     : INTEGER; { position in field list  }
  2662.                         VAR CNT     : INTEGER; { number of fields        }
  2663.                         VAR BUF)               { output buffer           }
  2664.                                 : INTEGER;
  2665. begin
  2666.   if (PrimitivesManagerLoaded) then
  2667.     begin
  2668.  
  2669.       {                                                                 }
  2670.       { Set up parameters for Scalable SQL request.                     }
  2671.       {                                                                 }
  2672.  
  2673.       with RP_PARMS, tdescData do
  2674.         begin
  2675.           fcn             := tDescribeFcn;
  2676.           handle          := VHANDLE;
  2677.           option          := SUBF;
  2678.           desclen         := DLEN;
  2679.           position        := POS;
  2680.           count           := CNT;
  2681.           desclist.OffSet := Ofs(BUF);
  2682.           desclist.Seg    := Seg(BUF);
  2683.  
  2684.           PrimitiveCall;
  2685.  
  2686.           DLEN := desclen;
  2687.           CNT  := count;
  2688.         end;
  2689.     end;
  2690.   xDescribe := RP_PARMS.stat;
  2691. end;    {  xDescribe   }
  2692.  
  2693. FUNCTION xFetch (       VHANDLE : INTEGER;       { view handle          }
  2694.                     VAR DLEN    : INTEGER;       { output buffer length }
  2695.                         FETCH_OP: INTEGER;       { option               }
  2696.                     VAR SELCNT,                  { max select count     }
  2697.                         REJCNT  : LONGINT;       { max reject count     }
  2698.                     VAR BUF)                     { output buffer        }
  2699.                  : INTEGER;
  2700. begin
  2701.   if (PrimitivesManagerLoaded) then
  2702.     begin
  2703.  
  2704.       {                                                                 }
  2705.       { Set up parameters for Scalable SQL request.                     }
  2706.       {                                                                 }
  2707.  
  2708.       with RP_PARMS, tfetchData do
  2709.         begin
  2710.           fcn          := tFetchFcn;
  2711.           handle       := VHANDLE;
  2712.           datalen      := DLEN;
  2713.           op           := FETCH_OP;
  2714.           select       := SELCNT;
  2715.           reject       := REJCNT;
  2716.           databuf.Seg  := Seg(BUF);
  2717.           databuf.OffSet  := Ofs(BUF);
  2718.  
  2719.           PrimitiveCall;
  2720.  
  2721.           DLEN    := datalen;
  2722.           SELCNT  := select;
  2723.           REJCNT  := reject;
  2724.         end;
  2725.     end;
  2726.   xFetch := RP_PARMS.stat;
  2727. end;    {  xFetch      }
  2728.  
  2729. FUNCTION xCompute (         VHANDLE  : INTEGER; { view handle           }
  2730.                         VAR FNAME;              { expression field name }
  2731.                             DATA_TYPE,          { field data type       }
  2732.                             DATA_SIZE,          { internal size         }
  2733.                             DEC      : INTEGER; { decimal places        }
  2734.                         VAR ELEN     : INTEGER; { length of expression  }
  2735.                         VAR EBUF)               { buffer for expression }
  2736.                                    : INTEGER;
  2737. begin
  2738.   if (PrimitivesManagerLoaded) then
  2739.     begin
  2740.  
  2741.       {                                                                 }
  2742.       { Set up parameters for Scalable SQL request.                     }
  2743.       {                                                                 }
  2744.  
  2745.       with RP_PARMS, tcompData do
  2746.         begin
  2747.           fcn         := tComputeFcn;
  2748.           handle      := VHANDLE;
  2749.           fldname.OffSet := Ofs(FNAME);
  2750.           fldname.Seg := Seg(FNAME);
  2751.           fldtype     := DATA_TYPE;
  2752.           fldsize     := DATA_SIZE;
  2753.           flddec      := DEC;
  2754.           explen      := ELEN;
  2755.           expbuf.OffSet  := Ofs(EBUF);
  2756.           expbuf.Seg  := Seg(EBUF);
  2757.  
  2758.           PrimitiveCall;
  2759.  
  2760.           if (stat >= 0) then
  2761.             ELEN := explen;
  2762.         end;
  2763.     end;
  2764.   xCompute := RP_PARMS.stat;
  2765. end;                            {  xCompute  }
  2766.  
  2767. FUNCTION xOrder (       VHANDLE,            { view handle               }
  2768.                         CNT  : INTEGER;     { count of fields in list   }
  2769.                     VAR BUF)                { fields which define order }
  2770.                 : INTEGER;
  2771. begin
  2772.   if (PrimitivesManagerLoaded) then
  2773.     begin
  2774.  
  2775.       {                                                                 }
  2776.       { Set up parameters for Scalable SQL request.                     }
  2777.       {                                                                 }
  2778.  
  2779.       with RP_PARMS, tordData do
  2780.         begin
  2781.           fcn         := tOrderFcn;
  2782.           handle      := VHANDLE;
  2783.           count       := CNT;
  2784.           fldlist.Seg := Seg(BUF);
  2785.           fldlist.OffSet := Ofs(BUF);
  2786.  
  2787.           PrimitiveCall;
  2788.         end;
  2789.     end;
  2790.   xOrder := RP_PARMS.stat;
  2791. end;    {  xOrder     }
  2792.  
  2793. FUNCTION xRestrict (    VHANDLE,              { view handle             }
  2794.                         NEW_EXP : INTEGER;    { new/continue expr.      }
  2795.                     VAR ELEN    : INTEGER;    { length of expression    }
  2796.                     VAR EBUF)                 { ASCII expression buffer }
  2797.                    : INTEGER;
  2798. begin
  2799.   if (PrimitivesManagerLoaded) then
  2800.     begin
  2801.  
  2802.       {                                                                 }
  2803.       { Set up parameters for Scalable SQL request.                     }
  2804.       {                                                                 }
  2805.  
  2806.       with RP_PARMS, trestData do
  2807.         begin
  2808.           fcn        := tRestrictFcn;
  2809.           handle     := VHANDLE;
  2810.           newexp     := NEW_EXP;
  2811.           explen     := ELEN;
  2812.           expbuf.Seg := Seg(EBUF);
  2813.           expbuf.OffSet := Ofs(EBUF);
  2814.  
  2815.           PrimitiveCall;
  2816.  
  2817.           if (stat >= 0) then
  2818.             ELEN := explen;
  2819.         end;
  2820.     end;
  2821.   xRestrict := RP_PARMS.stat;
  2822. end;    {  xRestrict  }
  2823.  
  2824. FUNCTION xJoin (    VHANDLE  : INTEGER; { view handle                   }
  2825.                 VAR NEWFILE,            { file to join to view          }
  2826.                     OWNERNAME;          { owner for new file            }
  2827.                     JTYPE,              { include nulls?                }
  2828.                     VCOUNT   : INTEGER; { # of fields from current view }
  2829.                 VAR VNAMES;             { field list from current view  }
  2830.                     NCOUNT   : INTEGER; { # of fields from new file     }
  2831.                 VAR NNAMES)             { field list from new file      }
  2832.                : INTEGER;
  2833. begin
  2834.   if (PrimitivesManagerLoaded) then
  2835.     begin
  2836.  
  2837.       {                                                                 }
  2838.       { Set up parameters for Scalable SQL request.                     }
  2839.       {                                                                 }
  2840.  
  2841.       with RP_PARMS, tjoinData do
  2842.         begin
  2843.           fcn          := tJoinFcn;
  2844.           handle       := VHANDLE;
  2845.           joinType     := JTYPE;
  2846.           filename.Seg := Seg(NEWFILE);
  2847.           filename.OffSet := Ofs(NEWFILE);
  2848.           owner.Seg    := Seg(OWNERNAME);
  2849.           owner.OffSet    := Ofs(OWNERNAME);
  2850.           pCount       := VCOUNT;
  2851.           pNames.Seg   := Seg(VNAMES);
  2852.           pNames.OffSet   := Ofs(VNAMES);
  2853.           sCount       := NCOUNT;
  2854.           sNames.Seg   := Seg(NNAMES);
  2855.           sNames.OffSet   := Ofs(NNAMES);
  2856.  
  2857.           PrimitiveCall;
  2858.         end;
  2859.     end;
  2860.   xJoin := RP_PARMS.stat;
  2861. end;     {  xJoin  }
  2862.  
  2863. FUNCTION xEdit (    FNCTN,                      { edit function         }
  2864.                     VHANDLE : INTEGER;          { view handle           }
  2865.                 VAR COUNT   : INTEGER;          { file count            }
  2866.                 VAR FILES;                      { file list for insert  }
  2867.                 VAR EDITCNT : LONGINT;          { # rows to insert      }
  2868.                 VAR BUFFER)                     { insert row buffer     }
  2869.                  : INTEGER;
  2870. begin
  2871.   if (PrimitivesManagerLoaded) then
  2872.     begin
  2873.  
  2874.       {                                                                 }
  2875.       { Set up parameters for Scalable SQL request.                     }
  2876.       {                                                                 }
  2877.  
  2878.       with RP_PARMS, teditData do
  2879.         begin
  2880.           fcn          := FNCTN;
  2881.           handle       := VHANDLE;
  2882.           filecount    := COUNT;
  2883.           filelist.Seg := Seg(FILES);
  2884.           filelist.OffSet := Ofs(FILES);
  2885.           cnt          := EDITCNT;
  2886.           buf.Seg      := Seg(BUFFER);
  2887.           buf.OffSet      := Ofs(BUFFER);
  2888.  
  2889.           PrimitiveCall;
  2890.  
  2891.           EDITCNT := cnt;
  2892.           COUNT   := filecount;
  2893.         end;
  2894.     end;
  2895.   xEdit := RP_PARMS.stat;
  2896. end;    {  xEdit    }
  2897.  
  2898. FUNCTION xInsert (      VHANDLE : INTEGER;     { view handle            }
  2899.                     VAR COUNT   : INTEGER;   { # of files in list       }
  2900.                     VAR FILES;               { list of files to update  }
  2901.                     VAR EDITCNT : LONGINT;   { # of rows to update      }
  2902.                     VAR BUFFER)              { updated row buffer       }
  2903.                  : INTEGER;
  2904. begin
  2905.   xInsert := xEdit (tInsertFcn, VHANDLE, COUNT, FILES, EDITCNT, BUFFER);
  2906. end;
  2907.  
  2908. FUNCTION xUpdate (      VHANDLE : INTEGER;     { view handle            }
  2909.                     VAR COUNT   : INTEGER;   { # of files in list       }
  2910.                     VAR FILES;               { list of files to update  }
  2911.                     VAR EDITCNT : LONGINT;   { # of rows to update      }
  2912.                     VAR BUFFER)              { updated row buffer       }
  2913.                  : INTEGER;
  2914. begin
  2915.   xUpdate := xEdit (tUpdateFcn, VHANDLE, COUNT, FILES, EDITCNT, BUFFER);
  2916. end;
  2917.  
  2918. FUNCTION xUpdall (      VHANDLE   : INTEGER; { view handle                }
  2919.                     VAR UPDCOUNT  : INTEGER; { count of files to update   }
  2920.                     VAR FILES;               { list of files to update    }
  2921.                         UOP       : INTEGER; { option                     }
  2922.                     VAR SELCNT,              { maximum rows to update     }
  2923.                         REJCNT    : LONGINT; { maximum rows to reject     }
  2924.                         COLCNT    : INTEGER; { # of fields to update      }
  2925.                     VAR RESULT,
  2926.                         COMPARE)
  2927.                  : INTEGER;
  2928. begin
  2929.   if (PrimitivesManagerLoaded) then
  2930.     begin
  2931.  
  2932.       {                                                                 }
  2933.       { Set up parameters for Scalable SQL request.                     }
  2934.       {                                                                 }
  2935.  
  2936.       with RP_PARMS, tupdallData do
  2937.         begin
  2938.           fcn          := tUpdallFcn;
  2939.           handle       := VHANDLE;
  2940.           filecount    := UPDCOUNT;
  2941.           filelist.Seg := Seg(FILES);
  2942.           filelist.OffSet := Ofs(FILES);
  2943.           op           := UOP;
  2944.           select       := SELCNT;
  2945.           reject       := REJCNT;
  2946.           count        := COLCNT;
  2947.           res.Seg      := Seg(RESULT);
  2948.           res.OffSet      := Ofs(RESULT);
  2949.           comp.Seg     := Seg(COMPARE);
  2950.           comp.OffSet     := Ofs(COMPARE);
  2951.  
  2952.           PrimitiveCall;
  2953.  
  2954.           SELCNT := select;
  2955.           REJCNT := reject;
  2956.           UPDCOUNT  := filecount;
  2957.         end;
  2958.     end;
  2959.   xUpdall := RP_PARMS.stat;
  2960. end;    {  xUpdall     }
  2961.  
  2962. FUNCTION xRemove (      VHANDLE : INTEGER;    { view handle             }
  2963.                     VAR COUNT   : INTEGER;  { count of files in list    }
  2964.                     VAR FILES;              { list of files for remove  }
  2965.                     VAR EDITCNT : LONGINT)  { # of rows removed         }
  2966.                  : INTEGER;
  2967. begin
  2968.   if (PrimitivesManagerLoaded) then
  2969.     begin
  2970.  
  2971.       {                                                                 }
  2972.       { Set up parameters for Scalable SQL request.                     }
  2973.       {                                                                 }
  2974.  
  2975.       with RP_PARMS, teditData do
  2976.         begin
  2977.           fcn          := tRemoveFcn;
  2978.           handle       := VHANDLE;
  2979.           filecount    := COUNT;
  2980.           filelist.Seg := Seg(FILES);
  2981.           filelist.OffSet := Ofs(FILES);
  2982.           cnt          := EDITCNT;
  2983.           buf.Seg      := 0;
  2984.           buf.OffSet      := 0;
  2985.  
  2986.           PrimitiveCall;
  2987.  
  2988.           EDITCNT := cnt;
  2989.           COUNT   := filecount;
  2990.         end;
  2991.     end;
  2992.   xRemove := RP_PARMS.stat;
  2993. end;    {  xRemove    }
  2994.  
  2995. FUNCTION xRemall(
  2996.             VHANDLE : INTEGER;
  2997.         VAR COUNT   : INTEGER;
  2998.         VAR FILES;
  2999.             ROP     : INTEGER;
  3000.         VAR SELCNT  : LONGINT;
  3001.             REJCNT  : LONGINT ) : INTEGER;
  3002. begin
  3003.   if (PrimitivesManagerLoaded) then
  3004.     begin
  3005.  
  3006.       {                                                                 }
  3007.       { Set up parameters for Scalable SQL request.                     }
  3008.       {                                                                 }
  3009.  
  3010.       with RP_PARMS, tremallData do
  3011.         begin
  3012.           fcn          := tRemallFcn;
  3013.           handle       := VHANDLE;
  3014.           filecount    := COUNT;
  3015.           filelist.Seg := Seg(FILES);
  3016.           filelist.OffSet := Ofs(FILES);
  3017.           op           := ROP;
  3018.           select       := SELCNT;
  3019.           reject       := REJCNT;
  3020.  
  3021.           PrimitiveCall;
  3022.  
  3023.           SELCNT := select;
  3024.           REJCNT := reject;
  3025.           COUNT  := filecount;
  3026.         end;
  3027.     end;
  3028.   xRemall := RP_PARMS.stat;
  3029. end;    {  xRemall     }
  3030.  
  3031. FUNCTION xReset (VAR SRESERVED) : INTEGER;
  3032. begin
  3033.   if (PrimitivesManagerLoaded) then
  3034.     begin
  3035.  
  3036.       {                                                                 }
  3037.       { Set up parameters for Scalable SQL request.                     }
  3038.       {                                                                 }
  3039.  
  3040.       RP_PARMS.fcn                    := tResetFcn;
  3041.       RP_PARMS.handle                 := 0;
  3042.       RP_PARMS.tresetData.sreserved.Seg := Seg(SRESERVED);
  3043.       RP_PARMS.tresetData.sreserved.OffSet := Ofs(SRESERVED);
  3044.  
  3045.       PrimitiveCall;
  3046.     end;
  3047.   xReset := RP_PARMS.stat;
  3048. end;    {  xReset  }
  3049.  
  3050. FUNCTION xTrans (OPERATION : INTEGER)  : INTEGER; { option                  }
  3051. begin
  3052.   if (PrimitivesManagerLoaded) then
  3053.     begin
  3054.  
  3055.       {                                                                 }
  3056.       { Set up parameters for Scalable SQL request.                     }
  3057.       {                                                                 }
  3058.  
  3059.        RP_PARMS.fcn    := tTrans;
  3060.        RP_PARMS.handle := 0;
  3061.        RP_PARMS.ttransData.option := OPERATION;
  3062.        PrimitiveCall;
  3063.  
  3064.     end;
  3065.   xTrans := RP_PARMS.stat;
  3066. end;    {  xTrans  }
  3067.  
  3068. FUNCTION xStore (       VHANDLE : INTEGER;   { view handle              }
  3069.                     VAR VNAME;               { name of view to store    }
  3070.                         BLEN    : INTEGER;   { length of view buffer    }
  3071.                     VAR VBUF)                { view information buffer  }
  3072.                 : INTEGER;
  3073. begin
  3074.   if (PrimitivesManagerLoaded) then
  3075.     begin
  3076.  
  3077.       {                                                                 }
  3078.       { Set up parameters for Scalable SQL request.                     }
  3079.       {                                                                 }
  3080.  
  3081.       with RP_PARMS, tstoreData do
  3082.         begin
  3083.           fcn           := tStoreFcn;
  3084.           handle        := VHANDLE;
  3085.           StoreName.Seg := Seg(VNAME);
  3086.           StoreName.OffSet := Ofs(VNAME);
  3087.           BufLen        := BLEN;
  3088.           Buf.Seg       := Seg(VBUF);
  3089.           Buf.OffSet       := Ofs(VBUF);
  3090.  
  3091.           PrimitiveCall;
  3092.         end;
  3093.     end;
  3094.   xStore := RP_PARMS.stat;
  3095. end;    {  xStore    }
  3096.  
  3097. FUNCTION xRecall (  VAR VHANDLE : INTEGER;    { view handle             }
  3098.                     VAR VNAME;                { name of view to recall  }
  3099.                         ONUM    : INTEGER;    { # of owner names        }
  3100.                     VAR OLST;                 { list of owner names     }
  3101.                         MODE    : INTEGER;    { btrieve file open mode  }
  3102.                     VAR BLEN    : INTEGER;    { view buffer length      }
  3103.                     VAR VBUF)                 { view buffer             }
  3104.                  : INTEGER;
  3105. begin
  3106.   if (PrimitivesManagerLoaded) then
  3107.     begin
  3108.  
  3109.       {                                                                 }
  3110.       { Set up parameters for Scalable SQL request.                     }
  3111.       {                                                                 }
  3112.  
  3113.       with RP_PARMS, trecallData do
  3114.         begin
  3115.           fcn            := tRecallFcn;
  3116.           handle         := VHANDLE;
  3117.           RecallName.Seg := Seg(VNAME);
  3118.           RecallName.OffSet := Ofs(VNAME);
  3119.           ownernum       := ONUM;
  3120.           ownerlst.Seg   := Seg(OLST);
  3121.           ownerlst.OffSet   := Ofs(OLST);
  3122.           openmode       := MODE;
  3123.           buflen         := BLEN;
  3124.           buf.Seg        := Seg(VBUF);
  3125.           buf.OffSet        := Ofs(VBUF);
  3126.  
  3127.           PrimitiveCall;
  3128.  
  3129.           if (stat = 0) then
  3130.             begin
  3131.               VHANDLE := handle;
  3132.               BLEN    := buflen;
  3133.             end;
  3134.         end;
  3135.     end;
  3136.   xRecall := RP_PARMS.stat;
  3137. end;    {  xRecall    }
  3138.  
  3139. FUNCTION xStatus (      VHANDLE : INTEGER;
  3140.                         SUBFUNC : INTEGER;
  3141.                     VAR LEN : INTEGER;       { length of buffer   }
  3142.                     VAR STATBUF)
  3143.                    : INTEGER;
  3144. begin
  3145.   if (PrimitivesManagerLoaded) then
  3146.     begin
  3147.       with RP_PARMS, tstatData do
  3148.         begin
  3149.           fcn := tStatFcn;
  3150.           handle  := VHANDLE;
  3151.           option  := SUBFUNC;
  3152.           buflen  := LEN;
  3153.           buf.Seg := Seg (STATBUF);
  3154.           buf.OffSet := Ofs(STATBUF);
  3155.  
  3156.           PrimitiveCall;
  3157.           LEN := buflen;
  3158.         end;
  3159.     end;
  3160.   xStatus := RP_PARMS.stat;
  3161. end;  { xStatus }
  3162.  
  3163. FUNCTION xStop : INTEGER;
  3164. begin
  3165.   if (PrimitivesManagerLoaded) then
  3166.     begin
  3167.  
  3168.       {                                                                 }
  3169.       { Set up parameters for Scalable SQL request.                     }
  3170.       {                                                                 }
  3171.  
  3172.       RP_PARMS.fcn := tStopFcn;
  3173.  
  3174.       PrimitiveCall;
  3175.     end;
  3176.   xStop := RP_PARMS.stat;
  3177. end;    {  xStop   }
  3178. {$ENDIF} {Historical Function Definitions}
  3179.  
  3180. END.
  3181.