{* Copyright © Oracle Corporation 1995.  All Rights Reserved. *}

{*++
 * FACILITY:  
 *	RDML -- Relational Data Manipulation Language Preprocessors
 *
 * ABSTRACT:
 *	Include file for VAXELN PASCAL modules preprocessed by RDML
 *
 * VERSION:
 *	RDML V1.3
 *--
 *}

CONST

	RDB$EOF	= CHR(1);
	RDB$NOTEOF = CHR(0);
	RDB$TRUE = CHR(1);

	BLR$K_DTYPE_B = CHR(6);
	BLR$K_DTYPE_W = CHR(7);
	BLR$K_DTYPE_L = CHR(8);
	BLR$K_DTYPE_Q = CHR(9);
	BLR$K_DTYPE_F = CHR(10);
	BLR$K_DTYPE_G = CHR(27);
	BLR$K_DTYPE_T = CHR(14);
	BLR$K_DTYPE_VT = CHR(37);
	BLR$K_DTYPE_ADT = CHR(35);

	TPB$K_VERSION1 = CHR(1);
	TPB$K_VERSION2 = CHR(2);
	TPB$K_VERSION3 = CHR(3);

	TPB$K_CONSISTENCY = CHR(1);
	TPB$K_CONCURRENCY = CHR(2);

	TPB$K_SHARED = CHR(3);
	TPB$K_PROTECTED = CHR(4);
	TPB$K_EXCLUSIVE = CHR(5);

	TPB$K_WAIT = CHR(6);
	TPB$K_NOWAIT = CHR(7);

	TPB$K_READ = CHR(8);
	TPB$K_WRITE = CHR(9);

	TPB$K_LOCK_READ = CHR(10);
	TPB$K_LOCK_WRITE = CHR(11);

	TPB$K_VERB_TIME = CHR(12);
	TPB$K_COMMIT_TIME = CHR(13);

	TPB$K_BATCH_UPDATE = CHR(14);

        TPB$K_RETAIN_LOCKS = CHR(15);

        TPB$K_AUTO_LOCKS   = CHR(16);
        TPB$K_NOAUTO_LOCKS = CHR(17);

	BLR$K_END = CHR(255);
	BLR$K_ASSIGNMENT = CHR(1);
	BLR$K_BEGIN = CHR(2);
	BLR$K_DCL_VARIABLE = CHR(3);
	BLR$K_MESSAGE = CHR(4); 
	BLR$K_ERASE = CHR(5);
	BLR$K_FETCH = CHR(6);
	BLR$K_FOR = CHR(7);
	BLR$K_IF = CHR(8);
	BLR$K_LOOP = CHR(9);
	BLR$K_MODIFY = CHR(10);
	BLR$K_HANDLER = CHR(11);
	BLR$K_RECEIVE = CHR(12);
	BLR$K_SELECT = CHR(13);
	BLR$K_SEND = CHR(14);
	BLR$K_STORE = CHR(15);
	BLR$K_WHILE = CHR(16);
	BLR$K_STORE2 = CHR(19);
	BLR$K_LITERAL = CHR(21);
	BLR$K_DBKEY = CHR(22);
	BLR$K_FIELD = CHR(23);
	BLR$K_FIELD_ID = CHR(24);
	BLR$K_PARAMETER = CHR(25);
	BLR$K_VARIABLE = CHR(26);
	BLR$K_AVERAGE = CHR(27);
	BLR$K_COUNT = CHR(28);
	BLR$K_MAXIMUM = CHR(29);
	BLR$K_MINIMUM = CHR(30);
	BLR$K_TOTAL = CHR(31);
	BLR$K_MAX = CHR(32);
	BLR$K_MIN = CHR(33);
	BLR$K_ADD = CHR(34);
	BLR$K_SUB = CHR(35);
	BLR$K_MUL = CHR(36);
	BLR$K_DIV = CHR(37);
	BLR$K_NEGATE = CHR(38);
	BLR$K_CONCATENATE = CHR(39);
	BLR$K_SUBSTR = CHR(40);
	BLR$K_FROM = CHR(42);
	BLR$K_VIA = CHR(43);
	BLR$K_BOOL_MIN = CHR(46);
	BLR$K_EQL = CHR(47);
	BLR$K_NEQ = CHR(48);
	BLR$K_GTR = CHR(49);
	BLR$K_GEQ = CHR(50);
	BLR$K_LSS = CHR(51);
	BLR$K_LEQ = CHR(52);
	BLR$K_CONTAINING = CHR(53);
	BLR$K_MATCHING = CHR(54);
	BLR$K_STARTS = CHR(55);
	BLR$K_BETWEEN = CHR(56);
	BLR$K_OR = CHR(57);
	BLR$K_AND = CHR(58);
	BLR$K_NOT = CHR(59);
	BLR$K_ANY = CHR(60);
	BLR$K_MISSING = CHR(61);
	BLR$K_UNIQUE = CHR(62);
	BLR$K_RSE = CHR(67);
	BLR$K_FIRST = CHR(68);
	BLR$K_PROJECT = CHR(69);
	BLR$K_SORT = CHR(70);
	BLR$K_BOOLEAN = CHR(71);
	BLR$K_ASCENDING = CHR(72);
	BLR$K_DESCENDING = CHR(73);
	BLR$K_RELATION = CHR(74);
	BLR$K_RELATION_ID = CHR(75);
	BLR$K_EOC = CHR(76);
	BLR$K_LABEL = CHR(17);
	BLR$K_LEAVE = CHR(18);
	BLR$K_VERSION2 = CHR(2);
	BLR$K_VERSION3 = CHR(3);

	BLR$K_VERSION4 = CHR(4);

	RDB$DEFT_TRANS = TRUE;
	RDB$USER_TRANS = FALSE;

	RDB$MSG_VECTOR_SIZE = 20;
