{* 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 V1.3
 *--
 *}

{ Definitions Usable in the host program }
 
[HIDDEN] CONST

	RDB$MSG_VECTOR_SIZE = 20;

	(********************************)
	(*	SQL Error Codes		*)
	(********************************)

(*
 *	The converter produces the following constant names
 *	for SQL error codes.  These may be moved to a standard
 *	SQL include file
 *)

	SQL$_SUCCESS	= 0;
	SQL$_EOF	= 100;


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

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

	SQL$DB_NAME_TYPE   = VARYING [255] OF CHAR;

	{ A special type to cast Quadwords so that they may be compared }
	{ legally in PASCAL						}

	SQL$QCT		   = [QUAD, UNSAFE]
				PACKED ARRAY [1..8] OF CHAR;

	{ Some tests rely on the following name }
	RDML$HANDLE_TYPE    =  SQL$HANDLE_TYPE;
	DDTM$HANDLE_TYPE    =  SQL$HANDLE_TYPE;

	{ The following names are provided to reduce the conversion
	  overhead of procedure calls to SQL-ML routines.  No actual
	  objects are declared of this type, but some objects may be
	  passed to formal parameters of this type. }

	SQL$CHARSTRING = [UNSAFE] PACKED ARRAY [1..1] OF CHAR;
	SQL$VARSTRING  = [UNSAFE] VARYING [1] OF CHAR;


[HIDDEN] CONST

	{ Default missing values for the special types for
	  DATE, QUADWORD, and segmented strings. }

	SQL$DATE_ZERO      = SQL$DATE_TYPE(CHR(0),CHR(0),CHR(0),CHR(0),
					   CHR(0),CHR(0),CHR(0),CHR(0));

	SQL$QUAD_ZERO	   = SQL$QUAD_TYPE(0, 0);

	SQL$NULL_SEGSTR    = '        ';


[HIDDEN] VAR

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

	{ NOTE: This variable called RDB$TRANSACTION_HANDLE is not the same
	  thing as the "real" RDB$TRANSACTION_HANDLE.  This one must always
	  have a value zero since it is used to communicate with SQL and
	  DDTM.  Modules linked with SQL do not have access to the
	  RDB$TRANSACTION_HANDLE associated with databases.  This variable
	  is only named RDB$TRANSACTION_HANDLE so that it will be
	  compatible with programs that might explicitly specify this
	  name.
	}

    	RDB$MSG_VECTOR	   : [EXTERNAL] RDB$MSG_VECTOR_TYPE;	{ old name }
    	RDB$LU_TRHANDLE	   : [EXTERNAL] SQL$HANDLE_TYPE;    	{ old name }

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


{ Procedures which are shared across modules and provided by
  the converter's run-time support library.


	(****************************************)
	(*	   COMMIT and ROLLBACK		*)
	(****************************************)

{ /NOCONTEXT case - simpleest forms }
[HIDDEN, EXTERNAL (SQL$COMMIT)] PROCEDURE SQL$COMMIT(
	VAR SQLCODE: INTEGER);
  EXTERNAL;

[HIDDEN, EXTERNAL (SQL$ROLLBACK)] PROCEDURE SQL$ROLLBACK(
	VAR SQLCODE: INTEGER);
  EXTERNAL;

{ /CONTEXT specified, without a TRANSACTION_HANDLE, or 
  with TRANSACTION_HANDLE = RDB$TRANSACTION_HANDLE }
[HIDDEN, EXTERNAL (SQL$COMMIT_DEF)] PROCEDURE SQL$COMMIT_DEF(
	VAR SQLCODE: INTEGER;
	VAR HANDLE: DDTM$HANDLE_TYPE);
  EXTERNAL;

[HIDDEN, EXTERNAL (SQL$ROLLBACK_DEF)] PROCEDURE SQL$ROLLBACK_DEF(
	VAR SQLCODE: INTEGER;
	VAR HANDLE: DDTM$HANDLE_TYPE);
  EXTERNAL;

{ /CONTEXT specified, with a TRANSACTION_HANDLE }
[HIDDEN, EXTERNAL (SQL$COMMIT_TH)] PROCEDURE SQL$COMMIT_TH(
	VAR SQLCODE: INTEGER;
	VAR HANDLE: DDTM$HANDLE_TYPE);
  EXTERNAL;

[HIDDEN, EXTERNAL (SQL$ROLLBACK_TH)] PROCEDURE SQL$ROLLBACK_TH(
	VAR SQLCODE: INTEGER;
	VAR HANDLE: DDTM$HANDLE_TYPE);
  EXTERNAL;


	(*************************************************)
	(*	DDTM Support for START_TRANSACTION	 *)
	(*************************************************)

[HIDDEN, EXTERNAL(SQL$CHECK_TH)] PROCEDURE SQL$CHECK_TH(
	VAR SQLCODE: INTEGER;
	VAR HANDLE: DDTM$HANDLE_TYPE);
  EXTERNAL;
 
[HIDDEN, EXTERNAL(SQL$START_TH)] PROCEDURE SQL$START_TH(
	VAR SQLCODE: INTEGER;
	VAR HANDLE: DDTM$HANDLE_TYPE);
  EXTERNAL;
 
[HIDDEN, EXTERNAL(SQL$START_DEF_TID)] PROCEDURE SQL$START_DEF_TID(
	VAR SQLCODE: INTEGER;
	VAR HANDLE: DDTM$HANDLE_TYPE;
	VAR DISTRIBUTED_TRANS_ID: INTEGER);
  EXTERNAL;
 
[HIDDEN, EXTERNAL(SQL$START_TH_TID)] PROCEDURE SQL$START_TH_TID(
	VAR SQLCODE: INTEGER;
	VAR HANDLE: DDTM$HANDLE_TYPE;
	VAR DISTRIBUTED_TRANS_ID: INTEGER);
  EXTERNAL;

{	These routines check a transaction handle to insure that it
	is valid and that a transaction has been started.  If no
	transaction has been started, RE_START_TH will start a 
	transaction.  RE_CHECK_TH_ERR will not start a transaction
	but set an error code instead.				}

[HIDDEN, EXTERNAL(SQL$CHECK_TH_ERR)] PROCEDURE SQL$CHECK_TH_ERR(
	VAR SQLCODE: INTEGER;
	VAR HANDLE: DDTM$HANDLE_TYPE);
  EXTERNAL;
 
[HIDDEN, EXTERNAL(SQL$RE_START_TH)] PROCEDURE SQL$RE_START_TH(
	VAR SQLCODE: INTEGER;
	VAR HANDLE: DDTM$HANDLE_TYPE);
  EXTERNAL;


	(********************************)
	(*	SQL$ERROR_ABORT		*)
	(********************************)

{ Called when an SQL-ML procedure returns an abnormal status code and
  no ON ERROR block exists to handle the error. }

[HIDDEN, EXTERNAL (SQL$SIGNAL)] PROCEDURE SQL$ERROR_ABORT;
  EXTERNAL;