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

{*++
 * FACILITY:  
 *	RDML -- Relational Data Manipulation Language Preprocessor
 *
 * ABSTRACT:
 *	Include file for VMS PASCAL modules preprocessed by RDML
 *
 * VERSION:
 *	RDML V6.1
 *--
 *}

[HIDDEN] 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_VERSION2 =    CHR(2);
	BLR$K_VERSION3 =    CHR(3);
	BLR$K_VERSION4 =    CHR(4);

{ Verbs }

	BLR$K_ASSIGNMENT    = CHR(1);
	BLR$K_TRANSFER	    = CHR(1);	    { Same as BLR$K_ASSIGNMENT }
	BLR$K_BEGIN	    = CHR(2);
	BLR$K_DCL_VARIABLE  = CHR(3);
	BLR$K_MESSAGE	    = CHR(4); 
	BLR$K_DCL_PORT	    = CHR(4);	    { Same as BLR$K_MESSAGE }
	BLR$K_DECLARE_PORT  = CHR(4);	    { Same as BLR$K_MESSAGE }
	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_LABEL	    = CHR(17);
	BLR$K_LEAVE	    = CHR(18);
	BLR$K_STORE2	    = CHR(19);
	BLR$K_PLACE	    = CHR(20);

{ Values }

	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_ARGUMENT	    = CHR(25);	    { Same as BLR$K_PARAMETER }
	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_SMAX	    = CHR(32);
	BLR$K_MAX	    = CHR(32);	    { Same as BLR$K_SMAX }
	BLR$K_SMIN	    = CHR(33);
	BLR$K_MIN	    = CHR(33);	    { Same as BLR$K_SMIN }

	BLR$K_ADD	    = CHR(34);
	BLR$K_PLUS	    = CHR(34);	    { Same as BLR$K_ADD }
	BLR$K_SUBTRACT	    = CHR(35);
	BLR$K_SUB	    = CHR(35);	    { Same as BLR$K_SUBTRACT }
	BLR$K_MINUS	    = CHR(35);	    { Same as BLR$K_SUBTRACT }
	BLR$K_MULTIPLY	    = CHR(36);
	BLR$K_MUL	    = CHR(36);	    { Same as BLR$K_MULTIPLY }
	BLR$K_TIMES	    = CHR(36);	    { Same as BLR$K_MULTIPLY }
	BLR$K_DIVIDE	    = CHR(37);
	BLR$K_DIV	    = CHR(37);	    { Same as BLR$K_DIVIDE }
	BLR$K_NEGATE	    = CHR(38);

	BLR$K_CONCATENATE   = CHR(39);
	BLR$K_SUBSTR	    = CHR(40);
	BLR$K_PARAMETER2    = CHR(41);
	BLR$K_FROM	    = CHR(42);
	BLR$K_VIA	    = CHR(43);

{ Comparisons }

	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_MATCHES	    = CHR(54);
	BLR$K_MATCHING	    = CHR(54);	{ Same as BLR$K_MATCHES }
	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_IDENTITY	    = CHR(63);
	BLR$K_LIKE	    = CHR(64);
	BLR$K_ANY2	    = CHR(65);
	BLR$K_ALL	    = CHR(66);

{ Miscellaneous }

	BLR$K_RSE	    = CHR(67);

	BLR$K_FIRST	    = CHR(68);
	BLR$K_PROJECT	    = CHR(69);
	BLR$K_FIELDS	    = CHR(69);	    { Same as BLR$K_PROJECT }
	BLR$K_SORT	    = CHR(70);
	BLR$K_SORTS	    = CHR(70);	    { Same as BLR$K_SORT }
	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_AGGREGATE	    = CHR(77);
	BLR$K_AGG_AVERAGE   = CHR(78);
	BLR$K_AGG_COUNT	    = CHR(79);
	BLR$K_AGG_MAX	    = CHR(80);
	BLR$K_AGG_MAXIMUM   = CHR(80);	    { Same as BLR$K_AGG_MAX }
	BLR$K_AGG_MIN	    = CHR(81);
	BLR$K_AGG_MINIMUM   = CHR(81);	    { Same as BLR$K_AGG_MIN }
	BLR$K_AGG_TOTAL	    = CHR(82);
	BLR$K_CONTROL_BITS  = CHR(83);
	BLR$K_GROUP_BY	    = CHR(84);
	BLR$K_GROUP_VALUE   = CHR(85);
	BLR$K_MAP	    = CHR(86);
	BLR$K_MERGE	    = CHR(87);
	BLR$K_PARAMETER3    = CHR(88);

	BLR$K_END	    = CHR(255);

