Attachment #82338: gcc-4.0 patch for bug #120867

#ifndef WIN_NT

#ifndef WIN_NT

				signal(SIGPIPE, SIG_IGN);

				signal(SIGPIPE, SIG_IGN);

#endif

#endif

				break;

				break;

			}

			}

			else

			else

	tdgbl->action->act_action = ACT_restore;

	tdgbl->action->act_action = ACT_restore;

	if (!strcmp(fil->fil_name, "stdin")) {

	if (!strcmp(fil->fil_name, "stdin")) {

		tdgbl->file_desc = fil->fil_fd;

		tdgbl->file_desc = fil->fil_fd;

		tdgbl->gbl_sw_files = fil->fil_next;

		tdgbl->gbl_sw_files = fil->fil_next;

	}

	}

#include "firebird.h"

#include "firebird.h"

#ifdef WIN_NT

#ifdef WIN_NT

#include <windows.h>

#include <windows.h>

#else //WIN_NT

#else //WIN_NT

#endif //WIN_NT

#endif //WIN_NT

#endif  //GBAK_STD_DESC_H

#endif  //GBAK_STD_DESC_H

void operator delete[](void* mem) throw();

void operator delete[](void* mem) throw();

#ifdef DEBUG_GDS_ALLOC

#ifdef DEBUG_GDS_ALLOC

	return pool.allocate(s, 0, file, line);

	return pool.allocate(s, 0, file, line);

//	return pool.calloc(s, 0, file, line);

//	return pool.calloc(s, 0, file, line);

}

}

	return pool.allocate(s, 0, file, line);

	return pool.allocate(s, 0, file, line);

//	return pool.calloc(s, 0, file, line);

//	return pool.calloc(s, 0, file, line);

}

}

#define FB_NEW(pool) new(pool,__FILE__,__LINE__)

#define FB_NEW(pool) new(pool,__FILE__,__LINE__)

#define FB_NEW_RPT(pool,count) new(pool,count,__FILE__,__LINE__)

#define FB_NEW_RPT(pool,count) new(pool,count,__FILE__,__LINE__)

#else

#else

	return pool.allocate(s);

	return pool.allocate(s);

//	return pool.calloc(s);

//	return pool.calloc(s);

}

}

	return pool.allocate(s);

	return pool.allocate(s);

//	return pool.calloc(s);

//	return pool.calloc(s);

}

}

int Config::getSortMemBlockSize()

int Config::getSortMemBlockSize()

{

{

}

}

int Config::getSortMemUpperLimit()

int Config::getSortMemUpperLimit()

{

{

}

}

bool Config::getRemoteFileOpenAbility()

bool Config::getRemoteFileOpenAbility()

int Config::getGuardianOption()

int Config::getGuardianOption()

{

{

}

}

int Config::getCpuAffinityMask()

int Config::getCpuAffinityMask()

{

{

}

}

bool Config::getOldParameterOrdering()

bool Config::getOldParameterOrdering()

int Config::getTcpRemoteBufferSize()

int Config::getTcpRemoteBufferSize()

{

{

}

}

bool Config::getTcpNoNagle()

bool Config::getTcpNoNagle()

int Config::getIpcMapSize()

int Config::getIpcMapSize()

{

{

}

}

int Config::getDefaultDbCachePages()

int Config::getDefaultDbCachePages()

{

{

}

}

int Config::getConnectionTimeout()

int Config::getConnectionTimeout()

{

{

}

}

int Config::getDummyPacketInterval()

int Config::getDummyPacketInterval()

{

{

}

}

int Config::getLockMemSize()

int Config::getLockMemSize()

{

{

}

}

int Config::getLockSemCount()

int Config::getLockSemCount()

{

{

}

}

int Config::getLockSignal()

int Config::getLockSignal()

{

{

}

}

bool Config::getLockGrantOrder()

bool Config::getLockGrantOrder()

int Config::getLockHashSlots()

int Config::getLockHashSlots()

{

{

}

}

int Config::getLockAcquireSpins()

int Config::getLockAcquireSpins()

{

{

}

}

int Config::getEventMemSize()

int Config::getEventMemSize()

{

{

}

}

int Config::getDeadlockTimeout()

int Config::getDeadlockTimeout()

{

{

}

}

int Config::getSolarisStallValue()

int Config::getSolarisStallValue()

{

{

}

}

bool Config::getTraceMemoryPools()

bool Config::getTraceMemoryPools()

int Config::getPrioritySwitchDelay()

int Config::getPrioritySwitchDelay()

{

{

	if (rc < 1)

	if (rc < 1)

		rc = 1;

		rc = 1;

	return rc;

	return rc;

int Config::getDeadThreadsCollection()

int Config::getDeadThreadsCollection()

{

{

	if (rc < 1)

	if (rc < 1)

		rc = 1;

		rc = 1;

	return rc;

	return rc;

int Config::getPriorityBoost()

int Config::getPriorityBoost()

{

{

	if (rc < 1)

	if (rc < 1)

		rc = 1;

		rc = 1;

	if (rc > 1000)

	if (rc > 1000)

int Config::getRemoteServicePort()

int Config::getRemoteServicePort()

{

{

}

}

const char *Config::getRemotePipeName()

const char *Config::getRemotePipeName()

int Config::getMaxUnflushedWrites()

int Config::getMaxUnflushedWrites()

{

{

}

}

int Config::getMaxUnflushedWriteTime()

int Config::getMaxUnflushedWriteTime()

{

{

}

}

int Config::getProcessPriorityLevel()

int Config::getProcessPriorityLevel()

{

{

}

}

bool Config::getCreateInternalWindow()

bool Config::getCreateInternalWindow()

int Config::getRemoteAuxPort()

int Config::getRemoteAuxPort()

{

{

#ifdef SUPERSERVER

#ifdef SUPERSERVER

#else

#else

	return 0;

	return 0;

#endif

#endif

case 79:

case 79:

{ 

{ 

			lex.g_field->fld_dtype = dtype_cstring; 

			lex.g_field->fld_dtype = dtype_cstring; 

break;

break;

case 80:

case 80:

{ yyval = (DSQL_NOD) NULL; }

{ yyval = (DSQL_NOD) NULL; }

case 507:

case 507:

{ 

{ 

			lex.g_field->fld_dtype = dtype_blob; 

			lex.g_field->fld_dtype = dtype_blob; 

			lex.g_field->fld_sub_type = 0;

			lex.g_field->fld_sub_type = 0;

			}

			}

break;

break;

case 508:

case 508:

{ 

{ 

			lex.g_field->fld_dtype = dtype_blob; 

			lex.g_field->fld_dtype = dtype_blob; 

			}

			}

break;

break;

case 509:

case 509:

{ 

{ 

			lex.g_field->fld_dtype = dtype_blob; 

			lex.g_field->fld_dtype = dtype_blob; 

			lex.g_field->fld_seg_length = 80;

			lex.g_field->fld_seg_length = 80;

			}

			}

break;

break;

case 510:

case 510:

{

{

		  	}

		  	}

break;

break;

case 511:

case 511:

break;

break;

case 512:

case 512:

{

{

			}

			}

break;

break;

case 513:

case 513:

case 517:

case 517:

{ 

{ 

			lex.g_field->fld_dtype = dtype_text; 

			lex.g_field->fld_dtype = dtype_text; 

			lex.g_field->fld_flags |= FLD_national;

			lex.g_field->fld_flags |= FLD_national;

			}

			}

break;

break;

case 519:

case 519:

{ 

{ 

			lex.g_field->fld_dtype = dtype_varying; 

			lex.g_field->fld_dtype = dtype_varying; 

			lex.g_field->fld_flags |= FLD_national;

			lex.g_field->fld_flags |= FLD_national;

			}

			}

break;

break;

case 520:

case 520:

{ 

{ 

			lex.g_field->fld_dtype = dtype_text; 

			lex.g_field->fld_dtype = dtype_text; 

			}

			}

break;

break;

case 521:

case 521:

case 522:

case 522:

{ 

{ 

			lex.g_field->fld_dtype = dtype_varying; 

			lex.g_field->fld_dtype = dtype_varying; 

			}

			}

break;

break;

case 531:

case 531:

			    	lex.g_field->fld_dtype = dtype_long; 

			    	lex.g_field->fld_dtype = dtype_long; 

			    	lex.g_field->fld_length = sizeof (SLONG); 

			    	lex.g_field->fld_length = sizeof (SLONG); 

			    	}

			    	}

			}

			}

break;

break;

case 536:

case 536:

			    	lex.g_field->fld_length = sizeof (SLONG); 

			    	lex.g_field->fld_length = sizeof (SLONG); 

			    	}

			    	}

			    }

			    }

			}

			}

break;

break;

case 539:

case 539:

