home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / PASCAL / BMULKY.ZIP / MULKEY.INC < prev    next >
Encoding:
Text File  |  1988-05-18  |  16.9 KB  |  267 lines
  1. { MULKEY.INC }
  2.  
  3. { Hidden constants and types for Mulkey }
  4.  
  5. CONST
  6.       { --------------------- Btrieve Operation Codes ----------------------- }
  7.  
  8.                                    { Operation codes sent to Btrieve          }
  9.                                    { ---------------------------------------- }
  10.       AbortTransactionOp   = 21;   { Removes all operations performed since   }
  11.                                    {  the beginning of an active transaction  }
  12.                                    {  and terminates the transaction          }
  13.       BeginTransactionOp   = 19;   { Marks the beginning of a set of          }
  14.                                    {  related Btrieve operations              }
  15.       ClearOwnerOp         = 30;   { Removes the owner name associated with a }
  16.                                    {  Btrieve file                            }
  17.       CloseOp              = 1;    { Closes a Btrieve file                    }
  18.       CreateOp             = 14;   { Creates a Btrieve file                   }
  19.       DeleteOp             = 4;    { Removes an existing record from a file   }
  20.       EndTransactionOp     = 20;   { Completes a transaction and makes the    }
  21.                                    {  appropriate changes to affected files   }
  22.       ExtendOp             = 16;   { Divides a file over two logical drives   }
  23.       GetDirectOp          = 23;   { Retrieves the data record positioned at  }
  24.                                    { a specified physical address in the file }
  25.       GetEqualOp           = 5;    { Retrieves a record corresponding to a    }
  26.                                    {  specific key value                      }
  27.       GetGreaterOp         = 8;    { Retrieves a record corresponding to a    }
  28.                                    {  key value greater than that specified   }
  29.       GetGreaterOrEqualOp  = 9;    { Retrieves a record corresponding to a    }
  30.                                    {  key value greater or equal to the value }
  31.                                    {  specified                               }
  32.       GetHighestOp         = 13;   { Retrieves the record corresponding to    }
  33.                                    {  the highest key value in the file       }
  34.       GetKeyOp             = 50;   { Retrieves only the key information*      }
  35.       GetLessThanOp        = 10;   { Retireves a record corresponding to a    }
  36.                                    {  key value less than that specified      }
  37.       GetLessThanOrEqualOp = 11;   { Retireves a record with a key value less }
  38.                                    {  than or equal to that specified         }
  39.       GetLowestOp          = 12;   { Retrieves the record corresponding to    }
  40.                                    {  lowest key value for that key number    }
  41.       GetNextOp            = 6;    { Retrieves the record which follows the   }
  42.                                    {  current record                          }
  43.       GetPositionOp        = 22;   { Returns the physical position of the     }
  44.                                    {  current record                          }
  45.       GetPreviousOp        = 7;    { Retrieves the record which precedes the  }
  46.                                    {  current record                          }
  47.       InsertOp             = 2;    { Inserts a record into a Btrieve file     }
  48.       OpenOp               = 0;    { Opens a Btrieve file                     }
  49.       ResetOp              = 28;   { Releases all resources held by a station }
  50.       SetOwnerOp           = 29;   { Assigns an owner name to a Btrieve file  }
  51.       StatOp               = 15;   { Retrieves the characteristics of a file  }
  52.       StepDirectOp         = 24;   { Retrieves a record in the location       }
  53.                                    {  physically following the current record }
  54.       UnlockOp             = 27;   { Unlocks records previously locked        }
  55.       UpdateOp             = 3;    { Updates an existing record in a file     }
  56.       VersionOp            = 26;   { Returns the current Btrieve version      }
  57.  
  58.       { ----------------------- Bit Number Constants ------------------------ }
  59.  
  60.                                    { File Flags Constants                     }
  61.                                    { ---------------------------------------- }
  62.       VarLenRecsBit        = 0;    { Allow variable length records            }
  63.       BlankCompressBit     = 1;    { Perform blank compression on above       }
  64.       PreAllocateBit       = 2;    { Pre-allocate # pages in Allocation word  }
  65.  
  66.                                    { Key Flags Constants                      }
  67.                                    { ---------------------------------------- }
  68.       AllowDupsBit         = 0;    { Allow duplicate key values               }
  69.       ModifiableBit        = 1;    { Key is modifiable                        }
  70.                                    { Bit 2 is ignored by Btrieve under Mulkey }
  71.       NullValueBit         = 3;    { Key has null value                       }
  72.       SegmentedBit         = 4;    { Key has another segment following        }
  73.       AltColSeqBit         = 5;    { Key uses alternate collating sequence    }
  74.       DescendingSortBit    = 6;    { Key is sorting in descending sequence    }
  75.       SupplementalIndexBit = 7;    { Key is supplemental index - ret by stat  }
  76.       ExtendedTypeBit      = 8;    { Key is extended type - always in Mulkey  }
  77.  
  78.                                    { Owner Flags Constants                    }
  79.                                    { ---------------------------------------- }
  80.       ReadOnlyAccessBit    = 0;    { Allow read only access without owner     }
  81.       EncryptBit           = 1;    { Encrypts the data in the file by owner   }
  82.  
  83.       { -------------------- Btrieve Open Mode Constants -------------------- }
  84.  
  85.                                    { Values to send the open procedure        }
  86.                                    { ---------------------------------------- }
  87.       NormalOpen           = 0;    { Normal value to open a Btrieve file      }
  88.       AcceleratedOpen      = -1;   { Accelerated mode - defeats the automatic }
  89.                                    {  data recovery mode in Btrieve           }
  90.       ReadOnlyOpen         = -2;   { Allows opening a damaged file for reads  }
  91.       DOSVerifyOpen        = -3;   { Same as normal but forces DOS verify on  }
  92.       ExclusiveOpen        = -4;   { Same as normal but locks entire file     }
  93.  
  94.       { -------------------- Extended Key Types Constants ------------------- }
  95.  
  96.                                    { Type of Key (KeyType in KeySpecType)     }
  97.                                    { Mulkey uses only the extended key types, }
  98.                                    {  for more info see MULKEY.DOC            }
  99.                                    { ---------------------------------------- }
  100.       ArrayCharKey         = 0;    { Array of character     1-255 bytes       }
  101.       SignedIntKey         = 1;    { Signed whole number    Even # of bytes   }
  102.       FloatKey             = 2;    { IEEE floating point    4 or 8            }
  103.       DateKey              = 3;    { Date                   4 bytes           }
  104.       TimeKey              = 4;    { Time                   4 bytes           }
  105.       DecimalKey           = 5;    { semi-BCD               1-?? (variable)   }
  106.       MoneyKey             = 6;    { same as Decimal        1-?? (variable)   }
  107.       LogicalKey           = 7;    { Logical key            1 or 2 bytes      }
  108.       NumericKey           = 8;    { Numeric                1-255 variable    }
  109.       BFloatKey            = 9;    { Old Microsoft float    4 or 8 bytes      }
  110.       lStringKey           = 10;   { Pascal string          1-254 (255) bytes }
  111.       NullStringKey        = 11;   { Null terminated string 1-255 bytes       }
  112.       UnsignedIntKey       = 14;   { Unsigned whole number  Even # of bytes   }
  113.  
  114.       { -------------------- Mulkey version 3.01A --------------------------- }
  115.  
  116.                                     { Version Control Constants               }
  117.                                     { --------------------------------------- }
  118.       MajorVersion  = 3;            { This version of Mulkey - major version  }
  119.       MinorVersion  = 2;            { This version of Mulkey - minor version  }
  120.       Revision      = 'A';          { The revision (file layout version)      }
  121.       MulkeyDate    = '5-17-1988';  { The date of the release                 }
  122.       FileVersion   = 'MULKEY';     { The file layout version (owner of file) }
  123.  
  124.       { When opening the master FileDesc file, Mulkey uses a string formed    }
  125.       { by concatenating FileVersion with Revision above as the owner of the  }
  126.       { file.  If you attempt to open a file created under a different        }
  127.       { revision, Btrieve will deny access to the file because of an owner    }
  128.       { mismatch.  Mulkey versions 1 and 2 did not use this method so         }
  129.       { revision A begins with version 3.00.  Make sure FileVersion and       }
  130.       { Revision are not longer than the maximum owner length.                }
  131.  
  132.       { ----------------- Owner and Environment constants ------------------- }
  133.  
  134.                                                 { --------------------------- }
  135.       EnvVar        : STRING[8] = 'FILEDESC';   { Main Environment Variable   }
  136.                                                 {  this is a typed constant   }
  137.                                                 {  for changes in MULKEY.EXE  }
  138.  
  139.       { ----------------- Control and Field Size Constants ------------------ }
  140.  
  141.                             { If certain of these constants are changed, it   }
  142.                             { will affect your master FileDesc file layouts.  }
  143.                             { ----------------------------------------------- }
  144.       MaxKeys       = 24;   { Maximum number of keys or segments in Btrieve   }
  145.       MaxKeyLen     = 255;  { Maximum length in bytes of any key              }
  146.       MaxMulkey     = 40;   { Maximum number of Mulkey files open at once     }
  147.                             { Make sure MULKEY.ASM has same MaxMulkey number! }
  148.       MaxTries      = 5;    { Maximum number of retries for file errors       }
  149.       MinKSize      = 64;   { Minimum size of some data structures            }
  150.       MinVersion    = 4;    { Minimum Btrieve version number this requires    }
  151.       MinRevision   = 10;   { Minimum Btrieve revision number this requires   }
  152.       NoHandle      = 0;    { The handle passed if error occurs during open   }
  153.       FirstHandle   = 1;    { The first valid handle returned at open         }
  154.       PosBlockLen   = 128;  { Length in bytes for Btrieves Position Block     }
  155.       SpareBytes    = 21;   { Number of spare bytes in a FileDesc record      }
  156.       BtNotFoundErr = 12;   { File not found error number for Btrieve         }
  157.       ExtLaterCode  = 0;    { Extend file when disk is full operation code    }
  158.       ExtNowCode    = 255;  { Extend file now operation code of extend        }
  159.       ColSeqID      = $AC;  { ID byte of an alternate collating sequence      }
  160.       ColNameLen    = 8;    { Length of a Btreive Alt Collating Sequence name }
  161.       ColSeqLen     = 256;  { Number of bytes in an Alt Collating Sequence    }
  162.  
  163.       { -------------------- FDesc Key Number Constants --------------------- }
  164.  
  165.                                  { Key number for GetFileDesc procedure       }
  166.                                  { ------------------------------------------ }
  167.       FDescOnlyKey      = 1;     { Key number for the FDesc string only       }
  168.       SystemOnlyKey     = 2;     { Key number for System name string only     }
  169.       FDescAndSystemKey = 3;     { Key number for both FDesc and Sytem string }
  170.  
  171.       { ------------------------ Error Code Constants ----------------------- }
  172.  
  173.                               { Error codes for MULKEY only - start at 512    }
  174.                               { --------------------------------------------- }
  175.       NoErr         = 0;      { No error occured                              }
  176.       MulkeyInitErr = 512;    { Could not initialize Mulkey                   }
  177.       NoMemoryErr   = 513;    { Not enough memory                             }
  178.       NoHandlesErr  = 514;    { No more Mulkey handles                        }
  179.       GetOpErr      = 515;    { Error in get operation                        }
  180.       BadHandleErr  = 516;    { Handle not active                             }
  181.       NotActiveErr  = 517;    { Mulkey not initialized                        }
  182.       GetDirectErr  = 518;    { Error in get direct                           }
  183.       InvalidKeyErr = 519;    { Bad key number sent                           }
  184.       OwnerMatchErr = 520;    { Owners did not match                          }
  185.  
  186. { ----------------------- Memory and File Layout Types ---------------------- }
  187.  
  188. TYPE
  189.       MKeyRange     = 1..MaxKeys;
  190.       MKeyLenRange  = 1..MaxKeyLen;
  191.       MulkeyRange   = FirstHandle..MaxMulkey;
  192.  
  193.       BtVerType     = RECORD
  194.                           Version : WORD;
  195.                           Revision: WORD;
  196.                           Net     : CHAR;
  197.                       END; {BtVerType}
  198.  
  199.       ColSeqType    = RECORD
  200.                           ColSeqSign: BYTE;              { The signature byte }
  201.                           ColSeqName: ARRAY[1..ColNameLen] OF CHAR;
  202.                           ColSeq    : ARRAY[1..ColSeqLen] OF CHAR;
  203.                       END; {colseqtype}
  204.  
  205.       PosBlockType  = ARRAY[1..PosBlockLen] OF BYTE; { Btrieve position block }
  206.  
  207.       SpareData     = ARRAY[1..SpareBytes] OF BYTE;  { extra space in record  }
  208.  
  209.       KBLType       = BYTE;
  210.  
  211.       KBuf          = RECORD
  212.                           BufferLen: KBLType;
  213.                           KeyBuffer: ARRAY[MKeyLenRange] OF BYTE;
  214.                       END; {Kbuf}
  215.  
  216.       KeyBufType    = ARRAY[MKeyRange] OF ^KBuf;
  217.  
  218.       KeyBufPtr     = ^KeyBufType;
  219.  
  220.       MulkeyTable   = ARRAY[MulkeyRange] OF ^MemFileType;
  221.  
  222.       KeySpecType   = RECORD
  223.                          Position: WORD;                { Offset in data 1..  }
  224.                          Len     : WORD;                { Key length in bytes }
  225.                          Flags   : WORD;                { bit flags for key   }
  226.                          NotUsed : ARRAY[1..4] OF BYTE; { fill with 0's       }
  227.                          KeyType : BYTE;                { Key Type see above  }
  228.                          Reserved: ARRAY[1..5] OF BYTE; { fill with 0's       }
  229.                       END; {KeySpecType}
  230.  
  231.       FileSpecType  = RECORD
  232.                         CASE BYTE OF
  233.                            0: (RecordLen   : WORD;   { Record length in bytes }
  234.                                PageSize    : WORD;   { Page size to use       }
  235.                                NumIndexes  : WORD;   { # of keys NOT segments }
  236.                                NumRecs     : LONGINT;  { # of records in file }
  237.                                FileFlags   : WORD;   { Bit flags for file     }
  238.                                ReservedWord: WORD;   { Fill with $0000        }
  239.                                Allocation  : WORD;   { # pages to preallocate }
  240.                                KeyBuf      : ARRAY[MKeyRange] OF KeySpecType;
  241.                                AltColSeq   : ColSeqType); { Alternate col seq }
  242.                            1: (MinSize     : ARRAY[1..MinKSize] OF BYTE);
  243.                       END; {FileSpecType}
  244.  
  245.       FileDescType  = RECORD                        { Disk file record layout }
  246.                           TypeName: FDescStr;       { Search name             }
  247.                           SysName : FSystStr;       { System name             }
  248.                           Owner   : FOwnerStr;      { Owner for create ops    }
  249.                           AllowRO : BOOLEAN;        { Read Only OK w/o Owner  }
  250.                           Encrypt : BOOLEAN;        { Encrypt the file        }
  251.                           FileData: FileSpecType;   { Btrieve data            }
  252.                           Spare   : SpareData;      { Extra bytes             }
  253.                       END; {FileDescType}
  254.  
  255.       MemFileType   = RECORD                        { In memory file info     }
  256.                           PosBlock : PosBlockType;  { Btrieves position block }
  257.                           FileDesc : FileDescType;  { Memory info of the file }
  258.                           Extension: PathStr;       { Extension file (if any) }
  259.                           FileName : PathStr;       { Path & name of the file }
  260.                           OpenMode : BYTE;          { LO() of open mode       }
  261.                           Changed  : BOOLEAN;       { If file length changed  }
  262.                           LastKey  : BYTE;          { we keep SUCC of lastkey }
  263.                           LockAttr : FLockAttrib;   { File locking attributes }
  264.                           KeyPtr   : KeyBufPtr;     { Pointer to key buffers  }
  265.                           KeysAlloc: BYTE;          { # of keys allocated     }
  266.                       END; {MemFileType}
  267.