{ DPB flags and constants }
 
	RDB$K_DPB_VERSION1		= CHR(1);
	RDB$K_DPB_VERSION2		= CHR(2);

	RDB$K_DPB_CDD_PATHNAME		= CHR(1);
	RDB$K_DPB_ALLOCATION		= CHR(2);
	RDB$K_DPB_AIJ			= CHR(3);
	RDB$K_DPB_PAGE_SIZE		= CHR(4);
	RDB$K_DPB_NUM_BUFF		= CHR(5);
	RDB$K_DPB_BUFFER_LENGTH		= CHR(6);
	RDB$K_DPB_DEBUG			= CHR(7);
	RDB$K_DPB_GARBAGE_COLLECT	= CHR(8);
	RDB$K_DPB_VERIFY		= CHR(9);
	RDB$K_DPB_SWEEP			= CHR(10);
	RDB$K_DPB_ENABLE_JOURNAL	= CHR(11);
	RDB$K_DPB_DISABLE_JOURNAL	= CHR(12);
	RDB$K_DPB_DBKEY_SCOPE		= CHR(13);
	RDB$K_DPB_NUMBER_OF_USERS	= CHR(14);
 
	RDB$K_DPB_SNP_ALLOCATION        = CHR(19);
	RDB$K_DPB_SNP_ENABLED           = CHR(20);
	RDB$K_DPB_SNP_DISABLED          = CHR(21);
	RDB$K_DPB_SNP_EXTENT            = CHR(22);
	RDB$K_DPB_EXT_SNP_MIN_NUM_PAGES = CHR(23);
	RDB$K_DPB_EXT_SNP_MAX_NUM_PAGES = CHR(24);
	RDB$K_DPB_EXT_SNP_PCT_GROWTH    = CHR(25);
	RDB$K_DPB_AIJ_CONTINUOUS        = CHR(26);
	RDB$K_DPB_AIJ_ONCE              = CHR(27);
	RDB$K_DPB_AIJ_SPOOL_FILE        = CHR(28);
	RDB$K_DPB_DESCRIPTION_SOURCE    = CHR(29);
	RDB$K_DPB_CONVERT               = CHR(30);
	RDB$K_DPB_SNAPSHOT              = CHR(31);
	RDB$K_DPB_OPEN_MANUAL           = CHR(32);
	RDB$K_DPB_OPEN_AUTOMATIC        = CHR(33);
	RDB$K_DPB_DEFINE_STORAGE        = CHR(34);
	RDB$K_DPB_CHANGE_STORAGE        = CHR(35);
	RDB$K_DPB_STORAGE_NAME          = CHR(36);
	RDB$K_DPB_FILESPEC              = CHR(37);
	RDB$K_DPB_EXTENSIBLE            = CHR(38);
	RDB$K_DPB_SNP_DEFERRED          = CHR(39);
	RDB$K_DPB_NUM_NODES             = CHR(40);
	RDB$K_DPB_FILE_TYPE             = CHR(41);
	RDB$K_DPB_CDD_MAINTAINED        = CHR(42);
	RDB$K_DPB_CDD_REQUIRED          = CHR(43);
	RDB$K_DPB_SEGMENT_AREA          = CHR(44);
	RDB$K_DPB_SPAMS                 = CHR(45);
	RDB$K_DPB_SPAM_THRESHOLD_1      = CHR(46);
	RDB$K_DPB_SPAM_THRESHOLD_2      = CHR(47);
	RDB$K_DPB_SPAM_THRESHOLD_3      = CHR(48);
	RDB$K_DPB_SPAM_INTERVAL         = CHR(49);
	RDB$K_DPB_AIJ_ALLOCATION        = CHR(50);
	RDB$K_DPB_AIJ_EXTENT            = CHR(51);
	RDB$K_DPB_DBR_BUFFERS           = CHR(52);
	RDB$K_DPB_END_STORAGE_AREA      = CHR(53);
	RDB$K_DPB_MAX                   = CHR(53);
 
