Attachment #80752 for bug #120867





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

#if  __GNUC__ < 4
#define STATIC_NEW static
#else
#define STATIC_NEW
#endif

#ifdef DEBUG_GDS_ALLOC
STATIC_NEW inline void* operator new(size_t s, Firebird::MemoryPool& pool, char* file, int line) {
	return pool.allocate(s, 0, file, line);
//	return pool.calloc(s, 0, file, line);
}
STATIC_NEW inline void* operator new[](size_t s, Firebird::MemoryPool& pool, char* file, int line) {
	return pool.allocate(s, 0, file, line);
//	return pool.calloc(s, 0, file, line);
}
#define FB_NEW(pool) new(pool,__FILE__,__LINE__)
#define FB_NEW_RPT(pool,count) new(pool,count,__FILE__,__LINE__)
#else
STATIC_NEW inline void* operator new(size_t s, Firebird::MemoryPool& pool) {
	return pool.allocate(s);
//	return pool.calloc(s);
}
STATIC_NEW inline void* operator new[](size_t s, Firebird::MemoryPool& pool) {
	return pool.allocate(s);
//	return pool.calloc(s);
}





int Config::getSortMemBlockSize()
{
	return (int)(IPTR) sysConfig.values[KEY_SORT_MEM_BLOCK_SIZE];
}

int Config::getSortMemUpperLimit()
{
	return (int)(IPTR) sysConfig.values[KEY_SORT_MEM_UPPER_LIMIT];
}

bool Config::getRemoteFileOpenAbility()


int Config::getGuardianOption()
{
	return (int)(IPTR) sysConfig.values[KEY_GUARDIAN_OPTION];
}

int Config::getCpuAffinityMask()
{
	return (int)(IPTR) sysConfig.values[KEY_CPU_AFFINITY_MASK];
}

bool Config::getOldParameterOrdering()


int Config::getTcpRemoteBufferSize()
{
	return (int)(IPTR) sysConfig.values[KEY_TCP_REMOTE_BUFFER_SIZE];
}

bool Config::getTcpNoNagle()


int Config::getIpcMapSize()
{
	return (int)(IPTR) sysConfig.values[KEY_IPC_MAP_SIZE];
}

int Config::getDefaultDbCachePages()
{
	return (int)(IPTR) sysConfig.values[KEY_DEFAULT_DB_CACHE_PAGES];
}

int Config::getConnectionTimeout()
{
	return (int)(IPTR) sysConfig.values[KEY_CONNECTION_TIMEOUT];
}

int Config::getDummyPacketInterval()
{
	return (int)(IPTR) sysConfig.values[KEY_DUMMY_PACKET_INTERVAL];
}

int Config::getLockMemSize()
{
	return (int)(IPTR) sysConfig.values[KEY_LOCK_MEM_SIZE];
}

int Config::getLockSemCount()
{
	return (int)(IPTR) sysConfig.values[KEY_LOCK_SEM_COUNT];
}

int Config::getLockSignal()
{
	return (int)(IPTR) sysConfig.values[KEY_LOCK_SIGNAL];
}

bool Config::getLockGrantOrder()


int Config::getLockHashSlots()
{
	return (int)(IPTR) sysConfig.values[KEY_LOCK_HASH_SLOTS];
}

int Config::getLockAcquireSpins()
{
	return (int)(IPTR) sysConfig.values[KEY_LOCK_ACQUIRE_SPINS];
}

int Config::getEventMemSize()
{
	return (int)(IPTR) sysConfig.values[KEY_EVENT_MEM_SIZE];
}

int Config::getDeadlockTimeout()
{
	return (int)(IPTR) sysConfig.values[KEY_DEADLOCK_TIMEOUT];
}

int Config::getSolarisStallValue()
{
	return (int)(IPTR) sysConfig.values[KEY_SOLARIS_STALL_VALUE];
}

bool Config::getTraceMemoryPools()


