home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / pascal / tpw / owldemos / pxengine.pas < prev    next >
Pascal/Delphi Source File  |  1991-05-20  |  36KB  |  912 lines
  1. {************************************************}
  2. {                                                }
  3. {   Turbo Pascal for Windows                     }
  4. {   Paradox Engine demo interface unit           }
  5. {   Copyright (c) 1991 by Borland International  }
  6. {                                                }
  7. {************************************************}
  8.  
  9. unit PXEngine;
  10.  
  11. interface
  12.  
  13. uses WinProcs,WinTypes;
  14.  
  15. const
  16.  internalVersion  = $02000002;    { version number, same }
  17.                                   { as found in .lib files }
  18. { Type definitions  }
  19. type
  20.   TableHandle = word;             { table handle }
  21.   RecordHandle = word;            { record handle }
  22.   FieldHandle = word;             { field number 1.. }
  23.   LockHandle = Integer;           { lock handle }
  24.   RecordNumber = LongInt;         { record number 1.. }
  25.   Date = LongInt;                 { representation of date }
  26.  
  27. { Maximum and default values for dynamic configuration. }
  28. { The default values are used if not overwritten in PXSetDefaults (DOS) }
  29. { or in WIN.INI (Windows) }
  30. const
  31.   PXDefault =   0;                { use internal default value }
  32.  
  33.   MaxTableHandles =  64;          { maximum number of open }
  34.                                   { tables allowed at a time }
  35.   DefTableHandles =   5;          { default number of open }
  36.                                   { tables allowed at a time }
  37.   MaxRecordHandles = 128;         { maximum number of record }
  38.                                   { buffers available }
  39.   DefRecordHandles =  10;         { default number of record }
  40.                                   { buffers available }
  41.   MaxLockHandles = 128;           { maximum number of lock }
  42.                                   { handles per table }
  43.   DefLockHandles =  32;           { default number of lock }
  44.                                   { handles per table }
  45.   MaxFileHandles = 255;           { maximum number of DOS file }
  46.                                   { handles to use }
  47.   MinFileHandles =   2;           { minimum number of DOS file }
  48.                                   { handles to use }
  49.   DefFileHandles =  10;           { default number of DOS file }
  50.                                   { handles to use }
  51. const
  52.   DefSortOrder = #255;            { default sort order (ASCII) }
  53.  
  54. { Swap buffer size }
  55. const
  56.   MaxSwapSize = 256;              { maximum buffer size allowed (k)}
  57.   MinSwapSize =   8;              { minimum buffer size allowed (k)}
  58.   DefSwapSize =  32;              { default buffer size (k) }
  59.  
  60. { Network codes }
  61. { used in PXNetInit }
  62. const
  63.   NotOnNet = 1;                   { Not on a net }
  64.   NovellNet = 2;                  { Novell }
  65.   ThreeComNet = 3;                { 3Com }
  66.   ThreeOpenNet = 4;               { 3Com 3+Open }
  67.   OtherNet = 5;                   { other: unknown DOS 3.1 compatible }
  68.   StarLanNet = 7;                 { Starlan }
  69.   BanyanNet = 8;                  { Banyan }
  70.   IBMPCNet = 9;                   { IBM PC }
  71.  
  72. const
  73.   LocalShare = 32;                { enables sharing on local drives with }
  74.                                   { any net type }
  75.                                   { (i.e. OTHERNET | LOCALSHARE) }
  76. const
  77.   DefUserName = nil;              { use default username in PXNetInit() }
  78.  
  79.  
  80. { used in PXKeyAdd }
  81. const
  82.   Primary =  0;                   { primary index (key) }
  83.   Secondary =  1;                 { not maintained secondary index }
  84.   IncSecondary =  2;              { maintained secondary index }
  85.  
  86. { used in PXSrchFld, PXSrchKey }
  87. const
  88.   SearchFirst = 0;                { search from beginning of table }
  89.   SearchNext = 1;                 { search from next record in table }
  90.   ClosestRecord = 2;              { (modifier) goto 'nearest' record if }
  91.                                   { no match found (ordered fields only) }
  92.  
  93. { Lock types }
  94. { used in PXNetFileLock, PXNetFileUnlock, PXNetTblLock, PXNetTblUnlock }
  95. const
  96.   FL = 1;                         { full lock, no concurrency }
  97.   WL = 2;                         { write lock }
  98.   PWL = 3;                        { prevent write lock }
  99.   PFL = 4;                        { prevent full lock, full concurrency }
  100.  
  101. { macros for checking blank values }
  102. const
  103.   BlankDate = $80000000;
  104.   BlankLong = $80000000;
  105.   BlankShort = $8000;
  106.  
  107. function IsBlankAlpha(x: PChar): Boolean;
  108. inline(
  109.   $58/       { POP AX       }
  110.   $5A/       { POP DX       }
  111.   $1E/       { PUSH DS      }
  112.   $DA8E/     { MOV DS,DX    }
  113.   $C689/     { MOV SI,AX    }
  114.   $C031/     { XOR AX,AX    }
  115.   $AC/       { LODSB        }
  116.   $1F        { POP DS       }
  117. );
  118.  
  119. function IsBlankShort(x: Integer): Boolean;
  120. inline(
  121.   $58/       { POP AX       }
  122.   $35/$8000/ { XOR AX,$8000 }
  123.   $D8F7/     { NEG AX       }
  124.   $C01B/     { SBB AX,AX    }
  125.   $40        { INC AX       }
  126. );
  127.  
  128. function IsBlankLong(x: LongInt): Boolean;
  129. inline(
  130.   $5A/       { POP DX       }
  131.   $58/       { POP AX       }
  132.   $35/$8000/ { XOR AX,$8000 }
  133.   $C20B/     { OR  AX,DX    }
  134.   $D8F7/     { NEG AX       }
  135.   $C01B/     { SBB AX,AX    }
  136.   $40        { INC AX       }
  137. );
  138.  
  139. function IsBlankDate(x: Date): Boolean;
  140. inline(
  141.   $5A/       { POP DX       }
  142.   $58/       { POP AX       }
  143.   $35/$8000/ { XOR AX,$8000 }
  144.   $C20B/     { OR  AX,DX    }
  145.   $D8F7/     { NEG AX       }
  146.   $C01B/     { SBB AX,AX    }
  147.   $40        { INC AX       }
  148. );
  149.  
  150.  
  151. { successful Engine function operation returns }
  152. const
  153.   PXSuccess = 0;
  154.  
  155. { Error codes from Engine functions }
  156.  
  157. { initialization errors }
  158. const
  159.   PXErr_NotInitErr = 78;          { Engine not initialized }
  160.   PXErr_AlreadyInit = 82;         { Engine already initialized }
  161.   PXErr_NotLoggedIn = 98;         { Could not login on network }
  162.                                   { (to PARADOX.NET) }
  163.   PXErr_NoNetInit = 107;          { Engine not initialized }
  164.                                   { with PXNetInit }
  165.   PXErr_NetMultiple = 15;         { multiple PARADOX.NET files }
  166.  
  167.   PXErr_CantSharePDoxNet = 134;   { can't lock PARADOX.NET -- is }
  168.                                   { SHARE.EXE loaded? }
  169.   PXErr_WindowsRealMode = 135;    { can't run Engine in Windows  }
  170.                                   { real mode }
  171.  
  172. { hardware related errors }
  173. const
  174.   PXErr_DriveNotReady = 1;        { Drive not ready }
  175.   PXErr_DiskWritePro = 124;       { Disk is write protected }
  176.   PXErr_GeneralFailure = 126;     { General hardware error }
  177.  
  178. { directory reg error codes }
  179. const
  180.   PXErr_DirNotFound = 2;          { Directory not found }
  181.   PXErr_DirBusy = 10;             { Sharing violation }
  182.   PXErr_DirLocked  = 11;          { Sharing violation }
  183.   PXErr_DirNoAccess = 12;         { No access to directory }
  184.   PXErr_DirNotPrivate = 14;       { Single user, but directory is }
  185.                                   { shared }
  186.  
  187. { file oriented errors }
  188. const
  189.   PXErr_FileBusy = 3;             { File is busy }
  190.   PXErr_FileLocked = 4;           { File is locked }
  191.   PXErr_FileNotFound = 5;         { Could not find file }
  192.  
  193. { table oriented errors }
  194. const
  195.   PXErr_TableBusy = 118;          { Table is busy }
  196.   PXErr_TableLocked = 119;        { Table is locked }
  197.   PXErr_TableNotFound = 120;      { Table was not found }
  198.   PXErr_TableOpen =  83;          { Unable to perform operation }
  199.                                   { on open table }
  200.   PXErr_TableIndexed =  94;       { Table is indexed }
  201.   PXErr_TableNotIndexed =  95;    { Table is not indexed }
  202.   PXErr_TableEmpty = 105;         { Operation on empty table }
  203.   PXErr_TableWritePro =  22;      { Table is write protected }
  204.  
  205.   PXErr_TableCorrupted =   6;     { Table is corrupted }
  206.   PXErr_TableFull = 128;          { Table is full }
  207.   PXErr_TableSQL = 130;           { Table is SQL replica }
  208.   PXErr_InsufRights =  21;        { Insufficient password rights }
  209.  
  210.  
  211. { index oriented errors }
  212. const
  213.   PXErr_XCorrupted = 7;           { Primary index is corrupted }
  214.   PXErr_XOutOfDate = 8;           { Primary index is out of date }
  215.   PXErr_XSortVersion = 13;        { Sort for index different }
  216.                                   { from table }
  217.  
  218.   PXErr_SXCorrupted = 122;        { Secondary index is corrupted }
  219.   PXErr_SXOutOfDate =  96;        { Secondary index is out of date }
  220.   PXErr_SXNotFound = 121;         { Secondary index was not found }
  221.   PXErr_SXOpen = 123;             { Secondary index is already open }
  222.   PXErr_SXCantUpdate = 136;       { Can't update table open on non-maintained secondary }
  223.  
  224.   PXErr_RecTooBig = 125;          { Record too big for index }
  225.  
  226. { record oriented errors }
  227. const
  228.   PXErr_RecDeleted = 50;          { Another user deleted record }
  229.   PXErr_RecLocked = 9;            { Record is locked }
  230.   PXErr_RecNotFound = 89;         { Record was not found }
  231.   PXErr_KeyViol = 97;             { Key violation }
  232.  
  233.   PXErr_EndOfTable = 101;         { End of table }
  234.   PXErr_StartOfTable = 102;       { Start of table }
  235.  
  236.  
  237. { errors specific for Windows Engine DLL }
  238. const
  239.   PXErr_TooManyClients = 131;
  240.   PXErr_ExceedsConfigLimits = 132;
  241.   PXErr_CantRemapFileHandle = 133;
  242.  
  243. { resource errors }
  244. const
  245.   PXErr_OutOfMem = 40;            { Not enough memory to }
  246.                                   { complete operation }
  247.   PXErr_OutOfDisk = 41;           { Not enough disk space to }
  248.                                   { complete operation }
  249.   PXErr_OutOfStack = 127;         { Not enough stack space to }
  250.                                   { complete operation }
  251.   PXErr_OutOfSwapBuf = 129;       { Not enough swap buffer space to }
  252.                                   { complete operation }
  253.  
  254.   PXErr_OutOfFileHandles = 70;    { No more file handles available }
  255.   PXErr_OutOfTableHandles = 72;   { No more table handles available }
  256.   PXErr_OutOfRecHandles = 103;    { No more record handles available }
  257.   PXErr_OutOfLockHandles = 111;   { Too many locks on table }
  258.  
  259.   PXErr_NoMoreTmpNames = 86;      { No more temporary names }
  260.                                   { available }
  261.   PXErr_TooManyPassw = 115;       { Too many passwords specified }
  262.  
  263.  
  264. { invalid parameters to functions }
  265. const
  266.   PXErr_TypeMismatch = 30;        { Data type mismatch }
  267.   PXErr_OutOfRange = 31;          { Argument out of range }
  268.   PXErr_InvParameter = 33;        { Invalid argument }
  269.   PXErr_InvDate = 73;             { Invalid date given }
  270.  
  271.   PXErr_InvFieldHandle = 75;      { Invalid field handle }
  272.   PXErr_InvRecHandle = 104;       { Invalid record handle }
  273.   PXErr_InvTableHandle = 76;      { Invalid table handle }
  274.   PXErr_InvLockHandle = 110;      { Invalid lock handle }
  275.  
  276.   PXErr_InvDirName = 114;         { Invalid directory name }
  277.   PXErr_InvFileName = 108;        { Invalid file name }
  278.   PXErr_InvTableName = 99;        { Invalid table name }
  279.   PXErr_InvFieldName = 74;        { Invalid field name }
  280.  
  281.   PXErr_InvLockCode = 106;        { Invalid lock code }
  282.   PXErr_InvUnlock = 109;          { Invalid unlock }
  283.   PXErr_InvSortOrder = 112;       { Invalid sort order table }
  284.   PXErr_InvPassw = 116;           { Invalid password }
  285.   PXErr_InvNetType = 113;         { Invalid net type (PXNetInit) }
  286.   PXErr_BufTooSmall = 117;        { Buffer too small for result }
  287.  
  288.   PXErr_StructDiffer = 81;        { Table structures are different }
  289.  
  290.   PXErr_InvEngineState = 79;      { Previous fatal error; }
  291.                                   { cannot proceed }
  292.  
  293. { values for ShareMode argument to PXWinInit }
  294. const
  295.   PXSingleClient = 0;             { allow no other client access to Engine DLL }
  296.   PXExclusive = 1;                { open all tables with FULL LOCK }
  297.   PXShared = 2;                   { open all tables with PREVENT FULL LOCK }
  298.  
  299. { prototypes for engine functions }
  300.  
  301. { declarations of sort order tables, used in PXSetDefaults }
  302. const
  303.   SortOrderAscii = 'a';           { ASCII sort order }
  304.   SortOrderInt = 'i';             { international sort order }
  305.   SortOrderNorDan = 'n';          { Norwegian/Danish sort order }
  306.   SortOrderSwedFin = 's';         { Swedish/Finnish sort order }
  307.  
  308. { INITIALIZATION AND FINALIZATION FUNCTIONS }
  309.  
  310. { initialize Engine connection in Windows environment }
  311. function PXWinInit(
  312.   clientName: PChar;              { string containing name of application }
  313.   ShareMode: Integer              { Share mode: PXSingleClient, }
  314.                                   { PXExclusive, or PXShared }
  315.   ): Integer;
  316.  
  317. { exit and deallocate }
  318. function PXExit: Integer;
  319.  
  320. { overwrites internal default values }
  321. function PXSetDefaults(
  322.   bufSize: Integer;               { internal swap buffer size }
  323.                                   { MinSwapSize..MaxSwapSize (8..256), }
  324.                                   { default DefSwapSize (32) }
  325.                                   { allocated at initialization time }
  326.   maxTables: Integer;             { max number of tables open at a time }
  327.                                   { range 1..MaxTableHandles ,   (1..64) }
  328.                                   { default  DefTableHandles     (5) }
  329.   maxRecBufs: Integer;            { max number of record buffers at a time}
  330.                                   { range 1..MaxRecordHandles ,  (1..128) }
  331.                                   { default  DefRecordHandles    (10) }
  332.   maxLocks: Integer;              { max number of locks per table }
  333.                                   { range 1..MaxLockHandles  ,   (1..128) }
  334.                                   { default DefLockHandles       (32) }
  335.   maxFiles: Integer;              { max number of file handles to use }
  336.                                   { range MinFileHandles..MaxFileHandles }
  337.                                   { default DefFileHandles       (10) }
  338.   sortOrder: Char                 { code for sort order table defined }
  339.                                   { internally in the Engine : }
  340.                                   { SortOrderAscii/SortOrderInt/ }
  341.                                   { SortOrderNorDan/SortOrderSwedFin }
  342.                                   { default : SortOrderAscii }
  343.   ): Integer;
  344.  
  345.  
  346. { returns current default settings }
  347. function PXGetDefaults(
  348.   var swapSize: Integer;          { returns internal swap buffer size }
  349.   var maxTables: Integer;         { returns max number of tables at a time }
  350.   var maxRecBufs: Integer;        { returns max number of record buffers }
  351.   var maxLocks: Integer;          { returns max number of locks per table }
  352.   var maxFiles: Integer;          { returns max number of file handles to use }
  353.   var sortTable: Char             { returns code indicating default sort table }
  354.   ): Integer;
  355.  
  356. { enables/disables internal hardware error handler }
  357. function PXSetHWHandler(
  358.   hwHandler: Bool                 { enable(True) / disable (False) }
  359.   ): Integer;                     { default True }
  360.  
  361.  
  362. { UTILITY FUNCTIONS }
  363.  
  364. function IsBlankDouble(x: Double): Bool;
  365. procedure BlankDouble(var x: Double);
  366.  
  367. { TABLE FUNCTIONS }
  368.  
  369. { open table for access, returning table handle }
  370. function PXTblOpen(
  371.   tblName: PChar;                 { name of table to open }
  372.   var tblHandle: TableHandle;     { returns handle for opened table }
  373.   indexID: Integer;               { =0 mastertable else indexnumber }
  374.   saveEveryChange: Bool           { save each record as it is changed }
  375.                                   { don't buffer changes }
  376.   ): Integer;
  377.  
  378.  
  379. { close access to table }
  380. function PXTblClose(
  381.   tblHandle: TableHandle          { tblHandle of table to close }
  382.   ): Integer;
  383.  
  384. { create empty table }
  385. function PXTblCreate(
  386.   tblName: PChar;                 { name of table to create }
  387.   nFields: Integer;               { number of fields in table }
  388.   var fields;                     { field names }
  389.   var types                       { field types (N, S..) }
  390.   ): Integer;
  391.  
  392. { clear table for records }
  393. function PXTblEmpty(
  394.   tblName: PChar                  { name of table to empty }
  395.   ): Integer;
  396.  
  397. { delete table and its family }
  398. function PXTblDelete(
  399.   tblName: PChar                  { name of table to delete }
  400.   ): Integer;
  401.  
  402. { copy table and its family }
  403. function PXTblCopy(
  404.   fromName: PChar;                { source table of copy }
  405.   toName: PChar                   { destination table of copy }
  406.   ): Integer;
  407.  
  408. { rename table and its family }
  409. function PXTblRename(
  410.   fromName: PChar;                { source table of copy }
  411.   toName: PChar                   { destination table of copy }
  412.   ): Integer;
  413.  
  414. { add records from one table to another table }
  415. function PXTblAdd(
  416.   srcName: PChar;                 { source table of add }
  417.   destName: PChar                 { destination table of add }
  418.   ): Integer;
  419.  
  420.  
  421. { RECORD FUNCTIONS }
  422.  
  423. { insert record buffer in database (as last record if Heap) }
  424. function PXRecAppend(
  425.   tblHandle: TableHandle;         { table to append record to }
  426.   recHandle: RecordHandle         { record to append }
  427.   ): Integer;
  428.  
  429. { insert record buffer in database (before current if Heap) }
  430. function PXRecInsert(
  431.   tblHandle: TableHandle;         { table to insert record into }
  432.   recHandle: RecordHandle         { record to insert }
  433.   ): Integer;
  434.  
  435. { updates current record in database with contents of the record buffer }
  436. function PXRecUpdate(
  437.   tblHandle: TableHandle;         { table to update record into }
  438.   recHandle: RecordHandle         { changed record to post }
  439.   ): Integer;
  440.  
  441. { delete current record in table }
  442. function PXRecDelete(
  443.   tblHandle: TableHandle          { table to delete record in }
  444.   ): Integer;
  445.  
  446. { creates a record buffer for a table }
  447. function PXRecBufOpen(
  448.   tblHandle: TableHandle;         { table to create buffer for }
  449.   var recHandle: RecordHandle     { returns handle to record buffer }
  450.   ): Integer;
  451.  
  452. { deletes a record buffer for a table }
  453. function PXRecBufClose(
  454.   recHandle: RecordHandle         { record buffer to remove }
  455.   ): Integer;
  456.  
  457. { clears the record buffer (to blanks) }
  458. function PXRecBufEmpty(
  459.   recHandle: RecordHandle         { record buffer to clear }
  460.   ): Integer;
  461.  
  462. { copy record from a record buffer to another (compatible) record buffer }
  463. function PXRecBufCopy(
  464.   fromHandle: RecordHandle;       { record buffer to copy from }
  465.   toHandle: RecordHandle          { record buffer to copy to   }
  466.   ): Integer;
  467.  
  468. { gets the current record from the database into the record buffer }
  469. function PXRecGet(
  470.   tblHandle: TableHandle;         { table to get record from }
  471.   recHandle: RecordHandle         { record buffer to put record in }
  472.   ): Integer;
  473.  
  474. { FIELD FUNCTIONS }
  475.  
  476. { put short value into N/$/S field in record buffer }
  477. function PXPutShort(
  478.   recHandle: RecordHandle;        { record buffer to put value in }
  479.   fldHandle: FieldHandle;         { field in record }
  480.   value: Integer                  { value to put }
  481.   ): Integer;
  482.  
  483. { put Double value into N/$/S field in record buffer }
  484. function PXPutDoub(
  485.   recHandle: RecordHandle;        { record buffer to put value in }
  486.   fldHandle: FieldHandle;         { field in record }
  487.   value: Double                   { value to put }
  488.   ): Integer;
  489.  
  490. { put LongInt value into N/$/S field in record buffer }
  491. function PXPutlong(
  492.   recHandle: RecordHandle;        { record buffer to put value in }
  493.   fldHandle: FieldHandle;         { field in record }
  494.   value: LongInt                  { value to put }
  495.   ): Integer;
  496.  
  497. { put string into Alpha field in record buffer }
  498. function PXPutAlpha(
  499.   recHandle: RecordHandle;        { record buffer to put value in }
  500.   fldHandle: FieldHandle;         { field in record }
  501.   value: PChar                    { value to put }
  502.   ): Integer;
  503.  
  504. { put LongInt value into date field (encoded value) in record buffer }
  505. function PXPutDate(
  506.   recHandle: RecordHandle;        { record buffer to put value in }
  507.   fldHandle: FieldHandle;         { field in record }
  508.   value: Date                     { value to put }
  509.   ): Integer;
  510.  
  511. { put blank value into field in record buffer }
  512. function PXPutBlank(
  513.   recHandle: RecordHandle;        { record buffer to put blank in }
  514.   fldHandle: FieldHandle          { field in record }
  515.   ): Integer;
  516.  
  517. { get value from N/$/S field in record buffer, into short }
  518. function PXGetShort(
  519.   recHandle: RecordHandle;        { record buffer to get value from }
  520.   fldHandle: FieldHandle;         { field to get value from }
  521.   var value: Integer              { returns value }
  522.   ): Integer;
  523.  
  524. { get value from N/$/S field in record buffer, into Double }
  525. function PXGetDoub(
  526.   recHandle: RecordHandle;        { record buffer to get value from }
  527.   fldHandle: FieldHandle;         { field to get value from }
  528.   var value: Double               { returns value }
  529.   ): Integer;
  530.  
  531. { get value from N/$/S field in record buffer, into LongInt }
  532. function PXGetlong(
  533.   recHandle: RecordHandle;        { record buffer to get value from }
  534.   fldHandle: FieldHandle;         { field to get value from }
  535.   var value: LongInt              { returns value }
  536.   ): Integer;
  537.  
  538. { get string from alpha field in record buffer }
  539. function PXGetAlpha(
  540.   recHandle: RecordHandle;        { record buffer to get value from }
  541.   fldHandle: FieldHandle;         { field to get value from }
  542.   bufSize: Integer;               { size of return buffer }
  543.   dest: PChar                     { return buffer }
  544.   ): Integer;
  545.  
  546. { get value from date field in record buffer, into LongInt  (encoded value) }
  547. function PXGetDate(
  548.   recHandle: RecordHandle;        { record buffer to get value from }
  549.   fldHandle: FieldHandle;         { field to get value from }
  550.   var value: Date                 { returns value }
  551.   ): Integer;
  552.  
  553. { is value in specified field in record buffer a blank? }
  554. function PXFldBlank(
  555.   recHandle: RecordHandle;        { record to test value in }
  556.   fldHandle: FieldHandle;         { field to test }
  557.   var Blank: Bool                 { returns True/False }
  558.   ): Integer;
  559.  
  560. { move to record with specified record number }
  561. function PXRecGoto(
  562.   tblHandle: TableHandle;         { tblHandle of table to move in }
  563.   recNum: RecordNumber            { record number to move to }
  564.   ): Integer;
  565.  
  566. { move to first record in table }
  567. function PXRecFirst(
  568.   tblHandle: TableHandle          { table to move in }
  569.   ): Integer;
  570.  
  571. { move to last record in table }
  572. function PXRecLast(
  573.   tblHandle: TableHandle          { table to move in }
  574.   ): Integer;
  575.  
  576. { move to next record in table }
  577. function PXRecNext(
  578.   tblHandle: TableHandle          { table to move in }
  579.   ): Integer;
  580.  
  581. { move to previous record in table }
  582. function PXRecPrev(
  583.   tblHandle: TableHandle          { table to move in }
  584.   ): Integer;
  585.  
  586. { INDEX FUNCTIONS }
  587.  
  588. { add a primary or secondary (maintained/nonmaintained) index }
  589. function PXKeyAdd(
  590.   tblName: PChar;                 { name of table to add index for  }
  591.   nFlds: Integer;                 { number of fields in index }
  592.   var fldHandles;                 { array of field numbers in index }
  593.   mode: Integer                   { type of index to create }
  594.                                   { PRIMARY/SECONDARY/INCSECONDARY }
  595.   ): Integer;
  596.  
  597. { delete an index for a table (primary/secondary) }
  598. function PXKeyDrop(
  599.   tblName: PChar;                 { name of table to delete index for }
  600.   indexID: Integer                { 0 if primary key, else field number }
  601.                                   { of secondary index }
  602.   ): Integer;
  603.  
  604.  
  605. { DATE FUNCTIONS }
  606.  
  607. { decodes a date value stored in the Paradox format }
  608. function PXDateDecode(
  609.   aDate: Date;                    { LongInt value to decode }
  610.   var mo: Integer;                { decoded month value }
  611.   var da: Integer;                { decoded date value }
  612.   var yr: Integer                 { decoded year value }
  613.   ): Integer;
  614.  
  615. { encodes a date value to a LongInt value in Paradox format }
  616. function PXDateEncode(
  617.   mo,                             { month value to encode }
  618.   da,                             { date value to encode }
  619.   yr: Integer;                    { year value to encode }
  620.   var aDate: Date                 { encoded date value }
  621.   ): Integer;
  622.  
  623. { SEARCH FUNCTIONS }
  624.  
  625. { Searches a table for a given (sub) key }
  626. function PXSrchKey(
  627.   tblHandle: TableHandle;         { table to search in }
  628.   recHandle: RecordHandle;        { record buffer containing key to find }
  629.   nFlds,                          { number of fields in key }
  630.   mode: Integer                   { searching from first/next record }
  631.   ): Integer;
  632.  
  633. function PXSrchFld(
  634.   tblHandle: TableHandle;         { table to search in }
  635.   recHandle: RecordHandle;        { record buffer containing field to find }
  636.   fldHandle: FieldHandle;         { field number to search on }
  637.   mode: Integer                   { searching from first/next record }
  638.   ): Integer;
  639.  
  640. { PASSWORD FUNCTIONS }
  641.  
  642. { checks if table is encrypted }
  643. function PXTblProtected(
  644.   tblName: PChar;                 { name of table to check }
  645.   var Protected: Bool             { returns True/False }
  646.   ): Integer;
  647.  
  648. { enters a password to the Engine }
  649. function PXPswAdd(
  650.   password: PChar                 { password to enter into system }
  651.   ): Integer;
  652.  
  653. { deletes a password previously entered }
  654. function PXPswDel(
  655.   password: PChar                 { password to remove from system }
  656.   ): Integer;
  657.  
  658. { encrypt a table and make it password protected }
  659. function PXTblEncrypt(
  660.   tblName: PChar;                 { name of table to encrypt }
  661.   password: PChar                 { password for encrypted table }
  662.   ): Integer;
  663.  
  664. { decrypt a table, password must already have been entered }
  665. function PXTblDecrypt(
  666.   tblName: PChar                  { name of table to decrypt }
  667.   ): Integer;
  668.  
  669.  
  670. { INFORMATIONAL FUNCTIONS }
  671.  
  672. { checks if table exists }
  673. function PXTblExist(
  674.   tblName: PChar;                 { name of table to check }
  675.   var Exist: Bool                 { returns TRUE/FALSE }
  676.   ) : Integer;
  677.  
  678. { returns table name corresponding to a table handle }
  679. function PXTblName(
  680.   tblHandle: TableHandle;         { table to return name of }
  681.   bufSize: Integer;               { size of return buffer }
  682.   tblName: PChar                  { name of table, without extension }
  683.   ): Integer;
  684.  
  685. { returns record number of current record in table }
  686. function PXRecNum(
  687.   tblHandle: TableHandle;         { table to get record number from }
  688.   var recNum: RecordNumber        { returns record number }
  689.   ): Integer;
  690.  
  691. { returns number of records in table }
  692. function PXTblNRecs(
  693.   tblHandle: TableHandle;         { table to get number of records from }
  694.   var nRecs: RecordNumber         { returns number of records }
  695.   ): Integer;
  696.  
  697. { returns number of fields in a record }
  698. function PXRecNFlds(
  699.   tblHandle: TableHandle;         { table to get number of fields from }
  700.   var nFlds: Integer              { returns number of fields in a record }
  701.   ): Integer;
  702.  
  703. { return number of fields in key for table }
  704. function PXKeyNFlds(
  705.   tblHandle: TableHandle;         { table to get key size for }
  706.   var nKeyFlds: Integer           { returns number of fields in key }
  707.   ): Integer;
  708.  
  709. { returns field number of a given field name in a table }
  710. function PXFldHandle(
  711.   tblHandle: TableHandle;         { table to get field number from }
  712.   fieldName: PChar;               { name of field in table }
  713.   var fldHandle: FieldHandle      { returns field number }
  714.   ): Integer;
  715.  
  716. { returns field type of a given field in a table }
  717. function PXFldType(
  718.   tblHandle: TableHandle;         { table to get field type from }
  719.   fldHandle: FieldHandle;         { field number of field in table }
  720.   bufSize: Integer;               { size of return buffer }
  721.   fldType: PChar                  { field type of field as string }
  722.   ): Integer;
  723.  
  724. { returns field name of a given field in a table }
  725. function PXFldName(
  726.   tblHandle: TableHandle;         { table to get field name from }
  727.   fldHandle: FieldHandle;         { field number of field in table }
  728.   bufSize: Integer;               { size of return buffer }
  729.   fldName: PChar                  { returns name of field }
  730.   ): Integer;
  731.  
  732.  
  733. { MISCELLANEOUS FUNCTIONS }
  734. { sets maximum size of tables created with PXTblCreat() }
  735. function PXTblMaxSize(
  736.   maxsize: Integer                { maximum size of table }
  737.                                   { 64/128/256  (Megabytes) }
  738.   ): Integer;
  739.  
  740. { saves all buffered changes to disk }
  741. function PXSave: Integer;
  742.  
  743. { CONCURRENCY FUNCTIONS }
  744. { can be used only if PXNetInit() or PXWinInit() was successful }
  745.  
  746. { returns name of user as known on network }
  747. function PXNetUserName(
  748.   bufSize: Integer;               { size of return buffer }
  749.   userName: PChar                 { returns user name }
  750.   ): Integer;
  751.  
  752. { locks a file with specified lock (general function) }
  753. function PXNetFileLock(
  754.   fileName: PChar;                { name of file to lock }
  755.   lockType: Integer               { type of lock to put on file }
  756.                                   { (FL, WL, PFL, PWL) }
  757.   ): Integer;
  758.  
  759.  
  760. { unlocks a file with specified lock (general function) }
  761. function PXNetFileUnlock(
  762.   fileName: PChar;                { name of file to unlock }
  763.   lockType: Integer               { type of lock to remove from file }
  764.                                   { (FL, WL, PFL, PWL) }
  765.   ): Integer;
  766.  
  767.  
  768. { locks an open table with specified lock }
  769. function PXNetTblLock(
  770.   tblHandle: TableHandle;         { table to lock }
  771.   lockType: Integer               { type of lock to put on table }
  772.                                   { (FL, WL, PFL, PWL) }
  773.   ): Integer;
  774.  
  775.  
  776. { unlocks an open table with specified lock }
  777. function PXNetTblUnlock(
  778.   tblHandle: TableHandle;         { table to unlock }
  779.   lockType: Integer               { type of lock to remove from table }
  780.                                   { (FL, WL, PFL, PWL) }
  781.   ): Integer;
  782.  
  783. { locks the current record in a table }
  784. function PXNetRecLock(
  785.   tblHandle: TableHandle;         { table to lock record in }
  786.   var lckHandle: LockHandle       { returns handle to lock  }
  787.   ): Integer;
  788.  
  789. { unlocks record associated with lock handle in the table }
  790. function PXNetRecUnlock(
  791.   tblHandle: TableHandle;         { table to unlock record in }
  792.   lckHandle: LockHandle           { lock handle of record to unlock }
  793.   ): Integer;
  794.  
  795. { checks if current record in table is locked (by any user) }
  796. function PXNetRecLocked(
  797.   tblHandle: TableHandle;         { table to check record in }
  798.   var Locked: Bool                { returns True/False }
  799.   ): Integer;
  800.  
  801. { moves to the record in the table associated with the lock handle }
  802. function PXNetRecGotoLock(
  803.   tblHandle: TableHandle;         { table to move in }
  804.   lckHandle: LockHandle           { lock handle to record }
  805.   ): Integer;
  806.  
  807. { checks if table was changed by other user since last refresh }
  808. function PXNetTblChanged(
  809.   tblHandle: TableHandle;         { table to test }
  810.   var Changed: Bool               { returns True/False }
  811.   ): Integer;
  812.  
  813. { forces a refresh of a table if it was changed by another user }
  814. function PXNetTblRefresh(
  815.   tblHandle: TableHandle          { table to refresh }
  816.   ): Integer;
  817.  
  818.  
  819. { ERROR FUNCTIONS }
  820.  
  821. { returns error text associated with the error number }
  822. function PXErrMsg(
  823.   errCode: Integer                { errcode to return text for }
  824.   ): PChar;
  825.  
  826. { returns name of user causing a locking error }
  827. function PXNetErrUser(
  828.   bufSize: Integer;               { size of return buffer }
  829.   userName: PChar                 { returns user name }
  830.   ): Integer;
  831.  
  832. implementation
  833.  
  834. function PXExit;           external 'PXENGWIN' index  4;
  835. function PXSetDefaults;    external 'PXENGWIN' index  5;
  836. function PXGetDefaults;    external 'PXENGWIN' index  6;
  837. function PXSetHWHandler;   external 'PXENGWIN' index  7;
  838. function PXTblOpen;        external 'PXENGWIN' index  8;
  839. function PXTblClose;       external 'PXENGWIN' index  9;
  840. function PXTblCreate;      external 'PXENGWIN' index 10;
  841. function PXTblEmpty;       external 'PXENGWIN' index 11;
  842. function PXTblDelete;      external 'PXENGWIN' index 12;
  843. function PXTblCopy;        external 'PXENGWIN' index 13;
  844. function PXTblRename;      external 'PXENGWIN' index 14;
  845. function PXTblAdd;         external 'PXENGWIN' index 15;
  846. function PXRecAppend;      external 'PXENGWIN' index 16;
  847. function PXRecInsert;      external 'PXENGWIN' index 17;
  848. function PXRecUpdate;      external 'PXENGWIN' index 18;
  849. function PXRecBufOpen;     external 'PXENGWIN' index 19;
  850. function PXRecBufClose;    external 'PXENGWIN' index 20;
  851. function PXRecBufEmpty;    external 'PXENGWIN' index 21;
  852. function PXRecBufCopy;     external 'PXENGWIN' index 22;
  853. function PXRecGet;         external 'PXENGWIN' index 23;
  854. function PXPutShort;       external 'PXENGWIN' index 24;
  855. function PXPutDoub;        external 'PXENGWIN' index 25;
  856. function PXPutLong;        external 'PXENGWIN' index 26;
  857. function PXPutAlpha;       external 'PXENGWIN' index 27;
  858. function PXPutDate;        external 'PXENGWIN' index 28;
  859. function PXPutBlank;       external 'PXENGWIN' index 29;
  860. function PXGetShort;       external 'PXENGWIN' index 30;
  861. function PXGetDoub;        external 'PXENGWIN' index 31;
  862. function PXGetLong;        external 'PXENGWIN' index 32;
  863. function PXGetAlpha;       external 'PXENGWIN' index 33;
  864. function PXGetDate;        external 'PXENGWIN' index 34;
  865. function PXFldBlank;       external 'PXENGWIN' index 35;
  866. function PXRecGoto;        external 'PXENGWIN' index 36;
  867. function PXRecFirst;       external 'PXENGWIN' index 37;
  868. function PXRecLast;        external 'PXENGWIN' index 38;
  869. function PXRecNext;        external 'PXENGWIN' index 39;
  870. function PXRecPrev;        external 'PXENGWIN' index 40;
  871. function PXRecDelete;      external 'PXENGWIN' index 41;
  872. function PXKeyAdd;         external 'PXENGWIN' index 42;
  873. function PXKeyDrop;        external 'PXENGWIN' index 43;
  874. function PXDateDecode;     external 'PXENGWIN' index 44;
  875. function PXDateEncode;     external 'PXENGWIN' index 45;
  876. function PXSrchKey;        external 'PXENGWIN' index 46;
  877. function PXSrchFld;        external 'PXENGWIN' index 47;
  878. function PXTblProtected;   external 'PXENGWIN' index 48;
  879. function PXPswAdd;         external 'PXENGWIN' index 49;
  880. function PXPswDel;         external 'PXENGWIN' index 50;
  881. function PXTblEncrypt;     external 'PXENGWIN' index 51;
  882. function PXTblDecrypt;     external 'PXENGWIN' index 52;
  883. function PXTblExist;       external 'PXENGWIN' index 53;
  884. function PXTblName;        external 'PXENGWIN' index 54;
  885. function PXRecNum;         external 'PXENGWIN' index 55;
  886. function PXTblNRecs;       external 'PXENGWIN' index 56;
  887. function PXRecNFlds;       external 'PXENGWIN' index 57;
  888. function PXKeyNFlds;       external 'PXENGWIN' index 58;
  889. function PXFldHandle;      external 'PXENGWIN' index 59;
  890. function PXFldType;        external 'PXENGWIN' index 60;
  891. function PXFldName;        external 'PXENGWIN' index 61;
  892. function PXTblMaxSize;     external 'PXENGWIN' index 62;
  893. function PXSave;           external 'PXENGWIN' index 63;
  894. function PXNetUserName;    external 'PXENGWIN' index 64;
  895. function PXNetFileLock;    external 'PXENGWIN' index 65;
  896. function PXNetFileUnlock;  external 'PXENGWIN' index 66;
  897. function PXNetTblLock;     external 'PXENGWIN' index 67;
  898. function PXNetTblUnlock;   external 'PXENGWIN' index 68;
  899. function PXNetRecLock;     external 'PXENGWIN' index 69;
  900. function PXNetRecUnlock;   external 'PXENGWIN' index 70;
  901. function PXNetRecLocked;   external 'PXENGWIN' index 71;
  902. function PXNetRecGotoLock; external 'PXENGWIN' index 72;
  903. function PXNetTblChanged;  external 'PXENGWIN' index 73;
  904. function PXNetTblRefresh;  external 'PXENGWIN' index 74;
  905. function PXErrMsg;         external 'PXENGWIN' index 75;
  906. function PXNetErrUser;     external 'PXENGWIN' index 76;
  907. function PXWinInit;        external 'PXENGWIN' index 84;
  908. procedure BlankDouble;     external 'PXENGWIN' index 85;
  909. function IsBlankDouble;    external 'PXENGWIN' index 86;
  910.  
  911. end.
  912.