{ DPB 2 version specific }

	RDB$K_FACILITY_ALL     = CHR(0);
	RDB$K_FACILITY_RDB_VMS = CHR(1);
	RDB$K_FACILITY_RDB_ELN = CHR(2);
	RDB$K_FACILITY_VIDA    = CHR(3);
	RDB$K_FACILITY_VIDA2   = CHR(4);

	RDB$K_SECURE_VERSION1    = CHR(1); {version 1 of security buffer format}
	RDB$K_SECURE_FAC_UNKNOWN = CHR(0);
	RDB$K_SECURE_FAC_VMS     = CHR(1); { Rdb/VMS security information }
	RDB$K_SECURE_FAC_ELN     = CHR(2); { Rdb/ELN security information }
	RDB$K_SECURE_FAC_REMOTE  = CHR(3); { Rdb/Remote Database Interface }
	RDB$K_SECURE_FAC_VIDA    = CHR(4); { VIDA }
	RDB$K_SECURE_FAC_VIDA2   = CHR(5);

	RDB$K_DPB2_DBKEY_SCOPE   = CHR(1);

        RDB$K_DPB_ELN_NUM_BUFF   = CHR(1);  { Specific to Rdb/ELN }

	RDB$K_DPB2_MIN           = CHR(1);

	RDB$K_DPB2_AIJ                      = CHR(1);
	RDB$K_DPB2_ALLOCATION               = CHR(2);
	RDB$K_DPB2_PAGE_SIZE                = CHR(3);
	RDB$K_DPB2_NUM_BUFF                 = CHR(4);
	RDB$K_DPB2_BUFFER_LENGTH            = CHR(5);
	RDB$K_DPB2_NUM_USERS                = CHR(6);
	RDB$K_DPB2_EXT_DB_MIN_NUM_PAGES     = CHR(7);
	RDB$K_DPB2_EXT_DB_MAX_NUM_PAGES     = CHR(8);
	RDB$K_DPB2_EXT_DB_PCT_GROWTH        = CHR(9);
	RDB$K_DPB2_SNP_ALLOCATION           = CHR(10);
	RDB$K_DPB2_SNP_FLAG                 = CHR(11);
	RDB$K_DPB2_EXT_SNP_MIN_NUMPAGES     = CHR(12);
	RDB$K_DPB2_EXT_SNP_MAX_NUMPAGES     = CHR(13);
	RDB$K_DPB2_EXT_SNP_PCT_GROWTH       = CHR(14);

	RDB$K_DPB2_DB_EXTENT                = CHR(15);
	RDB$K_DPB2_CDD_PATHNAME             = CHR(16);
	RDB$K_DPB2_AIJ_ALLOCATION           = CHR(17);
	RDB$K_DPB2_AIJ_EXTENT               = CHR(18);
	RDB$K_DPB2_DBR_BUFFERS              = CHR(19);
	RDB$K_DPB2_SNP_ENABLED              = CHR(20);
	RDB$K_DPB2_SNP_DISABLED             = CHR(21);
	RDB$K_DPB2_SNP_EXTENT               = CHR(22);
	RDB$K_DPB2_SPAM_THRESHOLD_1         = CHR(23);
	RDB$K_DPB2_SPAM_THRESHOLD_2         = CHR(24);
	RDB$K_DPB2_SPAM_THRESHOLD_3         = CHR(25);
	RDB$K_DPB2_AIJ_CONTINUOUS           = CHR(26);
	RDB$K_DPB2_AIJ_ONCE                 = CHR(27);
	RDB$K_DPB2_AIJ_SPOOL_FILE           = CHR(28);
	RDB$K_DPB2_DESCRIPTION_SOURCE       = CHR(29);
	RDB$K_DPB2_CONVERT                  = CHR(30);
	RDB$K_DPB2_SNAPSHOT                 = CHR(31);
	RDB$K_DPB2_OPEN_MANUAL              = CHR(32);
	RDB$K_DPB2_OPEN_AUTOMATIC           = CHR(33);
	RDB$K_DPB2_DEFINE_STORAGE           = CHR(34);
	RDB$K_DPB2_CHANGE_STORAGE           = CHR(35);
	RDB$K_DPB2_STORAGE_NAME             = CHR(36);
	RDB$K_DPB2_FILESPEC                 = CHR(37);
	RDB$K_DPB2_EXTENSIBLE               = CHR(38);
	RDB$K_DPB2_SNP_DEFERRED             = CHR(39);
	RDB$K_DPB2_NUM_NODES                = CHR(40);
	RDB$K_DPB2_FILE_TYPE                = CHR(41);
	RDB$K_DPB2_CDD_MAINTAINED           = CHR(42);
	RDB$K_DPB2_CDD_REQUIRED             = CHR(43);
	RDB$K_DPB2_SEGMENT_AREA             = CHR(44);
	RDB$K_DPB2_SPAMS                    = CHR(45);
	RDB$K_DPB2_SPAM_INTERVAL            = CHR(46);
	RDB$K_DPB2_END_STORAGE_AREA         = CHR(47);
	RDB$K_DPB2_ALG                      = CHR(48);
	RDB$K_DPB2_DELETE_STORAGE           = CHR(49);
	RDB$K_DPB2_LAYERED_ACCESS           = CHR(50);
	RDB$K_DPB2_REQUEST_SCOPE            = CHR(51);
	RDB$K_DPB2_READ_ONLY                = CHR(52);
	RDB$K_DPB2_PROTECTION               = CHR(53);
	RDB$K_DPB2_COLLATION_SEQUENCE       = CHR(54);

	RDB$K_DPB2_MAX                      = CHR(54);

	RDB$K_DPB2_REQUEST_SCOPE_ATTACH     = CHR(0);
	RDB$K_DPB2_REQUEST_SCOPE_PROG       = CHR(1);

	RDB$K_DPB2_CLTN_MIN                 = CHR(1);
	RDB$K_DPB2_CLTN_NAME                = CHR(1);
	RDB$K_DPB2_CLTN_DESCRIPTION         = CHR(2);
	RDB$K_DPB2_CLTN_SEQUENCE_TABLE      = CHR(3);
	RDB$K_DPB2_CLTN_MAX                 = CHR(3);

