(*# call(o_a_size=>off) *)
(*# call(o_a_copy=>off) *)
(*# data(var_enum_size=>off) *)
DEFINITION MODULE Btree;
(*
        Copyright (C) 1988,1989,1990 Jensen & Partners International
*)

CONST
  MaxKeySize  = 128;
  LockQSize   = 20;

TYPE
  AccessMode      = (FixSize,Size16,Size32,NoDealoc,Compress);
  CmpRes          = (Less,Eq,Greater);
  CompareFunction = PROCEDURE (ADDRESS,ADDRESS) : CmpRes;
  KeyFunction     = PROCEDURE (ADDRESS,ADDRESS);
  FHandle         = POINTER TO IndexFile;
  IHandle         = RECORD
                      ID : FHandle;
                      In : CARDINAL;
                    END;
  Errors    = (OK,                           (* no error *)
               BadOpen,                      (* unable to open *)
               NoSlot,                       (* no slot available *)
               NotFHandle,                   (* not an FHandle *)
               NotIHandle,                   (* not an IHandle *)
               NotData,                      (* not a data file *)
               NotIndex,                     (* not an index file *)
               BadIndex,                     (* incorrect index *)
               BadSize,                      (* illegal size *)
               KeyTooBig,                    (* key size is too large *)
               ErrDupKey,                    (* duplicate key *)
               BadFree,                      (* deallocate not allowed *)
               BadRead,                      (* error during read *)
               BadWrite,                     (* error during write *)
               Locked,                       (* cannot acquire lock *)
               NotLocked,                    (* must already be locked *)
               FileError,                    (* file i/o error *)
               LockOverflow,                 (* too many locks *)
               UnknownError);                (* other error *)
(*# save *)
(*# call(o_a_size=>on) *)
  ErrorProc = PROCEDURE(Errors,ARRAY OF CHAR);
(*# restore *)

VAR
  ErrorHandler : ErrorProc;

CONST
  Null        = IHandle(NIL,MAX(CARDINAL));

PROCEDURE Open(Name: ARRAY OF CHAR; MaxIHandle: CARDINAL;
               AMode : AccessMode;
               readOnly,shared,Create: BOOLEAN): FHandle;
PROCEDURE OpenData(F: FHandle; I,RecordSize: CARDINAL; New: BOOLEAN): IHandle;
PROCEDURE OpenIndex(F: FHandle; D: IHandle; I: CARDINAL;
                    CompFct: CompareFunction; KeyFct: KeyFunction;
                    KeySize: CARDINAL; DupKey,New: BOOLEAN): IHandle;
PROCEDURE Close(VAR F: FHandle);
PROCEDURE FreeIHandle(VAR I: IHandle);
PROCEDURE Flush(F: FHandle);

PROCEDURE LastError (H: IHandle) : Errors;
PROCEDURE LastFError(F: FHandle) : Errors;

PROCEDURE Add     (D: IHandle; Data: ARRAY OF BYTE; Length: CARDINAL);
PROCEDURE AddIndex(I: IHandle; Key: ARRAY OF BYTE; DataLoc: LONGCARD);

PROCEDURE Delete     (D: IHandle);
PROCEDURE DeleteIndex(I: IHandle; Key: ARRAY OF BYTE; DataLoc: LONGCARD);

PROCEDURE Change(D: IHandle; Data: ARRAY OF BYTE; Length: CARDINAL);

PROCEDURE Find     (I: IHandle; Key: ARRAY OF BYTE;
                    VAR Data: ARRAY OF BYTE): BOOLEAN;
PROCEDURE FindIndex(I: IHandle; Key: ARRAY OF BYTE;
                    VAR DataLoc: LONGCARD): BOOLEAN;

PROCEDURE Search     (I: IHandle; Key: ARRAY OF BYTE;
                      VAR Data: ARRAY OF BYTE): BOOLEAN;
PROCEDURE SearchIndex(I: IHandle; Key: ARRAY OF BYTE;
                      VAR DataLoc: LONGCARD): BOOLEAN;

PROCEDURE Next     (I: IHandle; VAR Data: ARRAY OF BYTE): BOOLEAN;
PROCEDURE NextIndex(I: IHandle; VAR DataLoc: LONGCARD): BOOLEAN;

PROCEDURE Prev     (I: IHandle; VAR Data: ARRAY OF BYTE): BOOLEAN;
PROCEDURE PrevIndex(I: IHandle; VAR DataLoc: LONGCARD): BOOLEAN;

PROCEDURE Reset     (H: IHandle);

PROCEDURE SetSyncMode(D: IHandle; On: BOOLEAN);

PROCEDURE ClearIndex(VAR I: IHandle);

PROCEDURE Release(H: IHandle);
PROCEDURE Lock  (F: FHandle; DataLoc: LONGCARD): BOOLEAN;
PROCEDURE UnLock(F: FHandle; DataLoc: LONGCARD);
PROCEDURE LockIHandle  (H: IHandle): BOOLEAN;
PROCEDURE UnLockIHandle(H: IHandle);

PROCEDURE Allocate  (F: FHandle; Length: LONGCARD) : LONGCARD;
PROCEDURE DeAllocate(F: FHandle; Position: LONGCARD);

PROCEDURE Read (F: FHandle; Position: LONGCARD; Length: CARDINAL;
                VAR Data: ARRAY OF BYTE);
PROCEDURE Write(F: FHandle; Position: LONGCARD; Length: CARDINAL;
                Data: ARRAY OF BYTE);

PROCEDURE LastRef(I : IHandle): LONGCARD;

PROCEDURE RecordCount(I: IHandle): LONGCARD;

(*# save,call(near_call=>on) *)
VAR
  Packer : PROCEDURE(CARDINAL,ADDRESS,ADDRESS): CARDINAL;
  Unpacker : PROCEDURE(CARDINAL,ADDRESS,ADDRESS);
  UnpackedSize : PROCEDURE(CARDINAL,ADDRESS): CARDINAL;
  Packing : PROCEDURE(): BOOLEAN;
  AdjustBlock : PROCEDURE(CARDINAL): CARDINAL;
(*# restore *)

END Btree.