home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 5 / 05.iso / a / a006 / 2.ddi / CENG.ZIP / PXENGINE.H next >
Encoding:
C/C++ Source or Header  |  1991-03-11  |  39.2 KB  |  818 lines
  1. /* pxengine.h */
  2. /*    Copyright (c) 1991 by Borland International, Inc.                 */
  3.  
  4. #ifndef PXENGINE_H
  5. #define PXENGINE_H
  6.  
  7. #ifdef __cplusplus
  8.    extern "C" {               /* avoid name-mangling if used from C++   */
  9. #endif /* __cplusplus */
  10.  
  11.  
  12. #define InternalVersion 0x02000004L        /* version number, same      */
  13.                                            /* as found in .lib files    */
  14.  
  15.  
  16. /* Type definitions  */
  17.  
  18. typedef unsigned        TABLEHANDLE;       /* table handle              */
  19. typedef unsigned        RECORDHANDLE;      /* record handle             */
  20. typedef unsigned        FIELDHANDLE;       /* field number 1..          */
  21. typedef int             LOCKHANDLE;        /* lock handle               */
  22. typedef long            RECORDNUMBER;      /* record number 1..         */
  23. typedef long            DATE;              /* representation of date    */
  24. typedef TABLEHANDLE  far * PTABLEHANDLE;   /* pointer to table handle   */
  25. typedef RECORDHANDLE far * PRECORDHANDLE;  /* pointer to record handle  */
  26. typedef FIELDHANDLE  far * PFIELDHANDLE;   /* pointer to field handle   */
  27. typedef LOCKHANDLE   far * PLOCKHANDLE;    /* pointer to lockhandle     */
  28. typedef RECORDNUMBER far * PRECORDNUMBER;  /* pointer to record number  */
  29. typedef DATE         far * PDATE;          /* pointer to a date         */
  30.  
  31. /* Maximum and default values for dynamic configuration.                */
  32. /* The default values are used if not overwritten in PXSetDefaults (DOS)*/
  33. /* or in WIN.INI (Windows)                                              */
  34.  
  35. #define PXDEFAULT                0L     /* use internal default value   */
  36.  
  37. #define MAXTABLEHANDLES         64      /* maximum number of open       */
  38.                                         /* tables allowed at a time     */
  39. #define DEFTABLEHANDLES          5      /* default number of open       */
  40.                                         /* tables allowed at a time     */
  41. #define MAXRECORDHANDLES       128      /* maximum number of record     */
  42.                                         /* buffers available            */
  43. #define DEFRECORDHANDLES        10      /* default number of record     */
  44.                                         /* buffers available            */
  45. #define MAXLOCKHANDLES         128      /* maximum number of lock       */
  46.                                         /* handles per table            */
  47. #define DEFLOCKHANDLES          32      /* default number of lock       */
  48.                                         /* handles per table            */
  49. #define MAXFILEHANDLES          255     /* maximum number of DOS file   */
  50.                                         /* handles to use               */
  51. #define MINFILEHANDLES           2      /* minimum number of DOS file   */
  52.                                         /* handles to use               */
  53. #define DEFFILEHANDLES          10      /* default number of DOS file   */
  54.                                         /* handles to use               */
  55.  
  56. #ifdef _Windows      /* set by -W flag on bcc */
  57. #  ifndef WINDOWS
  58. #    define WINDOWS
  59. #    define _PX_DEFED_WINDOWS
  60. #  endif /* !WINDOWS */
  61. #endif /* _Windows */
  62.  
  63. #ifdef WINDOWS
  64. #  define DEFSORTORDER   (char) (-1)    /* default sort order (ASCII)   */
  65. #else /* !WINDOWS */
  66. #  define DEFSORTORDER   (char far *) (-1)  /* default sort order (ASCII)   */
  67. #endif /* WINDOWS */
  68.  
  69. /* Swap buffer size                                                     */
  70. #define MAXSWAPSIZE            256      /* maximum buffer size allowed (k)*/
  71. #define MINSWAPSIZE              8      /* minimum buffer size allowed (k)*/
  72. #define DEFSWAPSIZE             32      /* default buffer size (k)      */
  73.  
  74.  
  75. /* Network codes                                                        */
  76. /* used in PXNetInit                                                    */
  77.  
  78. #define NOTONNET        1       /* not on a net                         */
  79. #define NOVELLNET       2       /* Novell                               */
  80. #define THREECOMNET     3       /* 3Com                                 */
  81. #define THREEOPENNET    4       /* 3Com 3+Open                          */
  82. #define OTHERNET        5       /* other: unknown DOS 3.1 compatible    */
  83. #define STARLANNET      7       /* Starlan                              */
  84. #define BANYANNET       8       /* Banyan                               */
  85. #define IBMPCNET        9       /* IBM PC                               */
  86.  
  87. #define LOCALSHARE      32      /* enables sharing on local drives with */
  88.                                 /* any net type                         */
  89.                                 /* (i.e. OTHERNET | LOCALSHARE)         */
  90.  
  91. #define DEFUSERNAME     NULL    /* use default username in PXNetInit()  */
  92.  
  93.  
  94. /* used in PXKeyAdd                                                     */
  95.  
  96. #define PRIMARY       0  /* primary index (key)                         */
  97. #define SECONDARY     1  /* not maintained secondary index              */
  98. #define INCSECONDARY  2  /* maintained secondary index                  */
  99.  
  100.  
  101. /* used in PXSrchFld, PXSrchKey                                         */
  102.  
  103. #define SEARCHFIRST  0    /* search from beginning of table             */
  104. #define SEARCHNEXT   1    /* search from next record in table           */
  105. #define CLOSESTRECORD 2   /* (modifier) goto 'nearest' record if        */
  106.                           /* no match found (ordered fields only)       */
  107.  
  108. /* Lock types                                                            */
  109. /* used in PXNetFileLock, PXNetFileUnlock, PXNetTblLock, PXNetTblUnlock  */
  110.  
  111. #define FL              1       /* full lock, no concurrency            */
  112. #define WL              2       /* write lock                           */
  113. #define PWL             3       /* prevent write lock                   */
  114. #define PFL             4       /* prevent full lock, full concurrency  */
  115.  
  116.  
  117. /* commonly used constants                                              */
  118.  
  119. #ifndef TRUE
  120. #  define TRUE    1
  121. #endif  /* TRUE */
  122.  
  123. #ifndef FALSE
  124. #  define FALSE   0
  125. #endif  /* FALSE */
  126.  
  127. #ifndef NULL
  128. #  define NULL  0L                
  129. #endif  /* NULL */
  130.  
  131.  
  132. /* macros for checking blank values                                     */
  133.  
  134. #define BLANKDATE       0x80000000L
  135. #define BLANKLONG       0x80000000L
  136. #define BLANKSHORT      0x8000
  137.  
  138. #define ISBLANKALPHA(x)  ((x)[0]                == 0x0)
  139. #define ISBLANKSHORT(x)  ((unsigned short)(x)   == BLANKSHORT)
  140. #define ISBLANKLONG(x)   ((unsigned long)(x)    == BLANKLONG)
  141. #define ISBLANKDATE(x)   ((unsigned long)(x)    == BLANKDATE)
  142.  
  143.  
  144. /* successful Engine function operation returns                         */
  145.  
  146. #define PXSUCCESS    0  
  147.  
  148. /* errorcodes from Engine functions                                     */
  149.  
  150.  
  151. /* initialization errors                                                */
  152.  
  153. #define PXERR_NOTINITERR        78      /* Engine not initialized       */
  154. #define PXERR_ALREADYINIT       82      /* Engine already initialized */
  155. #define PXERR_NOTLOGGEDIN       98      /* Could not login on network   */
  156.                                         /* (to PARADOX.NET)             */
  157. #define PXERR_NONETINIT        107      /* Engine not initialized       */
  158.                                         /* with PXNetInit               */
  159. #define PXERR_NETMULTIPLE       15      /* multiple PARADOX.NET files   */
  160.  
  161. #define PXERR_CANTSHAREPDOXNET 134      /* can't lock PARADOX.NET -- is */
  162.                                         /* SHARE.EXE loaded?            */
  163. #define PXERR_WINDOWSREALMODE  135      /* can't run Engine in Windows  */
  164.                                         /* real mode                    */
  165.  
  166. /* hardware related errors                                              */
  167.  
  168. #define PXERR_DRIVENOTREADY     1       /* Drive not ready              */
  169. #define PXERR_DISKWRITEPRO      124     /* Disk is write protected      */
  170. #define PXERR_GENERALFAILURE    126     /* General hardware error       */
  171.  
  172.  
  173. /* directory reg error codes                                            */
  174.  
  175. #define PXERR_DIRNOTFOUND       2       /* Directory not found          */
  176. #define PXERR_DIRBUSY           10      /* Sharing violation            */
  177. #define PXERR_DIRLOCKED         11      /* Sharing violation            */
  178. #define PXERR_DIRNOACCESS       12      /* No access to directory       */
  179. #define PXERR_DIRNOTPRIVATE     14      /* Single user, but directory is*/
  180.                                         /* shared                       */
  181.  
  182. /* file oriented errors                                                 */
  183.  
  184. #define PXERR_FILEBUSY          3       /* File is busy                 */
  185. #define PXERR_FILELOCKED        4       /* File is locked               */
  186. #define PXERR_FILENOTFOUND      5       /* Could not find file          */
  187.  
  188. /* table oriented errors                                                */
  189.  
  190. #define PXERR_TABLEBUSY        118      /* Table is busy                */
  191. #define PXERR_TABLELOCKED      119      /* Table is locked              */
  192. #define PXERR_TABLENOTFOUND    120      /* Table was not found          */
  193. #define PXERR_TABLEOPEN         83      /* Unable to perform operation  */
  194.                                         /* on open table                */
  195. #define PXERR_TABLEINDEXED      94      /* Table is indexed             */
  196. #define PXERR_TABLENOTINDEXED   95      /* Table is not indexed         */
  197. #define PXERR_TABLEEMPTY       105      /* Operation on empty table     */
  198. #define PXERR_TABLEWRITEPRO     22      /* Table is write protected     */
  199.  
  200. #define PXERR_TABLECORRUPTED     6      /* Table is corrupted           */
  201. #define PXERR_TABLEFULL         128     /* Table is full                */
  202. #define PXERR_TABLESQL          130     /* Table is SQL replica         */
  203. #define PXERR_INSUFRIGHTS       21      /* Insufficient password rights */
  204.  
  205.  
  206. /* index oriented errors                                                */
  207.  
  208. #define PXERR_XCORRUPTED        7       /* Primary index is corrupted   */
  209. #define PXERR_XOUTOFDATE        8       /* Primary index is out of date */
  210. #define PXERR_XSORTVERSION      13      /* Sort for index different     */
  211.                                         /* from table                   */
  212.  
  213. #define PXERR_SXCORRUPTED       122     /* Secondary index is corrupted */
  214. #define PXERR_SXOUTOFDATE       96      /* Secondary index is out of date*/
  215. #define PXERR_SXNOTFOUND        121     /* Secondary index was not found */
  216. #define PXERR_SXOPEN            123     /* Secondary index is already open*/
  217. #define PXERR_SXCANTUPDATE      136     /* Can't update table open on non-maintained secondary */
  218.  
  219. #define PXERR_RECTOOBIG         125     /* Record too big for index     */
  220.  
  221. /* record oriented errors                                               */
  222.  
  223. #define PXERR_RECDELETED        50      /* Another user deleted record  */
  224. #define PXERR_RECLOCKED          9      /* Record is locked             */
  225. #define PXERR_RECNOTFOUND       89      /* Record was not found         */
  226. #define PXERR_KEYVIOL           97      /* Key violation                */
  227.  
  228. #define PXERR_ENDOFTABLE       101      /* End of table                 */
  229. #define PXERR_STARTOFTABLE     102      /* Start of table               */
  230.  
  231.  
  232. /* errors specific for Windows Engine DLL                               */
  233.  
  234. #define PXERR_TOOMANYCLIENTS   131
  235. #define PXERR_EXCEEDSCONFIGLIMITS 132
  236. #define PXERR_CANTREMAPFILEHANDLE 133
  237.  
  238. /* resource errors                                                      */
  239.  
  240. #define PXERR_OUTOFMEM          40      /* Not enough memory to         */
  241.                                         /* complete operation           */
  242. #define PXERR_OUTOFDISK         41      /* Not enough disk space to     */
  243.                                         /* complete operation           */
  244. #define PXERR_OUTOFSTACK        127     /* Not enough stack space to    */
  245.                                         /* complete operation           */
  246. #define PXERR_OUTOFSWAPBUF      129     /* Not enough swap buffer space to*/
  247.                                         /* complete operation           */
  248.  
  249. #define PXERR_OUTOFFILEHANDLES  70      /* No more file handles available*/
  250. #define PXERR_OUTOFTABLEHANDLES 72      /* No more table handles available*/
  251. #define PXERR_OUTOFRECHANDLES  103      /* No more record handles available*/
  252. #define PXERR_OUTOFLOCKHANDLES 111      /* Too many locks on table      */
  253.  
  254. #define PXERR_NOMORETMPNAMES    86      /* No more temporary names      */
  255.                                         /* available                    */
  256. #define PXERR_TOOMANYPASSW     115      /* Too many passwords specified */
  257.  
  258.  
  259. /* invalid parameters to functions                                      */
  260.  
  261. #define PXERR_TYPEMISMATCH      30      /* Data type mismatch           */
  262. #define PXERR_OUTOFRANGE        31      /* Argument out of range        */
  263. #define PXERR_INVPARAMETER      33      /* Invalid argument             */
  264. #define PXERR_INVDATE           73      /* Invalid date given           */
  265.  
  266. #define PXERR_INVFIELDHANDLE    75      /* Invalid field handle         */
  267. #define PXERR_INVRECHANDLE     104      /* Invalid record handle        */
  268. #define PXERR_INVTABLEHANDLE    76      /* Invalid table handle         */
  269. #define PXERR_INVLOCKHANDLE    110      /* Invalid lock handle          */
  270.  
  271.  
  272. #define PXERR_INVDIRNAME       114      /* Invalid directory name       */
  273. #define PXERR_INVFILENAME      108      /* Invalid file name            */
  274. #define PXERR_INVTABLENAME      99      /* Invalid table name           */
  275. #define PXERR_INVFIELDNAME      74      /* Invalid field name           */
  276.  
  277. #define PXERR_INVLOCKCODE      106      /* Invalid lock code            */
  278. #define PXERR_INVUNLOCK        109      /* Invalid unlock               */
  279. #define PXERR_INVSORTORDER     112      /* Invalid sort order table     */
  280. #define PXERR_INVPASSW         116      /* Invalid password             */
  281. #define PXERR_INVNETTYPE       113      /* Invalid net type (PXNetInit) */
  282. #define PXERR_BUFTOOSMALL      117      /* Buffer too small for result  */
  283.  
  284. #define PXERR_STRUCTDIFFER      81      /* Table structures are different*/
  285.  
  286. #define PXERR_INVENGINESTATE    79      /* Previous fatal error;        */
  287.                                         /* cannot proceed               */
  288.  
  289. /* values for ShareMode argument to PXWinInit */
  290.  
  291. #  define PXSINGLECLIENT 0 /* allow no other client access to Engine DLL */
  292. #  define PXEXCLUSIVE    1 /* open all tables with FULL LOCK */
  293. #  define PXSHARED       2 /* open all tables with PREVENT FULL LOCK */
  294.  
  295.  
  296. /*----------------------------------------------------------------------*/
  297. /* prototypes for engine functions                                      */
  298.  
  299. /* declarations of sort order tables, used in PXSetDefaults             */
  300. #ifdef WINDOWS
  301. #  define SortOrderAscii   'a'  /* ASCII sort order           */
  302. #  define SortOrderIntl    'i'  /* international sort order   */
  303. #  define SortOrderNorDan  'n'  /* Norwegian/Danish sort order*/
  304. #  define SortOrderSwedFin 's'  /* Swedish/Finnish sort order */
  305. #else /* !WINDOWS */
  306. extern char far * pascal far SortOrderAscii;   /* ASCII sort order             */
  307. extern char far * pascal far SortOrderIntl;    /* international sort order     */
  308. extern char far * pascal far SortOrderNorDan;  /* Norwegian/Danish sort order  */
  309. extern char far * pascal far SortOrderSwedFin; /* Swedish/Finnish sort order   */
  310. #endif /* WINDOWS */
  311.  
  312.  
  313. /* INITIALIZATION AND FINALIZATION FUNCTIONS */
  314.  
  315. #ifdef WINDOWS
  316. /* initialize Engine connection in Windows environment */
  317. int pascal far PXWinInit(
  318.         char far *clientName,    /* string containing name of application */
  319.         int ShareMode);          /* Share mode: PXSINGLECLIENT, PXEXCLUSIVE,
  320.                                  ** or PXSHARED
  321.                                  */
  322.  
  323. #else /* !WINDOWS */
  324.  
  325. /* initialize Engine  */
  326. int pascal far PXInit(void);
  327.  
  328. /* initialize Engine and net support */
  329. int pascal far PXNetInit(       /*                                      */
  330.         char far *netNamePath,  /* directory containing .NET file       */
  331.         int  netType,           /* type of network                      */
  332.         char far *userName);    /* user name, as put in .NET file       */
  333.  
  334.  
  335. #endif /* WINDOWS */
  336.  
  337. /* exit and deallocate                                                  */
  338. int pascal far PXExit(void);
  339.  
  340. /* overwrites internal default values                                   */
  341. int pascal far PXSetDefaults(   /*                                      */
  342.         int bufSize,            /* internal swap buffer size            */
  343.                                 /* MINSWAPSIZE..MAXSWAPSIZE (8..256),   */
  344.                                 /* default DEFSWAPSIZE (32)             */
  345.                                 /* allocated at initialization time     */
  346.         int maxTables,          /* max number of tables open at a time  */
  347.                                 /* range 1..MAXTABLEHANDLES ,   (1..64) */
  348.                                 /* default  DEFTABLEHANDLES     (5)     */
  349.         int maxRecBufs,         /* max number of record buffers at a time*/
  350.                                 /* range 1..MAXRECORDHANDLES ,  (1..128)*/
  351.                                 /* default  DEFRECORDHANDLES    (10)    */
  352.         int maxLocks,           /* max number of locks per table        */
  353.                                 /* range 1..MAXLOCKHANDLES  ,   (1..128)*/
  354.                                 /* default DEFLOCKHANDLES       (32)    */
  355.         int maxFiles,           /* max number of file handles to use    */
  356.                                 /* range MINFILEHANDLES..MAXFILEHANDLES */
  357.                                 /* default DEFFILEHANDLES       (10)    */
  358. #ifdef WINDOWS
  359.         char sortOrder          /* code for sort order table defined    */
  360.                                 /* internally in the Engine :           */
  361.                                 /* SortOrderAscii/SortOrderIntl/        */
  362.                                 /* SortOrderNorDan/SortOrderSwedFin     */
  363.                                 /* default : SortOrderAscii             */
  364. #else /* !WINDOWS */
  365.         char far *sortOrder     /* address of sort order table defined  */
  366.                                 /* internally in the Engine :           */
  367.                                 /* SortOrderAscii/SortOrderIntl/        */
  368.                                 /* SortOrderNorDan/SortOrderSwedFin     */
  369.                                 /* default : SortOrderAscii             */
  370. #endif /* !WINDOWS */
  371.         );
  372.  
  373.  
  374. /* returns current default settings                                       */
  375. int pascal far PXGetDefaults(
  376.         int far *swapSize,      /* returns internal swap buffer size      */
  377.         int far *maxTables,     /* returns max number of tables at a time */
  378.         int far *maxRecBufs,    /* returns max number of record buffers   */
  379.         int far *maxLocks,      /* returns max number of locks per table  */
  380.         int far *maxFiles,      /* returns max number of file handles to use*/
  381. #ifdef WINDOWS
  382.         char far *sortTable     /* returns code indicating default sort table*/
  383. #else /* !WINDOWS */
  384.         char far * far *sortTable /* returns address of default sort table  */
  385. #endif /* !WINDOWS */
  386.         );
  387.  
  388.  
  389. /* enables/disables internal hardware error handler                     */
  390. int pascal far PXSetHWHandler(
  391.                 int hwHandler); /* enable(TRUE) / disable (FALSE)       */
  392.                                 /* default TRUE                         */
  393.  
  394. /* UTILITY FUNCTIONS */
  395.  
  396. int pascal far ISBLANKDOUBLE(double x);
  397. void pascal far BLANKDOUBLE(double far *x);
  398.  
  399.  
  400. /* TABLE FUNCTIONS */
  401.  
  402. /* open table for access, returning table handle                        */
  403. int pascal far PXTblOpen(
  404.         char far *tblName,      /* name of table to open                */
  405.         PTABLEHANDLE ptblHandle,/* returns handle for opened table      */
  406.         int indexID,            /* =0 mastertable else indexnumber      */
  407.         int saveEveryChange);   /* save each record as it is changed    */
  408.                                 /* don't buffer changes                 */
  409.  
  410. /* close access to table                                                */
  411. int pascal far PXTblClose(
  412.         TABLEHANDLE tblHandle); /* tblHandle of table to close          */
  413.  
  414. /* create empty table                                                   */
  415. int pascal far PXTblCreate(
  416.         char far *tblName,      /* name of table to create              */
  417.         int nFields,            /* number of fields in table            */
  418.         char far * far *fields, /* field names                          */
  419.         char far * far *types); /* field types (N, S..)                 */
  420.  
  421. /* clear table for records                                              */
  422. int pascal far PXTblEmpty(
  423.         char far *tblName);     /* name of table to empty               */
  424.  
  425. /* delete table and its family                                          */
  426. int pascal far PXTblDelete(
  427.         char far *tblName);     /* name of table to delete              */
  428.  
  429. /* copy table and its family                                            */
  430. int pascal far PXTblCopy(
  431.         char far *fromName,     /* source table of copy                 */
  432.         char far *toName);      /* destination table of copy            */
  433.  
  434. /* rename table and its family                                          */
  435. int pascal far PXTblRename(
  436.         char far *fromName,     /* source table of copy                 */
  437.         char far *toName);      /* destination table of copy            */
  438.  
  439. /* add records from one table to another table                          */
  440. int pascal far PXTblAdd(
  441.         char far *srcName,      /* source table of add                  */
  442.         char far *destName);    /* destination table of add             */
  443.  
  444.  
  445. /* RECORD FUNCTIONS */
  446.  
  447. /* insert record buffer in database (as last record if Heap)            */
  448. int pascal far PXRecAppend(
  449.         TABLEHANDLE tblHandle,  /* table to append record to            */
  450.         RECORDHANDLE recHandle );/* record to append                    */
  451.  
  452. /* insert record buffer in database (before current if Heap)            */
  453. int pascal far PXRecInsert(
  454.         TABLEHANDLE tblHandle,  /* table to insert record into          */
  455.         RECORDHANDLE recHandle);/* record to insert                     */
  456.  
  457. /* updates current record in database with contents of the record buffer*/
  458. int pascal far PXRecUpdate(
  459.         TABLEHANDLE tblHandle,  /* table to update record into          */
  460.         RECORDHANDLE recHandle);/* changed record to post               */
  461.  
  462. /* delete current record in table                                       */
  463. int pascal far PXRecDelete(
  464.         TABLEHANDLE tblHandle); /* table to delete record in            */
  465.  
  466. /* creates a record buffer for a table                                  */
  467. int pascal far PXRecBufOpen(
  468.         TABLEHANDLE tblHandle,  /* table to create buffer for           */
  469.         PRECORDHANDLE precHandle);/* returns handle to record buffer    */
  470.  
  471. /* deletes a record buffer for a table                                  */
  472. int pascal far PXRecBufClose(
  473.         RECORDHANDLE recHandle);/* record buffer to remove              */
  474.  
  475. /* clears the record buffer (to blanks)                                 */
  476. int pascal far PXRecBufEmpty(
  477.         RECORDHANDLE recHandle);/* record buffer to clear               */
  478.  
  479. /* copy record from a record buffer to another (compatible) record buffer*/
  480. int pascal far PXRecBufCopy(
  481.         RECORDHANDLE fromHandle,/* record buffer to copy from           */
  482.         RECORDHANDLE toHandle); /* record buffer to copy to             */
  483.  
  484. /* gets the current record from the database into the record buffer     */
  485. int pascal far PXRecGet(
  486.         TABLEHANDLE tblHandle,  /* table to get record from             */
  487.         RECORDHANDLE recHandle);/* record buffer to put record in       */
  488.  
  489. /* FIELD FUNCTIONS */
  490.  
  491. /* put short value into N/$/S field in record buffer                    */
  492. int pascal far PXPutShort(
  493.         RECORDHANDLE recHandle, /* record buffer to put value in        */
  494.         FIELDHANDLE fldHandle,  /* field in record                      */
  495.         short value);           /* value to put                         */
  496.  
  497. /* put double value into N/$/S field in record buffer                   */
  498. int pascal far PXPutDoub(
  499.         RECORDHANDLE recHandle, /* record buffer to put value in        */
  500.         FIELDHANDLE fldHandle,  /* field in record                      */
  501.         double value);          /* value to put                         */
  502.  
  503. /* put long value into N/$/S field in record buffer                     */
  504. int pascal far PXPutLong(
  505.         RECORDHANDLE recHandle, /* record buffer to put value in        */
  506.         FIELDHANDLE fldHandle,  /* field in record                      */
  507.         long value);            /* value to put                         */
  508.  
  509. /* put string into Alpha field in record buffer                         */
  510. int pascal far PXPutAlpha(
  511.         RECORDHANDLE recHandle, /* record buffer to put value in        */
  512.         FIELDHANDLE fldHandle,  /* field in record                      */
  513.         char far *value);       /* value to put                         */
  514.  
  515. /* put long value into date field (encoded value) in record buffer      */
  516. int pascal far PXPutDate(
  517.         RECORDHANDLE recHandle, /* record buffer to put value in        */
  518.         FIELDHANDLE fldHandle,  /* field in record                      */
  519.         DATE value);            /* value to put                         */
  520.  
  521. /* put blank value into field in record buffer                          */
  522. int pascal far PXPutBlank(
  523.         RECORDHANDLE recHandle, /* record buffer to put blank in        */
  524.         FIELDHANDLE fldHandle); /* field in record                      */
  525.  
  526. /* get value from N/$/S field in record buffer, into short              */
  527. int pascal far PXGetShort(
  528.         RECORDHANDLE recHandle, /* record buffer to get value from      */
  529.         FIELDHANDLE fldHandle,  /* field to get value from              */
  530.         short far *Svalue);     /* returns value                        */
  531.  
  532. /* get value from N/$/S field in record buffer, into double             */
  533. int pascal far PXGetDoub(
  534.         RECORDHANDLE recHandle, /* record buffer to get value from      */
  535.         FIELDHANDLE fldHandle,  /* field to get value from              */
  536.         double far *Dvalue);    /* returns value                        */
  537.  
  538. /* get value from N/$/S field in record buffer, into long               */
  539. int pascal far PXGetLong(
  540.         RECORDHANDLE recHandle, /* record buffer to get value from      */
  541.         FIELDHANDLE fldHandle,  /* field to get value from              */
  542.         long far *Lvalue);      /* returns value                        */
  543.  
  544. /* get string from alpha field in record buffer                         */
  545. int pascal far PXGetAlpha(
  546.         RECORDHANDLE recHandle, /* record buffer to get value from      */
  547.         FIELDHANDLE fldHandle,  /* field to get value from              */
  548.         int bufSize,            /* size of return buffer                */
  549.         char far *dest);        /* return buffer                        */
  550.  
  551. /* get value from date field in record buffer, into long  (encoded value)*/
  552. int pascal far PXGetDate(
  553.         RECORDHANDLE recHandle, /* record buffer to get value from      */
  554.         FIELDHANDLE fldHandle,  /* field to get value from              */
  555.         PDATE pvalue);          /* returns value                        */
  556.  
  557. /* is value in specified field in record buffer a blank?                */
  558. int pascal far PXFldBlank(
  559.         RECORDHANDLE recHandle, /* record to test value in              */
  560.         FIELDHANDLE fldHandle,  /* field to test                        */
  561.         int far *Blank);        /* returns TRUE/FALSE                   */
  562.  
  563.  
  564.  
  565.  
  566. /*----------------------------------------------------------------------*/
  567.  
  568. /* move to record with specified record number                          */
  569. int pascal far PXRecGoto(
  570.         TABLEHANDLE tblHandle,  /* tblHandle of table to move in        */
  571.         RECORDNUMBER recNum);   /* record number to move to             */
  572.  
  573. /* move to first record in table                                        */
  574. int pascal far PXRecFirst(
  575.         TABLEHANDLE tblHandle); /* table to move in                     */
  576.  
  577. /* move to last record in table                                         */
  578. int pascal far PXRecLast(
  579.         TABLEHANDLE tblHandle); /* table to move in                     */
  580.  
  581. /* move to next record in table                                         */
  582. int pascal far PXRecNext(
  583.         TABLEHANDLE tblHandle); /* table to move in                     */
  584.  
  585. /* move to previous record in table                                     */
  586. int pascal far PXRecPrev(
  587.         TABLEHANDLE tblHandle); /* table to move in                     */
  588.  
  589.  
  590.  
  591.  
  592. /* INDEX FUNCTIONS */
  593.  
  594. /* add a primary or secondary (maintained/nonmaintained) index          */
  595. int pascal far PXKeyAdd(
  596.         char far *tblName,      /* name of table to add index for       */
  597.         int nFlds,              /* number of fields in index            */
  598.         PFIELDHANDLE pfldHandles,/* array of field numbers in index     */
  599.         int mode     );         /* type of index to create              */
  600.                                 /* PRIMARY/SECONDARY/INCSECONDARY       */
  601.  
  602. /* delete an index for a table (primary/secondary)                      */
  603. int pascal far PXKeyDrop(
  604.         char far *tblName,      /* name of table to delete index for    */
  605.         int indexID);           /* 0 if primary key, else field number  */
  606.                                 /* of secondary index                   */
  607.  
  608.  
  609. /* DATE FUNCTIONS */
  610.  
  611. /* decodes a date value stored in the Paradox format                    */
  612. int pascal far PXDateDecode(
  613.         DATE date,              /* long value to decode                 */
  614.         int far *mo,            /* decoded month value                  */
  615.         int far *da,            /* decoded date value                   */
  616.         int far *yr);           /* decoded year value                   */
  617.  
  618. /* encodes a date value to a long value in Paradox format               */
  619. int pascal far PXDateEncode(
  620.         int mo,                 /* month value to encode                */
  621.         int da,                 /* date value to encode                 */
  622.         int yr,                 /* year value to encode                 */
  623.         PDATE pdate);           /* encoded date value                   */
  624.  
  625.  
  626.  
  627. /* SEARCH FUNCTIONS */
  628.  
  629. /* Searches a table for a given (sub) key                               */
  630. int pascal far PXSrchKey(
  631.         TABLEHANDLE tblHandle,  /* table to search in                   */
  632.         RECORDHANDLE recHandle, /* record buffer containing key to find */
  633.         int nFlds,              /* number of fields in key              */
  634.         int mode);              /* searching from first/next record     */
  635.  
  636. int pascal far PXSrchFld(
  637.         TABLEHANDLE tblHandle,  /* table to search in                   */
  638.         RECORDHANDLE recHandle, /* record buffer containing field to find*/
  639.         FIELDHANDLE fldHandle,  /* field number to search on            */
  640.         int mode);              /* searching from first/next record     */
  641.  
  642. /* PASSWORD FUNCTIONS */
  643.  
  644. /* checks if table is encrypted                                         */
  645. int pascal far PXTblProtected(
  646.         char far *tblName,      /* name of table to check               */
  647.         int far *Protected);    /* returns TRUE/FALSE                   */
  648.  
  649. /* enters a password to the Engine                                      */
  650. int pascal far PXPswAdd(
  651.         char far *password);    /* password to enter into system        */
  652.  
  653. /* deletes a password previously entered                                */
  654. int pascal far PXPswDel(
  655.         char far *password);    /* password to remove from system       */
  656.  
  657. /* encrypt a table and make it password protected                       */
  658. int pascal far PXTblEncrypt(
  659.         char far *tblName,      /* name of table to encrypt             */
  660.         char far *password);    /* password for encrypted table         */
  661.  
  662. /* decrypt a table, password must already have been entered             */
  663. int pascal far PXTblDecrypt(
  664.         char far *tblName);     /* name of table to decrypt             */
  665.  
  666.  
  667. /* INFORMATIONAL FUNCTIONS */
  668.  
  669. /* checks if table exists                                               */
  670. int pascal far PXTblExist(
  671.         char far *tblName,      /* name of table to check               */
  672.         int far *Exist) ;       /* returns TRUE/FALSE                   */
  673.  
  674. /* returns table name corresponding to a table handle                   */
  675. int pascal far PXTblName(
  676.         TABLEHANDLE tblHandle,  /* table to return name of              */
  677.         int bufSize,            /* size of return buffer                */
  678.         char far *tblName);     /* name of table, without extension     */
  679.  
  680. /* returns record number of current record in table                     */
  681. int pascal far PXRecNum(
  682.         TABLEHANDLE tblHandle,  /* table to get record number from      */
  683.         PRECORDNUMBER precnum); /* returns record number                */
  684.  
  685. /* returns number of records in table                                   */
  686. int pascal far PXTblNRecs(
  687.         TABLEHANDLE tblHandle,  /* table to get number of records from  */
  688.         PRECORDNUMBER pnRecs);  /* returns number of records            */
  689.  
  690. /* returns number of fields in a record                                 */
  691. int pascal far PXRecNFlds(
  692.         TABLEHANDLE tblHandle,  /* table to get number of fields from   */
  693.         int far *nFlds);        /* returns number of fields in a record */
  694.  
  695. /* return number of fields in key for table                             */
  696. int pascal far PXKeyNFlds(
  697.         TABLEHANDLE tblHandle,  /* table to get key size for            */
  698.         int far *nKeyFlds);     /* returns number of fields in key      */
  699.  
  700. /* returns field number of a given field name in a table                */
  701. int pascal far PXFldHandle(
  702.         TABLEHANDLE tblHandle,  /* table to get field number from       */
  703.         char far *fieldName,    /* name of field in table               */
  704.         PFIELDHANDLE pfldHandle);/* returns field number                */
  705.                                 
  706. /* returns field type of a given field in a table                       */
  707. int pascal far PXFldType(
  708.         TABLEHANDLE tblHandle,  /* table to get field type from         */
  709.         FIELDHANDLE fldHandle,  /* field number of field in table       */
  710.         int bufSize,            /* size of return buffer                */
  711.         char far *fldType);     /* field type of field as string        */
  712.  
  713. /* returns field name of a given field in a table                       */
  714. int pascal far PXFldName(
  715.         TABLEHANDLE tblHandle,  /* table to get field name from         */
  716.         FIELDHANDLE fldHandle,  /* field number of field in table       */
  717.         int bufSize,            /* size of return buffer                */
  718.         char far *fldName);     /* returns name of field                */
  719.  
  720.  
  721.  
  722. /* MISCELLANEOUS FUNCTIONS                                              */
  723. /* sets maximum size of tables created with PXTblCreat()                */
  724. int pascal far PXTblMaxSize(
  725.         int maxsize);           /* maximum size of table                */
  726.                                 /* 64/128/256  (Megabytes)              */
  727.  
  728. /* saves all buffered changes to disk                                   */
  729. int pascal far PXSave(void);
  730.  
  731.  
  732. /* CONCURRENCY FUNCTIONS */
  733. /* can be used only if PXNetInit() or PXWinInit() was successful        */
  734.  
  735. /* returns name of user as known on network                             */
  736. int pascal far PXNetUserName(
  737.         int bufSize,            /* size of return buffer                */
  738.         char far *userName);    /* returns user name                    */
  739.  
  740. /* locks a file with specified lock (general function)                  */
  741. int pascal far PXNetFileLock(
  742.         char far *fileName,     /* name of file to lock                 */
  743.         int lockType);          /* type of lock to put on file          */
  744.                                 /* (FL, WL, PFL, PWL)                   */
  745.  
  746. /* unlocks a file with specified lock (general function)                */
  747. int pascal far PXNetFileUnlock(
  748.         char far *fileName,     /* name of file to unlock               */
  749.         int lockType);          /* type of lock to remove from file     */
  750.                                 /* (FL, WL, PFL, PWL)                   */
  751.  
  752. /* locks an open table with specified lock                              */
  753. int pascal far PXNetTblLock(
  754.         TABLEHANDLE tblHandle,  /* table to lock                        */
  755.         int lockType);          /* type of lock to put on table         */
  756.                                 /* (FL, WL, PFL, PWL)                   */
  757.  
  758. /* unlocks an open table with specified lock                            */
  759. int pascal far PXNetTblUnlock(
  760.         TABLEHANDLE tblHandle,  /* table to unlock                      */
  761.         int lockType);          /* type of lock to remove from table    */
  762.                                 /* (FL, WL, PFL, PWL)                   */
  763.  
  764. /* locks the current record in a table                                  */
  765. int pascal far PXNetRecLock(
  766.         TABLEHANDLE tblHandle,  /* table to lock record in              */
  767.         PLOCKHANDLE plckHandle); /* returns handle to lock              */
  768.  
  769. /* unlocks record associated with lock handle in the table              */
  770. int pascal far PXNetRecUnlock(
  771.         TABLEHANDLE tblHandle,  /* table to unlock record in            */
  772.         LOCKHANDLE lckHandle);  /* lock handle of record to unlock      */
  773.  
  774. /* checks if current record in table is locked (by any user)            */
  775. int pascal far PXNetRecLocked(
  776.         TABLEHANDLE tblHandle,  /* table to check record in             */
  777.         int far *Locked);       /* returns TRUE/FALSE                   */
  778.  
  779. /* moves to the record in the table associated with the lock handle     */
  780. int pascal far PXNetRecGotoLock(
  781.         TABLEHANDLE tblHandle,  /* table to move in                     */
  782.         LOCKHANDLE lckHandle);  /* lock handle to record                */
  783.  
  784. /* checks if table was changed by other user since last refresh         */
  785. int pascal far PXNetTblChanged(
  786.         TABLEHANDLE tblHandle,  /* table to test                        */
  787.         int far *Changed);      /* returns TRUE/FALSE                   */
  788.  
  789. /* forces a refresh of a table if it was changed by another user        */
  790. int pascal far PXNetTblRefresh(
  791.         TABLEHANDLE tblHandle); /* tabel to refresh                     */
  792.  
  793.  
  794.  
  795. /* ERROR FUNCTIONS */
  796.  
  797.  
  798. /* returns error text associated with the error number                  */
  799. char far *pascal far PXErrMsg(
  800.         int errCode);           /* errcode to return text for           */
  801.  
  802.  
  803. /* returns name of user causing a locking error                         */
  804. int pascal far PXNetErrUser(
  805.         int bufSize,            /* size of return buffer                */
  806.         char far *userName);    /* returns user name                    */
  807.  
  808. #ifdef _PX_DEFED_WINDOWS
  809. #  undef WINDOWS
  810. #  undef _PX_DEFED_WINDOWS
  811. #endif /* _PX_DEFED_WINDOWS */
  812.  
  813. #ifdef __cplusplus
  814.    }
  815. #endif /* __cplusplus */
  816.  
  817. #endif /* PXENGINE_H */
  818.