{ DBKEY_SCOPE Sub options }

	RDB$K_DPB_DBKEY_SCOPE_TRANS         = CHR(0);
	RDB$K_DPB_DBKEY_SCOPE_ATTACH        = CHR(1);

{ Deferred sub options }

	RDB$K_DPB_SNP_DEFERRED_NO           = CHR(0);
	RDB$K_DPB_SNP_DEFERRED_YES          = CHR(1);

{ CDD required suboptions }

	RDB$K_DPB_EXT_DICT_IGNORED          = CHR(0);
	RDB$K_DPB_EXT_DICT_REQUIRED         = CHR(1);

{ CDD update suboptions }

	RDB$K_DPB_CLI_DICT_IGNORED          = CHR(0);
	RDB$K_DPB_CLI_DICT_MAINTAINED       = CHR(1);

{ File types }

	RDB$K_DPB_FT_PARTITIONED            = CHR(0);
	RDB$K_DPB_FT_CLUSTERED              = CHR(1);

{ ALG suboptions }

	RDB$K_DPB2_ALG_ENABLED              = CHR(0);
	RDB$K_DPB2_ALG_DISABLED             = CHR(1);

{ Protection suboptions }

	RDB$K_DPB_PROT_DEFAULT              = CHR(0);
	RDB$K_DPB_PROT_ANSI_COMPLIANT       = CHR(1);