{ yyval = make_node (nod_table_lock, (int) 2, make_list (yyvsp[-1]), yyvsp[0]); }

{ yyval = make_node (nod_table_lock, (int) 2, make_list (yyvsp[-1]), yyvsp[0]); }

break;

break;

case 602:

case 602:

break;

break;

case 603:

case 603:

{ yyval = 0; }

{ yyval = 0; }

	args.pat_database = (DBB) init->nod_arg[3];

	args.pat_database = (DBB) init->nod_arg[3];

	args.pat_vector1 = status_vector(action);

	args.pat_vector1 = status_vector(action);

	args.pat_value2 = (int) event_list->nod_count;

	args.pat_value2 = (int) event_list->nod_count;

//  generate call to dynamically generate event blocks 

//  generate call to dynamically generate event blocks 

		event_init = (GPRE_NOD) event_action->act_object;

		event_init = (GPRE_NOD) event_action->act_object;

		stack_name = (SYM) event_init->nod_arg[0];

		stack_name = (SYM) event_init->nod_arg[0];

		if (!strcmp(event_name->sym_string, stack_name->sym_string)) {

		if (!strcmp(event_name->sym_string, stack_name->sym_string)) {

			database = (DBB) event_init->nod_arg[3];

			database = (DBB) event_init->nod_arg[3];

		}

		}

	}

	}

	case ACT_drop_shadow:

	case ACT_drop_shadow:

		put_numeric(request, gds_dyn_delete_shadow,

		put_numeric(request, gds_dyn_delete_shadow,

		STUFF_END;

		STUFF_END;

		break;

		break;

// ** Begin date/time/timestamp support *

// ** Begin date/time/timestamp support *

	case nod_extract:

	case nod_extract:

		STUFF(blr_extract);

		STUFF(blr_extract);

		{

		{

		case KW_YEAR:

		case KW_YEAR:

			STUFF(blr_extract_year);

			STUFF(blr_extract_year);

// ** Begin date/time/timestamp support *

// ** Begin date/time/timestamp support *

	case nod_extract:

	case nod_extract:

		{

		{

			CME_get_dtype(node->nod_arg[1], f);

			CME_get_dtype(node->nod_arg[1], f);

			switch (f->fld_dtype)

			switch (f->fld_dtype)

			{

			{

static void	gen_on_error (ACT);

static void	gen_on_error (ACT);

static void	gen_procedure (ACT);

static void	gen_procedure (ACT);

static void	gen_put_segment (ACT);

static void	gen_put_segment (ACT);

static void	gen_ready (ACT);

static void	gen_ready (ACT);

static void	gen_receive (ACT, POR);

static void	gen_receive (ACT, POR);

static void	gen_release (ACT);

static void	gen_release (ACT);

	args.pat_database = (DBB) init->nod_arg[3];

	args.pat_database = (DBB) init->nod_arg[3];

	args.pat_vector1 = status_vector(action);

	args.pat_vector1 = status_vector(action);

	args.pat_value2 = (int) event_list->nod_count;

	args.pat_value2 = (int) event_list->nod_count;

	args.pat_string1 = ISC_EVENT_BLOCK;

	args.pat_string1 = ISC_EVENT_BLOCK;

	args.pat_string2 = ISC_EVENT_WAIT;

	args.pat_string2 = ISC_EVENT_WAIT;

	LLS stack_ptr;

	LLS stack_ptr;

	ACT event_action;

	ACT event_action;

	SSHORT column;

	SSHORT column;

	TEXT s[64];

	TEXT s[64];

	TEXT *pattern1 =

	TEXT *pattern1 =

		"CALL \"%S2\" USING %V1, %RF%DH%RE, %VF%S4%N1L%VE, %VF%S4%N1A%VE, %VF%S4%N1B%VE";

		"CALL \"%S2\" USING %V1, %RF%DH%RE, %VF%S4%N1L%VE, %VF%S4%N1A%VE, %VF%S4%N1B%VE";

		event_init = (GPRE_NOD) event_action->act_object;

		event_init = (GPRE_NOD) event_action->act_object;

		stack_name = (SYM) event_init->nod_arg[0];

		stack_name = (SYM) event_init->nod_arg[0];

		if (!strcmp(event_name->sym_string, stack_name->sym_string)) {

		if (!strcmp(event_name->sym_string, stack_name->sym_string)) {

			database = (DBB) event_init->nod_arg[3];

			database = (DBB) event_init->nod_arg[3];

		}

		}

	}

	}

static void gen_raw(

static void gen_raw(

			   UCHAR * blr,

			   UCHAR * blr,

{

{

	UCHAR *c;

	UCHAR *c;

	TEXT s[256];

	TEXT s[256];

			printa(names[COLUMN_0], FALSE, "01  %s%d.",

			printa(names[COLUMN_0], FALSE, "01  %s%d.",

				   names[ISC_], blob->blb_bpb_ident);

				   names[ISC_], blob->blb_bpb_ident);

			gen_raw(blob->blb_bpb, request->req_type, blob->blb_bpb_length,

			gen_raw(blob->blb_bpb, request->req_type, blob->blb_bpb_length,

			printa(names[COMMENT], FALSE, " ");

			printa(names[COMMENT], FALSE, " ");

		}

		}

#ifdef PYXIS

#ifdef PYXIS

static void gen_type( ACT action)

static void gen_type( ACT action)

{

{

}

}

	USHORT pat_ident2;

	USHORT pat_ident2;

	TEXT *pat_vector1;

	TEXT *pat_vector1;

	TEXT *pat_vector2;

	TEXT *pat_vector2;

	int pat_value2;

	int pat_value2;

	int pat_value3;

	int pat_value3;

	int pat_value4;

	int pat_value4;

	request = tdbb->tdbb_request;

	request = tdbb->tdbb_request;

	source = (BID) from_desc->dsc_address;

	source = (BID) from_desc->dsc_address;

	destination = (BID) to_desc->dsc_address;

	destination = (BID) to_desc->dsc_address;

	relation = rpb->rpb_relation;

	relation = rpb->rpb_relation;

	record = rpb->rpb_record;

	record = rpb->rpb_record;

			FMT format;

			FMT format;

			USHORT id;

			USHORT id;

			format =

			format =

			if (id >= format->fmt_count) {

			if (id >= format->fmt_count) {

				desc->dsc_dtype = dtype_null;

				desc->dsc_dtype = dtype_null;

				desc->dsc_length = 0;

				desc->dsc_length = 0;

			sub = node->nod_arg[e_scl_field];

			sub = node->nod_arg[e_scl_field];

			relation =

			relation =

							 nod_arg[e_fld_stream]].csb_relation;

							 nod_arg[e_fld_stream]].csb_relation;

			field = MET_get_field(relation, id);

			field = MET_get_field(relation, id);

			if (!field || !(array = field->fld_array))

			if (!field || !(array = field->fld_array))

				IBERROR(223);	/* msg 223 argument of scalar operation must be an array */

				IBERROR(223);	/* msg 223 argument of scalar operation must be an array */

		return;

		return;

	case nod_extract:

	case nod_extract:

			/* QUADDATE - SECOND returns a float, or scaled! */

			/* QUADDATE - SECOND returns a float, or scaled! */

			desc->dsc_dtype = dtype_long;

			desc->dsc_dtype = dtype_long;

			desc->dsc_length = sizeof(ULONG);

			desc->dsc_length = sizeof(ULONG);

			message = node->nod_arg[e_arg_message];

			message = node->nod_arg[e_arg_message];

			format = (FMT) message->nod_arg[e_msg_format];

			format = (FMT) message->nod_arg[e_msg_format];

			return;

			return;

		}

		}

				!input->nod_arg[e_fld_id] && !input->nod_arg[e_fld_stream])

				!input->nod_arg[e_fld_id] && !input->nod_arg[e_fld_stream])

				--field_id;

				--field_id;

			else

			else

			if (remap_fld) {

			if (remap_fld) {

				JRD_REL relation;

				JRD_REL relation;

				JRD_FLD field;

				JRD_FLD field;

				relation = (*csb)->csb_rpt[stream].csb_relation;

				relation = (*csb)->csb_rpt[stream].csb_relation;

				field = MET_get_field(relation, field_id);

				field = MET_get_field(relation, field_id);

				if (field->fld_source)

				if (field->fld_source)

			}

			}

			if (remap)

			if (remap)

				stream = remap[stream];

				stream = remap[stream];

			node->nod_type = input->nod_type;

			node->nod_type = input->nod_type;

			node->nod_count = 0;

			node->nod_count = 0;

	/** 

	/** 

	    Last entry in the remap contains the the original stream number.

	    Last entry in the remap contains the the original stream number.

	    Get that stream number so that the flags can be copied 

	    Get that stream number so that the flags can be copied 

			node->nod_arg[e_prc_inputs] =

			node->nod_arg[e_prc_inputs] =

				copy(tdbb, csb, input->nod_arg[e_prc_inputs], remap, field_id,

				copy(tdbb, csb, input->nod_arg[e_prc_inputs], remap, field_id,

					 node->nod_arg[e_prc_in_msg], remap_fld);

					 node->nod_arg[e_prc_in_msg], remap_fld);

			new_stream = (*csb)->csb_n_stream++;

			new_stream = (*csb)->csb_n_stream++;

			node->nod_arg[e_prc_stream] = (JRD_NOD) (SLONG) new_stream;

			node->nod_arg[e_prc_stream] = (JRD_NOD) (SLONG) new_stream;

			/* TMN: Here we should really have the following assert */

			/* TMN: Here we should really have the following assert */

			element = CMP_csb_element(csb, new_stream);

			element = CMP_csb_element(csb, new_stream);

			// SKIDDER: Maybe we need to check if we really found a procedure ?

			// SKIDDER: Maybe we need to check if we really found a procedure ?

			element->csb_procedure = MET_lookup_procedure_id(tdbb,

			element->csb_procedure = MET_lookup_procedure_id(tdbb,

			(*csb)->csb_rpt[new_stream].csb_flags |=

			(*csb)->csb_rpt[new_stream].csb_flags |=

				(*csb)->csb_rpt[stream].csb_flags & csb_no_dbkey;

				(*csb)->csb_rpt[stream].csb_flags & csb_no_dbkey;

		node = PAR_make_node(tdbb, e_agg_length);

		node = PAR_make_node(tdbb, e_agg_length);

		node->nod_type = input->nod_type;

		node->nod_type = input->nod_type;

		node->nod_count = 0;

		node->nod_count = 0;

		assert(stream <= MAX_STREAMS);

		assert(stream <= MAX_STREAMS);

		new_stream = (*csb)->csb_n_stream++;

		new_stream = (*csb)->csb_n_stream++;

		assert(new_stream <= MAX_STREAMS);

		assert(new_stream <= MAX_STREAMS);

		node = PAR_make_node(tdbb, e_uni_length);

		node = PAR_make_node(tdbb, e_uni_length);

		node->nod_type = input->nod_type;

		node->nod_type = input->nod_type;

		node->nod_count = 2;

		node->nod_count = 2;

		new_stream = (*csb)->csb_n_stream++;

		new_stream = (*csb)->csb_n_stream++;

		node->nod_arg[e_uni_stream] = (JRD_NOD) (SLONG) new_stream;

		node->nod_arg[e_uni_stream] = (JRD_NOD) (SLONG) new_stream;

		/* TMN: Here we should really have the following assert */

		/* TMN: Here we should really have the following assert */

			csb_repeat *tail;

			csb_repeat *tail;

			JRD_REL relation;

			JRD_REL relation;

			csb->csb_rpt[stream].csb_flags |= csb_no_dbkey;

			csb->csb_rpt[stream].csb_flags |= csb_no_dbkey;

			tail = &csb->csb_rpt[stream];

			tail = &csb->csb_rpt[stream];

			if ( (relation = tail->csb_relation) )

			if ( (relation = tail->csb_relation) )

			JRD_FLD field;

			JRD_FLD field;

			UCHAR *map, local_map[MAP_LENGTH];

			UCHAR *map, local_map[MAP_LENGTH];

			/* Look at all rse's which are lower in scope than the rse which this field 

			/* Look at all rse's which are lower in scope than the rse which this field 

			   is referencing, and mark them as varying -- the rule is that if a field 

			   is referencing, and mark them as varying -- the rule is that if a field 

			if (!(relation = tail->csb_relation) ||

			if (!(relation = tail->csb_relation) ||

				!(field =

				!(field =

				  MET_get_field(relation,

				  MET_get_field(relation,

			/* if this is a modify or store, check REFERENCES access to any foreign keys. */

			/* if this is a modify or store, check REFERENCES access to any foreign keys. */

			sub = node->nod_arg[e_asgn_from];

			sub = node->nod_arg[e_asgn_from];

			if (sub->nod_type == nod_field) {

			if (sub->nod_type == nod_field) {

				field = MET_get_field((*csb)->csb_rpt[stream].csb_relation,

				field = MET_get_field((*csb)->csb_rpt[stream].csb_relation,

				if (field)

				if (field)

					node->nod_arg[e_asgn_missing2] = field->fld_missing_value;

					node->nod_arg[e_asgn_missing2] = field->fld_missing_value;

			}

			}

			sub = node->nod_arg[e_asgn_to];

			sub = node->nod_arg[e_asgn_to];

			if (sub->nod_type != nod_field)

			if (sub->nod_type != nod_field)

				break;

				break;

			tail = &(*csb)->csb_rpt[stream];

			tail = &(*csb)->csb_rpt[stream];

			if (!

			if (!

				(field =

				(field =

				 MET_get_field(tail->csb_relation,

				 MET_get_field(tail->csb_relation,

			if (field->fld_missing_value) {

			if (field->fld_missing_value) {

				node->nod_arg[e_asgn_missing] = field->fld_missing_value;

				node->nod_arg[e_asgn_missing] = field->fld_missing_value;

				node->nod_count = 3;

				node->nod_count = 3;

		break;

		break;

	case nod_modify:

	case nod_modify:

		tail = &(*csb)->csb_rpt[stream];

		tail = &(*csb)->csb_rpt[stream];

		tail->csb_flags |= csb_modify;

		tail->csb_flags |= csb_modify;

		pass1_modify(tdbb, csb, node);

		pass1_modify(tdbb, csb, node);

		/* assert(node->nod_arg [e_mod_new_stream] <= MAX_USHORT); */

		/* assert(node->nod_arg [e_mod_new_stream] <= MAX_USHORT); */

		if ( (node->nod_arg[e_mod_validate] =

		if ( (node->nod_arg[e_mod_validate] =

			make_validation(tdbb, csb,

			make_validation(tdbb, csb,

							nod_arg[e_mod_new_stream])) ) node->nod_count =

							nod_arg[e_mod_new_stream])) ) node->nod_count =

				MAX(node->nod_count, (USHORT) e_mod_validate + 1);

				MAX(node->nod_count, (USHORT) e_mod_validate + 1);

		break;

		break;

	case nod_erase:

	case nod_erase:

		tail = &(*csb)->csb_rpt[stream];

		tail = &(*csb)->csb_rpt[stream];

		tail->csb_flags |= csb_erase;

		tail->csb_flags |= csb_erase;

		pass1_erase(tdbb, csb, node);

		pass1_erase(tdbb, csb, node);

	case nod_store:

	case nod_store:

		sub = node->nod_arg[e_sto_relation];

		sub = node->nod_arg[e_sto_relation];

		tail = &(*csb)->csb_rpt[stream];

		tail = &(*csb)->csb_rpt[stream];

		tail->csb_flags |= csb_store;

		tail->csb_flags |= csb_store;

		sub = pass1_store(tdbb, csb, node);

		sub = pass1_store(tdbb, csb, node);

		if (sub) {

		if (sub) {

			if ((!node->nod_arg[e_sto_sub_store]) &&

			if ((!node->nod_arg[e_sto_sub_store]) &&

				(node->nod_arg[e_sto_validate] =

				(node->nod_arg[e_sto_validate] =

				 make_validation(tdbb, csb, stream))) node->nod_count =

				 make_validation(tdbb, csb, stream))) node->nod_count =

	case nod_aggregate:

	case nod_aggregate:

		assert((int)node->nod_arg[e_agg_stream] <= MAX_STREAMS);

		assert((int)node->nod_arg[e_agg_stream] <= MAX_STREAMS);

			csb_no_dbkey;

			csb_no_dbkey;

		ignore_dbkey(tdbb, *csb, (RSE) node->nod_arg[e_agg_rse], view);

		ignore_dbkey(tdbb, *csb, (RSE) node->nod_arg[e_agg_rse], view);

		node->nod_arg[e_agg_rse] =

		node->nod_arg[e_agg_rse] =

			NOD_T type;

			NOD_T type;

			type = node->nod_type;

			type = node->nod_type;

			if (!(*csb)->csb_rpt[stream].csb_map) 

			if (!(*csb)->csb_rpt[stream].csb_map) 

				return node;

				return node;

		break;

		break;

	case nod_cardinality:

	case nod_cardinality:

		(*csb)->csb_rpt[stream].csb_flags |= csb_compute;

		(*csb)->csb_rpt[stream].csb_flags |= csb_compute;

		break;

		break;

/* To support views of views, loop until we hit a real relation */

/* To support views of views, loop until we hit a real relation */

	for (;;) {

	for (;;) {

		tail = &(*csb)->csb_rpt[stream];

		tail = &(*csb)->csb_rpt[stream];

		tail->csb_flags |= csb_erase;

		tail->csb_flags |= csb_erase;

		relation = (*csb)->csb_rpt[stream].csb_relation;

		relation = (*csb)->csb_rpt[stream].csb_relation;

		parent = relation;

		parent = relation;

		parent_stream = stream;

		parent_stream = stream;

		node->nod_arg[e_erase_stream] = (JRD_NOD) (SLONG) map[new_stream];

		node->nod_arg[e_erase_stream] = (JRD_NOD) (SLONG) map[new_stream];

	}

	}

}

}

				field = MET_get_field(relation, id);

				field = MET_get_field(relation, id);

				if (field->fld_source)

				if (field->fld_source)

					new_id =

					new_id =

				else

				else

					new_id = id;

					new_id = id;

			}

			}

/* To support views of views, loop until we hit a real relation */

/* To support views of views, loop until we hit a real relation */

	for (;;) {

	for (;;) {

		tail = &(*csb)->csb_rpt[new_stream];

		tail = &(*csb)->csb_rpt[new_stream];

		tail->csb_flags |= csb_modify;

		tail->csb_flags |= csb_modify;

		relation = (*csb)->csb_rpt[stream].csb_relation;

		relation = (*csb)->csb_rpt[stream].csb_relation;

			node->nod_count =

			node->nod_count =

				MAX(node->nod_count, (USHORT) e_mod_map_view + 1);

				MAX(node->nod_count, (USHORT) e_mod_map_view + 1);

			map = (*csb)->csb_rpt[stream].csb_map;

			map = (*csb)->csb_rpt[stream].csb_map;

			stream = map[stream];

			stream = map[stream];

			view_stream = new_stream;

			view_stream = new_stream;

			map =

			map =

				alloc_map(tdbb, csb,

				alloc_map(tdbb, csb,

			source = copy(tdbb, csb, source, map, 0, NULL, FALSE);

			source = copy(tdbb, csb, source, map, 0, NULL, FALSE);

			/* TMN: Here we should really have the following assert */

			/* TMN: Here we should really have the following assert */

			/* assert(source->nod_arg [e_rel_stream] <= MAX_UCHAR); */

			/* assert(source->nod_arg [e_rel_stream] <= MAX_UCHAR); */

			view_node = copy(tdbb, csb, node, map, 0, NULL, TRUE);

			view_node = copy(tdbb, csb, node, map, 0, NULL, TRUE);

			view_node->nod_arg[e_mod_org_stream] = (JRD_NOD) (SLONG) stream;

			view_node->nod_arg[e_mod_org_stream] = (JRD_NOD) (SLONG) stream;

			view_node->nod_arg[e_mod_new_stream] =

			view_node->nod_arg[e_mod_new_stream] =

				source->nod_arg[e_rel_stream];

				source->nod_arg[e_rel_stream];

			view_node->nod_arg[e_mod_map_view] = NULL;

			view_node->nod_arg[e_mod_map_view] = NULL;

			node->nod_arg[e_mod_sub_mod] = view_node;

			node->nod_arg[e_mod_sub_mod] = view_node;

			view_node->nod_arg[e_mod_statement] =

			view_node->nod_arg[e_mod_statement] =

				pass1_expand_view(tdbb, *csb, view_stream, new_stream, TRUE);

				pass1_expand_view(tdbb, *csb, view_stream, new_stream, TRUE);

			node->nod_count =

			node->nod_count =

			/* View passes muster -- do some translation.  Start with source stream */

			/* View passes muster -- do some translation.  Start with source stream */

			map = (*csb)->csb_rpt[stream].csb_map;

			map = (*csb)->csb_rpt[stream].csb_map;

			node->nod_arg[e_mod_org_stream] = (JRD_NOD) (SLONG) map[stream];

			node->nod_arg[e_mod_org_stream] = (JRD_NOD) (SLONG) map[stream];

			/* Next, do update stream */

			/* Next, do update stream */

			map =

			map =

				alloc_map(tdbb, csb,

				alloc_map(tdbb, csb,

			source = copy(tdbb, csb, source, map, 0, NULL, FALSE);

			source = copy(tdbb, csb, source, map, 0, NULL, FALSE);

			node->nod_arg[e_mod_new_stream] = source->nod_arg[e_rel_stream];

			node->nod_arg[e_mod_new_stream] = source->nod_arg[e_rel_stream];

		}

		}

		pass1(tdbb, csb, source, parent_view, view_stream, FALSE);

		pass1(tdbb, csb, source, parent_view, view_stream, FALSE);

		procedure = MET_lookup_procedure_id(tdbb, 

		procedure = MET_lookup_procedure_id(tdbb, 

		post_procedure_access(tdbb, *csb, procedure);

		post_procedure_access(tdbb, *csb, procedure);

		CMP_post_resource(&(*csb)->csb_resources, (BLK) procedure,

		CMP_post_resource(&(*csb)->csb_resources, (BLK) procedure,

						  Resource::rsc_procedure, procedure->prc_id);

						  Resource::rsc_procedure, procedure->prc_id);

					  view->rel_id);

					  view->rel_id);

	source->nod_arg[e_rel_view] = (JRD_NOD) parent_view;

	source->nod_arg[e_rel_view] = (JRD_NOD) parent_view;

	element = CMP_csb_element(csb, stream);

	element = CMP_csb_element(csb, stream);

	element->csb_view = parent_view;

	element->csb_view = parent_view;

/* TMN: Here we should really have the following assert */

/* TMN: Here we should really have the following assert */

		for (vcx_ptr = &parent_view->rel_view_contexts; *vcx_ptr;

		for (vcx_ptr = &parent_view->rel_view_contexts; *vcx_ptr;

			 vcx_ptr = &(*vcx_ptr)->vcx_next)

			 vcx_ptr = &(*vcx_ptr)->vcx_next)

			if ((*vcx_ptr)->vcx_context ==

			if ((*vcx_ptr)->vcx_context ==

				element->csb_alias = (*vcx_ptr)->vcx_context_name;

				element->csb_alias = (*vcx_ptr)->vcx_context_name;

				break;

				break;

			}

			}

	for (;;) {

	for (;;) {

		original = node->nod_arg[e_sto_relation];

		original = node->nod_arg[e_sto_relation];

		tail = &(*csb)->csb_rpt[stream];

		tail = &(*csb)->csb_rpt[stream];

		tail->csb_flags |= csb_store;

		tail->csb_flags |= csb_store;

		relation = (*csb)->csb_rpt[stream].csb_relation;

		relation = (*csb)->csb_rpt[stream].csb_relation;

			node->nod_arg[e_sto_relation] =

			node->nod_arg[e_sto_relation] =

				copy(tdbb, csb, source, map, 0, NULL, FALSE);

				copy(tdbb, csb, source, map, 0, NULL, FALSE);

			new_stream =

			new_stream =

			node->nod_arg[e_sto_statement] =

			node->nod_arg[e_sto_statement] =

				pass1_expand_view(tdbb, *csb, stream, new_stream, TRUE);

				pass1_expand_view(tdbb, *csb, stream, new_stream, TRUE);

			node->nod_arg[e_sto_statement] =

			node->nod_arg[e_sto_statement] =

		/* AB: Mark the streams involved with an UPDATE statement

		/* AB: Mark the streams involved with an UPDATE statement

		   active. So that the optimizer can use indices for 

		   active. So that the optimizer can use indices for 

		   eventually used sub-selects. */

		   eventually used sub-selects. */

		csb->csb_rpt[stream].csb_flags |= csb_active;

		csb->csb_rpt[stream].csb_flags |= csb_active;

		csb->csb_rpt[stream].csb_flags |= csb_active;

		csb->csb_rpt[stream].csb_flags |= csb_active;

	}

	}

	if (node->nod_type == nod_modify) {

	if (node->nod_type == nod_modify) {

		/* AB: Remove the previous flags */

		/* AB: Remove the previous flags */

		csb->csb_rpt[stream].csb_flags &= ~csb_active;

		csb->csb_rpt[stream].csb_flags &= ~csb_active;

		csb->csb_rpt[stream].csb_flags &= ~csb_active;

		csb->csb_rpt[stream].csb_flags &= ~csb_active;

	}

	}

			FMT format;

			FMT format;

			fmt::fmt_desc_iterator desc;

			fmt::fmt_desc_iterator desc;

			csb->csb_rpt[stream].csb_flags |= csb_update;

			csb->csb_rpt[stream].csb_flags |= csb_update;

			format = CMP_format(tdbb, csb, stream);

			format = CMP_format(tdbb, csb, stream);

			desc = format->fmt_desc.begin();

			desc = format->fmt_desc.begin();

		break;

		break;

	case nod_erase:

	case nod_erase:

		csb->csb_rpt[stream].csb_flags |= csb_update;

		csb->csb_rpt[stream].csb_flags |= csb_update;

		break;

		break;

	case nod_field:

	case nod_field:

		SBM_set(tdbb, &csb->csb_rpt[stream].csb_fields, id);

		SBM_set(tdbb, &csb->csb_rpt[stream].csb_fields, id);

		if (node->nod_flags & nod_value) {

		if (node->nod_flags & nod_value) {

			csb->csb_impure += sizeof(struct vlux);

			csb->csb_impure += sizeof(struct vlux);

		pass2_rse(tdbb, csb, (RSE) node->nod_arg[e_agg_rse]);

		pass2_rse(tdbb, csb, (RSE) node->nod_arg[e_agg_rse]);

		pass2(tdbb, csb, node->nod_arg[e_agg_map], node);

		pass2(tdbb, csb, node->nod_arg[e_agg_map], node);

		pass2(tdbb, csb, node->nod_arg[e_agg_group], node);

		pass2(tdbb, csb, node->nod_arg[e_agg_group], node);

		assert(stream <= MAX_STREAMS);

		assert(stream <= MAX_STREAMS);

		process_map(tdbb, csb, node->nod_arg[e_agg_map],

		process_map(tdbb, csb, node->nod_arg[e_agg_map],

					&csb->csb_rpt[stream].csb_format);

					&csb->csb_rpt[stream].csb_format);

		node = *ptr;

		node = *ptr;

		if (node->nod_type == nod_relation) {

		if (node->nod_type == nod_relation) {

			csb->csb_rpt[stream].csb_flags |= csb_active;

			csb->csb_rpt[stream].csb_flags |= csb_active;

			pass2(tdbb, csb, node, (JRD_NOD) rse);

			pass2(tdbb, csb, node, (JRD_NOD) rse);

		}

		}

			pass2_rse(tdbb, csb, (RSE) node);

			pass2_rse(tdbb, csb, (RSE) node);

		}

		}

		else if (node->nod_type == nod_procedure) {

		else if (node->nod_type == nod_procedure) {

			csb->csb_rpt[stream].csb_flags |= csb_active;

			csb->csb_rpt[stream].csb_flags |= csb_active;

			pass2(tdbb, csb, node, (JRD_NOD) rse);

			pass2(tdbb, csb, node, (JRD_NOD) rse);

		}

		}

		else if (node->nod_type == nod_aggregate) {

		else if (node->nod_type == nod_aggregate) {

			assert(stream <= MAX_STREAMS);

			assert(stream <= MAX_STREAMS);

			csb->csb_rpt[stream].csb_flags |= csb_active;

			csb->csb_rpt[stream].csb_flags |= csb_active;

			pass2(tdbb, csb, node, (JRD_NOD) rse);

			pass2(tdbb, csb, node, (JRD_NOD) rse);

/* Make up a format block sufficiently large to hold instantiated record */

/* Make up a format block sufficiently large to hold instantiated record */

	clauses = node->nod_arg[e_uni_clauses];

	clauses = node->nod_arg[e_uni_clauses];

	format = &csb->csb_rpt[id].csb_format;

	format = &csb->csb_rpt[id].csb_format;

/* Process alternating rse and map blocks */

/* Process alternating rse and map blocks */

	for (ptr = rse->rse_relation, end = ptr + rse->rse_count; ptr < end;

	for (ptr = rse->rse_relation, end = ptr + rse->rse_count; ptr < end;

		 ptr++) if ((*ptr)->nod_type == nod_relation) {

		 ptr++) if ((*ptr)->nod_type == nod_relation) {

			if (!(csb->csb_rpt[stream].csb_plan))

			if (!(csb->csb_rpt[stream].csb_plan))

				ERR_post(gds_no_stream_plan, gds_arg_string,

				ERR_post(gds_no_stream_plan, gds_arg_string,

						 csb->csb_rpt[stream].csb_relation->rel_name, 0);

						 csb->csb_rpt[stream].csb_relation->rel_name, 0);

/* find the tail for the relation specified in the rse */

/* find the tail for the relation specified in the rse */

	tail = &csb->csb_rpt[stream];

	tail = &csb->csb_rpt[stream];

/* if the plan references a view, find the real base relation 

/* if the plan references a view, find the real base relation 

		 ptr < end; ptr++) {

		 ptr < end; ptr++) {

		node = *ptr;

		node = *ptr;

		if (node->nod_type == nod_relation) {

		if (node->nod_type == nod_relation) {

			csb->csb_rpt[stream].csb_flags &= ~csb_active;

			csb->csb_rpt[stream].csb_flags &= ~csb_active;

		}

		}

		else if (node->nod_type == nod_procedure) {

		else if (node->nod_type == nod_procedure) {

			csb->csb_rpt[stream].csb_flags &= ~csb_active;

			csb->csb_rpt[stream].csb_flags &= ~csb_active;

		}

		}

		else if (node->nod_type == nod_aggregate) {

		else if (node->nod_type == nod_aggregate) {

			assert(stream <= MAX_STREAMS);

			assert(stream <= MAX_STREAMS);

			csb->csb_rpt[stream].csb_flags &= ~csb_active;

			csb->csb_rpt[stream].csb_flags &= ~csb_active;

		}

		}

	for (end = ptr + map->nod_count; ptr < end; ptr++) {

	for (end = ptr + map->nod_count; ptr < end; ptr++) {

		assignment = *ptr;

		assignment = *ptr;

		field = assignment->nod_arg[e_asgn_to];

		field = assignment->nod_arg[e_asgn_to];

		if (id >= format->fmt_count) {

		if (id >= format->fmt_count) {

			format->fmt_desc.resize(id + 1);

			format->fmt_desc.resize(id + 1);

		}

		}

		/* for aggregates, check current rse, if not found then check 

		/* for aggregates, check current rse, if not found then check 

		   the sub-rse */

		   the sub-rse */

		if (sub->nod_type == nod_aggregate) {

		if (sub->nod_type == nod_aggregate) {

				(stream_in_rse(stream, (RSE) sub->nod_arg[e_agg_rse])))

				(stream_in_rse(stream, (RSE) sub->nod_arg[e_agg_rse])))

				return TRUE;	/* do not mark as variant */

				return TRUE;	/* do not mark as variant */

		}

		}

		if ((sub->nod_type == nod_relation) &&

		if ((sub->nod_type == nod_relation) &&

			return TRUE;		/* do not mark as variant */

			return TRUE;		/* do not mark as variant */

	}

	}

#define JRD_BUGCHK 15			/* facility code for bugcheck messages */

#define JRD_BUGCHK 15			/* facility code for bugcheck messages */

#ifndef OFFSET

#ifndef OFFSET

#endif

#endif

#ifndef ODS_ALIGNMENT

#ifndef ODS_ALIGNMENT

	DEBUG if (stack)

	DEBUG if (stack)

		while (*stack)

		while (*stack)

	CCH_precedence(tdbb, &rpb->rpb_window, -rpb->rpb_transaction);

	CCH_precedence(tdbb, &rpb->rpb_window, -rpb->rpb_transaction);

	CCH_MARK(tdbb, &rpb->rpb_window);

	CCH_MARK(tdbb, &rpb->rpb_window);

   If the page need to be compressed, compress it. */

   If the page need to be compressed, compress it. */

	while (*stack)

	while (*stack)

	CCH_MARK(tdbb, &rpb->rpb_window);

	CCH_MARK(tdbb, &rpb->rpb_window);

	i = page->dpg_count + ((slot) ? 0 : 1);

	i = page->dpg_count + ((slot) ? 0 : 1);

		arg_number = (int)(IPTR)node->nod_arg[e_arg_number];

		arg_number = (int)(IPTR)node->nod_arg[e_arg_number];

		desc = &format->fmt_desc[arg_number];

		desc = &format->fmt_desc[arg_number];

		impure->vlu_desc.dsc_address =

		impure->vlu_desc.dsc_address =

		impure->vlu_desc.dsc_dtype = desc->dsc_dtype;

		impure->vlu_desc.dsc_dtype = desc->dsc_dtype;

		impure->vlu_desc.dsc_length = desc->dsc_length;

		impure->vlu_desc.dsc_length = desc->dsc_length;

		impure->vlu_desc.dsc_scale = desc->dsc_scale;

		impure->vlu_desc.dsc_scale = desc->dsc_scale;

		// may happen. I checked triggers and insert/update statements.

		// may happen. I checked triggers and insert/update statements.

		// All seem to work fine.

		// All seem to work fine.

		record =

		record =

				  &impure->vlu_desc);

				  &impure->vlu_desc);

		if (!impure->vlu_desc.dsc_address)

		if (!impure->vlu_desc.dsc_address)

			ERR_post(gds_read_only_field, 0);

			ERR_post(gds_read_only_field, 0);

			impure = (INV) ((SCHAR *) tdbb->tdbb_request + node->nod_impure);

			impure = (INV) ((SCHAR *) tdbb->tdbb_request + node->nod_impure);

			SBM_reset(&impure->inv_bitmap);

			SBM_reset(&impure->inv_bitmap);

			desc = EVL_expr(tdbb, node->nod_arg[0]);

			desc = EVL_expr(tdbb, node->nod_arg[0]);

			numbers = desc->dsc_address;

			numbers = desc->dsc_address;

			numbers += id * sizeof(SLONG);

			numbers += id * sizeof(SLONG);

			MOVE_FAST(numbers, &rel_dbkey, sizeof(SLONG));

			MOVE_FAST(numbers, &rel_dbkey, sizeof(SLONG));

			}

			}

			message = node->nod_arg[e_arg_message];

			message = node->nod_arg[e_arg_message];

			format = (FMT) message->nod_arg[e_msg_format];

			format = (FMT) message->nod_arg[e_msg_format];

			impure->vlu_desc.dsc_address = (UCHAR *) request +

			impure->vlu_desc.dsc_address = (UCHAR *) request +

			impure->vlu_desc.dsc_dtype = desc->dsc_dtype;

			impure->vlu_desc.dsc_dtype = desc->dsc_dtype;

			impure->vlu_desc.dsc_length = desc->dsc_length;

			impure->vlu_desc.dsc_length = desc->dsc_length;

			impure->vlu_desc.dsc_scale = desc->dsc_scale;

			impure->vlu_desc.dsc_scale = desc->dsc_scale;

	case nod_field:

	case nod_field:

		{

		{

			REC record =

			REC record =

			/* In order to "map a null to a default" value (in EVL_field()), 

			/* In order to "map a null to a default" value (in EVL_field()), 

			 * the relation block is referenced. 

			 * the relation block is referenced. 

			 * Reference: Bug 10116, 10424 

			 * Reference: Bug 10116, 10424 

			 */

			 */

							record,

							record,

							&impure->vlu_desc))

							&impure->vlu_desc))

			{

			{

				request->req_flags |= req_null;

				request->req_flags |= req_null;

			ULONG extract_part;

			ULONG extract_part;

			impure = (VLU) ((SCHAR *) request + node->nod_impure);

			impure = (VLU) ((SCHAR *) request + node->nod_impure);

			value = EVL_expr(tdbb, node->nod_arg[e_extract_value]);

			value = EVL_expr(tdbb, node->nod_arg[e_extract_value]);

			impure->vlu_desc.dsc_dtype = dtype_short;

			impure->vlu_desc.dsc_dtype = dtype_short;

		switch (node->nod_type) {

		switch (node->nod_type) {

		case nod_gen_id:		/* return a 32-bit generator value */

		case nod_gen_id:		/* return a 32-bit generator value */

														   node->nod_arg

														   node->nod_arg

														   [e_gen_id], 0,

														   [e_gen_id], 0,

														   MOV_get_int64

														   MOV_get_int64

		case nod_gen_id2:

		case nod_gen_id2:

			impure->vlu_misc.vlu_int64 = DPM_gen_id(tdbb,

			impure->vlu_misc.vlu_int64 = DPM_gen_id(tdbb,

													node->nod_arg[e_gen_id],

													node->nod_arg[e_gen_id],

													0,

													0,

													MOV_get_int64(values[0],

													MOV_get_int64(values[0],

		return FALSE;

		return FALSE;

	}

	}

	if (TEST_NULL(record, id)) {

	if (TEST_NULL(record, id)) {

		desc->dsc_flags |= DSC_null;

		desc->dsc_flags |= DSC_null;

	{

	{

		from = (*ptr)->nod_arg[e_asgn_from];

		from = (*ptr)->nod_arg[e_asgn_from];

		field = (*ptr)->nod_arg[e_asgn_to];

		field = (*ptr)->nod_arg[e_asgn_to];

		record =

		record =

		impure = (VLUX) ((SCHAR *) request + from->nod_impure);

		impure = (VLUX) ((SCHAR *) request + from->nod_impure);

		switch (from->nod_type)

		switch (from->nod_type)

		{

		{

	request = tdbb->tdbb_request;

	request = tdbb->tdbb_request;

	impure = (VLU) ((SCHAR *) request + node->nod_impure);

	impure = (VLU) ((SCHAR *) request + node->nod_impure);

	relation = rpb->rpb_relation;

	relation = rpb->rpb_relation;

/* Format dbkey as vector of relation id, record number */

/* Format dbkey as vector of relation id, record number */

	request = tdbb->tdbb_request;

	request = tdbb->tdbb_request;

	impure = (VLU) ((SCHAR *) request + node->nod_impure);

	impure = (VLU) ((SCHAR *) request + node->nod_impure);

/* If the current transaction has updated the record, the record version

/* If the current transaction has updated the record, the record version

 * coming in from DSQL will have the original transaction # (or current

 * coming in from DSQL will have the original transaction # (or current

	if (to->nod_type == nod_field)

	if (to->nod_type == nod_field)

	{

	{

		if (null) {

		if (null) {

			SET_NULL(record, id);

			SET_NULL(record, id);

		} else {

		} else {

	message = request->req_message;

	message = request->req_message;

	format = (FMT) message->nod_arg[e_msg_format];

	format = (FMT) message->nod_arg[e_msg_format];

		ERR_post(gds_req_sync, 0);

		ERR_post(gds_req_sync, 0);

	if (length != format->fmt_length)

	if (length != format->fmt_length)

		for (ptr = node->nod_arg, end = ptr + node->nod_count; ptr < end;

		for (ptr = node->nod_arg, end = ptr + node->nod_count; ptr < end;

			 ptr++) {

			 ptr++) {

			message = (*ptr)->nod_arg[e_send_message];

			message = (*ptr)->nod_arg[e_send_message];

				request->req_next = *ptr;

				request->req_next = *ptr;

				break;

				break;

			}

			}

	format = (FMT) message->nod_arg[e_msg_format];

	format = (FMT) message->nod_arg[e_msg_format];

		ERR_post(gds_req_sync, 0);

		ERR_post(gds_req_sync, 0);

	if (length != format->fmt_length)

	if (length != format->fmt_length)

		desc = &format->fmt_desc[n];

		desc = &format->fmt_desc[n];

		if (!desc->dsc_address)

		if (!desc->dsc_address)

			continue;

			continue;

		if (TEST_NULL(record, n))

		if (TEST_NULL(record, n))

		{

		{

			if (length = desc->dsc_length)

			if (length = desc->dsc_length)

	request = tdbb->tdbb_request;

	request = tdbb->tdbb_request;

	transaction = request->req_transaction;

	transaction = request->req_transaction;

	relation = rpb->rpb_relation;

	relation = rpb->rpb_relation;

#ifdef PC_ENGINE

#ifdef PC_ENGINE

			case jrd_req::req_evaluate:

			case jrd_req::req_evaluate:

				if (transaction != dbb->dbb_sys_trans) {

				if (transaction != dbb->dbb_sys_trans) {

					TEXT * node_savepoint_name = (TEXT*) node->nod_arg[e_sav_name]; 

					TEXT * node_savepoint_name = (TEXT*) node->nod_arg[e_sav_name]; 

					// Skip the savepoint created by EXE_start

					// Skip the savepoint created by EXE_start

				break;

				break;

			case jrd_req::req_unwind:

			case jrd_req::req_unwind:

						(request->req_flags & (req_leave | req_error_handler))) {

						(request->req_flags & (req_leave | req_error_handler))) {

					request->req_flags &= ~req_leave;

					request->req_flags &= ~req_leave;

					request->req_operation = jrd_req::req_return;

					request->req_operation = jrd_req::req_return;

		case nod_leave:

		case nod_leave:

			request->req_flags |= req_leave;

			request->req_flags |= req_leave;

			request->req_operation = jrd_req::req_unwind;

			request->req_operation = jrd_req::req_unwind;

			node = node->nod_parent;

			node = node->nod_parent;

			break;

			break;

				DSC *desc;

				DSC *desc;

				desc = EVL_expr(tdbb, node->nod_arg[e_gen_value]);

				desc = EVL_expr(tdbb, node->nod_arg[e_gen_value]);

								  MOV_get_int64(desc, 0));

								  MOV_get_int64(desc, 0));

				request->req_operation = jrd_req::req_return;

				request->req_operation = jrd_req::req_return;

			}

			}

				DSC *desc;

				DSC *desc;

				desc = EVL_expr(tdbb, node->nod_arg[e_gen_value]);

				desc = EVL_expr(tdbb, node->nod_arg[e_gen_value]);

								  MOV_get_int64(desc, 0));

								  MOV_get_int64(desc, 0));

				request->req_operation = jrd_req::req_return;

				request->req_operation = jrd_req::req_return;

			}

			}

	transaction = request->req_transaction;

	transaction = request->req_transaction;

	impure = (STA) ((SCHAR *) request + node->nod_impure);

	impure = (STA) ((SCHAR *) request + node->nod_impure);

	org_rpb = &request->req_rpb[org_stream];

	org_rpb = &request->req_rpb[org_stream];

	relation = org_rpb->rpb_relation;

	relation = org_rpb->rpb_relation;

	new_rpb = &request->req_rpb[new_stream];

	new_rpb = &request->req_rpb[new_stream];

#ifdef PC_ENGINE

#ifdef PC_ENGINE

	JRD_REQ    request     = tdbb->tdbb_request;

	JRD_REQ    request     = tdbb->tdbb_request;

	JRD_TRA    transaction = request->req_transaction;

	JRD_TRA    transaction = request->req_transaction;

	STA    impure      = (STA) ((SCHAR *) request + node->nod_impure);

	STA    impure      = (STA) ((SCHAR *) request + node->nod_impure);

	RPB*   rpb         = &request->req_rpb[stream];

	RPB*   rpb         = &request->req_rpb[stream];

	JRD_REL    relation    = rpb->rpb_relation;

	JRD_REL    relation    = rpb->rpb_relation;

			if (node->nod_type == nod_field)

			if (node->nod_type == nod_field)

			{

			{

				relation = request->req_rpb[stream].rpb_relation;

				relation = request->req_rpb[stream].rpb_relation;

				if ((vector = relation->rel_fields) &&

				if ((vector = relation->rel_fields) &&

	record = rpb->rpb_record;

	record = rpb->rpb_record;

	format = record->rec_format;

	format = record->rec_format;

	p = record->rec_data + offset;

	p = record->rec_data + offset;

	l = record->rec_length - offset;

	l = record->rec_length - offset;

			continue;

			continue;

		if ( (literal = (LIT) field->fld_missing_value) ) {

		if ( (literal = (LIT) field->fld_missing_value) ) {

			desc = *desc_ptr;

			desc = *desc_ptr;

			if (!MOV_compare(&literal->lit_desc, &desc))

			if (!MOV_compare(&literal->lit_desc, &desc))

				continue;

				continue;

		}

		}

			desc_ptr->dsc_length &&

			desc_ptr->dsc_length &&

			TEST_NULL(record, i))

			TEST_NULL(record, i))

		{

		{

			if ( (literal = (LIT) field->fld_missing_value) ) {

			if ( (literal = (LIT) field->fld_missing_value) ) {

				desc = *desc_ptr;

				desc = *desc_ptr;

				desc.dsc_address = p;

				desc.dsc_address = p;

		}

		}

	}

	}

	p = record->rec_data + offset;

	p = record->rec_data + offset;

	l = record->rec_length - offset;

	l = record->rec_length - offset;

		return result;

		return result;

	if (stdio_flag)

	if (stdio_flag)

			return (void *)-1;

			return (void *)-1;

	if (expanded_string)

	if (expanded_string)

			 index_number < idx->idx_foreign_primaries->count();

			 index_number < idx->idx_foreign_primaries->count();

			 index_number++) {

			 index_number++) {

			if (idx->idx_id !=

			if (idx->idx_id !=

			partner_relation =

			partner_relation =

				MET_relation(tdbb,

				MET_relation(tdbb,

			index_id =

			index_id =

			if ( (result =

			if ( (result =

				check_partner_index(tdbb, relation, record, transaction, idx,

				check_partner_index(tdbb, relation, record, transaction, idx,

									partner_relation, index_id)) )

									partner_relation, index_id)) )

			node = request->req_message;

			node = request->req_message;

			if (item == gds_info_message_number)

			if (item == gds_info_message_number)

				length =

				length =

								buffer_ptr);

								buffer_ptr);

			else {

			else {

				format = (FMT) node->nod_arg[e_msg_format];

				format = (FMT) node->nod_arg[e_msg_format];

			if (desc->dsc_address)

			if (desc->dsc_address)

			{

			{

				format->fmt_length =

				format->fmt_length =

				break;

				break;

			}

			}

		}

		}

				 index_number < references->frgn_reference_ids->count();

				 index_number < references->frgn_reference_ids->count();

				 index_number++)

				 index_number++)

			{

			{

											[index_number])

											[index_number])

				{

				{

					idx->idx_primary_relation =

					idx->idx_primary_relation =

					idx->idx_primary_index =

					idx->idx_primary_index =

					return TRUE;

					return TRUE;

				}

				}

			}

			}

				 index_number < dependencies->prim_reference_ids->count();

				 index_number < dependencies->prim_reference_ids->count();

				 index_number++)

				 index_number++)

			{

			{

											[index_number])

											[index_number])

				{

				{

					idx->idx_foreign_primaries =

					idx->idx_foreign_primaries =

		{

		{

			if ( (node = csb_->csb_rpt[i].csb_message) )

			if ( (node = csb_->csb_rpt[i].csb_message) )

			{

			{

				{

				{

					procedure->prc_input_msg = node;

					procedure->prc_input_msg = node;

				{

				{

					procedure->prc_output_msg = node;

					procedure->prc_output_msg = node;

				}

				}

		node = (JRD_NOD) LLS_POP(&csb->csb_dependencies);

		node = (JRD_NOD) LLS_POP(&csb->csb_dependencies);

		if (!node->nod_arg[e_dep_object])

		if (!node->nod_arg[e_dep_object])

			continue;

			continue;

        relation = NULL;

        relation = NULL;

        procedure = NULL;

        procedure = NULL;

        switch (dpdo_type) {

        switch (dpdo_type) {

            dpdo_name = (TEXT*) procedure->prc_name->str_data;

            dpdo_name = (TEXT*) procedure->prc_name->str_data;

            break;

            break;

        case obj_exception:

        case obj_exception:

            MET_lookup_exception (tdbb, number, name, NULL);

            MET_lookup_exception (tdbb, number, name, NULL);

            dpdo_name = name;

            dpdo_name = name;

            break;

            break;

            /* CVC: Here I'm going to track those pesky things named generators and UDFs. */

            /* CVC: Here I'm going to track those pesky things named generators and UDFs. */

        case obj_generator:

        case obj_generator:

            MET_lookup_generator_id (tdbb, number, name);

            MET_lookup_generator_id (tdbb, number, name);

            dpdo_name = name;

            dpdo_name = name;

            break;

            break;

		{

		{

			if (field_node->nod_type == nod_field)

			if (field_node->nod_type == nod_field)

			{

			{

				if (relation)

				if (relation)

				{

				{

					if ( (field = MET_get_field(relation, fld_id)) )

					if ( (field = MET_get_field(relation, fld_id)) )

		if (node->nod_type != nod_rse)

		if (node->nod_type != nod_rse)

		{

		{

			assert(stream <= MAX_UCHAR);

			assert(stream <= MAX_UCHAR);

			assert(beds[0] < MAX_STREAMS && beds[0] < MAX_UCHAR);

			assert(beds[0] < MAX_STREAMS && beds[0] < MAX_UCHAR);

			beds[++beds[0]] = (UCHAR) stream;

			beds[++beds[0]] = (UCHAR) stream;

						  (USHORT) (key_streams[0] - i));

						  (USHORT) (key_streams[0] - i));

			assert(local_streams[0] < MAX_STREAMS && local_streams[0] < MAX_UCHAR);

			assert(local_streams[0] < MAX_STREAMS && local_streams[0] < MAX_UCHAR);

			local_streams[++local_streams[0]] =

			local_streams[++local_streams[0]] =

		}

		}

		else if (node->nod_type == nod_aggregate) {

		else if (node->nod_type == nod_aggregate) {

			assert((int)node->nod_arg[e_agg_stream] <= MAX_STREAMS);

			assert((int)node->nod_arg[e_agg_stream] <= MAX_STREAMS);

			rsb = gen_aggregate(tdbb, opt_, node);

			rsb = gen_aggregate(tdbb, opt_, node);

			assert(local_streams[0] < MAX_STREAMS && local_streams[0] < MAX_UCHAR);

			assert(local_streams[0] < MAX_STREAMS && local_streams[0] < MAX_UCHAR);

			local_streams[++local_streams[0]] =

			local_streams[++local_streams[0]] =

		}

		}

		else if (node->nod_type == nod_procedure) {

		else if (node->nod_type == nod_procedure) {

			rsb = gen_procedure(tdbb, opt_, node);

			rsb = gen_procedure(tdbb, opt_, node);

			assert(local_streams[0] < MAX_STREAMS && local_streams[0] < MAX_UCHAR);

			assert(local_streams[0] < MAX_STREAMS && local_streams[0] < MAX_UCHAR);

			local_streams[++local_streams[0]] =

			local_streams[++local_streams[0]] =

		}

		}

		else if (node->nod_type == nod_rse) {

		else if (node->nod_type == nod_rse) {

			compute_rse_streams(csb, (RSE) node, beds);

			compute_rse_streams(csb, (RSE) node, beds);

/* Make sure we have the correct stream */

/* Make sure we have the correct stream */

		return NULL;

		return NULL;

/* If this is a dbkey for the appropriate stream, it's invertable */

/* If this is a dbkey for the appropriate stream, it's invertable */

	switch (node->nod_type) {

	switch (node->nod_type) {

	case nod_field:

	case nod_field:

		if (allowOnlyCurrentStream) {

		if (allowOnlyCurrentStream) {

			if (n != stream) {

			if (n != stream) {

	case nod_dbkey:

	case nod_dbkey:

		if (allowOnlyCurrentStream) {

		if (allowOnlyCurrentStream) {

			if (n != stream) {

			if (n != stream) {

	for (ptr = rse->rse_relation, end = ptr + rse->rse_count; ptr < end; ptr++) {

	for (ptr = rse->rse_relation, end = ptr + rse->rse_count; ptr < end; ptr++) {

		if ((*ptr)->nod_type != nod_rse) {

		if ((*ptr)->nod_type != nod_rse) {

			csb->csb_rpt[n].csb_flags |= csb_active;

			csb->csb_rpt[n].csb_flags |= csb_active;

		}

		}

	}

	}

	{

	{

		if ((*ptr)->nod_type != nod_rse)

		if ((*ptr)->nod_type != nod_rse)

		{

		{

			csb->csb_rpt[n].csb_flags &= ~csb_active;

			csb->csb_rpt[n].csb_flags &= ~csb_active;

		}

		}

	}

	}

	switch (node->nod_type) {

	switch (node->nod_type) {

	case nod_field:

	case nod_field:

		SET_DEP_BIT(dependencies, n);

		SET_DEP_BIT(dependencies, n);

		return;

		return;

	case nod_dbkey:

	case nod_dbkey:

		SET_DEP_BIT(dependencies, n);

		SET_DEP_BIT(dependencies, n);

		return;

		return;

	for (ptr = rse->rse_relation, end = ptr + rse->rse_count; ptr < end; ptr++) {

	for (ptr = rse->rse_relation, end = ptr + rse->rse_count; ptr < end; ptr++) {

		if ((*ptr)->nod_type != nod_rse) {

		if ((*ptr)->nod_type != nod_rse) {

			CLEAR_DEP_BIT(dependencies, n);

			CLEAR_DEP_BIT(dependencies, n);

		}

		}

	}

	}

	if (node->nod_type == nod_relation) {

	if (node->nod_type == nod_relation) {

		assert(streams[0] < MAX_STREAMS && streams[0] < MAX_UCHAR);

		assert(streams[0] < MAX_STREAMS && streams[0] < MAX_UCHAR);

	}

	}

	else if (node->nod_type == nod_union) {

	else if (node->nod_type == nod_union) {

		clauses = node->nod_arg[e_uni_clauses];

		clauses = node->nod_arg[e_uni_clauses];

		node = *ptr;

		node = *ptr;

		if (node->nod_type != nod_rse) {

		if (node->nod_type != nod_rse) {

			assert(streams[0] < MAX_STREAMS && streams[0] < MAX_UCHAR);

			assert(streams[0] < MAX_STREAMS && streams[0] < MAX_UCHAR);

		}

		}

		else {

		else {

			compute_rse_streams(csb, (RSE) node, streams);

			compute_rse_streams(csb, (RSE) node, streams);

	JRD_NOD dbkey_temp, *ptr, *end;

	JRD_NOD dbkey_temp, *ptr, *end;

	DEV_BLKCHK(dbkey, type_nod);

	DEV_BLKCHK(dbkey, type_nod);

	if (dbkey->nod_type == nod_dbkey) {

	if (dbkey->nod_type == nod_dbkey) {

			return dbkey;

			return dbkey;

		else {

		else {

			*position = *position + 1;

			*position = *position + 1;

		temp[0]++;

		temp[0]++;

		relation_node = plan_node->nod_arg[e_retrieve_relation];

		relation_node = plan_node->nod_arg[e_retrieve_relation];

	}

	}

	// just because the user specified a join does not mean that 

	// just because the user specified a join does not mean that 

	rsb->rsb_type = rsb_aggregate;

	rsb->rsb_type = rsb_aggregate;

	assert((int)node->nod_arg[e_agg_stream] <= MAX_STREAMS);

	assert((int)node->nod_arg[e_agg_stream] <= MAX_STREAMS);

	assert((int)node->nod_arg[e_agg_stream] <= MAX_UCHAR);

	assert((int)node->nod_arg[e_agg_stream] <= MAX_UCHAR);

	rsb->rsb_format = csb->csb_rpt[rsb->rsb_stream].csb_format;

	rsb->rsb_format = csb->csb_rpt[rsb->rsb_stream].csb_format;

	rsb->rsb_next = OPT_compile(tdbb, csb, rse, NULL);

	rsb->rsb_next = OPT_compile(tdbb, csb, rse, NULL);

	rsb->rsb_arg[0] = (RSB) node;

	rsb->rsb_arg[0] = (RSB) node;

		 idx->idx_rpt; ptr < end; ptr++, idx_tail++) {

		 idx->idx_rpt; ptr < end; ptr++, idx_tail++) {

		node = *ptr;

		node = *ptr;

		if (node->nod_type != nod_field

		if (node->nod_type != nod_field

			|| ptr[2*sort->nod_count] /* do not use index if NULLS FIRST is used */

			|| ptr[2*sort->nod_count] /* do not use index if NULLS FIRST is used */

#ifdef SCROLLABLE_CURSORS

#ifdef SCROLLABLE_CURSORS

			)

			)

		{

		{

			stream_ptr[i]->stream_rsb = NULL;

			stream_ptr[i]->stream_rsb = NULL;

			stream_ptr[i]->stream_num =

			stream_ptr[i]->stream_num =

		}

		}

	}

	}

	SET_TDBB(tdbb);

	SET_TDBB(tdbb);

	csb = opt->opt_csb;	

	csb = opt->opt_csb;	

	procedure = MET_lookup_procedure_id(tdbb,

	procedure = MET_lookup_procedure_id(tdbb,

	rsb = FB_NEW_RPT(*tdbb->tdbb_default, RSB_PRC_count) Rsb();

	rsb = FB_NEW_RPT(*tdbb->tdbb_default, RSB_PRC_count) Rsb();

	rsb->rsb_type = rsb_procedure;

	rsb->rsb_type = rsb_procedure;

	rsb->rsb_procedure = procedure;

	rsb->rsb_procedure = procedure;

	rsb->rsb_format = procedure->prc_format;

	rsb->rsb_format = procedure->prc_format;

	rsb->rsb_impure = CMP_impure(csb, sizeof(struct irsb_procedure));

	rsb->rsb_impure = CMP_impure(csb, sizeof(struct irsb_procedure));

			for (node_ptr = sort->nod_arg; node_ptr < end_node; node_ptr++) {

			for (node_ptr = sort->nod_arg; node_ptr < end_node; node_ptr++) {

				node = *node_ptr;

				node = *node_ptr;

				if (node->nod_type == nod_field

				if (node->nod_type == nod_field

					desc = &descriptor;

					desc = &descriptor;

					CMP_get_desc(tdbb, csb, node, desc);

					CMP_get_desc(tdbb, csb, node, desc);

					/* International type text has a computed key */

					/* International type text has a computed key */

		map_item->smb_desc.dsc_address = (UCHAR *) map_length;

		map_item->smb_desc.dsc_address = (UCHAR *) map_length;

		map_length += desc->dsc_length;

		map_length += desc->dsc_length;

		if (node->nod_type == nod_field) {

		if (node->nod_type == nod_field) {

		}

		}

	}

	}

   field has already been mentioned as a sort key, don't bother to repeat

   field has already been mentioned as a sort key, don't bother to repeat

   it. */

   it. */

	while (stream_stack) {

	while (stream_stack) {

		format = CMP_format(tdbb, csb, stream);

		format = CMP_format(tdbb, csb, stream);

		desc = &format->fmt_desc[id];

		desc = &format->fmt_desc[id];

		if (id >= format->fmt_count || desc->dsc_length == 0)

		if (id >= format->fmt_count || desc->dsc_length == 0)

	rsb = FB_NEW_RPT(*tdbb->tdbb_default, count + nstreams + 1) Rsb();

	rsb = FB_NEW_RPT(*tdbb->tdbb_default, count + nstreams + 1) Rsb();

	rsb->rsb_type = rsb_union;

	rsb->rsb_type = rsb_union;

	rsb->rsb_count = count;

	rsb->rsb_count = count;