TYPE
	RDB$POINTER = ^ANYTYPE;
	RDML$HANDLE_TYPE = ^ANYTYPE;
	RDML$UWORD_TYPE	= [WORD] 0..65535;
	RDML$WORD_TYPE = [WORD] -32768..32767;
	RDB$BLOBID = LARGE_INTEGER;

	RDB$MSG_VECTOR_TYPE = ARRAY [1..RDB$MSG_VECTOR_SIZE] OF INTEGER;

	RDB$BLOB_TYPE (S:INTEGER) =
	    PACKED RECORD
	      CASE INTEGER OF
		0:  ( LEN: RDML$UWORD_TYPE;
		      VAL: STRING(S) );
		1:  ( ACTUAL_VAL: VARYING_STRING(S) );
	    END;

VAR
	RDB$_F_NO_CURRENCY : [EXTERNAL] INTEGER;
	RDB$_F_STREAM_END  : [EXTERNAL] INTEGER;

    { Old and new names for message vector and default transaction handle }
    { (To allow RDML modules to coexist with RDBPRE and SQLPRE modules)   }

    	RDB$MSG_VECTOR	   : [EXTERNAL] RDB$MSG_VECTOR_TYPE; { old name }
    	RDB$MESSAGE_VECTOR : [EXTERNAL] RDB$MSG_VECTOR_TYPE; { new name }
    	RDB$LU_TRHANDLE	   : [EXTERNAL] RDML$HANDLE_TYPE;     { old name }
    	RDB$TRANSACTION_HANDLE : [EXTERNAL] RDML$HANDLE_TYPE; { new name }

FUNCTION RDB$ATTACH_DATABASE (
	VAR stat_vect	: RDB$MSG_VECTOR_TYPE;
	    db_file	: RDB$POINTER;
	VAR dbb 	: RDML$HANDLE_TYPE;
	    para_length	: INTEGER;
	    param_block : RDB$POINTER)
    : BOOLEAN; EXTERNAL;

FUNCTION RDB$CANCEL_SEGMENTED_STRING (
	VAR STAT_VECT	: RDB$MSG_VECTOR_TYPE;
	VAR BLOBHANDLE	: RDML$HANDLE_TYPE)
    : BOOLEAN; EXTERNAL;

FUNCTION RDB$CLOSE_SEGMENTED_STRING (
	VAR STAT_VECT	: RDB$MSG_VECTOR_TYPE;
	VAR BLOBHANDLE	: RDML$HANDLE_TYPE)
    : BOOLEAN; EXTERNAL;