{ Other sub options }

	RDB$M_DPB_SWP_PAGES		= CHR(1);
	RDB$M_DPB_SWP_RECORDS		= CHR(2);
	RDB$M_DPB_SWP_INDICES		= CHR(4);
	RDB$M_DPB_SWP_TRANSACTIONS	= CHR(8);
 
	RDB$K_DB_TYPE_ELAN	        = CHR(2);
 
{ Definitions Usable in the host program }
 
	RDB$MSG_VECTOR_SIZE = 20;

[HIDDEN] TYPE
	RDML$UBYTE_TYPE     = [BYTE,UNSAFE] 0..255;
	RDML$BYTE_TYPE     = [BYTE,UNSAFE] -128..127;
	RDML$UWORD_TYPE	    = [WORD] 0..65535;
	RDML$WORD_TYPE      = [WORD] -32768..32767;
    	RDML$QUAD_TYPE      = [QUAD,UNSAFE] RECORD L0:UNSIGNED; L1:INTEGER; END;
	RDML$POINTER_TYPE   = [LONG,VOLATILE,UNSAFE] ^UNSIGNED;
	RDML$HANDLE_TYPE    = [LONG,VOLATILE,UNSAFE] UNSIGNED;
	RDML$CDDADT_TYPE    = [BYTE(8)] RECORD END;
	RDML$PACADT_TYPE    = PACKED ARRAY [1..8] OF CHAR;
	RDML$SEGSTR_ID_TYPE = PACKED ARRAY [1..8] OF CHAR;
	RDML$CDDADT_TYPE2    = [BYTE(8)] RECORD 
				L1:UNSIGNED;
				L2:UNSIGNED;
				END;

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

[HIDDEN] 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$LU_TRHANDLE	   : [EXTERNAL] RDML$HANDLE_TYPE;     	{ old name }

    	RDB$MESSAGE_VECTOR : [COMMON, ALIGNED(2)] 
    				RDB$MSG_VECTOR_TYPE; 		{ new name }
    	RDB$TRANSACTION_HANDLE : [COMMON, ALIGNED(2)] 
    				RDML$HANDLE_TYPE; 		{ new name }