int Config::getPrioritySwitchDelay()
{
	int rc = (int)(IPTR) sysConfig.values[KEY_PRIORITY_SWITCH_DELAY];
	if (rc < 1)
		rc = 1;
	return rc;


int Config::getDeadThreadsCollection()
{
	int rc = (int)(IPTR) sysConfig.values[KEY_DEAD_THREADS_COLLECTION];
	if (rc < 1)
		rc = 1;
	return rc;


int Config::getPriorityBoost()
{
	int rc = (int)(IPTR) sysConfig.values[KEY_PRIORITY_BOOST];
	if (rc < 1)
		rc = 1;
	if (rc > 1000)


int Config::getRemoteServicePort()
{
	return (int)(IPTR) sysConfig.values[KEY_REMOTE_SERVICE_PORT];
}

const char *Config::getRemotePipeName()


int Config::getMaxUnflushedWrites()
{
	return (int)(IPTR) sysConfig.values[KEY_MAX_UNFLUSHED_WRITES];
}

int Config::getMaxUnflushedWriteTime()
{
	return (int)(IPTR) sysConfig.values[KEY_MAX_UNFLUSHED_WRITE_TIME];
}

int Config::getProcessPriorityLevel()
{
	return (int)(IPTR) sysConfig.values[KEY_PROCESS_PRIORITY_LEVEL];
}

bool Config::getCreateInternalWindow()

int Config::getRemoteAuxPort()
{
#ifdef SUPERSERVER
	return (int)(IPTR) sysConfig.values[KEY_REMOTE_AUX_PORT];
#else
	return 0;
#endif

Lines 2184-2190 Link Here

(-)firebird2-1.5.3.4870~/src/gpre/c_cxx.cpp (-2 / +2 lines)
2184		2184
2185	args.pat_database = (DBB) init->nod_arg[3];	2185	args.pat_database = (DBB) init->nod_arg[3];
2186	args.pat_vector1 = status_vector(action);	2186	args.pat_vector1 = status_vector(action);
2187	args.pat_long1 = (int) init->nod_arg[2];	2187	args.pat_long1 = (int)(IPTR) init->nod_arg[2];
2188	args.pat_value2 = (int) event_list->nod_count;	2188	args.pat_value2 = (int) event_list->nod_count;
2189		2189
2190	// generate call to dynamically generate event blocks	2190	// generate call to dynamically generate event blocks
Lines 2255-2261 Link Here
2255	event_init = (GPRE_NOD) event_action->act_object;	2255	event_init = (GPRE_NOD) event_action->act_object;
2256	stack_name = (SYM) event_init->nod_arg[0];	2256	stack_name = (SYM) event_init->nod_arg[0];
2257	if (!strcmp(event_name->sym_string, stack_name->sym_string)) {	2257	if (!strcmp(event_name->sym_string, stack_name->sym_string)) {
2258	ident = (int) event_init->nod_arg[2];	2258	ident = (int)(IPTR) event_init->nod_arg[2];
2259	database = (DBB) event_init->nod_arg[3];	2259	database = (DBB) event_init->nod_arg[3];
2260	}	2260	}
2261	}	2261	}

Lines 204-210 Link Here

(-)firebird2-1.5.3.4870~/src/gpre/cmd.cpp (-1 / +1 lines)
204		204
205	case ACT_drop_shadow:	205	case ACT_drop_shadow:
206	put_numeric(request, gds_dyn_delete_shadow,	206	put_numeric(request, gds_dyn_delete_shadow,
207	(SSHORT) action->act_object);	207	(SSHORT)(IPTR) action->act_object);
208	STUFF_END;	208	STUFF_END;
209	break;	209	break;
210		210

Lines 251-257 Link Here

(-)firebird2-1.5.3.4870~/src/gpre/cme.cpp (-2 / +2 lines)
251	// ** Begin date/time/timestamp support *	251	// ** Begin date/time/timestamp support *
252	case nod_extract:	252	case nod_extract:
253	STUFF(blr_extract);	253	STUFF(blr_extract);
254	switch ((KWWORDS) (int) node->nod_arg[0])	254	switch ((KWWORDS) (int)(IPTR) node->nod_arg[1])
255	{	255	{
256	case KW_YEAR:	256	case KW_YEAR:
257	STUFF(blr_extract_year);	257	STUFF(blr_extract_year);
Lines 478-484 Link Here
478	// ** Begin date/time/timestamp support *	478	// ** Begin date/time/timestamp support *
479	case nod_extract:	479	case nod_extract:
480	{	480	{
481	KWWORDS kw_word = (KWWORDS) (int) node->nod_arg[0];	481	KWWORDS kw_word = (KWWORDS) (int)(IPTR) node->nod_arg[0];
482	CME_get_dtype(node->nod_arg[1], f);	482	CME_get_dtype(node->nod_arg[1], f);
483	switch (f->fld_dtype)	483	switch (f->fld_dtype)
484	{	484	{




static void	gen_on_error (ACT);
static void	gen_procedure (ACT);
static void	gen_put_segment (ACT);
static void	gen_raw (UCHAR *, enum req_t, int, IPTR);
static void	gen_ready (ACT);
static void	gen_receive (ACT, POR);
static void	gen_release (ACT);


	args.pat_database = (DBB) init->nod_arg[3];
	args.pat_vector1 = status_vector(action);
	args.pat_value1 = (IPTR) init->nod_arg[2];
	args.pat_value2 = (int) event_list->nod_count;
	args.pat_string1 = ISC_EVENT_BLOCK;
	args.pat_string2 = ISC_EVENT_WAIT;

	LLS stack_ptr;
	ACT event_action;
	SSHORT column;
	IPTR ident;
	TEXT s[64];
	TEXT *pattern1 =
		"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;
		stack_name = (SYM) event_init->nod_arg[0];
		if (!strcmp(event_name->sym_string, stack_name->sym_string)) {
			ident = (IPTR) event_init->nod_arg[2];
			database = (DBB) event_init->nod_arg[3];
		}
	}


static void gen_raw(
			   UCHAR * blr,
			   enum req_t request_type, int request_length, IPTR ident)
{
	UCHAR *c;
	TEXT s[256];

			printa(names[COLUMN_0], FALSE, "01  %s%d.",
				   names[ISC_], blob->blb_bpb_ident);
			gen_raw(blob->blb_bpb, request->req_type, blob->blb_bpb_length,
					(IPTR) request);
			printa(names[COMMENT], FALSE, " ");
		}
#ifdef PYXIS

static void gen_type( ACT action)
{

	printa(names[COLUMN], TRUE, "%ld", (IPTR) action->act_object);
}



Lines 85-91 Link Here

(-)firebird2-1.5.3.4870~/src/gpre/pat.h (-1 / +1 lines)
85	USHORT pat_ident2;	85	USHORT pat_ident2;
86	TEXT *pat_vector1;	86	TEXT *pat_vector1;
87	TEXT *pat_vector2;	87	TEXT *pat_vector2;
88	int pat_value1;	88	IPTR pat_value1;
89	int pat_value2;	89	int pat_value2;
90	int pat_value3;	90	int pat_value3;
91	int pat_value4;	91	int pat_value4;

Lines 860-867 Link Here

(-)firebird2-1.5.3.4870~/src/jrd/blb.cpp (-2 / +2 lines)
860	request = tdbb->tdbb_request;	860	request = tdbb->tdbb_request;
861	source = (BID) from_desc->dsc_address;	861	source = (BID) from_desc->dsc_address;
862	destination = (BID) to_desc->dsc_address;	862	destination = (BID) to_desc->dsc_address;
863	id = (USHORT) field->nod_arg[e_fld_id];	863	id = (USHORT)(IPTR) field->nod_arg[e_fld_id];
864	rpb = &request->req_rpb[(int) field->nod_arg[e_fld_stream]];	864	rpb = &request->req_rpb[(int)(IPTR) field->nod_arg[e_fld_stream]];
865	relation = rpb->rpb_relation;	865	relation = rpb->rpb_relation;
866	record = rpb->rpb_record;	866	record = rpb->rpb_record;
867		867




			FMT format;
			USHORT id;

			id = (USHORT)(IPTR) node->nod_arg[e_fld_id];
			format =
				CMP_format(tdbb, csb, (USHORT)(IPTR) node->nod_arg[e_fld_stream]);
			if (id >= format->fmt_count) {
				desc->dsc_dtype = dtype_null;
				desc->dsc_length = 0;


			sub = node->nod_arg[e_scl_field];
			relation =
				csb->csb_rpt[(USHORT)(IPTR) sub->
							 nod_arg[e_fld_stream]].csb_relation;
			id = (USHORT)(IPTR) sub->nod_arg[e_fld_id];
			field = MET_get_field(relation, id);
			if (!field || !(array = field->fld_array))
				IBERROR(223);	/* msg 223 argument of scalar operation must be an array */

		return;

	case nod_extract:
		if ((ULONG)(IPTR) node->nod_arg[e_extract_part] == blr_extract_second) {
			/* QUADDATE - SECOND returns a float, or scaled! */
			desc->dsc_dtype = dtype_long;
			desc->dsc_length = sizeof(ULONG);


			message = node->nod_arg[e_arg_message];
			format = (FMT) message->nod_arg[e_msg_format];
			*desc = format->fmt_desc[(int)(IPTR) node->nod_arg[e_arg_number]];
			return;
		}


				!input->nod_arg[e_fld_id] && !input->nod_arg[e_fld_stream])
				--field_id;
			else
				field_id = (USHORT)(IPTR) input->nod_arg[e_fld_id];
			stream = (USHORT)(IPTR) input->nod_arg[e_fld_stream];
			if (remap_fld) {
				JRD_REL relation;
				JRD_FLD field;

				relation = (*csb)->csb_rpt[stream].csb_relation;
				field = MET_get_field(relation, field_id);
				if (field->fld_source)
					field_id = (USHORT)(IPTR) field->fld_source->nod_arg[e_fld_id];
			}
			if (remap)
				stream = remap[stream];

			node->nod_type = input->nod_type;
			node->nod_count = 0;

			stream = (USHORT)(IPTR) input->nod_arg[e_rel_stream];
	/** 
	    Last entry in the remap contains the the original stream number.
	    Get that stream number so that the flags can be copied 

			node->nod_arg[e_prc_inputs] =
				copy(tdbb, csb, input->nod_arg[e_prc_inputs], remap, field_id,
					 node->nod_arg[e_prc_in_msg], remap_fld);
			stream = (USHORT)(IPTR) input->nod_arg[e_prc_stream];
			new_stream = (*csb)->csb_n_stream++;
			node->nod_arg[e_prc_stream] = (JRD_NOD) (SLONG) new_stream;
			/* TMN: Here we should really have the following assert */

			element = CMP_csb_element(csb, new_stream);
			// SKIDDER: Maybe we need to check if we really found a procedure ?
			element->csb_procedure = MET_lookup_procedure_id(tdbb,
			  (SSHORT)(IPTR)node->nod_arg[e_prc_procedure],FALSE,FALSE,0);

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

		node = PAR_make_node(tdbb, e_agg_length);
		node->nod_type = input->nod_type;
		node->nod_count = 0;
		stream = (USHORT)(IPTR) input->nod_arg[e_agg_stream];
		assert(stream <= MAX_STREAMS);
		new_stream = (*csb)->csb_n_stream++;
		assert(new_stream <= MAX_STREAMS);

		node = PAR_make_node(tdbb, e_uni_length);
		node->nod_type = input->nod_type;
		node->nod_count = 2;
		stream = (USHORT)(IPTR) input->nod_arg[e_uni_stream];
		new_stream = (*csb)->csb_n_stream++;
		node->nod_arg[e_uni_stream] = (JRD_NOD) (SLONG) new_stream;
		/* TMN: Here we should really have the following assert */

			csb_repeat *tail;
			JRD_REL relation;

			stream = (USHORT)(IPTR) node->nod_arg[e_rel_stream];
			csb->csb_rpt[stream].csb_flags |= csb_no_dbkey;
			tail = &csb->csb_rpt[stream];
			if ( (relation = tail->csb_relation) )

			JRD_FLD field;
			UCHAR *map, local_map[MAP_LENGTH];

			stream = (USHORT)(IPTR) node->nod_arg[e_fld_stream];

			/* 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 

			if (!(relation = tail->csb_relation) ||
				!(field =
				  MET_get_field(relation,
								(USHORT)(IPTR) node->nod_arg[e_fld_id]))) break;

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



			sub = node->nod_arg[e_asgn_from];
			if (sub->nod_type == nod_field) {
				stream = (USHORT)(IPTR) sub->nod_arg[e_fld_stream];
				field = MET_get_field((*csb)->csb_rpt[stream].csb_relation,
									  (USHORT)(IPTR) sub->nod_arg[e_fld_id]);
				if (field)
					node->nod_arg[e_asgn_missing2] = field->fld_missing_value;
			}

			sub = node->nod_arg[e_asgn_to];
			if (sub->nod_type != nod_field)
				break;
			stream = (USHORT)(IPTR) sub->nod_arg[e_fld_stream];
			tail = &(*csb)->csb_rpt[stream];
			if (!
				(field =
				 MET_get_field(tail->csb_relation,
							   (USHORT)(IPTR) sub->nod_arg[e_fld_id]))) break;
			if (field->fld_missing_value) {
				node->nod_arg[e_asgn_missing] = field->fld_missing_value;
				node->nod_count = 3;

		break;

	case nod_modify:
		stream = (USHORT)(IPTR) node->nod_arg[e_mod_new_stream];
		tail = &(*csb)->csb_rpt[stream];
		tail->csb_flags |= csb_modify;
		pass1_modify(tdbb, csb, node);

		/* assert(node->nod_arg [e_mod_new_stream] <= MAX_USHORT); */
		if ( (node->nod_arg[e_mod_validate] =
			make_validation(tdbb, csb,
							(USHORT)(IPTR) node->
							nod_arg[e_mod_new_stream])) ) node->nod_count =
				MAX(node->nod_count, (USHORT) e_mod_validate + 1);
		break;

	case nod_erase:
		stream = (USHORT)(IPTR) node->nod_arg[e_erase_stream];
		tail = &(*csb)->csb_rpt[stream];
		tail->csb_flags |= csb_erase;
		pass1_erase(tdbb, csb, node);


	case nod_store:
		sub = node->nod_arg[e_sto_relation];
		stream = (USHORT)(IPTR) sub->nod_arg[e_rel_stream];
		tail = &(*csb)->csb_rpt[stream];
		tail->csb_flags |= csb_store;
		sub = pass1_store(tdbb, csb, node);
		if (sub) {
			stream = (USHORT)(IPTR) sub->nod_arg[e_rel_stream];
			if ((!node->nod_arg[e_sto_sub_store]) &&
				(node->nod_arg[e_sto_validate] =
				 make_validation(tdbb, csb, stream))) node->nod_count =


	case nod_aggregate:
		assert((int)node->nod_arg[e_agg_stream] <= MAX_STREAMS);
		(*csb)->csb_rpt[(USHORT)(IPTR) node->nod_arg[e_agg_stream]].csb_flags |=
			csb_no_dbkey;
		ignore_dbkey(tdbb, *csb, (RSE) node->nod_arg[e_agg_rse], view);
		node->nod_arg[e_agg_rse] =

			NOD_T type;

			type = node->nod_type;
			stream = (USHORT)(IPTR) node->nod_arg[0];

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

		break;

	case nod_cardinality:
		stream = (USHORT)(IPTR) node->nod_arg[e_card_stream];
		(*csb)->csb_rpt[stream].csb_flags |= csb_compute;
		break;


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

	for (;;) {
		stream = new_stream = (USHORT)(IPTR) node->nod_arg[e_erase_stream];
		tail = &(*csb)->csb_rpt[stream];
		tail->csb_flags |= csb_erase;
		relation = (*csb)->csb_rpt[stream].csb_relation;


		parent = relation;
		parent_stream = stream;
		new_stream = (USHORT)(IPTR) source->nod_arg[e_rel_stream];
		node->nod_arg[e_erase_stream] = (JRD_NOD) (SLONG) map[new_stream];
	}
}

				field = MET_get_field(relation, id);
				if (field->fld_source)
					new_id =
						(USHORT)(IPTR) (JRD_NOD) (field->fld_source)->nod_arg[e_fld_id];
				else
					new_id = id;
			}

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

	for (;;) {
		stream = (USHORT)(IPTR) node->nod_arg[e_mod_org_stream];
		new_stream = (USHORT)(IPTR) node->nod_arg[e_mod_new_stream];
		tail = &(*csb)->csb_rpt[new_stream];
		tail->csb_flags |= csb_modify;
		relation = (*csb)->csb_rpt[stream].csb_relation;

			node->nod_count =
				MAX(node->nod_count, (USHORT) e_mod_map_view + 1);
			map = (*csb)->csb_rpt[stream].csb_map;
			stream = (USHORT)(IPTR) source->nod_arg[e_rel_stream];
			stream = map[stream];
			view_stream = new_stream;



			map =
				alloc_map(tdbb, csb,
						  (SSHORT)(IPTR) node->nod_arg[e_mod_new_stream]);
			source = copy(tdbb, csb, source, map, 0, NULL, FALSE);
			/* TMN: Here we should really have the following assert */
			/* assert(source->nod_arg [e_rel_stream] <= MAX_UCHAR); */
			map[new_stream] = (UCHAR)(IPTR) source->nod_arg[e_rel_stream];
			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_new_stream] =
				source->nod_arg[e_rel_stream];
			view_node->nod_arg[e_mod_map_view] = NULL;
			node->nod_arg[e_mod_sub_mod] = view_node;
			new_stream = (USHORT)(IPTR) source->nod_arg[e_rel_stream];
			view_node->nod_arg[e_mod_statement] =
				pass1_expand_view(tdbb, *csb, view_stream, new_stream, TRUE);
			node->nod_count =

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

			map = (*csb)->csb_rpt[stream].csb_map;
			stream = (USHORT)(IPTR) source->nod_arg[e_rel_stream];
			node->nod_arg[e_mod_org_stream] = (JRD_NOD) (SLONG) map[stream];

			/* Next, do update stream */

			map =
				alloc_map(tdbb, csb,
						  (SSHORT)(IPTR) node->nod_arg[e_mod_new_stream]);
			source = copy(tdbb, csb, source, map, 0, NULL, FALSE);
			node->nod_arg[e_mod_new_stream] = source->nod_arg[e_rel_stream];
		}


		pass1(tdbb, csb, source, parent_view, view_stream, FALSE);
		procedure = MET_lookup_procedure_id(tdbb, 
		  (SSHORT)(IPTR)source->nod_arg[e_prc_procedure], FALSE, FALSE, 0);
		post_procedure_access(tdbb, *csb, procedure);
		CMP_post_resource(&(*csb)->csb_resources, (BLK) procedure,
						  Resource::rsc_procedure, procedure->prc_id);

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

	stream = (USHORT)(IPTR) source->nod_arg[e_rel_stream];
	element = CMP_csb_element(csb, stream);
	element->csb_view = parent_view;
/* TMN: Here we should really have the following assert */

		for (vcx_ptr = &parent_view->rel_view_contexts; *vcx_ptr;
			 vcx_ptr = &(*vcx_ptr)->vcx_next)
			if ((*vcx_ptr)->vcx_context ==
				(USHORT)(IPTR) source->nod_arg[e_rel_context]) {
				element->csb_alias = (*vcx_ptr)->vcx_context_name;
				break;
			}


	for (;;) {
		original = node->nod_arg[e_sto_relation];
		stream = (USHORT)(IPTR) original->nod_arg[e_rel_stream];
		tail = &(*csb)->csb_rpt[stream];
		tail->csb_flags |= csb_store;
		relation = (*csb)->csb_rpt[stream].csb_relation;

			node->nod_arg[e_sto_relation] =
				copy(tdbb, csb, source, map, 0, NULL, FALSE);
			new_stream =
				(USHORT)(IPTR) node->nod_arg[e_sto_relation]->nod_arg[e_rel_stream];
			node->nod_arg[e_sto_statement] =
				pass1_expand_view(tdbb, *csb, stream, new_stream, TRUE);
			node->nod_arg[e_sto_statement] =

		/* AB: Mark the streams involved with an UPDATE statement
		   active. So that the optimizer can use indices for 
		   eventually used sub-selects. */
		stream = (USHORT)(IPTR) node->nod_arg[e_mod_org_stream];
		csb->csb_rpt[stream].csb_flags |= csb_active;
		stream = (USHORT)(IPTR) node->nod_arg[e_mod_new_stream];
		csb->csb_rpt[stream].csb_flags |= csb_active;
	}



	if (node->nod_type == nod_modify) {
		/* AB: Remove the previous flags */
		stream = (USHORT)(IPTR) node->nod_arg[e_mod_org_stream];
		csb->csb_rpt[stream].csb_flags &= ~csb_active;
		stream = (USHORT)(IPTR) node->nod_arg[e_mod_new_stream];
		csb->csb_rpt[stream].csb_flags &= ~csb_active;
	}


			FMT format;
			fmt::fmt_desc_iterator desc;

			stream = (USHORT)(IPTR) node->nod_arg[e_mod_org_stream];
			csb->csb_rpt[stream].csb_flags |= csb_update;
			format = CMP_format(tdbb, csb, stream);
			desc = format->fmt_desc.begin();

		break;

	case nod_erase:
		stream = (USHORT)(IPTR) node->nod_arg[e_erase_stream];
		csb->csb_rpt[stream].csb_flags |= csb_update;
		break;

	case nod_field:
		stream = (USHORT)(IPTR) node->nod_arg[e_fld_stream];
		id = (USHORT)(IPTR) node->nod_arg[e_fld_id];
		SBM_set(tdbb, &csb->csb_rpt[stream].csb_fields, id);
		if (node->nod_flags & nod_value) {
			csb->csb_impure += sizeof(struct vlux);

		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_group], node);
		stream = (USHORT)(IPTR) node->nod_arg[e_agg_stream];
		assert(stream <= MAX_STREAMS);
		process_map(tdbb, csb, node->nod_arg[e_agg_map],
					&csb->csb_rpt[stream].csb_format);


		node = *ptr;
		if (node->nod_type == nod_relation) {
			USHORT stream = (USHORT)(IPTR) node->nod_arg[e_rel_stream];
			csb->csb_rpt[stream].csb_flags |= csb_active;
			pass2(tdbb, csb, node, (JRD_NOD) rse);
		}

			pass2_rse(tdbb, csb, (RSE) node);
		}
		else if (node->nod_type == nod_procedure) {
			USHORT stream = (USHORT)(IPTR) node->nod_arg[e_prc_stream];
			csb->csb_rpt[stream].csb_flags |= csb_active;
			pass2(tdbb, csb, node, (JRD_NOD) rse);
		}
		else if (node->nod_type == nod_aggregate) {
			USHORT stream = (USHORT)(IPTR) node->nod_arg[e_agg_stream];
			assert(stream <= MAX_STREAMS);
			csb->csb_rpt[stream].csb_flags |= csb_active;
			pass2(tdbb, csb, node, (JRD_NOD) rse);

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

	clauses = node->nod_arg[e_uni_clauses];
	id = (USHORT)(IPTR) node->nod_arg[e_uni_stream];
	format = &csb->csb_rpt[id].csb_format;

/* Process alternating rse and map blocks */


	for (ptr = rse->rse_relation, end = ptr + rse->rse_count; ptr < end;
		 ptr++) if ((*ptr)->nod_type == nod_relation) {
			stream = (USHORT)(IPTR) (*ptr)->nod_arg[e_rel_stream];
			if (!(csb->csb_rpt[stream].csb_plan))
				ERR_post(gds_no_stream_plan, gds_arg_string,
						 csb->csb_rpt[stream].csb_relation->rel_name, 0);


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

	stream = (USHORT)(IPTR) plan_relation_node->nod_arg[e_rel_stream];
	tail = &csb->csb_rpt[stream];

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

		 ptr < end; ptr++) {
		node = *ptr;
		if (node->nod_type == nod_relation) {
			USHORT stream = (USHORT)(IPTR) node->nod_arg[e_rel_stream];
			csb->csb_rpt[stream].csb_flags &= ~csb_active;
		}
		else if (node->nod_type == nod_procedure) {
			USHORT stream = (USHORT)(IPTR) node->nod_arg[e_prc_stream];
			csb->csb_rpt[stream].csb_flags &= ~csb_active;
		}
		else if (node->nod_type == nod_aggregate) {
			USHORT stream = (USHORT)(IPTR) node->nod_arg[e_agg_stream];
			assert(stream <= MAX_STREAMS);
			csb->csb_rpt[stream].csb_flags &= ~csb_active;
		}

	for (end = ptr + map->nod_count; ptr < end; ptr++) {
		assignment = *ptr;
		field = assignment->nod_arg[e_asgn_to];
		id = (USHORT)(IPTR) field->nod_arg[e_fld_id];
		if (id >= format->fmt_count) {
			format->fmt_desc.resize(id + 1);
		}

		/* for aggregates, check current rse, if not found then check 
		   the sub-rse */
		if (sub->nod_type == nod_aggregate) {
			if ((stream == (USHORT)(IPTR) sub->nod_arg[e_rel_stream]) ||
				(stream_in_rse(stream, (RSE) sub->nod_arg[e_agg_rse])))
				return TRUE;	/* do not mark as variant */
		}

		if ((sub->nod_type == nod_relation) &&
			(stream == (USHORT)(IPTR) sub->nod_arg[e_rel_stream]))
			return TRUE;		/* do not mark as variant */
	}


Lines 856-863 Link Here

(-)firebird2-1.5.3.4870~/src/jrd/common.h (-2 / +2 lines)
856		856
857	#define JRD_BUGCHK 15 /* facility code for bugcheck messages */	857	#define JRD_BUGCHK 15 /* facility code for bugcheck messages */
858	#ifndef OFFSET	858	#ifndef OFFSET
859	#define OFFSET(struct,fld) ((int) &((struct) 0)->fld)	859	#define OFFSET(struct,fld) ((int)(IPTR) &((struct) 0)->fld)
860	#define OFFSETA(struct,fld) ((int) ((struct) 0)->fld)	860	#define OFFSETA(struct,fld) ((int)(IPTR) ((struct) 0)->fld)
861	#endif	861	#endif
862		862
863	#ifndef ODS_ALIGNMENT	863	#ifndef ODS_ALIGNMENT

Lines 2119-2125 Link Here

(-)firebird2-1.5.3.4870~/src/jrd/dpm.epp (-2 / +2 lines)
2119		2119
2120	DEBUG if (stack)	2120	DEBUG if (stack)
2121	while (*stack)	2121	while (*stack)
2122	CCH_precedence(tdbb, &rpb->rpb_window, (SLONG) LLS_POP(stack));	2122	CCH_precedence(tdbb, &rpb->rpb_window, (SLONG)(IPTR) LLS_POP(stack));
2123		2123
2124	CCH_precedence(tdbb, &rpb->rpb_window, -rpb->rpb_transaction);	2124	CCH_precedence(tdbb, &rpb->rpb_window, -rpb->rpb_transaction);
2125	CCH_MARK(tdbb, &rpb->rpb_window);	2125	CCH_MARK(tdbb, &rpb->rpb_window);
Lines 2736-2742 Link Here
2736	If the page need to be compressed, compress it. */	2736	If the page need to be compressed, compress it. */
2737		2737
2738	while (*stack)	2738	while (*stack)
2739	CCH_precedence(tdbb, &rpb->rpb_window, (SLONG) LLS_POP(stack));	2739	CCH_precedence(tdbb, &rpb->rpb_window, (SLONG)(IPTR) LLS_POP(stack));
2740	CCH_MARK(tdbb, &rpb->rpb_window);	2740	CCH_MARK(tdbb, &rpb->rpb_window);
2741	i = page->dpg_count + ((slot) ? 0 : 1);	2741	i = page->dpg_count + ((slot) ? 0 : 1);
2742		2742




		arg_number = (int)(IPTR)node->nod_arg[e_arg_number];
		desc = &format->fmt_desc[arg_number];
		impure->vlu_desc.dsc_address =
			(UCHAR *) request + message->nod_impure + (int)(IPTR) desc->dsc_address;
		impure->vlu_desc.dsc_dtype = desc->dsc_dtype;
		impure->vlu_desc.dsc_length = desc->dsc_length;
		impure->vlu_desc.dsc_scale = desc->dsc_scale;

		// may happen. I checked triggers and insert/update statements.
		// All seem to work fine.
		record =
			request->req_rpb[(int)(IPTR) node->nod_arg[e_fld_stream]].rpb_record;
		EVL_field(0, record, (USHORT)(IPTR) node->nod_arg[e_fld_id],
				  &impure->vlu_desc);
		if (!impure->vlu_desc.dsc_address)
			ERR_post(gds_read_only_field, 0);

			impure = (INV) ((SCHAR *) tdbb->tdbb_request + node->nod_impure);
			SBM_reset(&impure->inv_bitmap);
			desc = EVL_expr(tdbb, node->nod_arg[0]);
			id = 1 + 2 * (USHORT)(IPTR) node->nod_arg[1];
			numbers = desc->dsc_address;
			numbers += id * sizeof(SLONG);
			MOVE_FAST(numbers, &rel_dbkey, sizeof(SLONG));

			}
			message = node->nod_arg[e_arg_message];
			format = (FMT) message->nod_arg[e_msg_format];
			desc = &format->fmt_desc[(int)(IPTR) node->nod_arg[e_arg_number]];

			impure->vlu_desc.dsc_address = (UCHAR *) request +
				message->nod_impure + (int)(IPTR) desc->dsc_address;
			impure->vlu_desc.dsc_dtype = desc->dsc_dtype;
			impure->vlu_desc.dsc_length = desc->dsc_length;
			impure->vlu_desc.dsc_scale = desc->dsc_scale;

	case nod_field:
		{
			REC record =
				request->req_rpb[(int)(IPTR)node->nod_arg[e_fld_stream]].rpb_record;
			/* In order to "map a null to a default" value (in EVL_field()), 
			 * the relation block is referenced. 
			 * Reference: Bug 10116, 10424 
			 */
			if (!EVL_field(request->req_rpb[(USHORT)(IPTR) node->nod_arg[e_fld_stream]].rpb_relation,
							record,
							(USHORT)(IPTR) node->nod_arg[e_fld_id],
							&impure->vlu_desc))
			{
				request->req_flags |= req_null;

			ULONG extract_part;

			impure = (VLU) ((SCHAR *) request + node->nod_impure);
			extract_part = (ULONG)(IPTR) node->nod_arg[e_extract_part];
			value = EVL_expr(tdbb, node->nod_arg[e_extract_value]);

			impure->vlu_desc.dsc_dtype = dtype_short;


		switch (node->nod_type) {
		case nod_gen_id:		/* return a 32-bit generator value */
			impure->vlu_misc.vlu_long = (SLONG)(IPTR) DPM_gen_id(tdbb,
														   (SLONG)(IPTR)
														   node->nod_arg
														   [e_gen_id], 0,
														   MOV_get_int64


		case nod_gen_id2:
			impure->vlu_misc.vlu_int64 = DPM_gen_id(tdbb,
													(SLONG)(IPTR)
													node->nod_arg[e_gen_id],
													0,
													MOV_get_int64(values[0],

		return FALSE;
	}

	desc->dsc_address = record->rec_data + (int)(IPTR) desc->dsc_address;

	if (TEST_NULL(record, id)) {
		desc->dsc_flags |= DSC_null;

	{
		from = (*ptr)->nod_arg[e_asgn_from];
		field = (*ptr)->nod_arg[e_asgn_to];
		id = (USHORT)(IPTR) field->nod_arg[e_fld_id];
		record =
			request->req_rpb[(int)(IPTR) field->nod_arg[e_fld_stream]].rpb_record;
		impure = (VLUX) ((SCHAR *) request + from->nod_impure);
		switch (from->nod_type)
		{


	request = tdbb->tdbb_request;
	impure = (VLU) ((SCHAR *) request + node->nod_impure);
	rpb = &request->req_rpb[(int)(IPTR) node->nod_arg[0]];
	relation = rpb->rpb_relation;

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


	request = tdbb->tdbb_request;
	impure = (VLU) ((SCHAR *) request + node->nod_impure);
	rpb = &request->req_rpb[(int)(IPTR) node->nod_arg[0]];

/* If the current transaction has updated the record, the record version
 * coming in from DSQL will have the original transaction # (or current





	if (to->nod_type == nod_field)
	{
		SSHORT id = (USHORT)(IPTR) to->nod_arg[e_fld_id];
		REC record = request->req_rpb[(int)(IPTR) to->nod_arg[e_fld_stream]].rpb_record;
		if (null) {
			SET_NULL(record, id);
		} else {

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

	if (msg != (USHORT)(IPTR) message->nod_arg[e_msg_number])
		ERR_post(gds_req_sync, 0);

	if (length != format->fmt_length)

		for (ptr = node->nod_arg, end = ptr + node->nod_count; ptr < end;
			 ptr++) {
			message = (*ptr)->nod_arg[e_send_message];
			if ((USHORT)(IPTR) message->nod_arg[e_msg_number] == msg) {
				request->req_next = *ptr;
				break;
			}


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

	if (msg != (USHORT)(IPTR) message->nod_arg[e_msg_number])
		ERR_post(gds_req_sync, 0);

	if (length != format->fmt_length)

		desc = &format->fmt_desc[n];
		if (!desc->dsc_address)
			continue;
		p = record->rec_data + (SLONG)(IPTR) desc->dsc_address;
		if (TEST_NULL(record, n))
		{
			if (length = desc->dsc_length)


	request = tdbb->tdbb_request;
	transaction = request->req_transaction;
	rpb = &request->req_rpb[(int)(IPTR) node->nod_arg[e_erase_stream]];
	relation = rpb->rpb_relation;

#ifdef PC_ENGINE

			case jrd_req::req_evaluate:
				if (transaction != dbb->dbb_sys_trans) {

					UCHAR operation = (UCHAR)(IPTR) node->nod_arg[e_sav_operation];
					TEXT * node_savepoint_name = (TEXT*) node->nod_arg[e_sav_name]; 

					// Skip the savepoint created by EXE_start

				break;

			case jrd_req::req_unwind:
				if ((request->req_label == (USHORT)(IPTR) node->nod_arg[e_lbl_label]) &&
						(request->req_flags & (req_leave | req_error_handler))) {
					request->req_flags &= ~req_leave;
					request->req_operation = jrd_req::req_return;

		case nod_leave:
			request->req_flags |= req_leave;
			request->req_operation = jrd_req::req_unwind;
			request->req_label = (USHORT)(IPTR) node->nod_arg[0];
			node = node->nod_parent;
			break;


				DSC *desc;

				desc = EVL_expr(tdbb, node->nod_arg[e_gen_value]);
				(void) DPM_gen_id(tdbb, (SLONG)(IPTR) node->nod_arg[e_gen_id], 1,
								  MOV_get_int64(desc, 0));
				request->req_operation = jrd_req::req_return;
			}

				DSC *desc;

				desc = EVL_expr(tdbb, node->nod_arg[e_gen_value]);
				(void) DPM_gen_id(tdbb, (SLONG)(IPTR) node->nod_arg[e_gen_id], 1,
								  MOV_get_int64(desc, 0));
				request->req_operation = jrd_req::req_return;
			}

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

	org_stream = (USHORT)(IPTR) node->nod_arg[e_mod_org_stream];
	org_rpb = &request->req_rpb[org_stream];
	relation = org_rpb->rpb_relation;

	new_stream = (USHORT)(IPTR) node->nod_arg[e_mod_new_stream];
	new_rpb = &request->req_rpb[new_stream];

#ifdef PC_ENGINE

	JRD_REQ    request     = tdbb->tdbb_request;
	JRD_TRA    transaction = request->req_transaction;
	STA    impure      = (STA) ((SCHAR *) request + node->nod_impure);
	SSHORT stream      = (USHORT)(IPTR) node->nod_arg[e_sto_relation]->nod_arg[e_rel_stream];
	RPB*   rpb         = &request->req_rpb[stream];
	JRD_REL    relation    = rpb->rpb_relation;



			if (node->nod_type == nod_field)
			{
				stream = (USHORT)(IPTR) node->nod_arg[e_fld_stream];
				id = (USHORT)(IPTR) node->nod_arg[e_fld_id];
				relation = request->req_rpb[stream].rpb_relation;

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




	record = rpb->rpb_record;
	format = record->rec_format;

	offset = (SSHORT)(IPTR) format->fmt_desc[0].dsc_address;
	p = record->rec_data + offset;
	l = record->rec_length - offset;


			continue;
		if ( (literal = (LIT) field->fld_missing_value) ) {
			desc = *desc_ptr;
			desc.dsc_address = record->rec_data + (int)(IPTR) desc.dsc_address;
			if (!MOV_compare(&literal->lit_desc, &desc))
				continue;
		}

			desc_ptr->dsc_length &&
			TEST_NULL(record, i))
		{
			p = record->rec_data + (int)(IPTR) desc_ptr->dsc_address;
			if ( (literal = (LIT) field->fld_missing_value) ) {
				desc = *desc_ptr;
				desc.dsc_address = p;

		}
	}

	offset = (USHORT)(IPTR) format->fmt_desc[0].dsc_address;
	p = record->rec_data + offset;
	l = record->rec_length - offset;


Lines 2287-2293 Link Here

(-)firebird2-1.5.3.4870~/src/jrd/gds.cpp (-1 / +1 lines)
2287	return result;	2287	return result;
2288		2288
2289	if (stdio_flag)	2289	if (stdio_flag)
2290	if (!(result = ib_fdopen((int) result, "w+")))	2290	if (!(result = ib_fdopen((int)(IPTR) result, "w+")))
2291	return (void *)-1;	2291	return (void *)-1;
2292		2292
2293	if (expanded_string)	2293	if (expanded_string)




			 index_number < idx->idx_foreign_primaries->count();
			 index_number++) {
			if (idx->idx_id !=
				(UCHAR)(IPTR) (*idx->idx_foreign_primaries)[index_number]) continue;
			partner_relation =
				MET_relation(tdbb,
							 (int)(IPTR) (*idx->idx_foreign_relations)[index_number]);
			index_id =
				(USHORT)(IPTR) (*idx->idx_foreign_indexes)[index_number];
			if ( (result =
				check_partner_index(tdbb, relation, record, transaction, idx,
									partner_relation, index_id)) )

Lines 972-978 Link Here

(-)firebird2-1.5.3.4870~/src/jrd/inf.cpp (-1 / +1 lines)
972	node = request->req_message;	972	node = request->req_message;
973	if (item == gds_info_message_number)	973	if (item == gds_info_message_number)
974	length =	974	length =
975	INF_convert((SLONG) node->nod_arg[e_msg_number],	975	INF_convert((SLONG)(IPTR) node->nod_arg[e_msg_number],
976	buffer_ptr);	976	buffer_ptr);
977	else {	977	else {
978	format = (FMT) node->nod_arg[e_msg_format];	978	format = (FMT) node->nod_arg[e_msg_format];




			if (desc->dsc_address)
			{
				format->fmt_length =
					(ULONG)(IPTR) desc->dsc_address + desc->dsc_length;
				break;
			}
		}

				 index_number < references->frgn_reference_ids->count();
				 index_number++)
			{
				if (idx->idx_id == (UCHAR)(IPTR) (*references->frgn_reference_ids)
											[index_number])
				{
					idx->idx_primary_relation =
						(USHORT)(IPTR) (*references->frgn_relations)[index_number];
					idx->idx_primary_index =
						(UCHAR)(IPTR) (*references->frgn_indexes)[index_number];
					return TRUE;
				}
			}

				 index_number < dependencies->prim_reference_ids->count();
				 index_number++)
			{
				if (idx->idx_id == (UCHAR)(IPTR) (*dependencies->prim_reference_ids)
											[index_number])
				{
					idx->idx_foreign_primaries =

		{
			if ( (node = csb_->csb_rpt[i].csb_message) )
			{
				if ((int)(IPTR) node->nod_arg[e_msg_number] == 0)
				{
					procedure->prc_input_msg = node;
				} else if ((int)(IPTR) node->nod_arg[e_msg_number] == 1)
				{
					procedure->prc_output_msg = node;
				}

		node = (JRD_NOD) LLS_POP(&csb->csb_dependencies);
		if (!node->nod_arg[e_dep_object])
			continue;
		dpdo_type = (SSHORT)(IPTR) node->nod_arg[e_dep_object_type];
        relation = NULL;
        procedure = NULL;
        switch (dpdo_type) {

            dpdo_name = (TEXT*) procedure->prc_name->str_data;
            break;
        case obj_exception:
            number = (SLONG)(IPTR) node->nod_arg [e_dep_object];
            MET_lookup_exception (tdbb, number, name, NULL);
            dpdo_name = name;
            break;
            /* CVC: Here I'm going to track those pesky things named generators and UDFs. */
        case obj_generator:
            number = (SLONG)(IPTR) node->nod_arg [e_dep_object];
            MET_lookup_generator_id (tdbb, number, name);
            dpdo_name = name;
            break;

		{
			if (field_node->nod_type == nod_field)
			{
				fld_id = (SSHORT)(IPTR) field_node->nod_arg[0];
				if (relation)
				{
					if ( (field = MET_get_field(relation, fld_id)) )

Lines 699-705 Link Here

(-)firebird2-1.5.3.4870~/src/jrd/sdl.cpp (-1 / +1 lines)
699	}	699	}
700	element_desc = array_desc->ads_rpt[value].ads_desc;	700	element_desc = array_desc->ads_rpt[value].ads_desc;
701	element_desc.dsc_address = (BLOB_PTR *) arg->sdl_arg_array +	701	element_desc.dsc_address = (BLOB_PTR *) arg->sdl_arg_array +
702	(SLONG) element_desc.dsc_address +	702	(SLONG)(IPTR) element_desc.dsc_address +
703	(array_desc->ads_element_length * subscript);	703	(array_desc->ads_element_length * subscript);
704		704
705	/* Is this element within the array bounds? */	705	/* Is this element within the array bounds? */

Lines 2220-2226 Link Here

(-)firebird-1.5.3.4870/src/qli/expand.cpp.orig (-1 / +1 lines)
2220	for (i = 0; i < node->nod_count; i++) {	2220	for (i = 0; i < node->nod_count; i++) {
2221	expr = *syn_ptr++;	2221	expr = *syn_ptr++;
2222	if (expr->syn_type == nod_position) {	2222	if (expr->syn_type == nod_position) {
2223	position = (USHORT) expr->syn_arg[0];	2223	position = (USHORT)(IPTR) expr->syn_arg[0];
2224	if (!list \|\| !position \|\| position > list->nod_count)	2224	if (!list \|\| !position \|\| position > list->nod_count)
2225	IBERROR(152); /* Msg152 invalid ORDER BY ordinal */	2225	IBERROR(152); /* Msg152 invalid ORDER BY ordinal */
2226	item = (ITM) list->nod_arg[position - 1];	2226	item = (ITM) list->nod_arg[position - 1];




	ptr = node->syn_arg;

	for (i = 0; i < node->syn_count; i++) {
		foo = (USHORT)(IPTR) * ptr++;
		sw = (ENUM set_t) foo;
		value = *ptr++;
		switch (sw) {
		case set_blr:
			QLI_blr = (USHORT)(IPTR) value;
			break;

		case set_statistics:
			QLI_statistics = (USHORT)(IPTR) value;
			break;

		case set_columns:
			QLI_name_columns = QLI_columns = (USHORT)(IPTR) value;
			break;

		case set_lines:
			QLI_lines = (USHORT)(IPTR) value;
			break;

		case set_semi:
			QLI_semi = (USHORT)(IPTR) value;
			break;

		case set_echo:
			QLI_echo = (USHORT)(IPTR) value;
			break;

		case set_form:

			break;

		case set_count:
			QLI_count = (USHORT)(IPTR) value;
			break;

		case set_charset:

Lines 3795-3801 Link Here

(-)firebird-1.5.3.4870/src/qli/meta.epp.orig (-1 / +1 lines)
3795	RLB rlb;	3795	RLB rlb;
3796		3796
3797		3797
3798	privileges = (USHORT) node->syn_arg[s_grant_privileges];	3798	privileges = (USHORT)(IPTR) node->syn_arg[s_grant_privileges];
3799	relation = (QLI_REL) node->syn_arg[s_grant_relation];	3799	relation = (QLI_REL) node->syn_arg[s_grant_relation];
3800	relation->rel_database = database = setup_update(relation->rel_database);	3800	relation->rel_database = database = setup_update(relation->rel_database);
3801	relation_name = relation->rel_symbol->sym_string;	3801	relation_name = relation->rel_symbol->sym_string;




case 79:
{ 
			lex.g_field->fld_dtype = dtype_cstring; 
			lex.g_field->fld_character_length = (USHORT)(IPTR) yyvsp[-2]; }
break;
case 80:
{ yyval = (DSQL_NOD) NULL; }

case 507:
{ 
			lex.g_field->fld_dtype = dtype_blob; 
			lex.g_field->fld_seg_length = (USHORT)(IPTR) yyvsp[-1];
			lex.g_field->fld_sub_type = 0;
			}
break;
case 508:
{ 
			lex.g_field->fld_dtype = dtype_blob; 
			lex.g_field->fld_seg_length = (USHORT)(IPTR) yyvsp[-3];
			lex.g_field->fld_sub_type = (USHORT)(IPTR) yyvsp[-1];
			}
break;
case 509:
{ 
			lex.g_field->fld_dtype = dtype_blob; 
			lex.g_field->fld_seg_length = 80;
			lex.g_field->fld_sub_type = (USHORT)(IPTR) yyvsp[-1];
			}
break;
case 510:
{
			lex.g_field->fld_seg_length = (USHORT)(IPTR) yyvsp[0];
		  	}
break;
case 511:

break;
case 512:
{
			lex.g_field->fld_sub_type = (USHORT)(IPTR) yyvsp[0];
			}
break;
case 513:

case 517:
{ 
			lex.g_field->fld_dtype = dtype_text; 
			lex.g_field->fld_character_length = (USHORT)(IPTR) yyvsp[-1]; 
			lex.g_field->fld_flags |= FLD_national;
			}
break;

case 519:
{ 
			lex.g_field->fld_dtype = dtype_varying; 
			lex.g_field->fld_character_length = (USHORT)(IPTR) yyvsp[-1]; 
			lex.g_field->fld_flags |= FLD_national;
			}
break;
case 520:
{ 
			lex.g_field->fld_dtype = dtype_text; 
			lex.g_field->fld_character_length = (USHORT)(IPTR) yyvsp[-1]; 
			}
break;
case 521:

case 522:
{ 
			lex.g_field->fld_dtype = dtype_varying; 
			lex.g_field->fld_character_length = (USHORT)(IPTR) yyvsp[-1]; 
			}
break;
case 531:

			    	lex.g_field->fld_dtype = dtype_long; 
			    	lex.g_field->fld_length = sizeof (SLONG); 
			    	}
			lex.g_field->fld_precision = (USHORT)(IPTR) yyvsp[-1];
			}
break;
case 536:

			    	lex.g_field->fld_length = sizeof (SLONG); 
			    	}
			    }
			lex.g_field->fld_precision = (USHORT)(IPTR) yyvsp[-3];
			lex.g_field->fld_scale = - (SSHORT)(IPTR) yyvsp[-1];
			}
break;
case 539:

{ yyval = make_node (nod_table_lock, (int) 2, make_list (yyvsp[-1]), yyvsp[0]); }
break;
case 602:
{ yyval = make_flag_node (nod_lock_mode, (SSHORT) ((SSHORT)(IPTR) yyvsp[-1] | (SSHORT)(IPTR) yyvsp[0]), (SSHORT) 0, NULL); }
break;
case 603:
{ yyval = 0; }




#include "firebird.h"

#ifdef WIN_NT

#include <windows.h>

typedef HANDLE DESC;

static inline DESC GBAK_STDIN_DESC(void)
{
	return GetStdHandle(STD_INPUT_HANDLE); // standard input file descriptor 
}
static inline DESC GBAK_STDOUT_DESC(void)
{
	return GetStdHandle(STD_OUTPUT_HANDLE);	// standard output file descriptor
}

#else //WIN_NT

typedef int DESC;

static inline DESC GBAK_STDIN_DESC(void)
{
	return 0;	// standard input file descriptor 
}
static inline DESC GBAK_STDOUT_DESC(void)
{
	return 1;	// standard output file descriptor
}

const int INVALID_HANDLE_VALUE = -1;

#endif //WIN_NT

#endif  //GBAK_STD_DESC_H

Lines 1606-1612 Link Here

(-)firebird-1.5.3.4870/src/burp/burp.cpp.orig (-2 / +2 lines)
1606	#ifndef WIN_NT	1606	#ifndef WIN_NT
1607	signal(SIGPIPE, SIG_IGN);	1607	signal(SIGPIPE, SIG_IGN);
1608	#endif	1608	#endif
1609	fil->fil_fd = reinterpret_cast<DESC>(GBAK_STDOUT_DESC);	1609	fil->fil_fd = GBAK_STDOUT_DESC();
1610	break;	1610	break;
1611	}	1611	}
1612	else	1612	else
Lines 1724-1730 Link Here
1724		1724
1725	tdgbl->action->act_action = ACT_restore;	1725	tdgbl->action->act_action = ACT_restore;
1726	if (!strcmp(fil->fil_name, "stdin")) {	1726	if (!strcmp(fil->fil_name, "stdin")) {
1727	fil->fil_fd = reinterpret_cast<DESC>(GBAK_STDIN_DESC);	1727	fil->fil_fd = GBAK_STDIN_DESC();
1728	tdgbl->file_desc = fil->fil_fd;	1728	tdgbl->file_desc = fil->fil_fd;
1729	tdgbl->gbl_sw_files = fil->fil_next;	1729	tdgbl->gbl_sw_files = fil->fil_next;
1730	}	1730	}

Lines 2518-2524 Link Here

(-)firebird-1.5.3.4870/src/jrd/par.cpp.orig (-1 / +1 lines)
2518	node->nod_arg[e_agg_rse] = parse(tdbb, csb, TYPE_RSE);	2518	node->nod_arg[e_agg_rse] = parse(tdbb, csb, TYPE_RSE);
2519	node->nod_arg[e_agg_group] = parse(tdbb, csb, OTHER);	2519	node->nod_arg[e_agg_group] = parse(tdbb, csb, OTHER);
2520	node->nod_arg[e_agg_map] =	2520	node->nod_arg[e_agg_map] =
2521	par_map(tdbb, csb, (USHORT) node->nod_arg[e_agg_stream]);	2521	par_map(tdbb, csb, (USHORT)(IPTR) node->nod_arg[e_agg_stream]);
2522	break;	2522	break;
2523		2523
2524	case blr_group_by:	2524	case blr_group_by:




				/* Initialize the record number of each stream in the union */

				ptr = &rsb->rsb_arg[rsb->rsb_count];
				for (end = ptr + (USHORT)(IPTR) * ptr; ++ptr <= end;)
					request->req_rpb[(USHORT)(IPTR) * ptr].rpb_number = -1;

				rsb = rsb->rsb_arg[0];
			}

	request = tdbb->tdbb_request;
	stack = (LLS) rsb->rsb_arg[streams];
	for (; stack; stack = stack->lls_next) {
		rpb = &request->req_rpb[(USHORT)(IPTR) stack->lls_object];

		/* Make sure a record block has been allocated.  If there isn't
		   one, first find the format, then allocate the record block */

		   list that contains the data to send back
		 */
		if (IS_INTL_DATA(&item->smb_desc) &&
			(USHORT)(IPTR) item->smb_desc.dsc_address <
			map->smb_key_length * sizeof(ULONG)) continue;

		rpb = &request->req_rpb[item->smb_stream];

				   the sort record, then want to sort by language dependent order */

				if (IS_INTL_DATA(&item->smb_desc) &&
					(USHORT)(IPTR) item->smb_desc.dsc_address <
					map->smb_key_length * sizeof(ULONG)) {
					INTL_string_to_key(tdbb, INTL_INDEX_TYPE(&item->smb_desc),
									   from, &to, FALSE);





		if (node->nod_type != nod_rse)
		{
			stream = (USHORT)(IPTR) node->nod_arg[STREAM_INDEX(node)];
			assert(stream <= MAX_UCHAR);
			assert(beds[0] < MAX_STREAMS && beds[0] < MAX_UCHAR);
			beds[++beds[0]] = (UCHAR) stream;

						  (USHORT) (key_streams[0] - i));
			assert(local_streams[0] < MAX_STREAMS && local_streams[0] < MAX_UCHAR);
			local_streams[++local_streams[0]] =
				(UCHAR)(IPTR) node->nod_arg[e_uni_stream];
		}
		else if (node->nod_type == nod_aggregate) {
			assert((int)node->nod_arg[e_agg_stream] <= MAX_STREAMS);

			rsb = gen_aggregate(tdbb, opt_, node);
			assert(local_streams[0] < MAX_STREAMS && local_streams[0] < MAX_UCHAR);
			local_streams[++local_streams[0]] =
				(UCHAR)(IPTR) node->nod_arg[e_agg_stream];
		}
		else if (node->nod_type == nod_procedure) {
			rsb = gen_procedure(tdbb, opt_, node);
			assert(local_streams[0] < MAX_STREAMS && local_streams[0] < MAX_UCHAR);
			local_streams[++local_streams[0]] =
				(UCHAR)(IPTR) node->nod_arg[e_prc_stream];
		}
		else if (node->nod_type == nod_rse) {
			compute_rse_streams(csb, (RSE) node, beds);


/* Make sure we have the correct stream */

	if ((USHORT)(IPTR) dbkey->nod_arg[0] != stream)
		return NULL;

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

	switch (node->nod_type) {
	case nod_field:

		n = (USHORT)(IPTR) node->nod_arg[e_fld_stream];

		if (allowOnlyCurrentStream) {
			if (n != stream) {


	case nod_dbkey:

		n = (USHORT)(IPTR) node->nod_arg[0];

		if (allowOnlyCurrentStream) {
			if (n != stream) {


	for (ptr = rse->rse_relation, end = ptr + rse->rse_count; ptr < end; ptr++) {
		if ((*ptr)->nod_type != nod_rse) {
			n = (USHORT)(IPTR) (*ptr)->nod_arg[STREAM_INDEX((*ptr))];
			csb->csb_rpt[n].csb_flags |= csb_active;
		}
	}

	{
		if ((*ptr)->nod_type != nod_rse)
		{
			n = (USHORT)(IPTR) (*ptr)->nod_arg[STREAM_INDEX((*ptr))];
			csb->csb_rpt[n].csb_flags &= ~csb_active;
		}
	}


	switch (node->nod_type) {
	case nod_field:
		n = (USHORT)(IPTR) node->nod_arg[e_fld_stream];
		SET_DEP_BIT(dependencies, n);
		return;

	case nod_dbkey:
		n = (USHORT)(IPTR) node->nod_arg[0];
		SET_DEP_BIT(dependencies, n);
		return;



	for (ptr = rse->rse_relation, end = ptr + rse->rse_count; ptr < end; ptr++) {
		if ((*ptr)->nod_type != nod_rse) {
			n = (USHORT)(IPTR) (*ptr)->nod_arg[STREAM_INDEX((*ptr))];
			CLEAR_DEP_BIT(dependencies, n);
		}
	}


	if (node->nod_type == nod_relation) {
		assert(streams[0] < MAX_STREAMS && streams[0] < MAX_UCHAR);
		streams[++streams[0]] = (UCHAR)(IPTR) node->nod_arg[e_rel_stream];
	}
	else if (node->nod_type == nod_union) {
		clauses = node->nod_arg[e_uni_clauses];

		node = *ptr;
		if (node->nod_type != nod_rse) {
			assert(streams[0] < MAX_STREAMS && streams[0] < MAX_UCHAR);
			streams[++streams[0]] = (UCHAR)(IPTR) node->nod_arg[STREAM_INDEX(node)];
		}
		else {
			compute_rse_streams(csb, (RSE) node, streams);

	JRD_NOD dbkey_temp, *ptr, *end;
	DEV_BLKCHK(dbkey, type_nod);
	if (dbkey->nod_type == nod_dbkey) {
		if ((USHORT)(IPTR) dbkey->nod_arg[0] == stream)
			return dbkey;
		else {
			*position = *position + 1;


		temp[0]++;
		relation_node = plan_node->nod_arg[e_retrieve_relation];
		temp[temp[0]] = (UCHAR)(IPTR) relation_node->nod_arg[e_rel_stream];
	}

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

	rsb->rsb_type = rsb_aggregate;
	assert((int)node->nod_arg[e_agg_stream] <= MAX_STREAMS);
	assert((int)node->nod_arg[e_agg_stream] <= MAX_UCHAR);
	rsb->rsb_stream = (UCHAR)(IPTR) node->nod_arg[e_agg_stream];
	rsb->rsb_format = csb->csb_rpt[rsb->rsb_stream].csb_format;
	rsb->rsb_next = OPT_compile(tdbb, csb, rse, NULL);
	rsb->rsb_arg[0] = (RSB) node;

		 idx->idx_rpt; ptr < end; ptr++, idx_tail++) {
		node = *ptr;
		if (node->nod_type != nod_field
			|| (USHORT)(IPTR) node->nod_arg[e_fld_stream] != stream
			|| (USHORT)(IPTR) node->nod_arg[e_fld_id] != idx_tail->idx_field
			|| ptr[2*sort->nod_count] /* do not use index if NULLS FIRST is used */
#ifdef SCROLLABLE_CURSORS
			)

		{
			stream_ptr[i]->stream_rsb = NULL;
			stream_ptr[i]->stream_num =
				(USHORT)(IPTR) node->nod_arg[STREAM_INDEX(node)];
		}
	}


	SET_TDBB(tdbb);
	csb = opt->opt_csb;	
	procedure = MET_lookup_procedure_id(tdbb,
	   (SSHORT)(IPTR)node->nod_arg[e_prc_procedure], FALSE, FALSE, 0);
	rsb = FB_NEW_RPT(*tdbb->tdbb_default, RSB_PRC_count) Rsb();
	rsb->rsb_type = rsb_procedure;
	rsb->rsb_stream = (UCHAR)(IPTR) node->nod_arg[e_prc_stream];
	rsb->rsb_procedure = procedure;
	rsb->rsb_format = procedure->prc_format;
	rsb->rsb_impure = CMP_impure(csb, sizeof(struct irsb_procedure));

			for (node_ptr = sort->nod_arg; node_ptr < end_node; node_ptr++) {
				node = *node_ptr;
				if (node->nod_type == nod_field
					&& (USHORT)(IPTR) node->nod_arg[e_fld_stream] == *ptr
					&& (USHORT)(IPTR) node->nod_arg[e_fld_id] == id) {
					desc = &descriptor;
					CMP_get_desc(tdbb, csb, node, desc);
					/* International type text has a computed key */

		map_item->smb_desc.dsc_address = (UCHAR *) map_length;
		map_length += desc->dsc_length;
		if (node->nod_type == nod_field) {
			map_item->smb_stream = (USHORT)(IPTR) node->nod_arg[e_fld_stream];
			map_item->smb_field_id = (USHORT)(IPTR) node->nod_arg[e_fld_id];
		}
	}


   field has already been mentioned as a sort key, don't bother to repeat
   it. */
	while (stream_stack) {
		id = (USHORT)(IPTR) LLS_POP(&id_stack);
		stream = (USHORT)(IPTR) LLS_POP(&stream_stack);
		format = CMP_format(tdbb, csb, stream);
		desc = &format->fmt_desc[id];
		if (id >= format->fmt_count || desc->dsc_length == 0)

	rsb = FB_NEW_RPT(*tdbb->tdbb_default, count + nstreams + 1) Rsb();
	rsb->rsb_type = rsb_union;
	rsb->rsb_count = count;
	rsb->rsb_stream = (UCHAR)(IPTR) union_node->nod_arg[e_uni_stream];
	rsb->rsb_format = csb->csb_rpt[rsb->rsb_stream].csb_format;
	rsb->rsb_impure = CMP_impure(csb, sizeof(struct irsb));
	rsb_ptr = rsb->rsb_arg;

	field = boolean->nod_arg[0];
	if (field->nod_type != nod_field)
		return NULL;
	if ((USHORT)(IPTR) field->nod_arg[e_fld_stream] != stream ||
		(USHORT)(IPTR) field->nod_arg[e_fld_id] != idx->idx_rpt[0].idx_field)
		return NULL;
	node = make_index_node(tdbb, relation, opt->opt_csb, idx);
	retrieval = (IRB) node->nod_arg[e_idx_retrieval];

			return NULL;
	}

	if ((USHORT)(IPTR) field->nod_arg[e_fld_stream] != stream ||
		(USHORT)(IPTR) field->nod_arg[e_fld_id] != idx->idx_rpt[0].idx_field
		|| !(idx->idx_rpt[0].idx_itype == idx_string
			 || idx->idx_rpt[0].idx_itype == idx_byte_array
			 || idx->idx_rpt[0].idx_itype == idx_metadata

		if (access_type) {
			for (arg = access_type->nod_arg, end = arg + plan_count;
				 arg < end; arg += 3) {
				if (relation_id != (SSHORT)(IPTR) * arg)
					/* index %s cannot be used in the specified plan */
					ERR_post(gds_index_unused, gds_arg_string, *(arg + 2), 0);
				if (idx->idx_id == (USHORT)(IPTR) * (arg + 1))
					if (access_type->nod_type == nod_navigational)
						idx->idx_runtime_flags |= idx_plan_navigate;
					else		/* nod_indices */

		   If left side is still not a field, give up */

		if (match->nod_type != nod_field ||
			(USHORT)(IPTR) match->nod_arg[e_fld_stream] != stream ||
			!computable(opt->opt_csb, value, stream, true, false))
		{
			match = value;
			value = boolean->nod_arg[0];
			if (match->nod_type != nod_field ||
				(USHORT)(IPTR) match->nod_arg[e_fld_stream] != stream ||
				!computable(opt->opt_csb, value, stream, true, false))
			{
				return 0;

#ifdef EXPRESSION_INDICES
			(idx->idx_expression ||
#endif
			 ((USHORT)(IPTR) match->nod_arg[e_fld_id] == idx->idx_rpt[i].idx_field)
#ifdef EXPRESSION_INDICES
			)
#endif

		return FALSE;
	for (streams = river->riv_streams, end =
		 streams + river->riv_count; streams < end; streams++)
		if ((USHORT)(IPTR) node->nod_arg[e_fld_stream] == *streams)
			return TRUE;
	return FALSE;
}

		 ptr < end; ptr++) {
		node = *ptr;
		if (node->nod_type != nod_rse) {
			stream = (USHORT)(IPTR) node->nod_arg[STREAM_INDEX(node)];
			csb->csb_rpt[stream].csb_flags &= ~csb_active;
		}
		else

Return to bug 120867

Lines 261-272 Link Here

(-)firebird2-1.5.3.4870~/src/common/config/config.cpp (-25 / +25 lines)
261		261
262	int Config::getSortMemBlockSize()	262	int Config::getSortMemBlockSize()
263	{	263	{
264	return (int) sysConfig.values[KEY_SORT_MEM_BLOCK_SIZE];	264	return (int)(IPTR) sysConfig.values[KEY_SORT_MEM_BLOCK_SIZE];
265	}	265	}
266		266
267	int Config::getSortMemUpperLimit()	267	int Config::getSortMemUpperLimit()
268	{	268	{
269	return (int) sysConfig.values[KEY_SORT_MEM_UPPER_LIMIT];	269	return (int)(IPTR) sysConfig.values[KEY_SORT_MEM_UPPER_LIMIT];
270	}	270	}
271		271
272	bool Config::getRemoteFileOpenAbility()	272	bool Config::getRemoteFileOpenAbility()
Lines 276-287 Link Here
276		276
277	int Config::getGuardianOption()	277	int Config::getGuardianOption()
278	{	278	{
279	return (int) sysConfig.values[KEY_GUARDIAN_OPTION];	279	return (int)(IPTR) sysConfig.values[KEY_GUARDIAN_OPTION];
280	}	280	}
281		281
282	int Config::getCpuAffinityMask()	282	int Config::getCpuAffinityMask()
283	{	283	{
284	return (int) sysConfig.values[KEY_CPU_AFFINITY_MASK];	284	return (int)(IPTR) sysConfig.values[KEY_CPU_AFFINITY_MASK];
285	}	285	}
286		286
287	bool Config::getOldParameterOrdering()	287	bool Config::getOldParameterOrdering()
Lines 291-297 Link Here
291		291
292	int Config::getTcpRemoteBufferSize()	292	int Config::getTcpRemoteBufferSize()
293	{	293	{
294	return (int) sysConfig.values[KEY_TCP_REMOTE_BUFFER_SIZE];	294	return (int)(IPTR) sysConfig.values[KEY_TCP_REMOTE_BUFFER_SIZE];
295	}	295	}
296		296
297	bool Config::getTcpNoNagle()	297	bool Config::getTcpNoNagle()
Lines 301-337 Link Here
301		301
302	int Config::getIpcMapSize()	302	int Config::getIpcMapSize()
303	{	303	{
304	return (int) sysConfig.values[KEY_IPC_MAP_SIZE];	304	return (int)(IPTR) sysConfig.values[KEY_IPC_MAP_SIZE];
305	}	305	}
306		306
307	int Config::getDefaultDbCachePages()	307	int Config::getDefaultDbCachePages()
308	{	308	{
309	return (int) sysConfig.values[KEY_DEFAULT_DB_CACHE_PAGES];	309	return (int)(IPTR) sysConfig.values[KEY_DEFAULT_DB_CACHE_PAGES];
310	}	310	}
311		311
312	int Config::getConnectionTimeout()	312	int Config::getConnectionTimeout()
313	{	313	{
314	return (int) sysConfig.values[KEY_CONNECTION_TIMEOUT];	314	return (int)(IPTR) sysConfig.values[KEY_CONNECTION_TIMEOUT];
315	}	315	}
316		316
317	int Config::getDummyPacketInterval()	317	int Config::getDummyPacketInterval()
318	{	318	{
319	return (int) sysConfig.values[KEY_DUMMY_PACKET_INTERVAL];	319	return (int)(IPTR) sysConfig.values[KEY_DUMMY_PACKET_INTERVAL];
320	}	320	}
321		321
322	int Config::getLockMemSize()	322	int Config::getLockMemSize()
323	{	323	{
324	return (int) sysConfig.values[KEY_LOCK_MEM_SIZE];	324	return (int)(IPTR) sysConfig.values[KEY_LOCK_MEM_SIZE];
325	}	325	}
326		326
327	int Config::getLockSemCount()	327	int Config::getLockSemCount()
328	{	328	{
329	return (int) sysConfig.values[KEY_LOCK_SEM_COUNT];	329	return (int)(IPTR) sysConfig.values[KEY_LOCK_SEM_COUNT];
330	}	330	}
331		331
332	int Config::getLockSignal()	332	int Config::getLockSignal()
333	{	333	{
334	return (int) sysConfig.values[KEY_LOCK_SIGNAL];	334	return (int)(IPTR) sysConfig.values[KEY_LOCK_SIGNAL];
335	}	335	}
336		336
337	bool Config::getLockGrantOrder()	337	bool Config::getLockGrantOrder()
Lines 341-367 Link Here
341		341
342	int Config::getLockHashSlots()	342	int Config::getLockHashSlots()
343	{	343	{
344	return (int) sysConfig.values[KEY_LOCK_HASH_SLOTS];	344	return (int)(IPTR) sysConfig.values[KEY_LOCK_HASH_SLOTS];
345	}	345	}
346		346
347	int Config::getLockAcquireSpins()	347	int Config::getLockAcquireSpins()
348	{	348	{
349	return (int) sysConfig.values[KEY_LOCK_ACQUIRE_SPINS];	349	return (int)(IPTR) sysConfig.values[KEY_LOCK_ACQUIRE_SPINS];
350	}	350	}
351		351
352	int Config::getEventMemSize()	352	int Config::getEventMemSize()
353	{	353	{
354	return (int) sysConfig.values[KEY_EVENT_MEM_SIZE];	354	return (int)(IPTR) sysConfig.values[KEY_EVENT_MEM_SIZE];
355	}	355	}
356		356
357	int Config::getDeadlockTimeout()	357	int Config::getDeadlockTimeout()
358	{	358	{
359	return (int) sysConfig.values[KEY_DEADLOCK_TIMEOUT];	359	return (int)(IPTR) sysConfig.values[KEY_DEADLOCK_TIMEOUT];
360	}	360	}
361		361
362	int Config::getSolarisStallValue()	362	int Config::getSolarisStallValue()
363	{	363	{
364	return (int) sysConfig.values[KEY_SOLARIS_STALL_VALUE];	364	return (int)(IPTR) sysConfig.values[KEY_SOLARIS_STALL_VALUE];
365	}	365	}
366		366
367	bool Config::getTraceMemoryPools()	367	bool Config::getTraceMemoryPools()
Lines 371-377 Link Here
371		371
372	int Config::getPrioritySwitchDelay()	372	int Config::getPrioritySwitchDelay()
373	{	373	{
374	int rc = (int) sysConfig.values[KEY_PRIORITY_SWITCH_DELAY];	374	int rc = (int)(IPTR) sysConfig.values[KEY_PRIORITY_SWITCH_DELAY];
375	if (rc < 1)	375	if (rc < 1)
376	rc = 1;	376	rc = 1;
377	return rc;	377	return rc;
Lines 379-385 Link Here
379		379
380	int Config::getDeadThreadsCollection()	380	int Config::getDeadThreadsCollection()
381	{	381	{
382	int rc = (int) sysConfig.values[KEY_DEAD_THREADS_COLLECTION];	382	int rc = (int)(IPTR) sysConfig.values[KEY_DEAD_THREADS_COLLECTION];
383	if (rc < 1)	383	if (rc < 1)
384	rc = 1;	384	rc = 1;
385	return rc;	385	return rc;
Lines 387-393 Link Here
387		387
388	int Config::getPriorityBoost()	388	int Config::getPriorityBoost()
389	{	389	{
390	int rc = (int) sysConfig.values[KEY_PRIORITY_BOOST];	390	int rc = (int)(IPTR) sysConfig.values[KEY_PRIORITY_BOOST];
391	if (rc < 1)	391	if (rc < 1)
392	rc = 1;	392	rc = 1;
393	if (rc > 1000)	393	if (rc > 1000)
Lines 402-408 Link Here
402		402
403	int Config::getRemoteServicePort()	403	int Config::getRemoteServicePort()
404	{	404	{
405	return (int) sysConfig.values[KEY_REMOTE_SERVICE_PORT];	405	return (int)(IPTR) sysConfig.values[KEY_REMOTE_SERVICE_PORT];
406	}	406	}
407		407
408	const char *Config::getRemotePipeName()	408	const char *Config::getRemotePipeName()
Lines 417-433 Link Here
417		417
418	int Config::getMaxUnflushedWrites()	418	int Config::getMaxUnflushedWrites()
419	{	419	{
420	return (int) sysConfig.values[KEY_MAX_UNFLUSHED_WRITES];	420	return (int)(IPTR) sysConfig.values[KEY_MAX_UNFLUSHED_WRITES];
421	}	421	}
422		422
423	int Config::getMaxUnflushedWriteTime()	423	int Config::getMaxUnflushedWriteTime()
424	{	424	{
425	return (int) sysConfig.values[KEY_MAX_UNFLUSHED_WRITE_TIME];	425	return (int)(IPTR) sysConfig.values[KEY_MAX_UNFLUSHED_WRITE_TIME];
426	}	426	}
427		427
428	int Config::getProcessPriorityLevel()	428	int Config::getProcessPriorityLevel()
429	{	429	{
430	return (int) sysConfig.values[KEY_PROCESS_PRIORITY_LEVEL];	430	return (int)(IPTR) sysConfig.values[KEY_PROCESS_PRIORITY_LEVEL];
431	}	431	}
432		432
433	bool Config::getCreateInternalWindow()	433	bool Config::getCreateInternalWindow()
Lines 443-449 Link Here
443	int Config::getRemoteAuxPort()	443	int Config::getRemoteAuxPort()
444	{	444	{
445	#ifdef SUPERSERVER	445	#ifdef SUPERSERVER
446	return (int) sysConfig.values[KEY_REMOTE_AUX_PORT];	446	return (int)(IPTR) sysConfig.values[KEY_REMOTE_AUX_PORT];
447	#else	447	#else
448	return 0;	448	return 0;
449	#endif	449	#endif

Lines 382-388 Link Here

(-)firebird2-1.5.3.4870~/src/gpre/cob.cpp (-7 / +7 lines)
382	static void gen_on_error (ACT);	382	static void gen_on_error (ACT);
383	static void gen_procedure (ACT);	383	static void gen_procedure (ACT);
384	static void gen_put_segment (ACT);	384	static void gen_put_segment (ACT);
385	static void gen_raw (UCHAR *, enum req_t, int, int);	385	static void gen_raw (UCHAR *, enum req_t, int, IPTR);
386	static void gen_ready (ACT);	386	static void gen_ready (ACT);
387	static void gen_receive (ACT, POR);	387	static void gen_receive (ACT, POR);
388	static void gen_release (ACT);	388	static void gen_release (ACT);
Lines 2656-2662 Link Here
2656		2656
2657	args.pat_database = (DBB) init->nod_arg[3];	2657	args.pat_database = (DBB) init->nod_arg[3];
2658	args.pat_vector1 = status_vector(action);	2658	args.pat_vector1 = status_vector(action);
2659	args.pat_value1 = (int) init->nod_arg[2];	2659	args.pat_value1 = (IPTR) init->nod_arg[2];
2660	args.pat_value2 = (int) event_list->nod_count;	2660	args.pat_value2 = (int) event_list->nod_count;
2661	args.pat_string1 = ISC_EVENT_BLOCK;	2661	args.pat_string1 = ISC_EVENT_BLOCK;
2662	args.pat_string2 = ISC_EVENT_WAIT;	2662	args.pat_string2 = ISC_EVENT_WAIT;
Lines 2712-2718 Link Here
2712	LLS stack_ptr;	2712	LLS stack_ptr;
2713	ACT event_action;	2713	ACT event_action;
2714	SSHORT column;	2714	SSHORT column;
2715	int ident;	2715	IPTR ident;
2716	TEXT s[64];	2716	TEXT s[64];
2717	TEXT *pattern1 =	2717	TEXT *pattern1 =
2718	"CALL \"%S2\" USING %V1, %RF%DH%RE, %VF%S4%N1L%VE, %VF%S4%N1A%VE, %VF%S4%N1B%VE";	2718	"CALL \"%S2\" USING %V1, %RF%DH%RE, %VF%S4%N1L%VE, %VF%S4%N1A%VE, %VF%S4%N1B%VE";
Lines 2730-2736 Link Here
2730	event_init = (GPRE_NOD) event_action->act_object;	2730	event_init = (GPRE_NOD) event_action->act_object;
2731	stack_name = (SYM) event_init->nod_arg[0];	2731	stack_name = (SYM) event_init->nod_arg[0];
2732	if (!strcmp(event_name->sym_string, stack_name->sym_string)) {	2732	if (!strcmp(event_name->sym_string, stack_name->sym_string)) {
2733	ident = (int) event_init->nod_arg[2];	2733	ident = (IPTR) event_init->nod_arg[2];
2734	database = (DBB) event_init->nod_arg[3];	2734	database = (DBB) event_init->nod_arg[3];
2735	}	2735	}
2736	}	2736	}
Lines 3845-3851 Link Here
3845		3845
3846	static void gen_raw(	3846	static void gen_raw(
3847	UCHAR * blr,	3847	UCHAR * blr,
3848	enum req_t request_type, int request_length, int ident)	3848	enum req_t request_type, int request_length, IPTR ident)
3849	{	3849	{
3850	UCHAR *c;	3850	UCHAR *c;
3851	TEXT s[256];	3851	TEXT s[256];
Lines 4193-4199 Link Here
4193	printa(names[COLUMN_0], FALSE, "01 %s%d.",	4193	printa(names[COLUMN_0], FALSE, "01 %s%d.",
4194	names[ISC_], blob->blb_bpb_ident);	4194	names[ISC_], blob->blb_bpb_ident);
4195	gen_raw(blob->blb_bpb, request->req_type, blob->blb_bpb_length,	4195	gen_raw(blob->blb_bpb, request->req_type, blob->blb_bpb_length,
4196	(int) request);	4196	(IPTR) request);
4197	printa(names[COMMENT], FALSE, " ");	4197	printa(names[COMMENT], FALSE, " ");
4198	}	4198	}
4199	#ifdef PYXIS	4199	#ifdef PYXIS
Lines 4703-4709 Link Here
4703	static void gen_type( ACT action)	4703	static void gen_type( ACT action)
4704	{	4704	{
4705		4705
4706	printa(names[COLUMN], TRUE, "%ld", action->act_object);	4706	printa(names[COLUMN], TRUE, "%ld", (IPTR) action->act_object);
4707	}	4707	}
4708		4708
4709		4709

Lines 375-382 Link Here

(-)firebird2-1.5.3.4870~/src/jrd/exe.cpp (-17 / +17 lines)
375		375
376	if (to->nod_type == nod_field)	376	if (to->nod_type == nod_field)
377	{	377	{
378	SSHORT id = (USHORT) to->nod_arg[e_fld_id];	378	SSHORT id = (USHORT)(IPTR) to->nod_arg[e_fld_id];
379	REC record = request->req_rpb[(int) to->nod_arg[e_fld_stream]].rpb_record;	379	REC record = request->req_rpb[(int)(IPTR) to->nod_arg[e_fld_stream]].rpb_record;
380	if (null) {	380	if (null) {
381	SET_NULL(record, id);	381	SET_NULL(record, id);
382	} else {	382	} else {
Lines 639-645 Link Here
639	message = request->req_message;	639	message = request->req_message;
640	format = (FMT) message->nod_arg[e_msg_format];	640	format = (FMT) message->nod_arg[e_msg_format];
641		641
642	if (msg != (USHORT) message->nod_arg[e_msg_number])	642	if (msg != (USHORT)(IPTR) message->nod_arg[e_msg_number])
643	ERR_post(gds_req_sync, 0);	643	ERR_post(gds_req_sync, 0);
644		644
645	if (length != format->fmt_length)	645	if (length != format->fmt_length)
Lines 788-794 Link Here
788	for (ptr = node->nod_arg, end = ptr + node->nod_count; ptr < end;	788	for (ptr = node->nod_arg, end = ptr + node->nod_count; ptr < end;
789	ptr++) {	789	ptr++) {
790	message = (*ptr)->nod_arg[e_send_message];	790	message = (*ptr)->nod_arg[e_send_message];
791	if ((USHORT) message->nod_arg[e_msg_number] == msg) {	791	if ((USHORT)(IPTR) message->nod_arg[e_msg_number] == msg) {
792	request->req_next = *ptr;	792	request->req_next = *ptr;
793	break;	793	break;
794	}	794	}
Lines 798-804 Link Here
798		798
799	format = (FMT) message->nod_arg[e_msg_format];	799	format = (FMT) message->nod_arg[e_msg_format];
800		800
801	if (msg != (USHORT) message->nod_arg[e_msg_number])	801	if (msg != (USHORT)(IPTR) message->nod_arg[e_msg_number])
802	ERR_post(gds_req_sync, 0);	802	ERR_post(gds_req_sync, 0);
803		803
804	if (length != format->fmt_length)	804	if (length != format->fmt_length)
Lines 1049-1055 Link Here
1049	desc = &format->fmt_desc[n];	1049	desc = &format->fmt_desc[n];
1050	if (!desc->dsc_address)	1050	if (!desc->dsc_address)
1051	continue;	1051	continue;
1052	p = record->rec_data + (SLONG) desc->dsc_address;	1052	p = record->rec_data + (SLONG)(IPTR) desc->dsc_address;
1053	if (TEST_NULL(record, n))	1053	if (TEST_NULL(record, n))
1054	{	1054	{
1055	if (length = desc->dsc_length)	1055	if (length = desc->dsc_length)
Lines 1134-1140 Link Here
1134		1134
1135	request = tdbb->tdbb_request;	1135	request = tdbb->tdbb_request;
1136	transaction = request->req_transaction;	1136	transaction = request->req_transaction;
1137	rpb = &request->req_rpb[(int) node->nod_arg[e_erase_stream]];	1137	rpb = &request->req_rpb[(int)(IPTR) node->nod_arg[e_erase_stream]];
1138	relation = rpb->rpb_relation;	1138	relation = rpb->rpb_relation;
1139		1139
1140	#ifdef PC_ENGINE	1140	#ifdef PC_ENGINE
Lines 2015-2021 Link Here
2015	case jrd_req::req_evaluate:	2015	case jrd_req::req_evaluate:
2016	if (transaction != dbb->dbb_sys_trans) {	2016	if (transaction != dbb->dbb_sys_trans) {
2017		2017
2018	UCHAR operation = (UCHAR) node->nod_arg[e_sav_operation];	2018	UCHAR operation = (UCHAR)(IPTR) node->nod_arg[e_sav_operation];
2019	TEXT * node_savepoint_name = (TEXT*) node->nod_arg[e_sav_name];	2019	TEXT * node_savepoint_name = (TEXT*) node->nod_arg[e_sav_name];
2020		2020
2021	// Skip the savepoint created by EXE_start	2021	// Skip the savepoint created by EXE_start
Lines 2328-2334 Link Here
2328	break;	2328	break;
2329		2329
2330	case jrd_req::req_unwind:	2330	case jrd_req::req_unwind:
2331	if ((request->req_label == (USHORT) node->nod_arg[e_lbl_label]) &&	2331	if ((request->req_label == (USHORT)(IPTR) node->nod_arg[e_lbl_label]) &&
2332	(request->req_flags & (req_leave \| req_error_handler))) {	2332	(request->req_flags & (req_leave \| req_error_handler))) {
2333	request->req_flags &= ~req_leave;	2333	request->req_flags &= ~req_leave;
2334	request->req_operation = jrd_req::req_return;	2334	request->req_operation = jrd_req::req_return;
Lines 2342-2348 Link Here
2342	case nod_leave:	2342	case nod_leave:
2343	request->req_flags \|= req_leave;	2343	request->req_flags \|= req_leave;
2344	request->req_operation = jrd_req::req_unwind;	2344	request->req_operation = jrd_req::req_unwind;
2345	request->req_label = (USHORT) node->nod_arg[0];	2345	request->req_label = (USHORT)(IPTR) node->nod_arg[0];
2346	node = node->nod_parent;	2346	node = node->nod_parent;
2347	break;	2347	break;
2348		2348
Lines 2652-2658 Link Here
2652	DSC *desc;	2652	DSC *desc;
2653		2653
2654	desc = EVL_expr(tdbb, node->nod_arg[e_gen_value]);	2654	desc = EVL_expr(tdbb, node->nod_arg[e_gen_value]);
2655	(void) DPM_gen_id(tdbb, (SLONG) node->nod_arg[e_gen_id], 1,	2655	(void) DPM_gen_id(tdbb, (SLONG)(IPTR) node->nod_arg[e_gen_id], 1,
2656	MOV_get_int64(desc, 0));	2656	MOV_get_int64(desc, 0));
2657	request->req_operation = jrd_req::req_return;	2657	request->req_operation = jrd_req::req_return;
2658	}	2658	}
Lines 2664-2670 Link Here
2664	DSC *desc;	2664	DSC *desc;
2665		2665
2666	desc = EVL_expr(tdbb, node->nod_arg[e_gen_value]);	2666	desc = EVL_expr(tdbb, node->nod_arg[e_gen_value]);
2667	(void) DPM_gen_id(tdbb, (SLONG) node->nod_arg[e_gen_id], 1,	2667	(void) DPM_gen_id(tdbb, (SLONG)(IPTR) node->nod_arg[e_gen_id], 1,
2668	MOV_get_int64(desc, 0));	2668	MOV_get_int64(desc, 0));
2669	request->req_operation = jrd_req::req_return;	2669	request->req_operation = jrd_req::req_return;
2670	}	2670	}
Lines 2794-2804 Link Here
2794	transaction = request->req_transaction;	2794	transaction = request->req_transaction;
2795	impure = (STA) ((SCHAR *) request + node->nod_impure);	2795	impure = (STA) ((SCHAR *) request + node->nod_impure);
2796		2796
2797	org_stream = (USHORT) node->nod_arg[e_mod_org_stream];	2797	org_stream = (USHORT)(IPTR) node->nod_arg[e_mod_org_stream];
2798	org_rpb = &request->req_rpb[org_stream];	2798	org_rpb = &request->req_rpb[org_stream];
2799	relation = org_rpb->rpb_relation;	2799	relation = org_rpb->rpb_relation;
2800		2800
2801	new_stream = (USHORT) node->nod_arg[e_mod_new_stream];	2801	new_stream = (USHORT)(IPTR) node->nod_arg[e_mod_new_stream];
2802	new_rpb = &request->req_rpb[new_stream];	2802	new_rpb = &request->req_rpb[new_stream];
2803		2803
2804	#ifdef PC_ENGINE	2804	#ifdef PC_ENGINE
Lines 3795-3801 Link Here
3795	JRD_REQ request = tdbb->tdbb_request;	3795	JRD_REQ request = tdbb->tdbb_request;
3796	JRD_TRA transaction = request->req_transaction;	3796	JRD_TRA transaction = request->req_transaction;
3797	STA impure = (STA) ((SCHAR *) request + node->nod_impure);	3797	STA impure = (STA) ((SCHAR *) request + node->nod_impure);
3798	SSHORT stream = (USHORT) node->nod_arg[e_sto_relation]->nod_arg[e_rel_stream];	3798	SSHORT stream = (USHORT)(IPTR) node->nod_arg[e_sto_relation]->nod_arg[e_rel_stream];
3799	RPB* rpb = &request->req_rpb[stream];	3799	RPB* rpb = &request->req_rpb[stream];
3800	JRD_REL relation = rpb->rpb_relation;	3800	JRD_REL relation = rpb->rpb_relation;
3801		3801
Lines 4201-4208 Link Here
4201		4201
4202	if (node->nod_type == nod_field)	4202	if (node->nod_type == nod_field)
4203	{	4203	{
4204	stream = (USHORT) node->nod_arg[e_fld_stream];	4204	stream = (USHORT)(IPTR) node->nod_arg[e_fld_stream];
4205	id = (USHORT) node->nod_arg[e_fld_id];	4205	id = (USHORT)(IPTR) node->nod_arg[e_fld_id];
4206	relation = request->req_rpb[stream].rpb_relation;	4206	relation = request->req_rpb[stream].rpb_relation;
4207		4207
4208	if ((vector = relation->rel_fields) &&	4208	if ((vector = relation->rel_fields) &&

Lines 266-272 Link Here

(-)firebird2-1.5.3.4870~/src/jrd/ext.cpp (-4 / +4 lines)
266	record = rpb->rpb_record;	266	record = rpb->rpb_record;
267	format = record->rec_format;	267	format = record->rec_format;
268		268
269	offset = (SSHORT) format->fmt_desc[0].dsc_address;	269	offset = (SSHORT)(IPTR) format->fmt_desc[0].dsc_address;
270	p = record->rec_data + offset;	270	p = record->rec_data + offset;
271	l = record->rec_length - offset;	271	l = record->rec_length - offset;
272		272
Lines 299-305 Link Here
299	continue;	299	continue;
300	if ( (literal = (LIT) field->fld_missing_value) ) {	300	if ( (literal = (LIT) field->fld_missing_value) ) {
301	desc = *desc_ptr;	301	desc = *desc_ptr;
302	desc.dsc_address = record->rec_data + (int) desc.dsc_address;	302	desc.dsc_address = record->rec_data + (int)(IPTR) desc.dsc_address;
303	if (!MOV_compare(&literal->lit_desc, &desc))	303	if (!MOV_compare(&literal->lit_desc, &desc))
304	continue;	304	continue;
305	}	305	}
Lines 512-518 Link Here
512	desc_ptr->dsc_length &&	512	desc_ptr->dsc_length &&
513	TEST_NULL(record, i))	513	TEST_NULL(record, i))
514	{	514	{
515	p = record->rec_data + (int) desc_ptr->dsc_address;	515	p = record->rec_data + (int)(IPTR) desc_ptr->dsc_address;
516	if ( (literal = (LIT) field->fld_missing_value) ) {	516	if ( (literal = (LIT) field->fld_missing_value) ) {
517	desc = *desc_ptr;	517	desc = *desc_ptr;
518	desc.dsc_address = p;	518	desc.dsc_address = p;
Lines 528-534 Link Here
528	}	528	}
529	}	529	}
530		530
531	offset = (USHORT) format->fmt_desc[0].dsc_address;	531	offset = (USHORT)(IPTR) format->fmt_desc[0].dsc_address;
532	p = record->rec_data + offset;	532	p = record->rec_data + offset;
533	l = record->rec_length - offset;	533	l = record->rec_length - offset;
534		534

Lines 1055-1066 Link Here

(-)firebird2-1.5.3.4870~/src/jrd/idx.cpp (-3 / +3 lines)
1055	index_number < idx->idx_foreign_primaries->count();	1055	index_number < idx->idx_foreign_primaries->count();
1056	index_number++) {	1056	index_number++) {
1057	if (idx->idx_id !=	1057	if (idx->idx_id !=
1058	(UCHAR) (*idx->idx_foreign_primaries)[index_number]) continue;	1058	(UCHAR)(IPTR) (*idx->idx_foreign_primaries)[index_number]) continue;
1059	partner_relation =	1059	partner_relation =
1060	MET_relation(tdbb,	1060	MET_relation(tdbb,
1061	(int) (*idx->idx_foreign_relations)[index_number]);	1061	(int)(IPTR) (*idx->idx_foreign_relations)[index_number]);
1062	index_id =	1062	index_id =
1063	(USHORT) (*idx->idx_foreign_indexes)[index_number];	1063	(USHORT)(IPTR) (*idx->idx_foreign_indexes)[index_number];
1064	if ( (result =	1064	if ( (result =
1065	check_partner_index(tdbb, relation, record, transaction, idx,	1065	check_partner_index(tdbb, relation, record, transaction, idx,
1066	partner_relation, index_id)) )	1066	partner_relation, index_id)) )

Lines 241-263 Link Here

(-)firebird2-1.5.3.4870~/src/common/classes/alloc.h (-4 / +10 lines)
241		241
242	void operator delete[](void* mem) throw();	242	void operator delete[](void* mem) throw();
243		243
		244	#if __GNUC__ < 4
		245	#define STATIC_NEW static
		246	#else
		247	#define STATIC_NEW
		248	#endif
		249
244	#ifdef DEBUG_GDS_ALLOC	250	#ifdef DEBUG_GDS_ALLOC
245	static inline void* operator new(size_t s, Firebird::MemoryPool& pool, char* file, int line) {	251	STATIC_NEW inline void* operator new(size_t s, Firebird::MemoryPool& pool, char* file, int line) {
246	return pool.allocate(s, 0, file, line);	252	return pool.allocate(s, 0, file, line);
247	// return pool.calloc(s, 0, file, line);	253	// return pool.calloc(s, 0, file, line);
248	}	254	}
249	static inline void* operator new[](size_t s, Firebird::MemoryPool& pool, char* file, int line) {	255	STATIC_NEW inline void* operator new[](size_t s, Firebird::MemoryPool& pool, char* file, int line) {
250	return pool.allocate(s, 0, file, line);	256	return pool.allocate(s, 0, file, line);
251	// return pool.calloc(s, 0, file, line);	257	// return pool.calloc(s, 0, file, line);
252	}	258	}
253	#define FB_NEW(pool) new(pool,__FILE__,__LINE__)	259	#define FB_NEW(pool) new(pool,__FILE__,__LINE__)
254	#define FB_NEW_RPT(pool,count) new(pool,count,__FILE__,__LINE__)	260	#define FB_NEW_RPT(pool,count) new(pool,count,__FILE__,__LINE__)
255	#else	261	#else
256	static inline void* operator new(size_t s, Firebird::MemoryPool& pool) {	262	STATIC_NEW inline void* operator new(size_t s, Firebird::MemoryPool& pool) {
257	return pool.allocate(s);	263	return pool.allocate(s);
258	// return pool.calloc(s);	264	// return pool.calloc(s);
259	}	265	}
260	static inline void* operator new[](size_t s, Firebird::MemoryPool& pool) {	266	STATIC_NEW inline void* operator new[](size_t s, Firebird::MemoryPool& pool) {
261	return pool.allocate(s);	267	return pool.allocate(s);
262	// return pool.calloc(s);	268	// return pool.calloc(s);
263	}	269	}

Lines 248-254 Link Here

(-)firebird2-1.5.3.4870~/src/jrd/evl.cpp (-18 / +18 lines)
248	arg_number = (int)(IPTR)node->nod_arg[e_arg_number];	248	arg_number = (int)(IPTR)node->nod_arg[e_arg_number];
249	desc = &format->fmt_desc[arg_number];	249	desc = &format->fmt_desc[arg_number];
250	impure->vlu_desc.dsc_address =	250	impure->vlu_desc.dsc_address =
251	(UCHAR *) request + message->nod_impure + (int) desc->dsc_address;	251	(UCHAR *) request + message->nod_impure + (int)(IPTR) desc->dsc_address;
252	impure->vlu_desc.dsc_dtype = desc->dsc_dtype;	252	impure->vlu_desc.dsc_dtype = desc->dsc_dtype;
253	impure->vlu_desc.dsc_length = desc->dsc_length;	253	impure->vlu_desc.dsc_length = desc->dsc_length;
254	impure->vlu_desc.dsc_scale = desc->dsc_scale;	254	impure->vlu_desc.dsc_scale = desc->dsc_scale;
Lines 288-295 Link Here
288	// may happen. I checked triggers and insert/update statements.	288	// may happen. I checked triggers and insert/update statements.
289	// All seem to work fine.	289	// All seem to work fine.
290	record =	290	record =
291	request->req_rpb[(int) node->nod_arg[e_fld_stream]].rpb_record;	291	request->req_rpb[(int)(IPTR) node->nod_arg[e_fld_stream]].rpb_record;
292	EVL_field(0, record, (USHORT) node->nod_arg[e_fld_id],	292	EVL_field(0, record, (USHORT)(IPTR) node->nod_arg[e_fld_id],
293	&impure->vlu_desc);	293	&impure->vlu_desc);
294	if (!impure->vlu_desc.dsc_address)	294	if (!impure->vlu_desc.dsc_address)
295	ERR_post(gds_read_only_field, 0);	295	ERR_post(gds_read_only_field, 0);
Lines 359-365 Link Here
359	impure = (INV) ((SCHAR *) tdbb->tdbb_request + node->nod_impure);	359	impure = (INV) ((SCHAR *) tdbb->tdbb_request + node->nod_impure);
360	SBM_reset(&impure->inv_bitmap);	360	SBM_reset(&impure->inv_bitmap);
361	desc = EVL_expr(tdbb, node->nod_arg[0]);	361	desc = EVL_expr(tdbb, node->nod_arg[0]);
362	id = 1 + 2 * (USHORT) node->nod_arg[1];	362	id = 1 + 2 * (USHORT)(IPTR) node->nod_arg[1];
363	numbers = desc->dsc_address;	363	numbers = desc->dsc_address;
364	numbers += id * sizeof(SLONG);	364	numbers += id * sizeof(SLONG);
365	MOVE_FAST(numbers, &rel_dbkey, sizeof(SLONG));	365	MOVE_FAST(numbers, &rel_dbkey, sizeof(SLONG));
Lines 828-837 Link Here
828	}	828	}
829	message = node->nod_arg[e_arg_message];	829	message = node->nod_arg[e_arg_message];
830	format = (FMT) message->nod_arg[e_msg_format];	830	format = (FMT) message->nod_arg[e_msg_format];
831	desc = &format->fmt_desc[(int) node->nod_arg[e_arg_number]];	831	desc = &format->fmt_desc[(int)(IPTR) node->nod_arg[e_arg_number]];
832		832
833	impure->vlu_desc.dsc_address = (UCHAR *) request +	833	impure->vlu_desc.dsc_address = (UCHAR *) request +
834	message->nod_impure + (int) desc->dsc_address;	834	message->nod_impure + (int)(IPTR) desc->dsc_address;
835	impure->vlu_desc.dsc_dtype = desc->dsc_dtype;	835	impure->vlu_desc.dsc_dtype = desc->dsc_dtype;
836	impure->vlu_desc.dsc_length = desc->dsc_length;	836	impure->vlu_desc.dsc_length = desc->dsc_length;
837	impure->vlu_desc.dsc_scale = desc->dsc_scale;	837	impure->vlu_desc.dsc_scale = desc->dsc_scale;
Lines 851-864 Link Here
851	case nod_field:	851	case nod_field:
852	{	852	{
853	REC record =	853	REC record =
854	request->req_rpb[(int)node->nod_arg[e_fld_stream]].rpb_record;	854	request->req_rpb[(int)(IPTR)node->nod_arg[e_fld_stream]].rpb_record;
855	/* In order to "map a null to a default" value (in EVL_field()),	855	/* In order to "map a null to a default" value (in EVL_field()),
856	* the relation block is referenced.	856	* the relation block is referenced.
857	* Reference: Bug 10116, 10424	857	* Reference: Bug 10116, 10424
858	*/	858	*/
859	if (!EVL_field(request->req_rpb[(USHORT) node->nod_arg[e_fld_stream]].rpb_relation,	859	if (!EVL_field(request->req_rpb[(USHORT)(IPTR) node->nod_arg[e_fld_stream]].rpb_relation,
860	record,	860	record,
861	(USHORT) node->nod_arg[e_fld_id],	861	(USHORT)(IPTR) node->nod_arg[e_fld_id],
862	&impure->vlu_desc))	862	&impure->vlu_desc))
863	{	863	{
864	request->req_flags \|= req_null;	864	request->req_flags \|= req_null;
Lines 997-1003 Link Here
997	ULONG extract_part;	997	ULONG extract_part;
998		998
999	impure = (VLU) ((SCHAR *) request + node->nod_impure);	999	impure = (VLU) ((SCHAR *) request + node->nod_impure);
1000	extract_part = (ULONG) node->nod_arg[e_extract_part];	1000	extract_part = (ULONG)(IPTR) node->nod_arg[e_extract_part];
1001	value = EVL_expr(tdbb, node->nod_arg[e_extract_value]);	1001	value = EVL_expr(tdbb, node->nod_arg[e_extract_value]);
1002		1002
1003	impure->vlu_desc.dsc_dtype = dtype_short;	1003	impure->vlu_desc.dsc_dtype = dtype_short;
Lines 1173-1180 Link Here
1173		1173
1174	switch (node->nod_type) {	1174	switch (node->nod_type) {
1175	case nod_gen_id: /* return a 32-bit generator value */	1175	case nod_gen_id: /* return a 32-bit generator value */
1176	impure->vlu_misc.vlu_long = (SLONG) DPM_gen_id(tdbb,	1176	impure->vlu_misc.vlu_long = (SLONG)(IPTR) DPM_gen_id(tdbb,
1177	(SLONG)	1177	(SLONG)(IPTR)
1178	node->nod_arg	1178	node->nod_arg
1179	[e_gen_id], 0,	1179	[e_gen_id], 0,
1180	MOV_get_int64	1180	MOV_get_int64
Lines 1189-1195 Link Here
1189		1189
1190	case nod_gen_id2:	1190	case nod_gen_id2:
1191	impure->vlu_misc.vlu_int64 = DPM_gen_id(tdbb,	1191	impure->vlu_misc.vlu_int64 = DPM_gen_id(tdbb,
1192	(SLONG)	1192	(SLONG)(IPTR)
1193	node->nod_arg[e_gen_id],	1193	node->nod_arg[e_gen_id],
1194	0,	1194	0,
1195	MOV_get_int64(values[0],	1195	MOV_get_int64(values[0],
Lines 1383-1389 Link Here
1383	return FALSE;	1383	return FALSE;
1384	}	1384	}
1385		1385
1386	desc->dsc_address = record->rec_data + (int) desc->dsc_address;	1386	desc->dsc_address = record->rec_data + (int)(IPTR) desc->dsc_address;
1387		1387
1388	if (TEST_NULL(record, id)) {	1388	if (TEST_NULL(record, id)) {
1389	desc->dsc_flags \|= DSC_null;	1389	desc->dsc_flags \|= DSC_null;
Lines 1725-1733 Link Here
1725	{	1725	{
1726	from = (*ptr)->nod_arg[e_asgn_from];	1726	from = (*ptr)->nod_arg[e_asgn_from];
1727	field = (*ptr)->nod_arg[e_asgn_to];	1727	field = (*ptr)->nod_arg[e_asgn_to];
1728	id = (USHORT) field->nod_arg[e_fld_id];	1728	id = (USHORT)(IPTR) field->nod_arg[e_fld_id];
1729	record =	1729	record =
1730	request->req_rpb[(int) field->nod_arg[e_fld_stream]].rpb_record;	1730	request->req_rpb[(int)(IPTR) field->nod_arg[e_fld_stream]].rpb_record;
1731	impure = (VLUX) ((SCHAR *) request + from->nod_impure);	1731	impure = (VLUX) ((SCHAR *) request + from->nod_impure);
1732	switch (from->nod_type)	1732	switch (from->nod_type)
1733	{	1733	{
Lines 3395-3401 Link Here
3395		3395
3396	request = tdbb->tdbb_request;	3396	request = tdbb->tdbb_request;
3397	impure = (VLU) ((SCHAR *) request + node->nod_impure);	3397	impure = (VLU) ((SCHAR *) request + node->nod_impure);
3398	rpb = &request->req_rpb[(int) node->nod_arg[0]];	3398	rpb = &request->req_rpb[(int)(IPTR) node->nod_arg[0]];
3399	relation = rpb->rpb_relation;	3399	relation = rpb->rpb_relation;
3400		3400
3401	/* Format dbkey as vector of relation id, record number */	3401	/* Format dbkey as vector of relation id, record number */
Lines 4500-4506 Link Here
4500		4500
4501	request = tdbb->tdbb_request;	4501	request = tdbb->tdbb_request;
4502	impure = (VLU) ((SCHAR *) request + node->nod_impure);	4502	impure = (VLU) ((SCHAR *) request + node->nod_impure);
4503	rpb = &request->req_rpb[(int) node->nod_arg[0]];	4503	rpb = &request->req_rpb[(int)(IPTR) node->nod_arg[0]];
4504		4504
4505	/* If the current transaction has updated the record, the record version	4505	/* If the current transaction has updated the record, the record version
4506	* coming in from DSQL will have the original transaction # (or current	4506	* coming in from DSQL will have the original transaction # (or current

Lines 932-938 Link Here

(-)firebird2-1.5.3.4870~/src/jrd/met.epp (-11 / +11 lines)
932	if (desc->dsc_address)	932	if (desc->dsc_address)
933	{	933	{
934	format->fmt_length =	934	format->fmt_length =
935	(ULONG) desc->dsc_address + desc->dsc_length;	935	(ULONG)(IPTR) desc->dsc_address + desc->dsc_length;
936	break;	936	break;
937	}	937	}
938	}	938	}
Lines 2133-2145 Link Here
2133	index_number < references->frgn_reference_ids->count();	2133	index_number < references->frgn_reference_ids->count();
2134	index_number++)	2134	index_number++)
2135	{	2135	{
2136	if (idx->idx_id == (UCHAR) (*references->frgn_reference_ids)	2136	if (idx->idx_id == (UCHAR)(IPTR) (*references->frgn_reference_ids)
2137	[index_number])	2137	[index_number])
2138	{	2138	{
2139	idx->idx_primary_relation =	2139	idx->idx_primary_relation =
2140	(USHORT) (*references->frgn_relations)[index_number];	2140	(USHORT)(IPTR) (*references->frgn_relations)[index_number];
2141	idx->idx_primary_index =	2141	idx->idx_primary_index =
2142	(UCHAR) (*references->frgn_indexes)[index_number];	2142	(UCHAR)(IPTR) (*references->frgn_indexes)[index_number];
2143	return TRUE;	2143	return TRUE;
2144	}	2144	}
2145	}	2145	}
Lines 2155-2161 Link Here
2155	index_number < dependencies->prim_reference_ids->count();	2155	index_number < dependencies->prim_reference_ids->count();
2156	index_number++)	2156	index_number++)
2157	{	2157	{
2158	if (idx->idx_id == (UCHAR) (*dependencies->prim_reference_ids)	2158	if (idx->idx_id == (UCHAR)(IPTR) (*dependencies->prim_reference_ids)
2159	[index_number])	2159	[index_number])
2160	{	2160	{
2161	idx->idx_foreign_primaries =	2161	idx->idx_foreign_primaries =
Lines 3001-3010 Link Here
3001	{	3001	{
3002	if ( (node = csb_->csb_rpt[i].csb_message) )	3002	if ( (node = csb_->csb_rpt[i].csb_message) )
3003	{	3003	{
3004	if ((int) node->nod_arg[e_msg_number] == 0)	3004	if ((int)(IPTR) node->nod_arg[e_msg_number] == 0)
3005	{	3005	{
3006	procedure->prc_input_msg = node;	3006	procedure->prc_input_msg = node;
3007	} else if ((int) node->nod_arg[e_msg_number] == 1)	3007	} else if ((int)(IPTR) node->nod_arg[e_msg_number] == 1)
3008	{	3008	{
3009	procedure->prc_output_msg = node;	3009	procedure->prc_output_msg = node;
3010	}	3010	}
Lines 4580-4586 Link Here
4580	node = (JRD_NOD) LLS_POP(&csb->csb_dependencies);	4580	node = (JRD_NOD) LLS_POP(&csb->csb_dependencies);
4581	if (!node->nod_arg[e_dep_object])	4581	if (!node->nod_arg[e_dep_object])
4582	continue;	4582	continue;
4583	dpdo_type = (SSHORT) node->nod_arg[e_dep_object_type];	4583	dpdo_type = (SSHORT)(IPTR) node->nod_arg[e_dep_object_type];
4584	relation = NULL;	4584	relation = NULL;
4585	procedure = NULL;	4585	procedure = NULL;
4586	switch (dpdo_type) {	4586	switch (dpdo_type) {
Lines 4593-4605 Link Here
4593	dpdo_name = (TEXT*) procedure->prc_name->str_data;	4593	dpdo_name = (TEXT*) procedure->prc_name->str_data;
4594	break;	4594	break;
4595	case obj_exception:	4595	case obj_exception:
4596	number = (SLONG) node->nod_arg [e_dep_object];	4596	number = (SLONG)(IPTR) node->nod_arg [e_dep_object];
4597	MET_lookup_exception (tdbb, number, name, NULL);	4597	MET_lookup_exception (tdbb, number, name, NULL);
4598	dpdo_name = name;	4598	dpdo_name = name;
4599	break;	4599	break;
4600	/* CVC: Here I'm going to track those pesky things named generators and UDFs. */	4600	/* CVC: Here I'm going to track those pesky things named generators and UDFs. */
4601	case obj_generator:	4601	case obj_generator:
4602	number = (SLONG) node->nod_arg [e_dep_object];	4602	number = (SLONG)(IPTR) node->nod_arg [e_dep_object];
4603	MET_lookup_generator_id (tdbb, number, name);	4603	MET_lookup_generator_id (tdbb, number, name);
4604	dpdo_name = name;	4604	dpdo_name = name;
4605	break;	4605	break;
Lines 4617-4623 Link Here
4617	{	4617	{
4618	if (field_node->nod_type == nod_field)	4618	if (field_node->nod_type == nod_field)
4619	{	4619	{
4620	fld_id = (SSHORT) field_node->nod_arg[0];	4620	fld_id = (SSHORT)(IPTR) field_node->nod_arg[0];
4621	if (relation)	4621	if (relation)
4622	{	4622	{
4623	if ( (field = MET_get_field(relation, fld_id)) )	4623	if ( (field = MET_get_field(relation, fld_id)) )

Lines 311-342 Link Here

(-)firebird-1.5.3.4870/src/qli/command.cpp.orig (-8 / +8 lines)
311	ptr = node->syn_arg;	311	ptr = node->syn_arg;
312		312
313	for (i = 0; i < node->syn_count; i++) {	313	for (i = 0; i < node->syn_count; i++) {
314	foo = (USHORT) * ptr++;	314	foo = (USHORT)(IPTR) * ptr++;
315	sw = (ENUM set_t) foo;	315	sw = (ENUM set_t) foo;
316	value = *ptr++;	316	value = *ptr++;
317	switch (sw) {	317	switch (sw) {
318	case set_blr:	318	case set_blr:
319	QLI_blr = (USHORT) value;	319	QLI_blr = (USHORT)(IPTR) value;
320	break;	320	break;
321		321
322	case set_statistics:	322	case set_statistics:
323	QLI_statistics = (USHORT) value;	323	QLI_statistics = (USHORT)(IPTR) value;
324	break;	324	break;
325		325
326	case set_columns:	326	case set_columns:
327	QLI_name_columns = QLI_columns = (USHORT) value;	327	QLI_name_columns = QLI_columns = (USHORT)(IPTR) value;
328	break;	328	break;
329		329
330	case set_lines:	330	case set_lines:
331	QLI_lines = (USHORT) value;	331	QLI_lines = (USHORT)(IPTR) value;
332	break;	332	break;
333		333
334	case set_semi:	334	case set_semi:
335	QLI_semi = (USHORT) value;	335	QLI_semi = (USHORT)(IPTR) value;
336	break;	336	break;
337		337
338	case set_echo:	338	case set_echo:
339	QLI_echo = (USHORT) value;	339	QLI_echo = (USHORT)(IPTR) value;
340	break;	340	break;
341		341
342	case set_form:	342	case set_form:
Lines 399-405 Link Here
399	break;	399	break;
400		400
401	case set_count:	401	case set_count:
402	QLI_count = (USHORT) value;	402	QLI_count = (USHORT)(IPTR) value;
403	break;	403	break;
404		404
405	case set_charset:	405	case set_charset:

Lines 6421-6427 Link Here

(-)firebird-1.5.3.4870/src/dsql/parse.cpp.orig (-15 / +15 lines)
6421	case 79:	6421	case 79:
6422	{	6422	{
6423	lex.g_field->fld_dtype = dtype_cstring;	6423	lex.g_field->fld_dtype = dtype_cstring;
6424	lex.g_field->fld_character_length = (USHORT) yyvsp[-2]; }	6424	lex.g_field->fld_character_length = (USHORT)(IPTR) yyvsp[-2]; }
6425	break;	6425	break;
6426	case 80:	6426	case 80:
6427	{ yyval = (DSQL_NOD) NULL; }	6427	{ yyval = (DSQL_NOD) NULL; }
Lines 7541-7567 Link Here
7541	case 507:	7541	case 507:
7542	{	7542	{
7543	lex.g_field->fld_dtype = dtype_blob;	7543	lex.g_field->fld_dtype = dtype_blob;
7544	lex.g_field->fld_seg_length = (USHORT) yyvsp[-1];	7544	lex.g_field->fld_seg_length = (USHORT)(IPTR) yyvsp[-1];
7545	lex.g_field->fld_sub_type = 0;	7545	lex.g_field->fld_sub_type = 0;
7546	}	7546	}
7547	break;	7547	break;
7548	case 508:	7548	case 508:
7549	{	7549	{
7550	lex.g_field->fld_dtype = dtype_blob;	7550	lex.g_field->fld_dtype = dtype_blob;
7551	lex.g_field->fld_seg_length = (USHORT) yyvsp[-3];	7551	lex.g_field->fld_seg_length = (USHORT)(IPTR) yyvsp[-3];
7552	lex.g_field->fld_sub_type = (USHORT) yyvsp[-1];	7552	lex.g_field->fld_sub_type = (USHORT)(IPTR) yyvsp[-1];
7553	}	7553	}
7554	break;	7554	break;
7555	case 509:	7555	case 509:
7556	{	7556	{
7557	lex.g_field->fld_dtype = dtype_blob;	7557	lex.g_field->fld_dtype = dtype_blob;
7558	lex.g_field->fld_seg_length = 80;	7558	lex.g_field->fld_seg_length = 80;
7559	lex.g_field->fld_sub_type = (USHORT) yyvsp[-1];	7559	lex.g_field->fld_sub_type = (USHORT)(IPTR) yyvsp[-1];
7560	}	7560	}
7561	break;	7561	break;
7562	case 510:	7562	case 510:
7563	{	7563	{
7564	lex.g_field->fld_seg_length = (USHORT) yyvsp[0];	7564	lex.g_field->fld_seg_length = (USHORT)(IPTR) yyvsp[0];
7565	}	7565	}
7566	break;	7566	break;
7567	case 511:	7567	case 511:
Lines 7571-7577 Link Here
7571	break;	7571	break;
7572	case 512:	7572	case 512:
7573	{	7573	{
7574	lex.g_field->fld_sub_type = (USHORT) yyvsp[0];	7574	lex.g_field->fld_sub_type = (USHORT)(IPTR) yyvsp[0];
7575	}	7575	}
7576	break;	7576	break;
7577	case 513:	7577	case 513:
Lines 7592-7598 Link Here
7592	case 517:	7592	case 517:
7593	{	7593	{
7594	lex.g_field->fld_dtype = dtype_text;	7594	lex.g_field->fld_dtype = dtype_text;
7595	lex.g_field->fld_character_length = (USHORT) yyvsp[-1];	7595	lex.g_field->fld_character_length = (USHORT)(IPTR) yyvsp[-1];
7596	lex.g_field->fld_flags \|= FLD_national;	7596	lex.g_field->fld_flags \|= FLD_national;
7597	}	7597	}
7598	break;	7598	break;
Lines 7606-7619 Link Here
7606	case 519:	7606	case 519:
7607	{	7607	{
7608	lex.g_field->fld_dtype = dtype_varying;	7608	lex.g_field->fld_dtype = dtype_varying;
7609	lex.g_field->fld_character_length = (USHORT) yyvsp[-1];	7609	lex.g_field->fld_character_length = (USHORT)(IPTR) yyvsp[-1];
7610	lex.g_field->fld_flags \|= FLD_national;	7610	lex.g_field->fld_flags \|= FLD_national;
7611	}	7611	}
7612	break;	7612	break;
7613	case 520:	7613	case 520:
7614	{	7614	{
7615	lex.g_field->fld_dtype = dtype_text;	7615	lex.g_field->fld_dtype = dtype_text;
7616	lex.g_field->fld_character_length = (USHORT) yyvsp[-1];	7616	lex.g_field->fld_character_length = (USHORT)(IPTR) yyvsp[-1];
7617	}	7617	}
7618	break;	7618	break;
7619	case 521:	7619	case 521:
Lines 7625-7631 Link Here
7625	case 522:	7625	case 522:
7626	{	7626	{
7627	lex.g_field->fld_dtype = dtype_varying;	7627	lex.g_field->fld_dtype = dtype_varying;
7628	lex.g_field->fld_character_length = (USHORT) yyvsp[-1];	7628	lex.g_field->fld_character_length = (USHORT)(IPTR) yyvsp[-1];
7629	}	7629	}
7630	break;	7630	break;
7631	case 531:	7631	case 531:
Lines 7705-7711 Link Here
7705	lex.g_field->fld_dtype = dtype_long;	7705	lex.g_field->fld_dtype = dtype_long;
7706	lex.g_field->fld_length = sizeof (SLONG);	7706	lex.g_field->fld_length = sizeof (SLONG);
7707	}	7707	}
7708	lex.g_field->fld_precision = (USHORT) yyvsp[-1];	7708	lex.g_field->fld_precision = (USHORT)(IPTR) yyvsp[-1];
7709	}	7709	}
7710	break;	7710	break;
7711	case 536:	7711	case 536:
Lines 7765-7772 Link Here
7765	lex.g_field->fld_length = sizeof (SLONG);	7765	lex.g_field->fld_length = sizeof (SLONG);
7766	}	7766	}
7767	}	7767	}
7768	lex.g_field->fld_precision = (USHORT) yyvsp[-3];	7768	lex.g_field->fld_precision = (USHORT)(IPTR) yyvsp[-3];
7769	lex.g_field->fld_scale = - (SSHORT) yyvsp[-1];	7769	lex.g_field->fld_scale = - (SSHORT)(IPTR) yyvsp[-1];
7770	}	7770	}
7771	break;	7771	break;
7772	case 539:	7772	case 539:
Lines 7932-7938 Link Here
7932	{ yyval = make_node (nod_table_lock, (int) 2, make_list (yyvsp[-1]), yyvsp[0]); }	7932	{ yyval = make_node (nod_table_lock, (int) 2, make_list (yyvsp[-1]), yyvsp[0]); }
7933	break;	7933	break;
7934	case 602:	7934	case 602:
7935	{ yyval = make_flag_node (nod_lock_mode, (SSHORT) ((SSHORT) yyvsp[-1] \| (SSHORT) yyvsp[0]), (SSHORT) 0, NULL); }	7935	{ yyval = make_flag_node (nod_lock_mode, (SSHORT) ((SSHORT)(IPTR) yyvsp[-1] \| (SSHORT)(IPTR) yyvsp[0]), (SSHORT) 0, NULL); }
7936	break;	7936	break;
7937	case 603:	7937	case 603:
7938	{ yyval = 0; }	7938	{ yyval = 0; }

Lines 35-46 Link Here

(-)firebird-1.5.3.4870/src/burp/std_desc.h.orig (-4 / +27 lines)
35	#include "firebird.h"	35	#include "firebird.h"
36		36
37	#ifdef WIN_NT	37	#ifdef WIN_NT
		38
38	#include <windows.h>	39	#include <windows.h>
39	#define GBAK_STDIN_DESC GetStdHandle(STD_INPUT_HANDLE) /* standart input file descriptor */	40
40	#define GBAK_STDOUT_DESC GetStdHandle(STD_OUTPUT_HANDLE) /* standart output file descriptor */	41	typedef HANDLE DESC;
		42
		43	static inline DESC GBAK_STDIN_DESC(void)
		44	{
		45	return GetStdHandle(STD_INPUT_HANDLE); // standard input file descriptor
		46	}
		47	static inline DESC GBAK_STDOUT_DESC(void)
		48	{
		49	return GetStdHandle(STD_OUTPUT_HANDLE); // standard output file descriptor
		50	}
		51
41	#else //WIN_NT	52	#else //WIN_NT
42	#define GBAK_STDIN_DESC (int)0 /* standart input file descriptor */	53
43	#define GBAK_STDOUT_DESC (int)1 /* standart output file descriptor */	54	typedef int DESC;
		55
		56	static inline DESC GBAK_STDIN_DESC(void)
		57	{
		58	return 0; // standard input file descriptor
		59	}
		60	static inline DESC GBAK_STDOUT_DESC(void)
		61	{
		62	return 1; // standard output file descriptor
		63	}
		64
		65	const int INVALID_HANDLE_VALUE = -1;
		66
44	#endif //WIN_NT	67	#endif //WIN_NT
45		68
46	#endif //GBAK_STD_DESC_H	69	#endif //GBAK_STD_DESC_H

Lines 730-737 Link Here

(-)firebird-1.5.3.4870/src/jrd/rse.cpp.orig (-5 / +5 lines)
730	/* Initialize the record number of each stream in the union */	730	/* Initialize the record number of each stream in the union */
731		731
732	ptr = &rsb->rsb_arg[rsb->rsb_count];	732	ptr = &rsb->rsb_arg[rsb->rsb_count];
733	for (end = ptr + (USHORT) * ptr; ++ptr <= end;)	733	for (end = ptr + (USHORT)(IPTR) * ptr; ++ptr <= end;)
734	request->req_rpb[(USHORT) * ptr].rpb_number = -1;	734	request->req_rpb[(USHORT)(IPTR) * ptr].rpb_number = -1;
735		735
736	rsb = rsb->rsb_arg[0];	736	rsb = rsb->rsb_arg[0];
737	}	737	}
Lines 2914-2920 Link Here
2914	request = tdbb->tdbb_request;	2914	request = tdbb->tdbb_request;
2915	stack = (LLS) rsb->rsb_arg[streams];	2915	stack = (LLS) rsb->rsb_arg[streams];
2916	for (; stack; stack = stack->lls_next) {	2916	for (; stack; stack = stack->lls_next) {
2917	rpb = &request->req_rpb[(USHORT) stack->lls_object];	2917	rpb = &request->req_rpb[(USHORT)(IPTR) stack->lls_object];
2918		2918
2919	/* Make sure a record block has been allocated. If there isn't	2919	/* Make sure a record block has been allocated. If there isn't
2920	one, first find the format, then allocate the record block */	2920	one, first find the format, then allocate the record block */
Lines 2972-2978 Link Here
2972	list that contains the data to send back	2972	list that contains the data to send back
2973	*/	2973	*/
2974	if (IS_INTL_DATA(&item->smb_desc) &&	2974	if (IS_INTL_DATA(&item->smb_desc) &&
2975	(USHORT) item->smb_desc.dsc_address <	2975	(USHORT)(IPTR) item->smb_desc.dsc_address <
2976	map->smb_key_length * sizeof(ULONG)) continue;	2976	map->smb_key_length * sizeof(ULONG)) continue;
2977		2977
2978	rpb = &request->req_rpb[item->smb_stream];	2978	rpb = &request->req_rpb[item->smb_stream];
Lines 3238-3244 Link Here
3238	the sort record, then want to sort by language dependent order */	3238	the sort record, then want to sort by language dependent order */
3239		3239
3240	if (IS_INTL_DATA(&item->smb_desc) &&	3240	if (IS_INTL_DATA(&item->smb_desc) &&
3241	(USHORT) item->smb_desc.dsc_address <	3241	(USHORT)(IPTR) item->smb_desc.dsc_address <
3242	map->smb_key_length * sizeof(ULONG)) {	3242	map->smb_key_length * sizeof(ULONG)) {
3243	INTL_string_to_key(tdbb, INTL_INDEX_TYPE(&item->smb_desc),	3243	INTL_string_to_key(tdbb, INTL_INDEX_TYPE(&item->smb_desc),
3244	from, &to, FALSE);	3244	from, &to, FALSE);

Lines 380-386 Link Here

(-)firebird-1.5.3.4870/src/jrd/opt.cpp.orig (-40 / +40 lines)
380		380
381	if (node->nod_type != nod_rse)	381	if (node->nod_type != nod_rse)
382	{	382	{
383	stream = (USHORT) node->nod_arg[STREAM_INDEX(node)];	383	stream = (USHORT)(IPTR) node->nod_arg[STREAM_INDEX(node)];
384	assert(stream <= MAX_UCHAR);	384	assert(stream <= MAX_UCHAR);
385	assert(beds[0] < MAX_STREAMS && beds[0] < MAX_UCHAR);	385	assert(beds[0] < MAX_STREAMS && beds[0] < MAX_UCHAR);
386	beds[++beds[0]] = (UCHAR) stream;	386	beds[++beds[0]] = (UCHAR) stream;
Lines 400-406 Link Here
400	(USHORT) (key_streams[0] - i));	400	(USHORT) (key_streams[0] - i));
401	assert(local_streams[0] < MAX_STREAMS && local_streams[0] < MAX_UCHAR);	401	assert(local_streams[0] < MAX_STREAMS && local_streams[0] < MAX_UCHAR);
402	local_streams[++local_streams[0]] =	402	local_streams[++local_streams[0]] =
403	(UCHAR) node->nod_arg[e_uni_stream];	403	(UCHAR)(IPTR) node->nod_arg[e_uni_stream];
404	}	404	}
405	else if (node->nod_type == nod_aggregate) {	405	else if (node->nod_type == nod_aggregate) {
406	assert((int)node->nod_arg[e_agg_stream] <= MAX_STREAMS);	406	assert((int)node->nod_arg[e_agg_stream] <= MAX_STREAMS);
Lines 408-420 Link Here
408	rsb = gen_aggregate(tdbb, opt_, node);	408	rsb = gen_aggregate(tdbb, opt_, node);
409	assert(local_streams[0] < MAX_STREAMS && local_streams[0] < MAX_UCHAR);	409	assert(local_streams[0] < MAX_STREAMS && local_streams[0] < MAX_UCHAR);
410	local_streams[++local_streams[0]] =	410	local_streams[++local_streams[0]] =
411	(UCHAR) node->nod_arg[e_agg_stream];	411	(UCHAR)(IPTR) node->nod_arg[e_agg_stream];
412	}	412	}
413	else if (node->nod_type == nod_procedure) {	413	else if (node->nod_type == nod_procedure) {
414	rsb = gen_procedure(tdbb, opt_, node);	414	rsb = gen_procedure(tdbb, opt_, node);
415	assert(local_streams[0] < MAX_STREAMS && local_streams[0] < MAX_UCHAR);	415	assert(local_streams[0] < MAX_STREAMS && local_streams[0] < MAX_UCHAR);
416	local_streams[++local_streams[0]] =	416	local_streams[++local_streams[0]] =
417	(UCHAR) node->nod_arg[e_prc_stream];	417	(UCHAR)(IPTR) node->nod_arg[e_prc_stream];
418	}	418	}
419	else if (node->nod_type == nod_rse) {	419	else if (node->nod_type == nod_rse) {
420	compute_rse_streams(csb, (RSE) node, beds);	420	compute_rse_streams(csb, (RSE) node, beds);
Lines 895-901 Link Here
895		895
896	/* Make sure we have the correct stream */	896	/* Make sure we have the correct stream */
897		897
898	if ((USHORT) dbkey->nod_arg[0] != stream)	898	if ((USHORT)(IPTR) dbkey->nod_arg[0] != stream)
899	return NULL;	899	return NULL;
900		900
901	/* If this is a dbkey for the appropriate stream, it's invertable */	901	/* If this is a dbkey for the appropriate stream, it's invertable */
Lines 1687-1693 Link Here
1687	switch (node->nod_type) {	1687	switch (node->nod_type) {
1688	case nod_field:	1688	case nod_field:
1689		1689
1690	n = (USHORT) node->nod_arg[e_fld_stream];	1690	n = (USHORT)(IPTR) node->nod_arg[e_fld_stream];
1691		1691
1692	if (allowOnlyCurrentStream) {	1692	if (allowOnlyCurrentStream) {
1693	if (n != stream) {	1693	if (n != stream) {
Lines 1713-1719 Link Here
1713		1713
1714	case nod_dbkey:	1714	case nod_dbkey:
1715		1715
1716	n = (USHORT) node->nod_arg[0];	1716	n = (USHORT)(IPTR) node->nod_arg[0];
1717		1717
1718	if (allowOnlyCurrentStream) {	1718	if (allowOnlyCurrentStream) {
1719	if (n != stream) {	1719	if (n != stream) {
Lines 1784-1790 Link Here
1784		1784
1785	for (ptr = rse->rse_relation, end = ptr + rse->rse_count; ptr < end; ptr++) {	1785	for (ptr = rse->rse_relation, end = ptr + rse->rse_count; ptr < end; ptr++) {
1786	if ((*ptr)->nod_type != nod_rse) {	1786	if ((*ptr)->nod_type != nod_rse) {
1787	n = (USHORT) (ptr)->nod_arg[STREAM_INDEX((ptr))];	1787	n = (USHORT)(IPTR) (ptr)->nod_arg[STREAM_INDEX((ptr))];
1788	csb->csb_rpt[n].csb_flags \|= csb_active;	1788	csb->csb_rpt[n].csb_flags \|= csb_active;
1789	}	1789	}
1790	}	1790	}
Lines 1821-1827 Link Here
1821	{	1821	{
1822	if ((*ptr)->nod_type != nod_rse)	1822	if ((*ptr)->nod_type != nod_rse)
1823	{	1823	{
1824	n = (USHORT) (ptr)->nod_arg[STREAM_INDEX((ptr))];	1824	n = (USHORT)(IPTR) (ptr)->nod_arg[STREAM_INDEX((ptr))];
1825	csb->csb_rpt[n].csb_flags &= ~csb_active;	1825	csb->csb_rpt[n].csb_flags &= ~csb_active;
1826	}	1826	}
1827	}	1827	}
Lines 1862-1873 Link Here
1862		1862
1863	switch (node->nod_type) {	1863	switch (node->nod_type) {
1864	case nod_field:	1864	case nod_field:
1865	n = (USHORT) node->nod_arg[e_fld_stream];	1865	n = (USHORT)(IPTR) node->nod_arg[e_fld_stream];
1866	SET_DEP_BIT(dependencies, n);	1866	SET_DEP_BIT(dependencies, n);
1867	return;	1867	return;
1868		1868
1869	case nod_dbkey:	1869	case nod_dbkey:
1870	n = (USHORT) node->nod_arg[0];	1870	n = (USHORT)(IPTR) node->nod_arg[0];
1871	SET_DEP_BIT(dependencies, n);	1871	SET_DEP_BIT(dependencies, n);
1872	return;	1872	return;
1873		1873
Lines 1923-1929 Link Here
1923		1923
1924	for (ptr = rse->rse_relation, end = ptr + rse->rse_count; ptr < end; ptr++) {	1924	for (ptr = rse->rse_relation, end = ptr + rse->rse_count; ptr < end; ptr++) {
1925	if ((*ptr)->nod_type != nod_rse) {	1925	if ((*ptr)->nod_type != nod_rse) {
1926	n = (USHORT) (ptr)->nod_arg[STREAM_INDEX((ptr))];	1926	n = (USHORT)(IPTR) (ptr)->nod_arg[STREAM_INDEX((ptr))];
1927	CLEAR_DEP_BIT(dependencies, n);	1927	CLEAR_DEP_BIT(dependencies, n);
1928	}	1928	}
1929	}	1929	}
Lines 1951-1957 Link Here
1951		1951
1952	if (node->nod_type == nod_relation) {	1952	if (node->nod_type == nod_relation) {
1953	assert(streams[0] < MAX_STREAMS && streams[0] < MAX_UCHAR);	1953	assert(streams[0] < MAX_STREAMS && streams[0] < MAX_UCHAR);
1954	streams[++streams[0]] = (UCHAR) node->nod_arg[e_rel_stream];	1954	streams[++streams[0]] = (UCHAR)(IPTR) node->nod_arg[e_rel_stream];
1955	}	1955	}
1956	else if (node->nod_type == nod_union) {	1956	else if (node->nod_type == nod_union) {
1957	clauses = node->nod_arg[e_uni_clauses];	1957	clauses = node->nod_arg[e_uni_clauses];
Lines 1991-1997 Link Here
1991	node = *ptr;	1991	node = *ptr;
1992	if (node->nod_type != nod_rse) {	1992	if (node->nod_type != nod_rse) {
1993	assert(streams[0] < MAX_STREAMS && streams[0] < MAX_UCHAR);	1993	assert(streams[0] < MAX_STREAMS && streams[0] < MAX_UCHAR);
1994	streams[++streams[0]] = (UCHAR) node->nod_arg[STREAM_INDEX(node)];	1994	streams[++streams[0]] = (UCHAR)(IPTR) node->nod_arg[STREAM_INDEX(node)];
1995	}	1995	}
1996	else {	1996	else {
1997	compute_rse_streams(csb, (RSE) node, streams);	1997	compute_rse_streams(csb, (RSE) node, streams);
Lines 3289-3295 Link Here
3289	JRD_NOD dbkey_temp, ptr, end;	3289	JRD_NOD dbkey_temp, ptr, end;
3290	DEV_BLKCHK(dbkey, type_nod);	3290	DEV_BLKCHK(dbkey, type_nod);
3291	if (dbkey->nod_type == nod_dbkey) {	3291	if (dbkey->nod_type == nod_dbkey) {
3292	if ((USHORT) dbkey->nod_arg[0] == stream)	3292	if ((USHORT)(IPTR) dbkey->nod_arg[0] == stream)
3293	return dbkey;	3293	return dbkey;
3294	else {	3294	else {
3295	position = position + 1;	3295	position = position + 1;
Lines 3550-3556 Link Here
3550		3550
3551	temp[0]++;	3551	temp[0]++;
3552	relation_node = plan_node->nod_arg[e_retrieve_relation];	3552	relation_node = plan_node->nod_arg[e_retrieve_relation];
3553	temp[temp[0]] = (UCHAR) relation_node->nod_arg[e_rel_stream];	3553	temp[temp[0]] = (UCHAR)(IPTR) relation_node->nod_arg[e_rel_stream];
3554	}	3554	}
3555		3555
3556	// just because the user specified a join does not mean that	3556	// just because the user specified a join does not mean that
Lines 3724-3730 Link Here
3724	rsb->rsb_type = rsb_aggregate;	3724	rsb->rsb_type = rsb_aggregate;
3725	assert((int)node->nod_arg[e_agg_stream] <= MAX_STREAMS);	3725	assert((int)node->nod_arg[e_agg_stream] <= MAX_STREAMS);
3726	assert((int)node->nod_arg[e_agg_stream] <= MAX_UCHAR);	3726	assert((int)node->nod_arg[e_agg_stream] <= MAX_UCHAR);
3727	rsb->rsb_stream = (UCHAR) node->nod_arg[e_agg_stream];	3727	rsb->rsb_stream = (UCHAR)(IPTR) node->nod_arg[e_agg_stream];
3728	rsb->rsb_format = csb->csb_rpt[rsb->rsb_stream].csb_format;	3728	rsb->rsb_format = csb->csb_rpt[rsb->rsb_stream].csb_format;
3729	rsb->rsb_next = OPT_compile(tdbb, csb, rse, NULL);	3729	rsb->rsb_next = OPT_compile(tdbb, csb, rse, NULL);
3730	rsb->rsb_arg[0] = (RSB) node;	3730	rsb->rsb_arg[0] = (RSB) node;
Lines 4088-4095 Link Here
4088	idx->idx_rpt; ptr < end; ptr++, idx_tail++) {	4088	idx->idx_rpt; ptr < end; ptr++, idx_tail++) {
4089	node = *ptr;	4089	node = *ptr;
4090	if (node->nod_type != nod_field	4090	if (node->nod_type != nod_field
4091	\|\| (USHORT) node->nod_arg[e_fld_stream] != stream	4091	\|\| (USHORT)(IPTR) node->nod_arg[e_fld_stream] != stream
4092	\|\| (USHORT) node->nod_arg[e_fld_id] != idx_tail->idx_field	4092	\|\| (USHORT)(IPTR) node->nod_arg[e_fld_id] != idx_tail->idx_field
4093	\|\| ptr[2sort->nod_count] / do not use index if NULLS FIRST is used */	4093	\|\| ptr[2sort->nod_count] / do not use index if NULLS FIRST is used */
4094	#ifdef SCROLLABLE_CURSORS	4094	#ifdef SCROLLABLE_CURSORS
4095	)	4095	)
Lines 4249-4255 Link Here
4249	{	4249	{
4250	stream_ptr[i]->stream_rsb = NULL;	4250	stream_ptr[i]->stream_rsb = NULL;
4251	stream_ptr[i]->stream_num =	4251	stream_ptr[i]->stream_num =
4252	(USHORT) node->nod_arg[STREAM_INDEX(node)];	4252	(USHORT)(IPTR) node->nod_arg[STREAM_INDEX(node)];
4253	}	4253	}
4254	}	4254	}
4255		4255
Lines 4327-4336 Link Here
4327	SET_TDBB(tdbb);	4327	SET_TDBB(tdbb);
4328	csb = opt->opt_csb;	4328	csb = opt->opt_csb;
4329	procedure = MET_lookup_procedure_id(tdbb,	4329	procedure = MET_lookup_procedure_id(tdbb,
4330	(SSHORT)node->nod_arg[e_prc_procedure], FALSE, FALSE, 0);	4330	(SSHORT)(IPTR)node->nod_arg[e_prc_procedure], FALSE, FALSE, 0);
4331	rsb = FB_NEW_RPT(*tdbb->tdbb_default, RSB_PRC_count) Rsb();	4331	rsb = FB_NEW_RPT(*tdbb->tdbb_default, RSB_PRC_count) Rsb();
4332	rsb->rsb_type = rsb_procedure;	4332	rsb->rsb_type = rsb_procedure;
4333	rsb->rsb_stream = (UCHAR) node->nod_arg[e_prc_stream];	4333	rsb->rsb_stream = (UCHAR)(IPTR) node->nod_arg[e_prc_stream];
4334	rsb->rsb_procedure = procedure;	4334	rsb->rsb_procedure = procedure;
4335	rsb->rsb_format = procedure->prc_format;	4335	rsb->rsb_format = procedure->prc_format;
4336	rsb->rsb_impure = CMP_impure(csb, sizeof(struct irsb_procedure));	4336	rsb->rsb_impure = CMP_impure(csb, sizeof(struct irsb_procedure));
Lines 4943-4950 Link Here
4943	for (node_ptr = sort->nod_arg; node_ptr < end_node; node_ptr++) {	4943	for (node_ptr = sort->nod_arg; node_ptr < end_node; node_ptr++) {
4944	node = *node_ptr;	4944	node = *node_ptr;
4945	if (node->nod_type == nod_field	4945	if (node->nod_type == nod_field
4946	&& (USHORT) node->nod_arg[e_fld_stream] == *ptr	4946	&& (USHORT)(IPTR) node->nod_arg[e_fld_stream] == *ptr
4947	&& (USHORT) node->nod_arg[e_fld_id] == id) {	4947	&& (USHORT)(IPTR) node->nod_arg[e_fld_id] == id) {
4948	desc = &descriptor;	4948	desc = &descriptor;
4949	CMP_get_desc(tdbb, csb, node, desc);	4949	CMP_get_desc(tdbb, csb, node, desc);
4950	/* International type text has a computed key */	4950	/* International type text has a computed key */
Lines 5041-5048 Link Here
5041	map_item->smb_desc.dsc_address = (UCHAR *) map_length;	5041	map_item->smb_desc.dsc_address = (UCHAR *) map_length;
5042	map_length += desc->dsc_length;	5042	map_length += desc->dsc_length;
5043	if (node->nod_type == nod_field) {	5043	if (node->nod_type == nod_field) {
5044	map_item->smb_stream = (USHORT) node->nod_arg[e_fld_stream];	5044	map_item->smb_stream = (USHORT)(IPTR) node->nod_arg[e_fld_stream];
5045	map_item->smb_field_id = (USHORT) node->nod_arg[e_fld_id];	5045	map_item->smb_field_id = (USHORT)(IPTR) node->nod_arg[e_fld_id];
5046	}	5046	}
5047	}	5047	}
5048		5048
Lines 5054-5061 Link Here
5054	field has already been mentioned as a sort key, don't bother to repeat	5054	field has already been mentioned as a sort key, don't bother to repeat
5055	it. */	5055	it. */
5056	while (stream_stack) {	5056	while (stream_stack) {
5057	id = (USHORT) LLS_POP(&id_stack);	5057	id = (USHORT)(IPTR) LLS_POP(&id_stack);
5058	stream = (USHORT) LLS_POP(&stream_stack);	5058	stream = (USHORT)(IPTR) LLS_POP(&stream_stack);
5059	format = CMP_format(tdbb, csb, stream);	5059	format = CMP_format(tdbb, csb, stream);
5060	desc = &format->fmt_desc[id];	5060	desc = &format->fmt_desc[id];
5061	if (id >= format->fmt_count \|\| desc->dsc_length == 0)	5061	if (id >= format->fmt_count \|\| desc->dsc_length == 0)
Lines 5384-5390 Link Here
5384	rsb = FB_NEW_RPT(*tdbb->tdbb_default, count + nstreams + 1) Rsb();	5384	rsb = FB_NEW_RPT(*tdbb->tdbb_default, count + nstreams + 1) Rsb();
5385	rsb->rsb_type = rsb_union;	5385	rsb->rsb_type = rsb_union;
5386	rsb->rsb_count = count;	5386	rsb->rsb_count = count;
5387	rsb->rsb_stream = (UCHAR) union_node->nod_arg[e_uni_stream];	5387	rsb->rsb_stream = (UCHAR)(IPTR) union_node->nod_arg[e_uni_stream];
5388	rsb->rsb_format = csb->csb_rpt[rsb->rsb_stream].csb_format;	5388	rsb->rsb_format = csb->csb_rpt[rsb->rsb_stream].csb_format;
5389	rsb->rsb_impure = CMP_impure(csb, sizeof(struct irsb));	5389	rsb->rsb_impure = CMP_impure(csb, sizeof(struct irsb));
5390	rsb_ptr = rsb->rsb_arg;	5390	rsb_ptr = rsb->rsb_arg;
Lines 5926-5933 Link Here
5926	field = boolean->nod_arg[0];	5926	field = boolean->nod_arg[0];
5927	if (field->nod_type != nod_field)	5927	if (field->nod_type != nod_field)
5928	return NULL;	5928	return NULL;
5929	if ((USHORT) field->nod_arg[e_fld_stream] != stream \|\|	5929	if ((USHORT)(IPTR) field->nod_arg[e_fld_stream] != stream \|\|
5930	(USHORT) field->nod_arg[e_fld_id] != idx->idx_rpt[0].idx_field)	5930	(USHORT)(IPTR) field->nod_arg[e_fld_id] != idx->idx_rpt[0].idx_field)
5931	return NULL;	5931	return NULL;
5932	node = make_index_node(tdbb, relation, opt->opt_csb, idx);	5932	node = make_index_node(tdbb, relation, opt->opt_csb, idx);
5933	retrieval = (IRB) node->nod_arg[e_idx_retrieval];	5933	retrieval = (IRB) node->nod_arg[e_idx_retrieval];
Lines 5995-6002 Link Here
5995	return NULL;	5995	return NULL;
5996	}	5996	}
5997		5997
5998	if ((USHORT) field->nod_arg[e_fld_stream] != stream \|\|	5998	if ((USHORT)(IPTR) field->nod_arg[e_fld_stream] != stream \|\|
5999	(USHORT) field->nod_arg[e_fld_id] != idx->idx_rpt[0].idx_field	5999	(USHORT)(IPTR) field->nod_arg[e_fld_id] != idx->idx_rpt[0].idx_field
6000	\|\| !(idx->idx_rpt[0].idx_itype == idx_string	6000	\|\| !(idx->idx_rpt[0].idx_itype == idx_string
6001	\|\| idx->idx_rpt[0].idx_itype == idx_byte_array	6001	\|\| idx->idx_rpt[0].idx_itype == idx_byte_array
6002	\|\| idx->idx_rpt[0].idx_itype == idx_metadata	6002	\|\| idx->idx_rpt[0].idx_itype == idx_metadata
Lines 6094-6103 Link Here
6094	if (access_type) {	6094	if (access_type) {
6095	for (arg = access_type->nod_arg, end = arg + plan_count;	6095	for (arg = access_type->nod_arg, end = arg + plan_count;
6096	arg < end; arg += 3) {	6096	arg < end; arg += 3) {
6097	if (relation_id != (SSHORT) * arg)	6097	if (relation_id != (SSHORT)(IPTR) * arg)
6098	/* index %s cannot be used in the specified plan */	6098	/* index %s cannot be used in the specified plan */
6099	ERR_post(gds_index_unused, gds_arg_string, *(arg + 2), 0);	6099	ERR_post(gds_index_unused, gds_arg_string, *(arg + 2), 0);
6100	if (idx->idx_id == (USHORT) * (arg + 1))	6100	if (idx->idx_id == (USHORT)(IPTR) * (arg + 1))
6101	if (access_type->nod_type == nod_navigational)	6101	if (access_type->nod_type == nod_navigational)
6102	idx->idx_runtime_flags \|= idx_plan_navigate;	6102	idx->idx_runtime_flags \|= idx_plan_navigate;
6103	else /* nod_indices */	6103	else /* nod_indices */
Lines 6169-6181 Link Here
6169	If left side is still not a field, give up */	6169	If left side is still not a field, give up */
6170		6170
6171	if (match->nod_type != nod_field \|\|	6171	if (match->nod_type != nod_field \|\|
6172	(USHORT) match->nod_arg[e_fld_stream] != stream \|\|	6172	(USHORT)(IPTR) match->nod_arg[e_fld_stream] != stream \|\|
6173	!computable(opt->opt_csb, value, stream, true, false))	6173	!computable(opt->opt_csb, value, stream, true, false))
6174	{	6174	{
6175	match = value;	6175	match = value;
6176	value = boolean->nod_arg[0];	6176	value = boolean->nod_arg[0];
6177	if (match->nod_type != nod_field \|\|	6177	if (match->nod_type != nod_field \|\|
6178	(USHORT) match->nod_arg[e_fld_stream] != stream \|\|	6178	(USHORT)(IPTR) match->nod_arg[e_fld_stream] != stream \|\|
6179	!computable(opt->opt_csb, value, stream, true, false))	6179	!computable(opt->opt_csb, value, stream, true, false))
6180	{	6180	{
6181	return 0;	6181	return 0;
Lines 6194-6200 Link Here
6194	#ifdef EXPRESSION_INDICES	6194	#ifdef EXPRESSION_INDICES
6195	(idx->idx_expression \|\|	6195	(idx->idx_expression \|\|
6196	#endif	6196	#endif
6197	((USHORT) match->nod_arg[e_fld_id] == idx->idx_rpt[i].idx_field)	6197	((USHORT)(IPTR) match->nod_arg[e_fld_id] == idx->idx_rpt[i].idx_field)
6198	#ifdef EXPRESSION_INDICES	6198	#ifdef EXPRESSION_INDICES
6199	)	6199	)
6200	#endif	6200	#endif
Lines 6582-6588 Link Here
6582	return FALSE;	6582	return FALSE;
6583	for (streams = river->riv_streams, end =	6583	for (streams = river->riv_streams, end =
6584	streams + river->riv_count; streams < end; streams++)	6584	streams + river->riv_count; streams < end; streams++)
6585	if ((USHORT) node->nod_arg[e_fld_stream] == *streams)	6585	if ((USHORT)(IPTR) node->nod_arg[e_fld_stream] == *streams)
6586	return TRUE;	6586	return TRUE;
6587	return FALSE;	6587	return FALSE;
6588	}	6588	}
Lines 6779-6785 Link Here
6779	ptr < end; ptr++) {	6779	ptr < end; ptr++) {
6780	node = *ptr;	6780	node = *ptr;
6781	if (node->nod_type != nod_rse) {	6781	if (node->nod_type != nod_rse) {
6782	stream = (USHORT) node->nod_arg[STREAM_INDEX(node)];	6782	stream = (USHORT)(IPTR) node->nod_arg[STREAM_INDEX(node)];
6783	csb->csb_rpt[stream].csb_flags &= ~csb_active;	6783	csb->csb_rpt[stream].csb_flags &= ~csb_active;
6784	}	6784	}
6785	else	6785	else