FUNCTION RDB$COMMIT_TRANSACTION (
	VAR STAT_VECT	: RDB$MSG_VECTOR_TYPE ;
	VAR TRANS	: RDML$HANDLE_TYPE)
    : BOOLEAN; EXTERNAL;

FUNCTION RDB$COMMIT_TH_OE (
	VAR STAT_VECT	: RDB$MSG_VECTOR_TYPE;
	VAR TRANS	: RDML$HANDLE_TYPE)
    : BOOLEAN; EXTERNAL;

FUNCTION RDB$COMPILE_REQUEST (
	VAR STAT_VECT	: RDB$MSG_VECTOR_TYPE ;
	VAR DBB 	: RDML$HANDLE_TYPE;
	VAR CRQ		: RDML$HANDLE_TYPE;
	    LENGTH	: INTEGER;
	    REQUEST 	: RDB$POINTER )
    : BOOLEAN; EXTERNAL;

FUNCTION RDB$CREATE_DATABASE (
	VAR stat_vect	: RDB$MSG_VECTOR_TYPE;
	    db_file	: ^ANYTYPE;
	VAR dbb 	: RDML$HANDLE_TYPE;
	    para_length	: INTEGER;
	    param_block : ^ANYTYPE;
	    system	: INTEGER)
    : BOOLEAN; EXTERNAL;

FUNCTION RDB$CREATE_SEGMENTED_STRING (
	VAR STAT_VECT	: RDB$MSG_VECTOR_TYPE;
	VAR DBHANDLE	: RDML$HANDLE_TYPE;
	VAR TRHANDLE	: RDML$HANDLE_TYPE;
	VAR BLOBHANDLE	: RDML$HANDLE_TYPE;
	VAR BLOBID	: RDB$BLOBID)
    : BOOLEAN; EXTERNAL;

FUNCTION RDB$DETACH_DATABASE (
	VAR STAT_VECT	: RDB$MSG_VECTOR_TYPE ;
	VAR 	 DBB 	: RDML$HANDLE_TYPE)
    : BOOLEAN; EXTERNAL;

FUNCTION RDB$GET_SEGMENT (
	VAR  STAT_VECT	: RDB$MSG_VECTOR_TYPE;
	VAR  BLOBHANDLE	: RDML$HANDLE_TYPE;
	     SIZEREAD	: ^ANYTYPE;
	     BUFSIZE	: INTEGER;
	     BUFFER	: RDB$POINTER)
    : INTEGER; EXTERNAL;

FUNCTION RDB$OPEN_SEGMENTED_STRING (
	VAR  STAT_VECT	: RDB$MSG_VECTOR_TYPE;
	VAR  DBB	: RDML$HANDLE_TYPE;
	VAR  TRHANDLE	: RDML$HANDLE_TYPE;
	VAR  BLOBHANDLE	: RDML$HANDLE_TYPE;
	VAR  BLOBID	: RDB$BLOBID)
    : BOOLEAN; EXTERNAL;

FUNCTION RDB$PREPARE_TRANSACTION (
	VAR STAT_VECT	: RDB$MSG_VECTOR_TYPE ;
	VAR TRANS	: RDML$HANDLE_TYPE)
    : BOOLEAN; EXTERNAL;

FUNCTION RDB$PUT_SEGMENT (
	VAR STAT_VECT	: RDB$MSG_VECTOR_TYPE;
	VAR BLOBHANDLE	: RDML$HANDLE_TYPE;
	    LENGTH	: INTEGER;
	    BLOB	: RDB$POINTER)
    : BOOLEAN; EXTERNAL;

FUNCTION RDB$RECEIVE (
	VAR STAT_VECT	: RDB$MSG_VECTOR_TYPE ;
	VAR REQUEST	: RDML$HANDLE_TYPE;
	    MSG_NUMBER	: INTEGER;
	    LENGTH	: INTEGER;
	    MSG		: RDB$POINTER;
	    INSTANT	: INTEGER)
    : BOOLEAN; EXTERNAL;