FUNCTION RDB$ATTACH_DATABASE (
	%REF	MSGVEC	: RDB$MSG_VECTOR_TYPE;
	%STDESCR DBNAME	: PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR;
	%REF	DBH	: RDML$HANDLE_TYPE;
	%IMMED	DBPLEN	: INTEGER;
	%REF	DBP	: [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF RDML$UBYTE_TYPE)
    : [LONG] BOOLEAN; EXTERN;

FUNCTION RDB$CANCEL_SEGMENTED_STRING (
	%REF	MSGVEC	: RDB$MSG_VECTOR_TYPE;
	%REF	SEGSH	: RDML$HANDLE_TYPE)
    : [LONG] BOOLEAN; EXTERN;

FUNCTION RDB$CLOSE_SEGMENTED_STRING (
	%REF	MSGVEC	: RDB$MSG_VECTOR_TYPE;
	%REF	SEGSH	: RDML$HANDLE_TYPE)
    : [LONG] BOOLEAN; EXTERN;

FUNCTION RDB$COMMIT_TRANSACTION (
	%REF	MSGVEC	: RDB$MSG_VECTOR_TYPE;
	%REF	TRANH	: RDML$HANDLE_TYPE)
    : [LONG] BOOLEAN; EXTERN;

{ The following function exists to ensure that any VAX SQL cursor data	}
{ structures are cleaned up on a COMMIT.  				}
{   TH = transaction handle; OE means host language performs ON ERROR	}

FUNCTION RDB$COMMIT_TH_OE (
	%REF	MSGVEC	: RDB$MSG_VECTOR_TYPE;
	%REF	TRANH	: RDML$HANDLE_TYPE)
    : [LONG] BOOLEAN; EXTERN;

FUNCTION RDB$COMPILE_REQUEST (
	%REF	MSGVEC	: RDB$MSG_VECTOR_TYPE;
	%REF	DBH 	: RDML$HANDLE_TYPE;
	%REF	REQH	: RDML$HANDLE_TYPE;
	%IMMED	REQLEN	: INTEGER;		{RDML$UWORD_TYPE}
	%REF	REQ	: [UNSAFE] ARRAY [$l1..$u1:INTEGER] OF RDML$UBYTE_TYPE)
    : [LONG] BOOLEAN; EXTERN;

FUNCTION RDB$CREATE_DATABASE (
	%REF	MSGVEC	: RDB$MSG_VECTOR_TYPE;
	%STDESCR DBNAME	: PACKED ARRAY [$l1..$u1:INTEGER] OF CHAR;
	%REF	DBH 	: RDML$HANDLE_TYPE;
	%IMMED	DBPLEN	: INTEGER;
	%REF	DBP	: [UNSAFE] ARRAY [$l2..$u2:INTEGER] OF RDML$UBYTE_TYPE;
    	%IMMED	DB_TYPE	: INTEGER)
    : [LONG] BOOLEAN; EXTERN;

FUNCTION RDB$CREATE_SEGMENTED_STRING (
	%REF	MSGVEC	: RDB$MSG_VECTOR_TYPE;
	%REF	DBH	: RDML$HANDLE_TYPE;
	%REF	TRANH	: RDML$HANDLE_TYPE;
	%REF	SEGSH 	: RDML$HANDLE_TYPE;
	%REF	SEGSID	: RDML$SEGSTR_ID_TYPE)
    : [LONG] BOOLEAN; EXTERN;

FUNCTION RDB$DETACH_DATABASE (
	%REF	MSGVEC	: RDB$MSG_VECTOR_TYPE;
	%REF	DBH	: RDML$HANDLE_TYPE)
    : [LONG] BOOLEAN; EXTERN;

FUNCTION RDB$GET_SEGMENT (
	%REF	MSGVEC	: RDB$MSG_VECTOR_TYPE;
	%REF	SEGSH	: RDML$HANDLE_TYPE;
	%REF	ACTULEN	: RDML$UWORD_TYPE;
	%IMMED	BUFFLEN	: INTEGER;		{RDML$UWORD_TYPE}
	%REF	BUFF	: [UNSAFE] ARRAY [$l1..$u1:INTEGER] OF RDML$UBYTE_TYPE)
    : [LONG] INTEGER; EXTERN;

FUNCTION RDB$OPEN_SEGMENTED_STRING (
	%REF	MSGVEC	: RDB$MSG_VECTOR_TYPE;
	%REF	DBH	: RDML$HANDLE_TYPE;
	%REF	TRANH	: RDML$HANDLE_TYPE;
	%REF	SEGSH	: RDML$HANDLE_TYPE;
	%REF	SEGSID	: RDML$SEGSTR_ID_TYPE)
    : [LONG] BOOLEAN; EXTERN;

FUNCTION RDB$PREPARE_TRANSACTION (
	%REF	MSGVEC	: RDB$MSG_VECTOR_TYPE;
	%REF	TRANH	: RDML$HANDLE_TYPE)
    : [LONG] BOOLEAN; EXTERN;

FUNCTION RDB$PUT_SEGMENT (
	%REF	MSGVEC	: RDB$MSG_VECTOR_TYPE;
	%REF	SEGSH	: RDML$HANDLE_TYPE;
	%IMMED	SEGSLEN	: INTEGER;		{RDML$UWORD_TYPE}
	%REF	SEGS	: [UNSAFE] ARRAY [$l1..$u1:INTEGER] OF RDML$UBYTE_TYPE)
    : [LONG] BOOLEAN; EXTERN;

FUNCTION RDB$RECEIVE (
	%REF	MSGVEC	: RDB$MSG_VECTOR_TYPE;
	%REF	REQH	: RDML$HANDLE_TYPE;
	%IMMED	MSGNUM	: INTEGER;		{RDML$UBYTE_TYPE}
	%IMMED	MSGLEN	: INTEGER;		{RDML$UWORD_TYPE}
	%REF	MSG	: [UNSAFE] ARRAY [$l1..$u1:INTEGER] OF RDML$UBYTE_TYPE;
	%IMMED	INST	: RDML$UWORD_TYPE)
    : [LONG] BOOLEAN; EXTERN;

FUNCTION RDB$RELEASE_REQUEST (
	%REF	MSGVEC	: RDB$MSG_VECTOR_TYPE;
	%REF	REQH	: RDML$HANDLE_TYPE)
    : [LONG] BOOLEAN; EXTERN;

FUNCTION RDB$ROLLBACK_TRANSACTION (
	%REF	MSGVEC	: RDB$MSG_VECTOR_TYPE;
	%REF	TRANH	: RDML$HANDLE_TYPE)
    : [LONG] BOOLEAN; EXTERN;

{ The following function exists to ensure that any VAX SQL cursor data	}
{ structures are cleaned up on a ROLLBACK.  				}
{   TH = transaction handle; OE means host language performs ON ERROR	}

FUNCTION RDB$ROLLBACK_TH_OE (
	%REF	MSGVEC	: RDB$MSG_VECTOR_TYPE;
	%REF	TRANH	: RDML$HANDLE_TYPE)
    : [LONG] BOOLEAN; EXTERN;

FUNCTION RDB$SEND (
	%REF	MSGVEC	: RDB$MSG_VECTOR_TYPE;
	%REF	REQH	: RDML$HANDLE_TYPE;
	%IMMED  MSGNUM	: INTEGER;		{RDML$UBYTE_TYPE}
	%IMMED	MSGLEN	: INTEGER;		{RDML$UWORD_TYPE}
	%REF	MSG	: [UNSAFE] ARRAY [$l1..$u1:INTEGER] OF RDML$UBYTE_TYPE;
	%IMMED  INST	: RDML$UWORD_TYPE)
    : [LONG] BOOLEAN; EXTERN;

FUNCTION RDB$START_AND_SEND (
	%REF	MSGVEC	: RDB$MSG_VECTOR_TYPE;
	%REF	REQH	: RDML$HANDLE_TYPE;
	%REF	TRANH	: RDML$HANDLE_TYPE;
	%IMMED	MSGNUM	: INTEGER; 		{RDML$UBYTE_TYPE}
	%IMMED	MSGLEN	: INTEGER;		{RDML$UWORD_TYPE}
	%REF	MSG	: [UNSAFE] ARRAY [$l1..$u1:INTEGER] OF RDML$UBYTE_TYPE;
	%IMMED	INST	: RDML$UWORD_TYPE)
    : [LONG] BOOLEAN; EXTERN;

FUNCTION RDB$START_REQUEST (
	%REF	MSGVEC	: RDB$MSG_VECTOR_TYPE;
	%REF	REQH	: RDML$HANDLE_TYPE;
	%REF	TRANH	: RDML$HANDLE_TYPE;
	%IMMED	INST	: RDML$UWORD_TYPE)
    : [LONG] BOOLEAN; EXTERN;

FUNCTION RDB$START_TRANSACTION (
	%REF	MSGVEC	: RDB$MSG_VECTOR_TYPE;
	%REF	TRANH	: RDML$HANDLE_TYPE;
	%IMMED	DBHCNT 	: INTEGER;		{RDML$UWORD_TYPE}
	%REF	DBH 	: RDML$HANDLE_TYPE;
	%IMMED	TPBLEN	: INTEGER;		{RDML$UWORD_TYPE}
	%REF	TPB	: [UNSAFE] ARRAY [$l1..$u1:INTEGER] OF RDML$UBYTE_TYPE)
    : [LONG] BOOLEAN; EXTERN;

FUNCTION RDB$UNWIND_REQUEST (
	%REF	MSGVEC	: RDB$MSG_VECTOR_TYPE;
	%REF	REQH	: RDML$HANDLE_TYPE;
	%IMMED	INST	: RDML$UWORD_TYPE)
    : [LONG] BOOLEAN; EXTERN;

{* RDML Specific function and procedure definitions *}

{*==================== RDML$VPAS_INIT is now obsolete =======================*}
FUNCTION RDML$VPAS_INIT (
	%REF	IBLK	: [UNSAFE] ARRAY [$l1..$u1:INTEGER] OF RDML$UBYTE_TYPE)
    : BOOLEAN; EXTERNAL;
{*==================== RDML$VPAS_INIT is now obsolete =======================*}

FUNCTION RDML$VPAS_INITIALIZE (
	%REF	IBLK	: [UNSAFE] ARRAY [$l1..$u1:INTEGER] OF RDML$UBYTE_TYPE;
	%REF	IB2LK	: [UNSAFE,TRUNCATE] ARRAY [$l2..$u2:INTEGER] OF RDML$UBYTE_TYPE)
    : BOOLEAN; EXTERNAL;

FUNCTION RDML$VPAS_INITIALIZE2 (
	%IMMED	ARGCNT 	: INTEGER;
	%REF	IBLK	: [UNSAFE] ARRAY [$l1..$u1:INTEGER] OF RDML$UBYTE_TYPE;
	%REF	IB2LK	: [UNSAFE,TRUNCATE] ARRAY [$l2..$u2:INTEGER] OF RDML$UBYTE_TYPE)
    : BOOLEAN; EXTERNAL;

FUNCTION RDML$VPAS_INITIALIZE3 (
	%IMMED	ARGCNT 	: INTEGER;
	%REF	IBLK	: [UNSAFE] ARRAY [$l1..$u1:INTEGER] OF RDML$UBYTE_TYPE;
	%REF	IB2LK	: [UNSAFE,TRUNCATE] ARRAY [$l2..$u2:INTEGER] OF RDML$UBYTE_TYPE)
    : BOOLEAN; EXTERNAL;

FUNCTION RDML$VPAS_START_TRANS (
	%REF	ETPB	: [UNSAFE] ARRAY [$l1..$u1:INTEGER] OF RDML$UBYTE_TYPE;
	%REF	ETPB2	: [UNSAFE,TRUNCATE] ARRAY [$l2..$u2:INTEGER] OF RDML$UBYTE_TYPE)
    : BOOLEAN; EXTERNAL;

FUNCTION RDML$VPAS_START_TRANS2 (
	%IMMED	ARGCNT 	: INTEGER;
	%REF	ETPB	: [UNSAFE] ARRAY [$l1..$u1:INTEGER] OF RDML$UBYTE_TYPE;
	%REF	ETPB2	: [UNSAFE,TRUNCATE] ARRAY [$l2..$u2:INTEGER] OF RDML$UBYTE_TYPE)
    : BOOLEAN; EXTERNAL;

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

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

PROCEDURE RDML$SEGSTR_INIT(
	%REF	SEGSID	: RDML$SEGSTR_ID_TYPE); EXTERNAL;

PROCEDURE RDML$SEGSTR_COPY(
	%REF	SRCSEGSID : RDML$SEGSTR_ID_TYPE;
	%REF	DSTSEGSID : RDML$SEGSTR_ID_TYPE); EXTERNAL;

PROCEDURE RDML$SIGNAL_ERROR( 
	%REF	MSGVEC	: RDB$MSG_VECTOR_TYPE ); EXTERNAL;