FUNCTION RDB$RELEASE_REQUEST (
	VAR STAT_VECT	: RDB$MSG_VECTOR_TYPE ;
	VAR	 CRQ	: RDML$HANDLE_TYPE)
    : BOOLEAN; EXTERNAL;

FUNCTION RDB$ROLLBACK_TRANSACTION (
	VAR STAT_VECT	: RDB$MSG_VECTOR_TYPE ;
	VAR TRANS	: RDML$HANDLE_TYPE)
    : BOOLEAN; EXTERNAL;

FUNCTION RDB$ROLLBACK_TH_OE (
	VAR STAT_VECT	: RDB$MSG_VECTOR_TYPE ;
	VAR TRANS	: RDML$HANDLE_TYPE)
    : BOOLEAN; EXTERNAL;

FUNCTION RDB$SEND (
	VAR STAT_VECT	: RDB$MSG_VECTOR_TYPE ;
	VAR REQUEST	: RDML$HANDLE_TYPE;
	    MSG_NUMBER	: INTEGER;
	    LENGTH	: INTEGER;
	    MSG		: RDB$POINTER;
	    INSTANT	: INTEGER)
    : BOOLEAN; EXTERNAL;

FUNCTION RDB$START_AND_SEND (
	VAR STAT_VECT	: RDB$MSG_VECTOR_TYPE ;
	VAR REQUEST	: RDML$HANDLE_TYPE;
	VAR TRANS	: RDML$HANDLE_TYPE;
	    MSG_NUMBER	: INTEGER;
	    LENGTH	: INTEGER;
	    MSG		: RDB$POINTER;
	    INSTANT	: INTEGER)
    : BOOLEAN; EXTERNAL;

FUNCTION RDB$START_REQUEST (
	VAR STAT_VECT	: RDB$MSG_VECTOR_TYPE ;
	VAR REQUEST	: RDML$HANDLE_TYPE;
	VAR TRANS	: RDML$HANDLE_TYPE;
	    INSTANT	: INTEGER)
    : BOOLEAN; EXTERNAL;

FUNCTION RDB$START_TRANSACTION (
	VAR STAT_VECT	: RDB$MSG_VECTOR_TYPE ;
	VAR TRANS	: RDML$HANDLE_TYPE;
	    DBB_CNT	: INTEGER;
	VAR DBB 	: RDML$HANDLE_TYPE;
	    LENGTH	: INTEGER;
	    TPB		: RDB$POINTER)
    : BOOLEAN; EXTERNAL;

FUNCTION RDB$UNWIND_REQUEST (
	VAR STAT_VECT	: RDB$MSG_VECTOR_TYPE ;
	VAR REQUEST	: RDML$HANDLE_TYPE;
	    INSTANT	: INTEGER)
    : BOOLEAN; EXTERNAL;

{* RDML Specific function and procedure definitions *}

{*===================== RDML$EPAS_INIT is now obsolete =====================*}
FUNCTION RDML$EPAS_INIT (
	IB	: RDML$HANDLE_TYPE) : BOOLEAN; EXTERNAL;
{*===================== RDML$EPAS_INIT is now obsolete =====================*}

FUNCTION RDML$EPAS_INITIALIZE (
	IB	: RDML$HANDLE_TYPE) : BOOLEAN; EXTERNAL;

FUNCTION RDML$EPAS_START_TRANS (
	ETPB	: RDB$POINTER) : BOOLEAN; EXTERNAL;

FUNCTION RDML$SEGSTR_EOF (
	STATUS	: INTEGER) : BOOLEAN; EXTERNAL;

FUNCTION RDML$SEGSTR_ERROR (
	STATUS	: INTEGER) : BOOLEAN; EXTERNAL;

PROCEDURE RDML$SEGSTR_INIT(
	BLOBHANDLE : ^ANYTYPE ); 	EXTERNAL;

PROCEDURE RDML$SEGSTR_COPY(
	SOURCE_BLOBHANDLE : ^ANYTYPE;
	DEST_BLOBHANDLE   : ^ANYTYPE ); EXTERNAL;

PROCEDURE RDML$SIGNAL_ERROR( 
	STAT_VECT : ^ANYTYPE ); 	EXTERNAL;

PROCEDURE RDBB$SIGNAL (A: ^ANYTYPE); EXTERNAL;