Attachment #93546 for bug #120867

Lines 129-135 Link Here

(-)firebird-1.5.3.4870.old/src/alice/alice.cpp (-1 / +1 lines)
129	ALICE_gfix( service->svc_argc,	129	ALICE_gfix( service->svc_argc,
130	service->svc_argv,	130	service->svc_argv,
131	output_thread,	131	output_thread,
132	(SLONG) service);	132	(SLONG)(IPTR) service);
133		133
134	// Mark service thread as finished.	134	// Mark service thread as finished.
135	// If service is detached, cleanup memory being used by service.	135	// If service is detached, cleanup memory being used by service.

Lines 181-187 Link Here

(-)firebird-1.5.3.4870.old/src/burp/burp.cpp (-1 / +1 lines)
181	int exit_code;	181	int exit_code;
182		182
183	exit_code = BURP_gbak(service->svc_argc, service->svc_argv,	183	exit_code = BURP_gbak(service->svc_argc, service->svc_argv,
184	output_netware, (SLONG) service);	184	output_netware, (SLONG) (IPTR) service);
185		185
186	/* Mark service thread as finished. */	186	/* Mark service thread as finished. */
187	/* If service is detached, cleanup memory being used by service. */	187	/* If service is detached, cleanup memory being used by service. */

Lines 502-508 Link Here

(-)firebird-1.5.3.4870.old/src/burp/canonical.cpp (-1 / +1 lines)
502	UCHAR *p;	502	UCHAR *p;
503	SSHORT n;	503	SSHORT n;
504		504
505	p = buffer + (int) desc->dsc_address;	505	p = buffer + (int) (IPTR)desc->dsc_address;
506		506
507	switch (desc->dsc_dtype)	507	switch (desc->dsc_dtype)
508	{	508	{




	if (constant)
	{
		request->append_number(gds_dyn_trg_sequence,
				   (SSHORT)(SLONG)(IPTR) (constant ? constant->nod_arg[0] : 0));
	}

	if ((constant = node->nod_arg[e_cnstr_type]) != NULL)
	{
		const SSHORT type = (SSHORT)(SLONG)(IPTR) constant->nod_arg[0];
		request->append_number(gds_dyn_trg_type, type);
	}



			switch (element->nod_type) {
			case nod_file_length:
				start = (SLONG) (IPTR) (element->nod_arg[0]) + 1;
				break;

			default:


			case nod_group_commit_wait:
				request->append_uchar(gds_dyn_log_group_commit_wait);
				temp_long = (SLONG) (IPTR) (element->nod_arg[0]);
				request->append_ulong_with_length(temp_long);
				break;

			case nod_check_point_len:
				request->append_uchar(gds_dyn_log_check_point_length);
				temp_long = (SLONG) (IPTR) (element->nod_arg[0]);
				request->append_ulong_with_length(temp_long);
				break;

			case nod_num_log_buffers:
				request->append_uchar(gds_dyn_log_num_of_buffers);
				temp_short = (SSHORT)(SLONG) (IPTR) (element->nod_arg[0]);
				request->append_ushort_with_length(temp_short);
				break;

			case nod_log_buffer_size:
				request->append_uchar(gds_dyn_log_buffer_size);
				temp_short = (SSHORT)(SLONG) (IPTR) (element->nod_arg[0]);
				request->append_ushort_with_length(temp_short);
				break;


		request->append_number(gds_dyn_def_dimension, position);
		DSQL_NOD element = *ptr++;
		request->append_uchar(gds_dyn_dim_lower);
		SLONG lrange = (SLONG) (IPTR) (element->nod_arg[0]);
		request->append_ulong_with_length(lrange);
		element = *ptr;
		request->append_uchar(gds_dyn_dim_upper);
		SLONG hrange = (SLONG) (IPTR) (element->nod_arg[0]);
		request->append_ulong_with_length(hrange);
		request->append_uchar(gds_dyn_end);
		if (lrange >= hrange)

	request->append_cstring(gds_dyn_def_filter,
				((STR) (ptr[e_filter_name]))->str_data);
	request->append_number(gds_dyn_filter_in_subtype,
			   (SSHORT)(SLONG) (IPTR) ((ptr[e_filter_in_type])->nod_arg[0]));
	request->append_number(gds_dyn_filter_out_subtype,
			   (SSHORT)(SLONG) (IPTR) ((ptr[e_filter_out_type])->nod_arg[0]));
	request->append_cstring(gds_dyn_func_entry_point,
				((STR) (ptr[e_filter_entry_pt]))->str_data);
	request->append_cstring(gds_dyn_func_module_name,

				  gds_arg_gds, gds_dsql_shadow_number_err, 0);
	}

	request->append_number(gds_dyn_def_shadow, (SSHORT)(SLONG) (IPTR) (ptr[e_shadow_number]));
	request->append_cstring(gds_dyn_def_file, ((STR) (ptr[e_shadow_name]))->str_data);
	request->append_number(gds_dyn_shadow_man_auto,
			   (SSHORT)(SLONG) (IPTR) ((ptr[e_shadow_man_auto])->nod_arg[0]));
	request->append_number(gds_dyn_shadow_conditional,
			   (SSHORT)(SLONG) (IPTR) ((ptr[e_shadow_conditional])->nod_arg[0]));

	request->append_file_start(0);

	SLONG length = (SLONG) (IPTR) ptr[e_shadow_length];
	request->append_file_length(length);

	request->append_uchar(gds_dyn_end);


	if (constant = node->nod_arg[e_trg_active])
		request->append_number(gds_dyn_trg_inactive,
				   (SSHORT)(SLONG) (IPTR) constant->nod_arg[0]);

	if (constant = node->nod_arg[e_trg_position])
		request->append_number(gds_dyn_trg_sequence,
				   (SSHORT)(SLONG) (IPTR) constant->nod_arg[0]);

	if (constant = node->nod_arg[e_trg_type]) {
		request->append_number(gds_dyn_trg_type, (SSHORT)(SLONG) (IPTR) constant->nod_arg[0]);
		trig_type = (USHORT)(ULONG) (IPTR) constant->nod_arg[0];
	}
	else {
		assert(node->nod_type == nod_mod_trigger);

		for (DSQL_NOD* ptr = temp->nod_arg; ptr < end; ++ptr)
		{
			DSQL_NOD    message = *ptr;
			SSHORT number  = (SSHORT)(SLONG) (IPTR) message->nod_arg[e_msg_number];
			if (message->nod_type == nod_del_trigger_msg)
			{
				request->append_number(gds_dyn_delete_trigger_msg, number);

        // CVC: This is case of "returns <type> [by value|reference]"
		/* Some data types can not be returned as value */

		if (((int)(SLONG) (IPTR) (ret_val_ptr[1]->nod_arg[0]) == FUN_value) &&
			(field->fld_dtype == dtype_text ||
			 field->fld_dtype == dtype_varying ||
			 field->fld_dtype == dtype_cstring ||

        // CVC: This is case of "returns parameter <N>"


		position = (SSHORT)(SLONG) (IPTR) (ret_val_ptr[1]->nod_arg[0]);
		/* Function modifies an argument whose value is the function return value */

		if (!arguments || position > arguments->nod_count || position < 1) {

		if (field->fld_dtype == dtype_blob)
		{
        /* CVC: I need to test returning blobs by descriptor before allowing the        change there. For now, I ignore the return type specification. */
			BOOLEAN free_it = ((SSHORT)(SLONG) (IPTR) ret_val_ptr[1]->nod_arg[0] < 0);
			request->append_number(gds_dyn_def_function_arg, blob_position);
			request->append_number(gds_dyn_func_mechanism,
					   (SSHORT)(SLONG) ((free_it ? -1 : 1) * FUN_blob_struct));

		{
			request->append_number(gds_dyn_def_function_arg, (SSHORT) 0);
			request->append_number(gds_dyn_func_mechanism,
					   (SSHORT)(SLONG) (IPTR) (ret_val_ptr[1]->nod_arg[0]));
		}

		request->append_cstring(gds_dyn_function_name, udf_name);

			request->append_number(gds_dyn_def_function_arg, (SSHORT) position);

            if (param_node [e_udf_param_type]) {
                SSHORT arg_mechanism = (SSHORT)(SLONG) (IPTR) (param_node [e_udf_param_type]->nod_arg [0]);
				request->append_number(gds_dyn_func_mechanism, arg_mechanism);
            }
            else if (field->fld_dtype == dtype_blob) {

	if (constant)
	{
		request->append_number(gds_dyn_trg_sequence,
				   (SSHORT)(SLONG) (IPTR) (constant ? constant->nod_arg[0] : 0));
	}

	constant = node->nod_arg[e_cnstr_type];
	if (constant)
	{
		trig_type = (USHORT)(ULONG)(IPTR) constant->nod_arg[0];
		request->append_number(gds_dyn_trg_type, trig_type);
	}
	else


	case nod_del_shadow:
		request->append_number(gds_dyn_delete_shadow,
				   (SSHORT)(SLONG) (IPTR) (node->nod_arg[0]));
		request->append_uchar(gds_dyn_end);
		break;



		case nod_group_commit_wait:
			request->append_uchar(gds_dyn_log_group_commit_wait);
			temp_long = (SLONG)(IPTR) (element->nod_arg[0]);
			request->append_ulong_with_length(temp_long);
			break;

		case nod_check_point_len:
			request->append_uchar(gds_dyn_log_check_point_length);
			temp_long = (SLONG)(IPTR) (element->nod_arg[0]);
			request->append_ulong_with_length(temp_long);
			break;

		case nod_num_log_buffers:
			request->append_uchar(gds_dyn_log_num_of_buffers);
			temp_short = (SSHORT)(SLONG)(IPTR) (element->nod_arg[0]);
			request->append_ushort_with_length(temp_short);
			break;

		case nod_log_buffer_size:
			request->append_uchar(gds_dyn_log_buffer_size);
			temp_short = (SSHORT)(SLONG)(IPTR) (element->nod_arg[0]);
			request->append_ushort_with_length(temp_short);
			break;
		case nod_drop_log:

				const_node = element->nod_arg[e_mod_fld_pos_new_position];

                /* CVC: Since now the parser accepts pos=1..N, let's subtract one here. */
                constant = (SSHORT)(SLONG) (IPTR) const_node->nod_arg [0] - 1;

				request->append_cstring(gds_dyn_rel_name,
							relation_name->str_data);




			parameter = request->req_blob->blb_segment;
			PAR null = parameter->par_null;
			USHORT* ret_length =
				(USHORT *) (dsql_msg + (SLONG) (IPTR) null->par_user_desc.dsc_address);
			UCHAR* buffer = dsql_msg + (SLONG) (IPTR) parameter->par_user_desc.dsc_address;
			THREAD_EXIT;
			s = isc_get_segment(tdsql->tsql_status,
							GDS_REF(request->req_handle),

			parameter = request->req_blob->blb_segment;
			buffer =
				reinterpret_cast<SCHAR*>(
					dsql_msg + (SLONG) (IPTR) parameter->par_user_desc.dsc_address);
			THREAD_EXIT;
			s = isc_put_segment(tdsql->tsql_status,
							GDS_REF(request->req_handle),

	PAR parameter, null;

	if (node->nod_type == nod_constant)
		return (SSHORT)(SLONG) (IPTR) node->nod_arg[0];

	parameter = (PAR) node->nod_arg[e_par_parameter];
	if (null = parameter->par_null)

			 /* Make sure the message given to us is long enough */

			DSC    desc   = parameter->par_user_desc;
			USHORT length = (SLONG) (IPTR) desc.dsc_address + desc.dsc_length;
			if (length > msg_length)
				break;
			if (!desc.dsc_dtype)

			flag = NULL;
			if ((null = parameter->par_null) != NULL)
			{
				USHORT null_offset = (USHORT)(ULONG) (IPTR) (null->par_user_desc.dsc_address);
				length = null_offset + sizeof(SSHORT);
				if (length > msg_length)
					break;

				}
			}

			desc.dsc_address = dsql_msg + (SLONG) (IPTR) desc.dsc_address;
			if (!request)
				MOVD_move(&parameter->par_desc, &desc);
			else if (!flag || *flag >= 0)




	for (parameter = message->msg_parameters; parameter;
		 parameter = parameter->par_next)
			parameter->par_desc.dsc_address =
			message->msg_buffer + (SLONG) (IPTR) parameter->par_desc.dsc_address;
}



	case nod_exec_into:
		if (node->nod_arg[e_exec_into_block]) {
			STUFF(blr_label);
			STUFF((int)(SLONG) (IPTR) node->nod_arg[e_exec_into_number]);
		}
		STUFF(blr_exec_into);
		temp = node->nod_arg[e_exec_into_list];


    case nod_label:
        STUFF(blr_label);
        STUFF((int)(SLONG) (IPTR) node->nod_arg[e_label_number]);
        return;
	
    case nod_breakleave:
        STUFF(blr_leave);
        STUFF((int)(SLONG)(IPTR) node->nod_arg[e_breakleave_number]);
        return;

	case nod_store:


	case nod_abort:
		STUFF(blr_leave);
		STUFF((int)(SLONG) (IPTR) node->nod_arg[e_abrt_number]);
		return;

	case nod_start_savepoint:


	case nod_while:
		STUFF(blr_label);
		STUFF((int)(SLONG) (IPTR) node->nod_arg[e_while_number]);
		STUFF(blr_loop);
		STUFF(blr_begin);
		STUFF(blr_if);
		GEN_expr(request, node->nod_arg[e_while_cond]);
		GEN_statement(request, node->nod_arg[e_while_action]);
		STUFF(blr_leave);
		STUFF((int)(SLONG) (IPTR) node->nod_arg[e_while_number]);
		STUFF(blr_end);
		return;


	switch (node->nod_type) {
	case nod_sqlcode:
		STUFF(blr_sql_code);
		STUFF_WORD((USHORT)(ULONG) (IPTR) node->nod_arg[0]);
		return;

	case nod_gdscode:

       what loop is the user trying to abandon? */
    if (for_select->nod_arg [e_flp_action]) {
        STUFF (blr_label);
        STUFF ((int) (IPTR) for_select->nod_arg [e_flp_number]);
    }

/* Generate FOR loop */

	for (ptr = list->nod_arg, end = ptr + list->nod_count; ptr < end; ptr++) {
 		dsql_nod* nulls_placement = (*ptr)->nod_arg[e_order_nulls];
 		if (nulls_placement) {
 			switch ((SLONG) (IPTR) nulls_placement->nod_arg[0]) {
 				case NOD_NULLS_FIRST:
 					STUFF(blr_nullsfirst);
 					break;




		| set
		| update
		| KW_DEBUG signed_short_integer
			{ prepare_console_debug ((int)(IPTR) $2, &yydebug);
			  $$ = make_node (nod_null, (int) 0, NULL); }
		;


		| CSTRING '(' pos_short_integer ')' charset_clause
			{ 
			lex.g_field->fld_dtype = dtype_cstring; 
			lex.g_field->fld_character_length = (USHORT)(size_t) $3; }
		;

arg_desc_list1	: 

		;

logfile_attr	: KW_SIZE equals long_integer
			{ lex.g_file->fil_length = (SLONG)(IPTR) $3; }
/*
		| RAW_PARTITIONS equals pos_short_integer
			{ lex.g_file->fil_partitions = (SSHORT) $3; 

		;

file_clause	: STARTING file_clause_noise long_integer
			{ lex.g_file->fil_start = (SLONG)(IPTR) $3;}
		| LENGTH equals long_integer page_noise
			{ lex.g_file->fil_length = (SLONG)(IPTR) $3;}
		;

file_clause_noise :

		;

array_range	: signed_long_integer
	    		{ if ((SLONG)(IPTR) $1 < 1)
		     		$$ = make_node (nod_list, (int) 2, 
					MAKE_constant ((STR) $1, CONSTANT_SLONG), 
					MAKE_constant ((STR) 1, CONSTANT_SLONG)); 

		| BLOB '(' unsigned_short_integer ')'
			{ 
			lex.g_field->fld_dtype = dtype_blob; 
			lex.g_field->fld_seg_length = (USHORT)(size_t) $3;
			lex.g_field->fld_sub_type = 0;
			}
		| BLOB '(' unsigned_short_integer ',' signed_short_integer ')'
			{ 
			lex.g_field->fld_dtype = dtype_blob; 
			lex.g_field->fld_seg_length = (USHORT)(size_t) $3;
			lex.g_field->fld_sub_type = (USHORT)(size_t) $5;
			}
		| BLOB '(' ',' signed_short_integer ')'
			{ 
			lex.g_field->fld_dtype = dtype_blob; 
			lex.g_field->fld_seg_length = 80;
			lex.g_field->fld_sub_type = (USHORT)(size_t) $4;
			}
		;

blob_segsize	: SEGMENT KW_SIZE unsigned_short_integer
		  	{
			lex.g_field->fld_seg_length = (USHORT)(size_t) $3;
		  	}
		|
		  	{


blob_subtype	: SUB_TYPE signed_short_integer
			{
			lex.g_field->fld_sub_type = (USHORT)(size_t) $2;
			}
		| SUB_TYPE symbol_blob_subtype_name
			{

national_character_type	: national_character_keyword '(' pos_short_integer ')'
			{ 
			lex.g_field->fld_dtype = dtype_text; 
			lex.g_field->fld_character_length = (USHORT)(size_t) $3; 
			lex.g_field->fld_flags |= FLD_national;
			}
		| national_character_keyword

		| national_character_keyword VARYING '(' pos_short_integer ')'
			{ 
			lex.g_field->fld_dtype = dtype_varying; 
			lex.g_field->fld_character_length = (USHORT)(size_t) $4; 
			lex.g_field->fld_flags |= FLD_national;
			}
		;

character_type	: character_keyword '(' pos_short_integer ')'
			{ 
			lex.g_field->fld_dtype = dtype_text; 
			lex.g_field->fld_character_length = (USHORT)(size_t) $3; 
			}
		| character_keyword
			{ 

		| varying_keyword '(' pos_short_integer ')'
			{ 
			lex.g_field->fld_dtype = dtype_varying; 
			lex.g_field->fld_character_length = (USHORT)(size_t) $3; 
			}
		;


		    	}
		| '(' signed_long_integer ')'
			{         
			if ( ((SLONG)(IPTR) $2 < 1) || ((SLONG)(IPTR) $2 > 18) )
			    yyabandon (-842, isc_precision_err);
				/* Precision most be between 1 and 18. */ 
			if ((SLONG)(IPTR) $2 > 9)
			    {
			    if ( ( (client_dialect <= SQL_DIALECT_V5) &&
				   (db_dialect     >  SQL_DIALECT_V5) ) ||

			        }
			    }
			else 
			    if ((SLONG)(IPTR) $2 < 5)
			    	{
			    	lex.g_field->fld_dtype = dtype_short; 
			    	lex.g_field->fld_length = sizeof (SSHORT); 

			    	lex.g_field->fld_dtype = dtype_long; 
			    	lex.g_field->fld_length = sizeof (SLONG); 
			    	}
			lex.g_field->fld_precision = (USHORT)(size_t) $2;
			}
		| '(' signed_long_integer ',' signed_long_integer ')'
			{ 
			if ( ((SLONG)(IPTR) $2 < 1) || ((SLONG)(IPTR) $2 > 18) )
			    yyabandon (-842, isc_precision_err);
				/* Precision should be between 1 and 18 */ 
			if (((SLONG)(IPTR) $4 > (SLONG)(IPTR) $2) || ((SLONG)(IPTR) $4 < 0))
			    yyabandon (-842, isc_scale_nogt);
				/* Scale must be between 0 and precision */
			if ((SLONG)(IPTR) $2 > 9)
			    {
			    if ( ( (client_dialect <= SQL_DIALECT_V5) &&
				   (db_dialect     >  SQL_DIALECT_V5) ) ||

			    }
			else
			    {
			    if ((SLONG)(IPTR) $2 < 5)
			    	{
			    	lex.g_field->fld_dtype = dtype_short; 
			    	lex.g_field->fld_length = sizeof (SSHORT); 

			    	lex.g_field->fld_length = sizeof (SLONG); 
			    	}
			    }
			lex.g_field->fld_precision = (USHORT)(size_t) $2;
			lex.g_field->fld_scale = - (SSHORT)(size_t) $4;
			}
		;



float_type	: KW_FLOAT precision_opt
			{ 
			if ((SLONG)(IPTR) $2 > 7)
			    {
			    lex.g_field->fld_dtype = dtype_double;
			    lex.g_field->fld_length = sizeof (double); 

		;

table_lock	: FOR lock_type lock_mode
			{ $$ = make_flag_node (nod_lock_mode, (SSHORT) ((SSHORT)(size_t) $2 | (SSHORT)(size_t) $3), (SSHORT) 0, NULL); }
		|
			{ $$ = 0; }
		;


signed_short_integer	:	nonneg_short_integer
		| '-' neg_short_integer
			{ $$ = (DSQL_NOD) - (SLONG)(IPTR) $2; }
		;

nonneg_short_integer	: NUMBER
			{ if ((SLONG)(IPTR) $1 > SHRT_POS_MAX)
			    yyabandon (-842, isc_expec_short);
				/* Short integer expected */
			  $$ = $1;}
		;

neg_short_integer : NUMBER
			{ if ((SLONG)(IPTR) $1 > SHRT_NEG_MAX)
			    yyabandon (-842, isc_expec_short);
				/* Short integer expected */
			  $$ = $1;}
		;

pos_short_integer : nonneg_short_integer
			{ if ((SLONG)(IPTR) $1 == 0)
			    yyabandon (-842, isc_expec_positive);
				/* Positive number expected */
			  $$ = $1;}
		;

unsigned_short_integer : NUMBER
			{ if ((SLONG)(IPTR) $1 > SHRT_UNSIGNED_MAX)
			    yyabandon (-842, isc_expec_ushort);
				/* Unsigned short integer expected */
			  $$ = $1;}


signed_long_integer	:	long_integer
		| '-' long_integer
			{ $$ = (DSQL_NOD) - (SLONG)(IPTR) $2; }
		;

long_integer	: NUMBER


string_value_function	:  SUBSTRING '(' value FROM pos_short_integer ')'
				{ $$ = make_node (nod_substr, e_substr_count, $3,
					MAKE_constant ((STR) ((SLONG)(IPTR)($5) - 1), CONSTANT_SLONG),
					MAKE_constant ((STR) SHRT_POS_MAX, CONSTANT_SLONG)); }
			/* CVC: It was easier to provide a constant with maximum value if the
			third parameter -length- is ommitted than to chase and fix the functions
			that treat nod_substr as an aggregate and do not expect NULL arguments. */
			| SUBSTRING '(' value FROM pos_short_integer FOR nonneg_short_integer ')'
				{ $$ = make_node (nod_substr, e_substr_count, $3,
					MAKE_constant ((STR) ((SLONG)(IPTR)($5) - 1), CONSTANT_SLONG),
					MAKE_constant ((STR) ($7), CONSTANT_SLONG)); }
			| KW_UPPER '(' value ')'
				{ $$ = make_node (nod_upcase, 1, $3); }


    CHECK_BOUND(p);
    *p = 0;
    sym = HSHD_lookup (NULL_PTR, (TEXT *) string, (SSHORT)(size_t)(p - string), SYM_keyword, parser_version);
    if (sym)
	{
	/* 13 June 2003. Nickolay Samofatov




									  TRUE, TRUE,
									  /* Pass 0 here to restore older parameter 
										ordering behavior */
									  (USHORT)(ULONG)(IPTR) input->nod_arg[0]);
		return node;

	case nod_udf:

				}
				else {
					// we have Count(*)
					if (request->req_scope_level == (ULONG)(IPTR) node->nod_arg[1]) {
						aggregate = TRUE;
					}
				}

					(slist_node->nod_type == nod_list))
				{
					/* an select list is there */
					position = (ULONG)(IPTR) sub->nod_arg[0];
					if ((position < 1) || (position > (ULONG) slist_node->nod_count)) 
					{
						ERRD_post(gds_sqlerr, gds_arg_number, (SLONG) - 104,

		}

		if (node1->nod_type == nod_constant && node1->nod_desc.dsc_dtype == dtype_long) {
			position = (ULONG)(IPTR) (node1->nod_arg[0]);
			if ((position < 1) || !s_list || 
				(position > (ULONG) s_list->nod_count)) {
				ERRD_post(gds_sqlerr, gds_arg_number, (SLONG) - 104,

				ERRD_post(gds_sqlerr, gds_arg_number, (SLONG) - 104,
						  gds_arg_gds, gds_dsql_command_err, gds_arg_gds, gds_order_by_err,	/* invalid ORDER BY clause */
						  0);
			number = (SLONG)(IPTR) position->nod_arg[0];
			if (number < 1 || number > union_items->nod_count)
				ERRD_post(gds_sqlerr, gds_arg_number, (SLONG) - 104,
						  gds_arg_gds, gds_dsql_command_err, gds_arg_gds, gds_order_by_err,	/* invalid ORDER BY clause */

Lines 426-432 Link Here

(-)firebird-1.5.3.4870.old/src/dudley/generate.cpp (-1 / +1 lines)
426	case nod_abort:	426	case nod_abort:
427	CHECK_BLR(2);	427	CHECK_BLR(2);
428	STUFF(blr_leave);	428	STUFF(blr_leave);
429	STUFF((int) node->nod_arg[0]);	429	STUFF((int) (IPTR) node->nod_arg[0]);
430	return;	430	return;
431		431
432	case nod_erase:	432	case nod_erase:

Lines 244-250 Link Here

(-)firebird-1.5.3.4870.old/src/dudley/trn.cpp (-1 / +1 lines)
244	break;	244	break;
245		245
246	case act_d_shadow:	246	case act_d_shadow:
247	drop_shadow(dyn, (SLONG) (action->act_object));	247	drop_shadow(dyn, (SLONG)(IPTR) (action->act_object));
248	break;	248	break;
249		249
250	case act_m_trigger_msg:	250	case act_m_trigger_msg:

Lines 3877-3885 Link Here

(-)firebird-1.5.3.4870.old/src/jrd/jrd.cpp (-2 / +2 lines)
3877	{	3877	{
3878	if ( (node = csb->csb_rpt[i].csb_message) )	3878	if ( (node = csb->csb_rpt[i].csb_message) )
3879	{	3879	{
3880	if ((int) node->nod_arg[e_msg_number] == 0) {	3880	if ((int) (IPTR) node->nod_arg[e_msg_number] == 0) {
3881	in_message = node;	3881	in_message = node;
3882	} else if ((int) node->nod_arg[e_msg_number] == 1) {	3882	} else if ((int) (IPTR) node->nod_arg[e_msg_number] == 1) {
3883	out_message = node;	3883	out_message = node;
3884	}	3884	}
3885	}	3885	}




	for (loop = 0; loop < 20; loop++) {
		for (;;) {
			journal->jrn_channel = (int *) socket(AF_INET, SOCK_STREAM, 0);
			if ((int) (IPTR) journal->jrn_channel != -1)
				break;
			if (!SYSCALL_INTERRUPTED(errno)) {
				error(status_vector, journal, errno, "socket");

			return ret_val;
		}

		if (!connect((int) (IPTR) journal->jrn_channel, (sockaddr*)&address, sizeof(address)))
			break;

		sleep(3);

		if (loop < 16) {
			close((int) (IPTR) journal->jrn_channel);
			continue;
		}
		if (!SYSCALL_INTERRUPTED(errno)) {
			if (retry) {
				close((int) (IPTR) journal->jrn_channel);
				gds__free(journal);
				*ret_jrn = (JRN) NULL;
				return FB_SUCCESS;

			gds__free(journal);
			return FB_FAILURE;
		}
		close((int) (IPTR) journal->jrn_channel);
	}
#endif


		if (retry)
		{
#ifdef BSD_SOCKETS
			close((int) (IPTR) journal->jrn_channel);
#endif

#ifdef WIN_NT

    with us, so keep trying until successful.  */

	do {
		l = recv((int) (IPTR) journal->jrn_channel, (char *) reply, sizeof(struct jrnr), 0);
	} while (l < 0 && SYSCALL_INTERRUPTED(errno));

	if (l < 0) {

 **************************************/

#ifdef BSD_SOCKETS
	if (close((int) (IPTR) journal->jrn_channel) < 0) {
		error(status_vector, journal, errno, "close");
		return FB_FAILURE;
	}

    with us, so keep trying until successful.  */

	do {
		l = send((int) (IPTR) journal->jrn_channel, (char *) buffer, (int) length, 0);
	} while (l < 0 && SYSCALL_INTERRUPTED(errno));

	if (l < 0) {

Lines 87-94 Link Here

(-)firebird-1.5.3.4870.old/src/jrd/lck.cpp (-2 / +2 lines)
87	#ifdef SUPERSERVER	87	#ifdef SUPERSERVER
88		88
89	#define LCK_OWNER_ID_PROCESS (SLONG) getpid()	89	#define LCK_OWNER_ID_PROCESS (SLONG) getpid()
90	#define LCK_OWNER_ID_DBB (SLONG) dbb	90	#define LCK_OWNER_ID_DBB (SLONG)(IPTR) dbb
91	#define LCK_OWNER_ID_ATT (SLONG) attachment	91	#define LCK_OWNER_ID_ATT (SLONG)(IPTR) attachment
92		92
93	#define LCK_OWNER_TYPE_PROCESS LCK_OWNER_process	93	#define LCK_OWNER_TYPE_PROCESS LCK_OWNER_process
94	#define LCK_OWNER_TYPE_DBB LCK_OWNER_dbb	94	#define LCK_OWNER_TYPE_DBB LCK_OWNER_dbb





	init_fetch(impure);
	idx =
		(IDX *) ((SCHAR *) impure + (SLONG) (IPTR) rsb->rsb_arg[RSB_NAV_idx_offset]);

/* The bitmap is only valid when we are continuing on in one 
   direction.  It is of no help when we change direction,

#ifdef SCROLLABLE_CURSORS
		MOVE_FAST(
				  (impure->irsb_nav_data +
				   (2 * (SLONG) (IPTR) rsb->rsb_arg[RSB_NAV_key_length])),
				  upper.key_data, upper.key_length);
#else
		MOVE_FAST(
				  (impure->irsb_nav_data +
				   (SLONG) (IPTR) rsb->rsb_arg[RSB_NAV_key_length]), upper.key_data,
				  upper.key_length);
#endif
	}

		lower.key_length = impure->irsb_nav_lower_length;
		MOVE_FAST(
				  (impure->irsb_nav_data +
				   (SLONG) (IPTR) rsb->rsb_arg[RSB_NAV_key_length]), lower.key_data,
				  lower.key_length);
	}


	tdbb = GET_THREAD_DATA;

	idx =
		(IDX *) ((SCHAR *) impure + (SLONG) (IPTR) rsb->rsb_arg[RSB_NAV_idx_offset]);
	page = (BTR) CCH_FETCH(tdbb, window, LCK_read, pag_index);

/* the outer loop goes through all the sibling pages

	tdbb = GET_THREAD_DATA;
	request = tdbb->tdbb_request;
	idx =
		(IDX *) ((SCHAR *) impure + (SLONG) (IPTR) rsb->rsb_arg[RSB_NAV_idx_offset]);

	BOOLEAN result;


				rpb->rpb_record,
				reinterpret_cast <
				struct idx *>((SCHAR *) impure +
							  (SLONG) (IPTR) rsb->rsb_arg[RSB_NAV_idx_offset]),
				&value,
				0);
		if (compare_keys(idx, key->key_data, key->key_length, &value, FALSE)) {

	retrieval_node = (JRD_NOD) rsb->rsb_arg[RSB_NAV_index];
	retrieval = (IRB) retrieval_node->nod_arg[e_idx_retrieval];
	idx =
		(IDX *) ((SCHAR *) impure + (SLONG) (IPTR) rsb->rsb_arg[RSB_NAV_idx_offset]);
	page =
		BTR_find_page(tdbb, retrieval, window, idx, &lower, &upper,
					  (direction == RSE_get_backward));

			impure->irsb_nav_upper_length = upper.key_length;
			MOVE_FAST(upper.key_data,
					  (impure->irsb_nav_data +
					   (SLONG) (IPTR) rsb->rsb_arg[RSB_NAV_key_length]),
					  upper.key_length);
		}
		if (retrieval->irb_lower_count)

			impure->irsb_nav_lower_length = lower.key_length;
			MOVE_FAST(lower.key_data,
					  (impure->irsb_nav_data +
					   (SLONG) (IPTR) rsb->rsb_arg[RSB_NAV_key_length]),
					  lower.key_length);
		}
		if (retrieval->irb_upper_count)




	}

	desc = msg_format->fmt_desc[msg_format->fmt_count - 1];
	desc.dsc_address = (UCHAR *) (om + (int) (IPTR) desc.dsc_address);
	eos_desc.dsc_dtype = dtype_short;
	eos_desc.dsc_scale = 0;
	eos_desc.dsc_length = sizeof(SSHORT);

	for (item = map->smb_rpt; item < end_item; item++) {
		flag = *(data + item->smb_flag_offset);
		from = item->smb_desc;
		from.dsc_address = data + (ULONG) (IPTR) from.dsc_address;
		if ((node = item->smb_node) && node->nod_type != nod_field)
			continue;


		end_item = map->smb_rpt + map->smb_count;
		for (item = map->smb_rpt; item < end_item; item++) {
			to = item->smb_desc;
			to.dsc_address = data + (ULONG) (IPTR) to.dsc_address;
			flag = FALSE;
			if (item->smb_node) {
				from = EVL_expr(tdbb, item->smb_node);

	desc2.dsc_flags = 0;
	desc2.dsc_address = (UCHAR *) & indicator;
	desc1 = *flag_desc;
	desc1.dsc_address = msg + (int) (IPTR) flag_desc->dsc_address;
	MOV_move(&desc1, &desc2);
	if (indicator) {
		SET_NULL(record, to_id);
		l = to_desc->dsc_length;
		p = record->rec_data + (int) (IPTR) to_desc->dsc_address;
		switch (to_desc->dsc_dtype) {
		case dtype_text:
			/* YYY - not necessarily the right thing to do */

	else {
		CLEAR_NULL(record, to_id);
		desc1 = *from_desc;
		desc1.dsc_address = msg + (int) (IPTR) desc1.dsc_address;
		desc2 = *to_desc;
		desc2.dsc_address = record->rec_data + (int) (IPTR) desc2.dsc_address;
		if (!DSC_EQUIV((&desc1), (&desc2)))
			MOV_move(&desc1, &desc2);


	if (!sfb_->sfb_file_name) {
		TEXT file_name[128];

		sfb_->sfb_file = (int) (IPTR) gds__temp_file(FALSE, SCRATCH, file_name);
		if (sfb_->sfb_file == -1)
			SORT_error(tdbb->tdbb_status_vector, sfb_, "open", isc_io_error,
					   errno);

Lines 1788-1794 Link Here

(-)firebird-1.5.3.4870.old/src/jrd/sort.cpp (-1 / +1 lines)
1788	/* Create a scratch file */	1788	/* Create a scratch file */
1789		1789
1790	sfb->sfb_file =	1790	sfb->sfb_file =
1791	(int) gds__temp_file(FALSE, SCRATCH, file_name,	1791	(int) (IPTR) gds__temp_file(FALSE, SCRATCH, file_name,
1792	sfb->sfb_dls->dls_directory, TRUE);	1792	sfb->sfb_dls->dls_directory, TRUE);
1793		1793
1794	/* allocate the file name even if the file is not open,	1794	/* allocate the file name even if the file is not open,





	if (node->nod_type == nod_rpt_average && node->nod_arg[e_stt_default])
		if (node->nod_desc.dsc_dtype == dtype_long)
			*(SLONG *) node->nod_desc.dsc_address /= (SLONG) (IPTR) node->
				nod_arg[e_stt_default];
		else
			*(double *) node->nod_desc.dsc_address /= (SLONG) (IPTR) node->
				nod_arg[e_stt_default];
}



/* If this is the first value, just move it in. */

	count = (SLONG) (IPTR) node->nod_arg[e_stt_default] + 1;
	if (count == 1) {
		if (desc2->dsc_missing)
			desc1->dsc_missing = DSC_missing;

	case nod_rpt_min:
	case nod_rpt_total:
	case nod_rpt_average:
		if (!(SLONG) (IPTR) node->nod_arg[e_stt_default])
			desc->dsc_missing = DSC_missing;

	case nod_rpt_count:

Lines 1830-1836 Link Here

(-)firebird-1.5.3.4870.old/src/qli/expand.cpp (-2 / +2 lines)
1830		1830
1831	}	1831	}
1832		1832
1833	item->itm_count = (int) syn_item->syn_arg[0];	1833	item->itm_count = (int)(IPTR) syn_item->syn_arg[0];
1834	return item;	1834	return item;
1835	}	1835	}
1836		1836
Lines 2131-2137 Link Here
2131	/* Handle implicit boolean from SQL xxx IN (yyy FROM relation) */	2131	/* Handle implicit boolean from SQL xxx IN (yyy FROM relation) */
2132		2132
2133	if (input->syn_arg[s_rse_outer]) {	2133	if (input->syn_arg[s_rse_outer]) {
2134	eql_node = MAKE_NODE((enum nod_t)(int)input->syn_arg[s_rse_op], 2);	2134	eql_node = MAKE_NODE((enum nod_t)(int)(IPTR)input->syn_arg[s_rse_op], 2);
2135	eql_node->nod_arg[0] =	2135	eql_node->nod_arg[0] =
2136	expand_expression(input->syn_arg[s_rse_outer], old_stack);	2136	expand_expression(input->syn_arg[s_rse_outer], old_stack);
2137	eql_node->nod_arg[1] =	2137	eql_node->nod_arg[1] =

Lines 1556-1562 Link Here

(-)firebird-1.5.3.4870.old/src/qli/gener.cpp (-2 / +2 lines)
1556		1556
1557	rlb = CHECK_RLB(request->req_blr);	1557	rlb = CHECK_RLB(request->req_blr);
1558		1558
1559	if ((NOD_T) (int) node->nod_arg[e_rse_join_type] == (NOD_T) 0)	1559	if ((NOD_T) (int) (IPTR) node->nod_arg[e_rse_join_type] == (NOD_T) 0)
1560	STUFF(blr_rse);	1560	STUFF(blr_rse);
1561	else	1561	else
1562	STUFF(blr_rs_stream);	1562	STUFF(blr_rs_stream);
Lines 1625-1631 Link Here
1625	if (list = node->nod_arg[e_rse_reduced])	1625	if (list = node->nod_arg[e_rse_reduced])
1626	gen_sort(list, request, blr_project);	1626	gen_sort(list, request, blr_project);
1627		1627
1628	join_type = (NOD_T) (int) node->nod_arg[e_rse_join_type];	1628	join_type = (NOD_T) (int) (IPTR) node->nod_arg[e_rse_join_type];
1629	if (join_type != (NOD_T) 0 && join_type != nod_join_inner) {	1629	if (join_type != (NOD_T) 0 && join_type != nod_join_inner) {
1630	STUFF(blr_join_type);	1630	STUFF(blr_join_type);
1631	if (join_type == nod_join_left)	1631	if (join_type == nod_join_left)

Lines 597-603 Link Here

(-)firebird-1.5.3.4870.old/src/qli/lex.cpp (-1 / +1 lines)
597	for (temp = QLI_line;	597	for (temp = QLI_line;
598	temp->line_next && QLI_statements;	598	temp->line_next && QLI_statements;
599	temp = temp->line_next)	599	temp = temp->line_next)
600	if (temp->line_next->line_position == (SLONG) QLI_statements->lls_object) return;	600	if (temp->line_next->line_position == (SLONG) (IPTR) QLI_statements->lls_object) return;
601		601
602	statement = (LLS) ALLOCP(type_lls);	602	statement = (LLS) ALLOCP(type_lls);
603	statement->lls_object = (BLK) temp->line_position;	603	statement->lls_object = (BLK) temp->line_position;




			IBERROR(176);		/* Msg176 No statements issued yet */

		if (MATCH(KW_ASTERISK))
			LEX_edit((SLONG) 0, (SLONG) (IPTR) statement_list->lls_object);
		else {
			if (KEYWORD(KW_SEMI))
				l = 1;

			for (start = stop = statement_list;
				 l && start->lls_next; l--, start = start->lls_next);
			command_end();
			LEX_edit((SLONG) (IPTR) start->lls_object, (SLONG) (IPTR) stop->lls_object);
		}
	}
#ifdef PYXIS

			node->syn_arg[0] = INT_CAST 1;
			if (op == nod_column || QLI_token->tok_type == tok_number)
				node->syn_arg[0] = INT_CAST parse_ordinal();
			if ((op == nod_skip) && ((int) (IPTR) node->syn_arg[0] < 1))
				SYNTAX_ERROR(478);	/* Msg478 number > 0 */
		}
		LLS_PUSH(node, &stack);

Lines 154-160 Link Here

(-)firebird-1.5.3.4870.old/src/qli/show.epp (-1 / +1 lines)
154	ptr = node->syn_arg;	154	ptr = node->syn_arg;
155		155
156	for (i = 0; i < node->syn_count; i++) {	156	for (i = 0; i < node->syn_count; i++) {
157	sw = (ENUM show_t) (int) * ptr++;	157	sw = (ENUM show_t) (int)(IPTR) * ptr++;
158	value = *ptr++;	158	value = *ptr++;
159	if (sw != show_matching_language &&	159	if (sw != show_matching_language &&
160	sw != show_version &&	160	sw != show_version &&

Lines 380-386 Link Here

(-)firebird-1.5.3.4870.old/src/remote/inet_server.cpp (-1 / +1 lines)
380	if (!debug) {	380	if (!debug) {
381	FD_ZERO(&mask);	381	FD_ZERO(&mask);
382	FD_SET(2, &mask);	382	FD_SET(2, &mask);
383	divorce_terminal((int) &mask);	383	divorce_terminal((int) (IPTR) &mask);
384	}	384	}
385	{	385	{
386	ISC_STATUS_ARRAY status_vector;	386	ISC_STATUS_ARRAY status_vector;

Lines 3231-3237 Link Here

(-)firebird-1.5.3.4870.old/src/remote/interface.cpp (-3 / +3 lines)
3231	// Nickolay Samofatov: We pass this value to the server (as 32-bit value)	3231	// Nickolay Samofatov: We pass this value to the server (as 32-bit value)
3232	// then it returns it to us and we do not use it. Maybe pass zero here	3232	// then it returns it to us and we do not use it. Maybe pass zero here
3233	// to avoid client-side security risks?	3233	// to avoid client-side security risks?
3234	event->p_event_ast = (SLONG) ast;	3234	event->p_event_ast = (SLONG)(IPTR) ast;
3235	event->p_event_arg = (SLONG)(IPTR) arg;	3235	event->p_event_arg = (SLONG)(IPTR) arg;
3236		3236
3237	event->p_event_rid = rem_event->rvnt_id;	3237	event->p_event_rid = rem_event->rvnt_id;
Lines 6226-6233 Link Here
6226	for (; to_desc < end_desc; from_desc++, to_desc++) {	6226	for (; to_desc < end_desc; from_desc++, to_desc++) {
6227	from = *from_desc;	6227	from = *from_desc;
6228	to = *to_desc;	6228	to = *to_desc;
6229	from.dsc_address = from_msg + (SLONG) from.dsc_address;	6229	from.dsc_address = from_msg + (SLONG)(IPTR) from.dsc_address;
6230	to.dsc_address = to_msg + (SLONG) to.dsc_address;	6230	to.dsc_address = to_msg + (SLONG)(IPTR) to.dsc_address;
6231	CVT_move(&from, &to, (FPTR_VOID) move_error);	6231	CVT_move(&from, &to, (FPTR_VOID) move_error);
6232	}	6232	}
6233		6233

Lines 984-990 Link Here

(-)firebird-1.5.3.4870.old/src/remote/protocol.cpp (-1 / +1 lines)
984	BLOB_PTR *p;	984	BLOB_PTR *p;
985	SSHORT n;	985	SSHORT n;
986		986
987	p = buffer + (ULONG) desc->dsc_address;	987	p = buffer + (ULONG) (IPTR) desc->dsc_address;
988		988
989	switch (desc->dsc_dtype) {	989	switch (desc->dsc_dtype) {
990	case dtype_text:	990	case dtype_text:

Lines 4361-4367 Link Here

(-)firebird-1.5.3.4870.old/src/remote/server.cpp (-1 / +1 lines)
4361		4361
4362	// Nickolay Samofatov: We keep this values and even pass them to the client	4362	// Nickolay Samofatov: We keep this values and even pass them to the client
4363	// (as 32-bit values) when event is fired, but client ignores them.	4363	// (as 32-bit values) when event is fired, but client ignores them.
4364	p_event->p_event_ast = (SLONG) event->rvnt_ast;	4364	p_event->p_event_ast = (SLONG)(IPTR) event->rvnt_ast;
4365	p_event->p_event_arg = (SLONG)(IPTR) event->rvnt_arg;	4365	p_event->p_event_arg = (SLONG)(IPTR) event->rvnt_arg;
4366		4366
4367	p_event->p_event_rid = event->rvnt_rid;	4367	p_event->p_event_rid = event->rvnt_rid;

Lines 96-102 Link Here

(-)firebird-1.5.3.4870.old/src/utilities/gsec.cpp (-1 / +1 lines)
96	int exit_code;	96	int exit_code;
97		97
98	exit_code = UTIL_gsec(service->svc_argc, service->svc_argv,	98	exit_code = UTIL_gsec(service->svc_argc, service->svc_argv,
99	output_svc, (SLONG) service);	99	output_svc, (SLONG) (IPTR) service);
100		100
101	/* Mark service thread as finished. */	101	/* Mark service thread as finished. */
102	/* If service is detached, cleanup memory being used by service. */	102	/* If service is detached, cleanup memory being used by service. */

Lines 199-205 Link Here

(-)firebird-1.5.3.4870.old/src/wal/walw.cpp (-1 / +1 lines)
199	#ifdef SUPERSERVER	199	#ifdef SUPERSERVER
200	int argc;	200	int argc;
201		201
202	argc = (int) argv[0];	202	argc = (int) (IPTR) argv[0];
203	#endif	203	#endif
204		204
205	dbname = "";	205	dbname = "";

Lines 626-632 Link Here

(-)firebird-1.5.3.4870.old/src/dudley/exe.epp (-1 / +1 lines)
626	break;	626	break;
627		627
628	case act_d_shadow:	628	case act_d_shadow:
629	drop_shadow((SLONG) action->act_object);	629	drop_shadow((SLONG) (IPTR) action->act_object);
630	break;	630	break;
631		631
632	case act_a_generator:	632	case act_a_generator:

Return to bug 120867

Lines 1136-1143 Link Here

(-)firebird-1.5.3.4870.old/src/dsql/dsql.cpp (-7 / +7 lines)
1136	parameter = request->req_blob->blb_segment;	1136	parameter = request->req_blob->blb_segment;
1137	PAR null = parameter->par_null;	1137	PAR null = parameter->par_null;
1138	USHORT* ret_length =	1138	USHORT* ret_length =
1139	(USHORT *) (dsql_msg + (SLONG) null->par_user_desc.dsc_address);	1139	(USHORT *) (dsql_msg + (SLONG) (IPTR) null->par_user_desc.dsc_address);
1140	UCHAR* buffer = dsql_msg + (SLONG) parameter->par_user_desc.dsc_address;	1140	UCHAR* buffer = dsql_msg + (SLONG) (IPTR) parameter->par_user_desc.dsc_address;
1141	THREAD_EXIT;	1141	THREAD_EXIT;
1142	s = isc_get_segment(tdsql->tsql_status,	1142	s = isc_get_segment(tdsql->tsql_status,
1143	GDS_REF(request->req_handle),	1143	GDS_REF(request->req_handle),
Lines 1314-1320 Link Here
1314	parameter = request->req_blob->blb_segment;	1314	parameter = request->req_blob->blb_segment;
1315	buffer =	1315	buffer =
1316	reinterpret_cast<SCHAR*>(	1316	reinterpret_cast<SCHAR*>(
1317	dsql_msg + (SLONG) parameter->par_user_desc.dsc_address);	1317	dsql_msg + (SLONG) (IPTR) parameter->par_user_desc.dsc_address);
1318	THREAD_EXIT;	1318	THREAD_EXIT;
1319	s = isc_put_segment(tdsql->tsql_status,	1319	s = isc_put_segment(tdsql->tsql_status,
1320	GDS_REF(request->req_handle),	1320	GDS_REF(request->req_handle),
Lines 3210-3216 Link Here
3210	PAR parameter, null;	3210	PAR parameter, null;
3211		3211
3212	if (node->nod_type == nod_constant)	3212	if (node->nod_type == nod_constant)
3213	return (SSHORT)(SLONG) node->nod_arg[0];	3213	return (SSHORT)(SLONG) (IPTR) node->nod_arg[0];
3214		3214
3215	parameter = (PAR) node->nod_arg[e_par_parameter];	3215	parameter = (PAR) node->nod_arg[e_par_parameter];
3216	if (null = parameter->par_null)	3216	if (null = parameter->par_null)
Lines 3976-3982 Link Here
3976	/* Make sure the message given to us is long enough */	3976	/* Make sure the message given to us is long enough */
3977		3977
3978	DSC desc = parameter->par_user_desc;	3978	DSC desc = parameter->par_user_desc;
3979	USHORT length = (SLONG) desc.dsc_address + desc.dsc_length;	3979	USHORT length = (SLONG) (IPTR) desc.dsc_address + desc.dsc_length;
3980	if (length > msg_length)	3980	if (length > msg_length)
3981	break;	3981	break;
3982	if (!desc.dsc_dtype)	3982	if (!desc.dsc_dtype)
Lines 3985-3991 Link Here
3985	flag = NULL;	3985	flag = NULL;
3986	if ((null = parameter->par_null) != NULL)	3986	if ((null = parameter->par_null) != NULL)
3987	{	3987	{
3988	USHORT null_offset = (USHORT)(ULONG) (null->par_user_desc.dsc_address);	3988	USHORT null_offset = (USHORT)(ULONG) (IPTR) (null->par_user_desc.dsc_address);
3989	length = null_offset + sizeof(SSHORT);	3989	length = null_offset + sizeof(SSHORT);
3990	if (length > msg_length)	3990	if (length > msg_length)
3991	break;	3991	break;
Lines 4000-4006 Link Here
4000	}	4000	}
4001	}	4001	}
4002		4002
4003	desc.dsc_address = dsql_msg + (SLONG) desc.dsc_address;	4003	desc.dsc_address = dsql_msg + (SLONG) (IPTR) desc.dsc_address;
4004	if (!request)	4004	if (!request)
4005	MOVD_move(&parameter->par_desc, &desc);	4005	MOVD_move(&parameter->par_desc, &desc);
4006	else if (!flag \|\| *flag >= 0)	4006	else if (!flag \|\| *flag >= 0)

Lines 636-642 Link Here

(-)firebird-1.5.3.4870.old/src/dsql/gen.cpp (-10 / +10 lines)
636	for (parameter = message->msg_parameters; parameter;	636	for (parameter = message->msg_parameters; parameter;
637	parameter = parameter->par_next)	637	parameter = parameter->par_next)
638	parameter->par_desc.dsc_address =	638	parameter->par_desc.dsc_address =
639	message->msg_buffer + (SLONG) parameter->par_desc.dsc_address;	639	message->msg_buffer + (SLONG) (IPTR) parameter->par_desc.dsc_address;
640	}	640	}
641		641
642		642
Lines 1021-1027 Link Here
1021	case nod_exec_into:	1021	case nod_exec_into:
1022	if (node->nod_arg[e_exec_into_block]) {	1022	if (node->nod_arg[e_exec_into_block]) {
1023	STUFF(blr_label);	1023	STUFF(blr_label);
1024	STUFF((int)(SLONG) node->nod_arg[e_exec_into_number]);	1024	STUFF((int)(SLONG) (IPTR) node->nod_arg[e_exec_into_number]);
1025	}	1025	}
1026	STUFF(blr_exec_into);	1026	STUFF(blr_exec_into);
1027	temp = node->nod_arg[e_exec_into_list];	1027	temp = node->nod_arg[e_exec_into_list];
Lines 1049-1060 Link Here
1049		1049
1050	case nod_label:	1050	case nod_label:
1051	STUFF(blr_label);	1051	STUFF(blr_label);
1052	STUFF((int)(SLONG) node->nod_arg[e_label_number]);	1052	STUFF((int)(SLONG) (IPTR) node->nod_arg[e_label_number]);
1053	return;	1053	return;
1054		1054
1055	case nod_breakleave:	1055	case nod_breakleave:
1056	STUFF(blr_leave);	1056	STUFF(blr_leave);
1057	STUFF((int)(SLONG) node->nod_arg[e_breakleave_number]);	1057	STUFF((int)(SLONG)(IPTR) node->nod_arg[e_breakleave_number]);
1058	return;	1058	return;
1059		1059
1060	case nod_store:	1060	case nod_store:
Lines 1069-1075 Link Here
1069		1069
1070	case nod_abort:	1070	case nod_abort:
1071	STUFF(blr_leave);	1071	STUFF(blr_leave);
1072	STUFF((int)(SLONG) node->nod_arg[e_abrt_number]);	1072	STUFF((int)(SLONG) (IPTR) node->nod_arg[e_abrt_number]);
1073	return;	1073	return;
1074		1074
1075	case nod_start_savepoint:	1075	case nod_start_savepoint:
Lines 1149-1162 Link Here
1149		1149
1150	case nod_while:	1150	case nod_while:
1151	STUFF(blr_label);	1151	STUFF(blr_label);
1152	STUFF((int)(SLONG) node->nod_arg[e_while_number]);	1152	STUFF((int)(SLONG) (IPTR) node->nod_arg[e_while_number]);
1153	STUFF(blr_loop);	1153	STUFF(blr_loop);
1154	STUFF(blr_begin);	1154	STUFF(blr_begin);
1155	STUFF(blr_if);	1155	STUFF(blr_if);
1156	GEN_expr(request, node->nod_arg[e_while_cond]);	1156	GEN_expr(request, node->nod_arg[e_while_cond]);
1157	GEN_statement(request, node->nod_arg[e_while_action]);	1157	GEN_statement(request, node->nod_arg[e_while_action]);
1158	STUFF(blr_leave);	1158	STUFF(blr_leave);
1159	STUFF((int)(SLONG) node->nod_arg[e_while_number]);	1159	STUFF((int)(SLONG) (IPTR) node->nod_arg[e_while_number]);
1160	STUFF(blr_end);	1160	STUFF(blr_end);
1161	return;	1161	return;
1162		1162
Lines 1556-1562 Link Here
1556	switch (node->nod_type) {	1556	switch (node->nod_type) {
1557	case nod_sqlcode:	1557	case nod_sqlcode:
1558	STUFF(blr_sql_code);	1558	STUFF(blr_sql_code);
1559	STUFF_WORD((USHORT)(ULONG) node->nod_arg[0]);	1559	STUFF_WORD((USHORT)(ULONG) (IPTR) node->nod_arg[0]);
1560	return;	1560	return;
1561		1561
1562	case nod_gdscode:	1562	case nod_gdscode:
Lines 1667-1673 Link Here
1667	what loop is the user trying to abandon? */	1667	what loop is the user trying to abandon? */
1668	if (for_select->nod_arg [e_flp_action]) {	1668	if (for_select->nod_arg [e_flp_action]) {
1669	STUFF (blr_label);	1669	STUFF (blr_label);
1670	STUFF ((int) for_select->nod_arg [e_flp_number]);	1670	STUFF ((int) (IPTR) for_select->nod_arg [e_flp_number]);
1671	}	1671	}
1672		1672
1673	/* Generate FOR loop */	1673	/* Generate FOR loop */
Lines 2546-2552 Link Here
2546	for (ptr = list->nod_arg, end = ptr + list->nod_count; ptr < end; ptr++) {	2546	for (ptr = list->nod_arg, end = ptr + list->nod_count; ptr < end; ptr++) {
2547	dsql_nod* nulls_placement = (*ptr)->nod_arg[e_order_nulls];	2547	dsql_nod* nulls_placement = (*ptr)->nod_arg[e_order_nulls];
2548	if (nulls_placement) {	2548	if (nulls_placement) {
2549	switch ((SLONG)nulls_placement->nod_arg[0]) {	2549	switch ((SLONG) (IPTR) nulls_placement->nod_arg[0]) {
2550	case NOD_NULLS_FIRST:	2550	case NOD_NULLS_FIRST:
2551	STUFF(blr_nullsfirst);	2551	STUFF(blr_nullsfirst);
2552	break;	2552	break;

Lines 642-648 Link Here

(-)firebird-1.5.3.4870.old/src/dsql/pass1.cpp (-5 / +5 lines)
642	TRUE, TRUE,	642	TRUE, TRUE,
643	/* Pass 0 here to restore older parameter	643	/* Pass 0 here to restore older parameter
644	ordering behavior */	644	ordering behavior */
645	(USHORT)(ULONG) input->nod_arg[0]);	645	(USHORT)(ULONG)(IPTR) input->nod_arg[0]);
646	return node;	646	return node;
647		647
648	case nod_udf:	648	case nod_udf:
Lines 1561-1567 Link Here
1561	}	1561	}
1562	else {	1562	else {
1563	// we have Count(*)	1563	// we have Count(*)
1564	if (request->req_scope_level == (ULONG) node->nod_arg[1]) {	1564	if (request->req_scope_level == (ULONG)(IPTR) node->nod_arg[1]) {
1565	aggregate = TRUE;	1565	aggregate = TRUE;
1566	}	1566	}
1567	}	1567	}
Lines 4426-4432 Link Here
4426	(slist_node->nod_type == nod_list))	4426	(slist_node->nod_type == nod_list))
4427	{	4427	{
4428	/* an select list is there */	4428	/* an select list is there */
4429	position = (ULONG) sub->nod_arg[0];	4429	position = (ULONG)(IPTR) sub->nod_arg[0];
4430	if ((position < 1) \|\| (position > (ULONG) slist_node->nod_count))	4430	if ((position < 1) \|\| (position > (ULONG) slist_node->nod_count))
4431	{	4431	{
4432	ERRD_post(gds_sqlerr, gds_arg_number, (SLONG) - 104,	4432	ERRD_post(gds_sqlerr, gds_arg_number, (SLONG) - 104,
Lines 4819-4825 Link Here
4819	}	4819	}
4820		4820
4821	if (node1->nod_type == nod_constant && node1->nod_desc.dsc_dtype == dtype_long) {	4821	if (node1->nod_type == nod_constant && node1->nod_desc.dsc_dtype == dtype_long) {
4822	position = (ULONG) (node1->nod_arg[0]);	4822	position = (ULONG)(IPTR) (node1->nod_arg[0]);
4823	if ((position < 1) \|\| !s_list \|\|	4823	if ((position < 1) \|\| !s_list \|\|
4824	(position > (ULONG) s_list->nod_count)) {	4824	(position > (ULONG) s_list->nod_count)) {
4825	ERRD_post(gds_sqlerr, gds_arg_number, (SLONG) - 104,	4825	ERRD_post(gds_sqlerr, gds_arg_number, (SLONG) - 104,
Lines 5082-5088 Link Here
5082	ERRD_post(gds_sqlerr, gds_arg_number, (SLONG) - 104,	5082	ERRD_post(gds_sqlerr, gds_arg_number, (SLONG) - 104,
5083	gds_arg_gds, gds_dsql_command_err, gds_arg_gds, gds_order_by_err, /* invalid ORDER BY clause */	5083	gds_arg_gds, gds_dsql_command_err, gds_arg_gds, gds_order_by_err, /* invalid ORDER BY clause */
5084	0);	5084	0);
5085	number = (SLONG) position->nod_arg[0];	5085	number = (SLONG)(IPTR) position->nod_arg[0];
5086	if (number < 1 \|\| number > union_items->nod_count)	5086	if (number < 1 \|\| number > union_items->nod_count)
5087	ERRD_post(gds_sqlerr, gds_arg_number, (SLONG) - 104,	5087	ERRD_post(gds_sqlerr, gds_arg_number, (SLONG) - 104,
5088	gds_arg_gds, gds_dsql_command_err, gds_arg_gds, gds_order_by_err, /* invalid ORDER BY clause */	5088	gds_arg_gds, gds_dsql_command_err, gds_arg_gds, gds_order_by_err, /* invalid ORDER BY clause */

Lines 836-842 Link Here

(-)firebird-1.5.3.4870.old/src/jrd/jrn.cpp (-9 / +9 lines)
836	for (loop = 0; loop < 20; loop++) {	836	for (loop = 0; loop < 20; loop++) {
837	for (;;) {	837	for (;;) {
838	journal->jrn_channel = (int *) socket(AF_INET, SOCK_STREAM, 0);	838	journal->jrn_channel = (int *) socket(AF_INET, SOCK_STREAM, 0);
839	if ((int) journal->jrn_channel != -1)	839	if ((int) (IPTR) journal->jrn_channel != -1)
840	break;	840	break;
841	if (!SYSCALL_INTERRUPTED(errno)) {	841	if (!SYSCALL_INTERRUPTED(errno)) {
842	error(status_vector, journal, errno, "socket");	842	error(status_vector, journal, errno, "socket");
Lines 859-876 Link Here
859	return ret_val;	859	return ret_val;
860	}	860	}
861		861
862	if (!connect((int) journal->jrn_channel, (sockaddr*)&address, sizeof(address)))	862	if (!connect((int) (IPTR) journal->jrn_channel, (sockaddr*)&address, sizeof(address)))
863	break;	863	break;
864		864
865	sleep(3);	865	sleep(3);
866		866
867	if (loop < 16) {	867	if (loop < 16) {
868	close((int) journal->jrn_channel);	868	close((int) (IPTR) journal->jrn_channel);
869	continue;	869	continue;
870	}	870	}
871	if (!SYSCALL_INTERRUPTED(errno)) {	871	if (!SYSCALL_INTERRUPTED(errno)) {
872	if (retry) {	872	if (retry) {
873	close((int) journal->jrn_channel);	873	close((int) (IPTR) journal->jrn_channel);
874	gds__free(journal);	874	gds__free(journal);
875	*ret_jrn = (JRN) NULL;	875	*ret_jrn = (JRN) NULL;
876	return FB_SUCCESS;	876	return FB_SUCCESS;
Lines 879-885 Link Here
879	gds__free(journal);	879	gds__free(journal);
880	return FB_FAILURE;	880	return FB_FAILURE;
881	}	881	}
882	close((int) journal->jrn_channel);	882	close((int) (IPTR) journal->jrn_channel);
883	}	883	}
884	#endif	884	#endif
885		885
Lines 939-945 Link Here
939	if (retry)	939	if (retry)
940	{	940	{
941	#ifdef BSD_SOCKETS	941	#ifdef BSD_SOCKETS
942	close((int) journal->jrn_channel);	942	close((int) (IPTR) journal->jrn_channel);
943	#endif	943	#endif
944		944
945	#ifdef WIN_NT	945	#ifdef WIN_NT
Lines 1056-1062 Link Here
1056	with us, so keep trying until successful. */	1056	with us, so keep trying until successful. */
1057		1057
1058	do {	1058	do {
1059	l = recv((int) journal->jrn_channel, (char *) reply, sizeof(struct jrnr), 0);	1059	l = recv((int) (IPTR) journal->jrn_channel, (char *) reply, sizeof(struct jrnr), 0);
1060	} while (l < 0 && SYSCALL_INTERRUPTED(errno));	1060	} while (l < 0 && SYSCALL_INTERRUPTED(errno));
1061		1061
1062	if (l < 0) {	1062	if (l < 0) {
Lines 1095-1101 Link Here
1095	**************************************/	1095	**************************************/
1096		1096
1097	#ifdef BSD_SOCKETS	1097	#ifdef BSD_SOCKETS
1098	if (close((int) journal->jrn_channel) < 0) {	1098	if (close((int) (IPTR) journal->jrn_channel) < 0) {
1099	error(status_vector, journal, errno, "close");	1099	error(status_vector, journal, errno, "close");
1100	return FB_FAILURE;	1100	return FB_FAILURE;
1101	}	1101	}
Lines 1166-1172 Link Here
1166	with us, so keep trying until successful. */	1166	with us, so keep trying until successful. */
1167		1167
1168	do {	1168	do {
1169	l = send((int) journal->jrn_channel, (char *) buffer, (int) length, 0);	1169	l = send((int) (IPTR) journal->jrn_channel, (char *) buffer, (int) length, 0);
1170	} while (l < 0 && SYSCALL_INTERRUPTED(errno));	1170	} while (l < 0 && SYSCALL_INTERRUPTED(errno));
1171		1171
1172	if (l < 0) {	1172	if (l < 0) {

Lines 487-493 Link Here

(-)firebird-1.5.3.4870.old/src/jrd/nav.cpp (-10 / +10 lines)
487		487
488	init_fetch(impure);	488	init_fetch(impure);
489	idx =	489	idx =
490	(IDX ) ((SCHAR ) impure + (SLONG) rsb->rsb_arg[RSB_NAV_idx_offset]);	490	(IDX ) ((SCHAR ) impure + (SLONG) (IPTR) rsb->rsb_arg[RSB_NAV_idx_offset]);
491		491
492	/* The bitmap is only valid when we are continuing on in one	492	/* The bitmap is only valid when we are continuing on in one
493	direction. It is of no help when we change direction,	493	direction. It is of no help when we change direction,
Lines 521-532 Link Here
521	#ifdef SCROLLABLE_CURSORS	521	#ifdef SCROLLABLE_CURSORS
522	MOVE_FAST(	522	MOVE_FAST(
523	(impure->irsb_nav_data +	523	(impure->irsb_nav_data +
524	(2 * (SLONG) rsb->rsb_arg[RSB_NAV_key_length])),	524	(2 * (SLONG) (IPTR) rsb->rsb_arg[RSB_NAV_key_length])),
525	upper.key_data, upper.key_length);	525	upper.key_data, upper.key_length);
526	#else	526	#else
527	MOVE_FAST(	527	MOVE_FAST(
528	(impure->irsb_nav_data +	528	(impure->irsb_nav_data +
529	(SLONG) rsb->rsb_arg[RSB_NAV_key_length]), upper.key_data,	529	(SLONG) (IPTR) rsb->rsb_arg[RSB_NAV_key_length]), upper.key_data,
530	upper.key_length);	530	upper.key_length);
531	#endif	531	#endif
532	}	532	}
Lines 534-540 Link Here
534	lower.key_length = impure->irsb_nav_lower_length;	534	lower.key_length = impure->irsb_nav_lower_length;
535	MOVE_FAST(	535	MOVE_FAST(
536	(impure->irsb_nav_data +	536	(impure->irsb_nav_data +
537	(SLONG) rsb->rsb_arg[RSB_NAV_key_length]), lower.key_data,	537	(SLONG) (IPTR) rsb->rsb_arg[RSB_NAV_key_length]), lower.key_data,
538	lower.key_length);	538	lower.key_length);
539	}	539	}
540		540
Lines 1404-1410 Link Here
1404	tdbb = GET_THREAD_DATA;	1404	tdbb = GET_THREAD_DATA;
1405		1405
1406	idx =	1406	idx =
1407	(IDX ) ((SCHAR ) impure + (SLONG) rsb->rsb_arg[RSB_NAV_idx_offset]);	1407	(IDX ) ((SCHAR ) impure + (SLONG) (IPTR) rsb->rsb_arg[RSB_NAV_idx_offset]);
1408	page = (BTR) CCH_FETCH(tdbb, window, LCK_read, pag_index);	1408	page = (BTR) CCH_FETCH(tdbb, window, LCK_read, pag_index);
1409		1409
1410	/* the outer loop goes through all the sibling pages	1410	/* the outer loop goes through all the sibling pages
Lines 1619-1625 Link Here
1619	tdbb = GET_THREAD_DATA;	1619	tdbb = GET_THREAD_DATA;
1620	request = tdbb->tdbb_request;	1620	request = tdbb->tdbb_request;
1621	idx =	1621	idx =
1622	(IDX ) ((SCHAR ) impure + (SLONG) rsb->rsb_arg[RSB_NAV_idx_offset]);	1622	(IDX ) ((SCHAR ) impure + (SLONG) (IPTR) rsb->rsb_arg[RSB_NAV_idx_offset]);
1623		1623
1624	BOOLEAN result;	1624	BOOLEAN result;
1625		1625
Lines 1656-1662 Link Here
1656	rpb->rpb_record,	1656	rpb->rpb_record,
1657	reinterpret_cast <	1657	reinterpret_cast <
1658	struct idx >((SCHAR ) impure +	1658	struct idx >((SCHAR ) impure +
1659	(SLONG) rsb->rsb_arg[RSB_NAV_idx_offset]),	1659	(SLONG) (IPTR) rsb->rsb_arg[RSB_NAV_idx_offset]),
1660	&value,	1660	&value,
1661	0);	1661	0);
1662	if (compare_keys(idx, key->key_data, key->key_length, &value, FALSE)) {	1662	if (compare_keys(idx, key->key_data, key->key_length, &value, FALSE)) {
Lines 1757-1763 Link Here
1757	retrieval_node = (JRD_NOD) rsb->rsb_arg[RSB_NAV_index];	1757	retrieval_node = (JRD_NOD) rsb->rsb_arg[RSB_NAV_index];
1758	retrieval = (IRB) retrieval_node->nod_arg[e_idx_retrieval];	1758	retrieval = (IRB) retrieval_node->nod_arg[e_idx_retrieval];
1759	idx =	1759	idx =
1760	(IDX ) ((SCHAR ) impure + (SLONG) rsb->rsb_arg[RSB_NAV_idx_offset]);	1760	(IDX ) ((SCHAR ) impure + (SLONG) (IPTR) rsb->rsb_arg[RSB_NAV_idx_offset]);
1761	page =	1761	page =
1762	BTR_find_page(tdbb, retrieval, window, idx, &lower, &upper,	1762	BTR_find_page(tdbb, retrieval, window, idx, &lower, &upper,
1763	(direction == RSE_get_backward));	1763	(direction == RSE_get_backward));
Lines 1802-1808 Link Here
1802	impure->irsb_nav_upper_length = upper.key_length;	1802	impure->irsb_nav_upper_length = upper.key_length;
1803	MOVE_FAST(upper.key_data,	1803	MOVE_FAST(upper.key_data,
1804	(impure->irsb_nav_data +	1804	(impure->irsb_nav_data +
1805	(SLONG) rsb->rsb_arg[RSB_NAV_key_length]),	1805	(SLONG) (IPTR) rsb->rsb_arg[RSB_NAV_key_length]),
1806	upper.key_length);	1806	upper.key_length);
1807	}	1807	}
1808	if (retrieval->irb_lower_count)	1808	if (retrieval->irb_lower_count)
Lines 1813-1819 Link Here
1813	impure->irsb_nav_lower_length = lower.key_length;	1813	impure->irsb_nav_lower_length = lower.key_length;
1814	MOVE_FAST(lower.key_data,	1814	MOVE_FAST(lower.key_data,
1815	(impure->irsb_nav_data +	1815	(impure->irsb_nav_data +
1816	(SLONG) rsb->rsb_arg[RSB_NAV_key_length]),	1816	(SLONG) (IPTR) rsb->rsb_arg[RSB_NAV_key_length]),
1817	lower.key_length);	1817	lower.key_length);
1818	}	1818	}
1819	if (retrieval->irb_upper_count)	1819	if (retrieval->irb_upper_count)

Lines 1126-1137 Link Here

(-)firebird-1.5.3.4870.old/src/dsql/ddl.cpp (-33 / +33 lines)
1126	if (constant)	1126	if (constant)
1127	{	1127	{
1128	request->append_number(gds_dyn_trg_sequence,	1128	request->append_number(gds_dyn_trg_sequence,
1129	(SSHORT)(SLONG) (constant ? constant->nod_arg[0] : 0));	1129	(SSHORT)(SLONG)(IPTR) (constant ? constant->nod_arg[0] : 0));
1130	}	1130	}
1131		1131
1132	if ((constant = node->nod_arg[e_cnstr_type]) != NULL)	1132	if ((constant = node->nod_arg[e_cnstr_type]) != NULL)
1133	{	1133	{
1134	const SSHORT type = (SSHORT)(SLONG) constant->nod_arg[0];	1134	const SSHORT type = (SSHORT)(SLONG)(IPTR) constant->nod_arg[0];
1135	request->append_number(gds_dyn_trg_type, type);	1135	request->append_number(gds_dyn_trg_type, type);
1136	}	1136	}
1137		1137
Lines 1270-1276 Link Here
1270		1270
1271	switch (element->nod_type) {	1271	switch (element->nod_type) {
1272	case nod_file_length:	1272	case nod_file_length:
1273	start = (SLONG) (element->nod_arg[0]) + 1;	1273	start = (SLONG) (IPTR) (element->nod_arg[0]) + 1;
1274	break;	1274	break;
1275		1275
1276	default:	1276	default:
Lines 1336-1360 Link Here
1336		1336
1337	case nod_group_commit_wait:	1337	case nod_group_commit_wait:
1338	request->append_uchar(gds_dyn_log_group_commit_wait);	1338	request->append_uchar(gds_dyn_log_group_commit_wait);
1339	temp_long = (SLONG) (element->nod_arg[0]);	1339	temp_long = (SLONG) (IPTR) (element->nod_arg[0]);
1340	request->append_ulong_with_length(temp_long);	1340	request->append_ulong_with_length(temp_long);
1341	break;	1341	break;
1342		1342
1343	case nod_check_point_len:	1343	case nod_check_point_len:
1344	request->append_uchar(gds_dyn_log_check_point_length);	1344	request->append_uchar(gds_dyn_log_check_point_length);
1345	temp_long = (SLONG) (element->nod_arg[0]);	1345	temp_long = (SLONG) (IPTR) (element->nod_arg[0]);
1346	request->append_ulong_with_length(temp_long);	1346	request->append_ulong_with_length(temp_long);
1347	break;	1347	break;
1348		1348
1349	case nod_num_log_buffers:	1349	case nod_num_log_buffers:
1350	request->append_uchar(gds_dyn_log_num_of_buffers);	1350	request->append_uchar(gds_dyn_log_num_of_buffers);
1351	temp_short = (SSHORT)(SLONG) (element->nod_arg[0]);	1351	temp_short = (SSHORT)(SLONG) (IPTR) (element->nod_arg[0]);
1352	request->append_ushort_with_length(temp_short);	1352	request->append_ushort_with_length(temp_short);
1353	break;	1353	break;
1354		1354
1355	case nod_log_buffer_size:	1355	case nod_log_buffer_size:
1356	request->append_uchar(gds_dyn_log_buffer_size);	1356	request->append_uchar(gds_dyn_log_buffer_size);
1357	temp_short = (SSHORT)(SLONG) (element->nod_arg[0]);	1357	temp_short = (SSHORT)(SLONG) (IPTR) (element->nod_arg[0]);
1358	request->append_ushort_with_length(temp_short);	1358	request->append_ushort_with_length(temp_short);
1359	break;	1359	break;
1360		1360
Lines 1637-1647 Link Here
1637	request->append_number(gds_dyn_def_dimension, position);	1637	request->append_number(gds_dyn_def_dimension, position);
1638	DSQL_NOD element = *ptr++;	1638	DSQL_NOD element = *ptr++;
1639	request->append_uchar(gds_dyn_dim_lower);	1639	request->append_uchar(gds_dyn_dim_lower);
1640	SLONG lrange = (SLONG) (element->nod_arg[0]);	1640	SLONG lrange = (SLONG) (IPTR) (element->nod_arg[0]);
1641	request->append_ulong_with_length(lrange);	1641	request->append_ulong_with_length(lrange);
1642	element = *ptr;	1642	element = *ptr;
1643	request->append_uchar(gds_dyn_dim_upper);	1643	request->append_uchar(gds_dyn_dim_upper);
1644	SLONG hrange = (SLONG) (element->nod_arg[0]);	1644	SLONG hrange = (SLONG) (IPTR) (element->nod_arg[0]);
1645	request->append_ulong_with_length(hrange);	1645	request->append_ulong_with_length(hrange);
1646	request->append_uchar(gds_dyn_end);	1646	request->append_uchar(gds_dyn_end);
1647	if (lrange >= hrange)	1647	if (lrange >= hrange)
Lines 2062-2070 Link Here
2062	request->append_cstring(gds_dyn_def_filter,	2062	request->append_cstring(gds_dyn_def_filter,
2063	((STR) (ptr[e_filter_name]))->str_data);	2063	((STR) (ptr[e_filter_name]))->str_data);
2064	request->append_number(gds_dyn_filter_in_subtype,	2064	request->append_number(gds_dyn_filter_in_subtype,
2065	(SSHORT)(SLONG) ((ptr[e_filter_in_type])->nod_arg[0]));	2065	(SSHORT)(SLONG) (IPTR) ((ptr[e_filter_in_type])->nod_arg[0]));
2066	request->append_number(gds_dyn_filter_out_subtype,	2066	request->append_number(gds_dyn_filter_out_subtype,
2067	(SSHORT)(SLONG) ((ptr[e_filter_out_type])->nod_arg[0]));	2067	(SSHORT)(SLONG) (IPTR) ((ptr[e_filter_out_type])->nod_arg[0]));
2068	request->append_cstring(gds_dyn_func_entry_point,	2068	request->append_cstring(gds_dyn_func_entry_point,
2069	((STR) (ptr[e_filter_entry_pt]))->str_data);	2069	((STR) (ptr[e_filter_entry_pt]))->str_data);
2070	request->append_cstring(gds_dyn_func_module_name,	2070	request->append_cstring(gds_dyn_func_module_name,
Lines 2670-2685 Link Here
2670	gds_arg_gds, gds_dsql_shadow_number_err, 0);	2670	gds_arg_gds, gds_dsql_shadow_number_err, 0);
2671	}	2671	}
2672		2672
2673	request->append_number(gds_dyn_def_shadow, (SSHORT)(SLONG) (ptr[e_shadow_number]));	2673	request->append_number(gds_dyn_def_shadow, (SSHORT)(SLONG) (IPTR) (ptr[e_shadow_number]));
2674	request->append_cstring(gds_dyn_def_file, ((STR) (ptr[e_shadow_name]))->str_data);	2674	request->append_cstring(gds_dyn_def_file, ((STR) (ptr[e_shadow_name]))->str_data);
2675	request->append_number(gds_dyn_shadow_man_auto,	2675	request->append_number(gds_dyn_shadow_man_auto,
2676	(SSHORT)(SLONG) ((ptr[e_shadow_man_auto])->nod_arg[0]));	2676	(SSHORT)(SLONG) (IPTR) ((ptr[e_shadow_man_auto])->nod_arg[0]));
2677	request->append_number(gds_dyn_shadow_conditional,	2677	request->append_number(gds_dyn_shadow_conditional,
2678	(SSHORT)(SLONG) ((ptr[e_shadow_conditional])->nod_arg[0]));	2678	(SSHORT)(SLONG) (IPTR) ((ptr[e_shadow_conditional])->nod_arg[0]));
2679		2679
2680	request->append_file_start(0);	2680	request->append_file_start(0);
2681		2681
2682	SLONG length = (SLONG) ptr[e_shadow_length];	2682	SLONG length = (SLONG) (IPTR) ptr[e_shadow_length];
2683	request->append_file_length(length);	2683	request->append_file_length(length);
2684		2684
2685	request->append_uchar(gds_dyn_end);	2685	request->append_uchar(gds_dyn_end);
Lines 2806-2820 Link Here
2806		2806
2807	if (constant = node->nod_arg[e_trg_active])	2807	if (constant = node->nod_arg[e_trg_active])
2808	request->append_number(gds_dyn_trg_inactive,	2808	request->append_number(gds_dyn_trg_inactive,
2809	(SSHORT)(SLONG) constant->nod_arg[0]);	2809	(SSHORT)(SLONG) (IPTR) constant->nod_arg[0]);
2810		2810
2811	if (constant = node->nod_arg[e_trg_position])	2811	if (constant = node->nod_arg[e_trg_position])
2812	request->append_number(gds_dyn_trg_sequence,	2812	request->append_number(gds_dyn_trg_sequence,
2813	(SSHORT)(SLONG) constant->nod_arg[0]);	2813	(SSHORT)(SLONG) (IPTR) constant->nod_arg[0]);
2814		2814
2815	if (constant = node->nod_arg[e_trg_type]) {	2815	if (constant = node->nod_arg[e_trg_type]) {
2816	request->append_number(gds_dyn_trg_type, (SSHORT)(SLONG) constant->nod_arg[0]);	2816	request->append_number(gds_dyn_trg_type, (SSHORT)(SLONG) (IPTR) constant->nod_arg[0]);
2817	trig_type = (USHORT)(ULONG) constant->nod_arg[0];	2817	trig_type = (USHORT)(ULONG) (IPTR) constant->nod_arg[0];
2818	}	2818	}
2819	else {	2819	else {
2820	assert(node->nod_type == nod_mod_trigger);	2820	assert(node->nod_type == nod_mod_trigger);
Lines 2893-2899 Link Here
2893	for (DSQL_NOD* ptr = temp->nod_arg; ptr < end; ++ptr)	2893	for (DSQL_NOD* ptr = temp->nod_arg; ptr < end; ++ptr)
2894	{	2894	{
2895	DSQL_NOD message = *ptr;	2895	DSQL_NOD message = *ptr;
2896	SSHORT number = (SSHORT)(SLONG) message->nod_arg[e_msg_number];	2896	SSHORT number = (SSHORT)(SLONG) (IPTR) message->nod_arg[e_msg_number];
2897	if (message->nod_type == nod_del_trigger_msg)	2897	if (message->nod_type == nod_del_trigger_msg)
2898	{	2898	{
2899	request->append_number(gds_dyn_delete_trigger_msg, number);	2899	request->append_number(gds_dyn_delete_trigger_msg, number);
Lines 2954-2960 Link Here
2954	// CVC: This is case of "returns <type> [by value\|reference]"	2954	// CVC: This is case of "returns <type> [by value\|reference]"
2955	/* Some data types can not be returned as value */	2955	/* Some data types can not be returned as value */
2956		2956
2957	if (((int)(SLONG) (ret_val_ptr[1]->nod_arg[0]) == FUN_value) &&	2957	if (((int)(SLONG) (IPTR) (ret_val_ptr[1]->nod_arg[0]) == FUN_value) &&
2958	(field->fld_dtype == dtype_text \|\|	2958	(field->fld_dtype == dtype_text \|\|
2959	field->fld_dtype == dtype_varying \|\|	2959	field->fld_dtype == dtype_varying \|\|
2960	field->fld_dtype == dtype_cstring \|\|	2960	field->fld_dtype == dtype_cstring \|\|
Lines 2998-3004 Link Here
2998	// CVC: This is case of "returns parameter <N>"	2998	// CVC: This is case of "returns parameter <N>"
2999		2999
3000		3000
3001	position = (SSHORT)(SLONG) (ret_val_ptr[1]->nod_arg[0]);	3001	position = (SSHORT)(SLONG) (IPTR) (ret_val_ptr[1]->nod_arg[0]);
3002	/* Function modifies an argument whose value is the function return value */	3002	/* Function modifies an argument whose value is the function return value */
3003		3003
3004	if (!arguments \|\| position > arguments->nod_count \|\| position < 1) {	3004	if (!arguments \|\| position > arguments->nod_count \|\| position < 1) {
Lines 3024-3030 Link Here
3024	if (field->fld_dtype == dtype_blob)	3024	if (field->fld_dtype == dtype_blob)
3025	{	3025	{
3026	/* CVC: I need to test returning blobs by descriptor before allowing the change there. For now, I ignore the return type specification. */	3026	/* CVC: I need to test returning blobs by descriptor before allowing the change there. For now, I ignore the return type specification. */
3027	BOOLEAN free_it = ((SSHORT)(SLONG) ret_val_ptr[1]->nod_arg[0] < 0);	3027	BOOLEAN free_it = ((SSHORT)(SLONG) (IPTR) ret_val_ptr[1]->nod_arg[0] < 0);
3028	request->append_number(gds_dyn_def_function_arg, blob_position);	3028	request->append_number(gds_dyn_def_function_arg, blob_position);
3029	request->append_number(gds_dyn_func_mechanism,	3029	request->append_number(gds_dyn_func_mechanism,
3030	(SSHORT)(SLONG) ((free_it ? -1 : 1) * FUN_blob_struct));	3030	(SSHORT)(SLONG) ((free_it ? -1 : 1) * FUN_blob_struct));
Lines 3035-3041 Link Here
3035	{	3035	{
3036	request->append_number(gds_dyn_def_function_arg, (SSHORT) 0);	3036	request->append_number(gds_dyn_def_function_arg, (SSHORT) 0);
3037	request->append_number(gds_dyn_func_mechanism,	3037	request->append_number(gds_dyn_func_mechanism,
3038	(SSHORT)(SLONG) (ret_val_ptr[1]->nod_arg[0]));	3038	(SSHORT)(SLONG) (IPTR) (ret_val_ptr[1]->nod_arg[0]));
3039	}	3039	}
3040		3040
3041	request->append_cstring(gds_dyn_function_name, udf_name);	3041	request->append_cstring(gds_dyn_function_name, udf_name);
Lines 3070-3076 Link Here
3070	request->append_number(gds_dyn_def_function_arg, (SSHORT) position);	3070	request->append_number(gds_dyn_def_function_arg, (SSHORT) position);
3071		3071
3072	if (param_node [e_udf_param_type]) {	3072	if (param_node [e_udf_param_type]) {
3073	SSHORT arg_mechanism = (SSHORT)(SLONG) (param_node [e_udf_param_type]->nod_arg [0]);	3073	SSHORT arg_mechanism = (SSHORT)(SLONG) (IPTR) (param_node [e_udf_param_type]->nod_arg [0]);
3074	request->append_number(gds_dyn_func_mechanism, arg_mechanism);	3074	request->append_number(gds_dyn_func_mechanism, arg_mechanism);
3075	}	3075	}
3076	else if (field->fld_dtype == dtype_blob) {	3076	else if (field->fld_dtype == dtype_blob) {
Lines 3677-3689 Link Here
3677	if (constant)	3677	if (constant)
3678	{	3678	{
3679	request->append_number(gds_dyn_trg_sequence,	3679	request->append_number(gds_dyn_trg_sequence,
3680	(SSHORT)(SLONG) (constant ? constant->nod_arg[0] : 0));	3680	(SSHORT)(SLONG) (IPTR) (constant ? constant->nod_arg[0] : 0));
3681	}	3681	}
3682		3682
3683	constant = node->nod_arg[e_cnstr_type];	3683	constant = node->nod_arg[e_cnstr_type];
3684	if (constant)	3684	if (constant)
3685	{	3685	{
3686	trig_type = (USHORT)(ULONG) constant->nod_arg[0];	3686	trig_type = (USHORT)(ULONG)(IPTR) constant->nod_arg[0];
3687	request->append_number(gds_dyn_trg_type, trig_type);	3687	request->append_number(gds_dyn_trg_type, trig_type);
3688	}	3688	}
3689	else	3689	else
Lines 4173-4179 Link Here
4173		4173
4174	case nod_del_shadow:	4174	case nod_del_shadow:
4175	request->append_number(gds_dyn_delete_shadow,	4175	request->append_number(gds_dyn_delete_shadow,
4176	(SSHORT)(SLONG) (node->nod_arg[0]));	4176	(SSHORT)(SLONG) (IPTR) (node->nod_arg[0]));
4177	request->append_uchar(gds_dyn_end);	4177	request->append_uchar(gds_dyn_end);
4178	break;	4178	break;
4179		4179
Lines 4611-4635 Link Here
4611		4611
4612	case nod_group_commit_wait:	4612	case nod_group_commit_wait:
4613	request->append_uchar(gds_dyn_log_group_commit_wait);	4613	request->append_uchar(gds_dyn_log_group_commit_wait);
4614	temp_long = (SLONG) (element->nod_arg[0]);	4614	temp_long = (SLONG)(IPTR) (element->nod_arg[0]);
4615	request->append_ulong_with_length(temp_long);	4615	request->append_ulong_with_length(temp_long);
4616	break;	4616	break;
4617		4617
4618	case nod_check_point_len:	4618	case nod_check_point_len:
4619	request->append_uchar(gds_dyn_log_check_point_length);	4619	request->append_uchar(gds_dyn_log_check_point_length);
4620	temp_long = (SLONG) (element->nod_arg[0]);	4620	temp_long = (SLONG)(IPTR) (element->nod_arg[0]);
4621	request->append_ulong_with_length(temp_long);	4621	request->append_ulong_with_length(temp_long);
4622	break;	4622	break;
4623		4623
4624	case nod_num_log_buffers:	4624	case nod_num_log_buffers:
4625	request->append_uchar(gds_dyn_log_num_of_buffers);	4625	request->append_uchar(gds_dyn_log_num_of_buffers);
4626	temp_short = (SSHORT)(SLONG) (element->nod_arg[0]);	4626	temp_short = (SSHORT)(SLONG)(IPTR) (element->nod_arg[0]);
4627	request->append_ushort_with_length(temp_short);	4627	request->append_ushort_with_length(temp_short);
4628	break;	4628	break;
4629		4629
4630	case nod_log_buffer_size:	4630	case nod_log_buffer_size:
4631	request->append_uchar(gds_dyn_log_buffer_size);	4631	request->append_uchar(gds_dyn_log_buffer_size);
4632	temp_short = (SSHORT)(SLONG) (element->nod_arg[0]);	4632	temp_short = (SSHORT)(SLONG)(IPTR) (element->nod_arg[0]);
4633	request->append_ushort_with_length(temp_short);	4633	request->append_ushort_with_length(temp_short);
4634	break;	4634	break;
4635	case nod_drop_log:	4635	case nod_drop_log:
Lines 5095-5101 Link Here
5095	const_node = element->nod_arg[e_mod_fld_pos_new_position];	5095	const_node = element->nod_arg[e_mod_fld_pos_new_position];
5096		5096
5097	/* CVC: Since now the parser accepts pos=1..N, let's subtract one here. */	5097	/* CVC: Since now the parser accepts pos=1..N, let's subtract one here. */
5098	constant = (SSHORT)(SLONG) const_node->nod_arg [0] - 1;	5098	constant = (SSHORT)(SLONG) (IPTR) const_node->nod_arg [0] - 1;
5099		5099
5100	request->append_cstring(gds_dyn_rel_name,	5100	request->append_cstring(gds_dyn_rel_name,
5101	relation_name->str_data);	5101	relation_name->str_data);

Lines 551-557 Link Here

(-)firebird-1.5.3.4870.old/src/dsql/parse.y (-37 / +37 lines)
551	\| set	551	\| set
552	\| update	552	\| update
553	\| KW_DEBUG signed_short_integer	553	\| KW_DEBUG signed_short_integer
554	{ prepare_console_debug ((int) $2, &yydebug);	554	{ prepare_console_debug ((int)(IPTR) $2, &yydebug);
555	$$ = make_node (nod_null, (int) 0, NULL); }	555	$$ = make_node (nod_null, (int) 0, NULL); }
556	;	556	;
557		557
Lines 753-759 Link Here
753	\| CSTRING '(' pos_short_integer ')' charset_clause	753	\| CSTRING '(' pos_short_integer ')' charset_clause
754	{	754	{
755	lex.g_field->fld_dtype = dtype_cstring;	755	lex.g_field->fld_dtype = dtype_cstring;
756	lex.g_field->fld_character_length = (USHORT) $3; }	756	lex.g_field->fld_character_length = (USHORT)(size_t) $3; }
757	;	757	;
758		758
759	arg_desc_list1 :	759	arg_desc_list1 :
Lines 1158-1164 Link Here
1158	;	1158	;
1159		1159
1160	logfile_attr : KW_SIZE equals long_integer	1160	logfile_attr : KW_SIZE equals long_integer
1161	{ lex.g_file->fil_length = (SLONG) $3; }	1161	{ lex.g_file->fil_length = (SLONG)(IPTR) $3; }
1162	/*	1162	/*
1163	\| RAW_PARTITIONS equals pos_short_integer	1163	\| RAW_PARTITIONS equals pos_short_integer
1164	{ lex.g_file->fil_partitions = (SSHORT) $3;	1164	{ lex.g_file->fil_partitions = (SSHORT) $3;
Lines 1178-1186 Link Here
1178	;	1178	;
1179		1179
1180	file_clause : STARTING file_clause_noise long_integer	1180	file_clause : STARTING file_clause_noise long_integer
1181	{ lex.g_file->fil_start = (SLONG) $3;}	1181	{ lex.g_file->fil_start = (SLONG)(IPTR) $3;}
1182	\| LENGTH equals long_integer page_noise	1182	\| LENGTH equals long_integer page_noise
1183	{ lex.g_file->fil_length = (SLONG) $3;}	1183	{ lex.g_file->fil_length = (SLONG)(IPTR) $3;}
1184	;	1184	;
1185		1185
1186	file_clause_noise :	1186	file_clause_noise :
Lines 2186-2192 Link Here
2186	;	2186	;
2187		2187
2188	array_range : signed_long_integer	2188	array_range : signed_long_integer
2189	{ if ((SLONG) $1 < 1)	2189	{ if ((SLONG)(IPTR) $1 < 1)
2190	$$ = make_node (nod_list, (int) 2,	2190	$$ = make_node (nod_list, (int) 2,
2191	MAKE_constant ((STR) $1, CONSTANT_SLONG),	2191	MAKE_constant ((STR) $1, CONSTANT_SLONG),
2192	MAKE_constant ((STR) 1, CONSTANT_SLONG));	2192	MAKE_constant ((STR) 1, CONSTANT_SLONG));
Lines 2292-2317 Link Here
2292	\| BLOB '(' unsigned_short_integer ')'	2292	\| BLOB '(' unsigned_short_integer ')'
2293	{	2293	{
2294	lex.g_field->fld_dtype = dtype_blob;	2294	lex.g_field->fld_dtype = dtype_blob;
2295	lex.g_field->fld_seg_length = (USHORT) $3;	2295	lex.g_field->fld_seg_length = (USHORT)(size_t) $3;
2296	lex.g_field->fld_sub_type = 0;	2296	lex.g_field->fld_sub_type = 0;
2297	}	2297	}
2298	\| BLOB '(' unsigned_short_integer ',' signed_short_integer ')'	2298	\| BLOB '(' unsigned_short_integer ',' signed_short_integer ')'
2299	{	2299	{
2300	lex.g_field->fld_dtype = dtype_blob;	2300	lex.g_field->fld_dtype = dtype_blob;
2301	lex.g_field->fld_seg_length = (USHORT) $3;	2301	lex.g_field->fld_seg_length = (USHORT)(size_t) $3;
2302	lex.g_field->fld_sub_type = (USHORT) $5;	2302	lex.g_field->fld_sub_type = (USHORT)(size_t) $5;
2303	}	2303	}
2304	\| BLOB '(' ',' signed_short_integer ')'	2304	\| BLOB '(' ',' signed_short_integer ')'
2305	{	2305	{
2306	lex.g_field->fld_dtype = dtype_blob;	2306	lex.g_field->fld_dtype = dtype_blob;
2307	lex.g_field->fld_seg_length = 80;	2307	lex.g_field->fld_seg_length = 80;
2308	lex.g_field->fld_sub_type = (USHORT) $4;	2308	lex.g_field->fld_sub_type = (USHORT)(size_t) $4;
2309	}	2309	}
2310	;	2310	;
2311		2311
2312	blob_segsize : SEGMENT KW_SIZE unsigned_short_integer	2312	blob_segsize : SEGMENT KW_SIZE unsigned_short_integer
2313	{	2313	{
2314	lex.g_field->fld_seg_length = (USHORT) $3;	2314	lex.g_field->fld_seg_length = (USHORT)(size_t) $3;
2315	}	2315	}
2316	\|	2316	\|
2317	{	2317	{
Lines 2321-2327 Link Here
2321		2321
2322	blob_subtype : SUB_TYPE signed_short_integer	2322	blob_subtype : SUB_TYPE signed_short_integer
2323	{	2323	{
2324	lex.g_field->fld_sub_type = (USHORT) $2;	2324	lex.g_field->fld_sub_type = (USHORT)(size_t) $2;
2325	}	2325	}
2326	\| SUB_TYPE symbol_blob_subtype_name	2326	\| SUB_TYPE symbol_blob_subtype_name
2327	{	2327	{
Lines 2347-2353 Link Here
2347	national_character_type : national_character_keyword '(' pos_short_integer ')'	2347	national_character_type : national_character_keyword '(' pos_short_integer ')'
2348	{	2348	{
2349	lex.g_field->fld_dtype = dtype_text;	2349	lex.g_field->fld_dtype = dtype_text;
2350	lex.g_field->fld_character_length = (USHORT) $3;	2350	lex.g_field->fld_character_length = (USHORT)(size_t) $3;
2351	lex.g_field->fld_flags \|= FLD_national;	2351	lex.g_field->fld_flags \|= FLD_national;
2352	}	2352	}
2353	\| national_character_keyword	2353	\| national_character_keyword
Lines 2359-2365 Link Here
2359	\| national_character_keyword VARYING '(' pos_short_integer ')'	2359	\| national_character_keyword VARYING '(' pos_short_integer ')'
2360	{	2360	{
2361	lex.g_field->fld_dtype = dtype_varying;	2361	lex.g_field->fld_dtype = dtype_varying;
2362	lex.g_field->fld_character_length = (USHORT) $4;	2362	lex.g_field->fld_character_length = (USHORT)(size_t) $4;
2363	lex.g_field->fld_flags \|= FLD_national;	2363	lex.g_field->fld_flags \|= FLD_national;
2364	}	2364	}
2365	;	2365	;
Lines 2367-2373 Link Here
2367	character_type : character_keyword '(' pos_short_integer ')'	2367	character_type : character_keyword '(' pos_short_integer ')'
2368	{	2368	{
2369	lex.g_field->fld_dtype = dtype_text;	2369	lex.g_field->fld_dtype = dtype_text;
2370	lex.g_field->fld_character_length = (USHORT) $3;	2370	lex.g_field->fld_character_length = (USHORT)(size_t) $3;
2371	}	2371	}
2372	\| character_keyword	2372	\| character_keyword
2373	{	2373	{
Lines 2377-2383 Link Here
2377	\| varying_keyword '(' pos_short_integer ')'	2377	\| varying_keyword '(' pos_short_integer ')'
2378	{	2378	{
2379	lex.g_field->fld_dtype = dtype_varying;	2379	lex.g_field->fld_dtype = dtype_varying;
2380	lex.g_field->fld_character_length = (USHORT) $3;	2380	lex.g_field->fld_character_length = (USHORT)(size_t) $3;
2381	}	2381	}
2382	;	2382	;
2383		2383
Lines 2429-2438 Link Here
2429	}	2429	}
2430	\| '(' signed_long_integer ')'	2430	\| '(' signed_long_integer ')'
2431	{	2431	{
2432	if ( ((SLONG) $2 < 1) \|\| ((SLONG) $2 > 18) )	2432	if ( ((SLONG)(IPTR) $2 < 1) \|\| ((SLONG)(IPTR) $2 > 18) )
2433	yyabandon (-842, isc_precision_err);	2433	yyabandon (-842, isc_precision_err);
2434	/* Precision most be between 1 and 18. */	2434	/* Precision most be between 1 and 18. */
2435	if ((SLONG) $2 > 9)	2435	if ((SLONG)(IPTR) $2 > 9)
2436	{	2436	{
2437	if ( ( (client_dialect <= SQL_DIALECT_V5) &&	2437	if ( ( (client_dialect <= SQL_DIALECT_V5) &&
2438	(db_dialect > SQL_DIALECT_V5) ) \|\|	2438	(db_dialect > SQL_DIALECT_V5) ) \|\|
Lines 2469-2475 Link Here
2469	}	2469	}
2470	}	2470	}
2471	else	2471	else
2472	if ((SLONG) $2 < 5)	2472	if ((SLONG)(IPTR) $2 < 5)
2473	{	2473	{
2474	lex.g_field->fld_dtype = dtype_short;	2474	lex.g_field->fld_dtype = dtype_short;
2475	lex.g_field->fld_length = sizeof (SSHORT);	2475	lex.g_field->fld_length = sizeof (SSHORT);
Lines 2479-2495 Link Here
2479	lex.g_field->fld_dtype = dtype_long;	2479	lex.g_field->fld_dtype = dtype_long;
2480	lex.g_field->fld_length = sizeof (SLONG);	2480	lex.g_field->fld_length = sizeof (SLONG);
2481	}	2481	}
2482	lex.g_field->fld_precision = (USHORT) $2;	2482	lex.g_field->fld_precision = (USHORT)(size_t) $2;
2483	}	2483	}
2484	\| '(' signed_long_integer ',' signed_long_integer ')'	2484	\| '(' signed_long_integer ',' signed_long_integer ')'
2485	{	2485	{
2486	if ( ((SLONG) $2 < 1) \|\| ((SLONG) $2 > 18) )	2486	if ( ((SLONG)(IPTR) $2 < 1) \|\| ((SLONG)(IPTR) $2 > 18) )
2487	yyabandon (-842, isc_precision_err);	2487	yyabandon (-842, isc_precision_err);
2488	/* Precision should be between 1 and 18 */	2488	/* Precision should be between 1 and 18 */
2489	if (((SLONG) $4 > (SLONG) $2) \|\| ((SLONG) $4 < 0))	2489	if (((SLONG)(IPTR) $4 > (SLONG)(IPTR) $2) \|\| ((SLONG)(IPTR) $4 < 0))
2490	yyabandon (-842, isc_scale_nogt);	2490	yyabandon (-842, isc_scale_nogt);
2491	/* Scale must be between 0 and precision */	2491	/* Scale must be between 0 and precision */
2492	if ((SLONG) $2 > 9)	2492	if ((SLONG)(IPTR) $2 > 9)
2493	{	2493	{
2494	if ( ( (client_dialect <= SQL_DIALECT_V5) &&	2494	if ( ( (client_dialect <= SQL_DIALECT_V5) &&
2495	(db_dialect > SQL_DIALECT_V5) ) \|\|	2495	(db_dialect > SQL_DIALECT_V5) ) \|\|
Lines 2527-2533 Link Here
2527	}	2527	}
2528	else	2528	else
2529	{	2529	{
2530	if ((SLONG) $2 < 5)	2530	if ((SLONG)(IPTR) $2 < 5)
2531	{	2531	{
2532	lex.g_field->fld_dtype = dtype_short;	2532	lex.g_field->fld_dtype = dtype_short;
2533	lex.g_field->fld_length = sizeof (SSHORT);	2533	lex.g_field->fld_length = sizeof (SSHORT);
Lines 2538-2545 Link Here
2538	lex.g_field->fld_length = sizeof (SLONG);	2538	lex.g_field->fld_length = sizeof (SLONG);
2539	}	2539	}
2540	}	2540	}
2541	lex.g_field->fld_precision = (USHORT) $2;	2541	lex.g_field->fld_precision = (USHORT)(size_t) $2;
2542	lex.g_field->fld_scale = - (SSHORT) $4;	2542	lex.g_field->fld_scale = - (SSHORT)(size_t) $4;
2543	}	2543	}
2544	;	2544	;
2545		2545
Lines 2553-2559 Link Here
2553		2553
2554	float_type : KW_FLOAT precision_opt	2554	float_type : KW_FLOAT precision_opt
2555	{	2555	{
2556	if ((SLONG) $2 > 7)	2556	if ((SLONG)(IPTR) $2 > 7)
2557	{	2557	{
2558	lex.g_field->fld_dtype = dtype_double;	2558	lex.g_field->fld_dtype = dtype_double;
2559	lex.g_field->fld_length = sizeof (double);	2559	lex.g_field->fld_length = sizeof (double);
Lines 2756-2762 Link Here
2756	;	2756	;
2757		2757
2758	table_lock : FOR lock_type lock_mode	2758	table_lock : FOR lock_type lock_mode
2759	{ $$ = make_flag_node (nod_lock_mode, (SSHORT) ((SSHORT) $2 \| (SSHORT) $3), (SSHORT) 0, NULL); }	2759	{ $$ = make_flag_node (nod_lock_mode, (SSHORT) ((SSHORT)(size_t) $2 \| (SSHORT)(size_t) $3), (SSHORT) 0, NULL); }
2760	\|	2760	\|
2761	{ $$ = 0; }	2761	{ $$ = 0; }
2762	;	2762	;
Lines 3706-3737 Link Here
3706		3706
3707	signed_short_integer : nonneg_short_integer	3707	signed_short_integer : nonneg_short_integer
3708	\| '-' neg_short_integer	3708	\| '-' neg_short_integer
3709	{ $$ = (DSQL_NOD) - (SLONG) $2; }	3709	{ $$ = (DSQL_NOD) - (SLONG)(IPTR) $2; }
3710	;	3710	;
3711		3711
3712	nonneg_short_integer : NUMBER	3712	nonneg_short_integer : NUMBER
3713	{ if ((SLONG) $1 > SHRT_POS_MAX)	3713	{ if ((SLONG)(IPTR) $1 > SHRT_POS_MAX)
3714	yyabandon (-842, isc_expec_short);	3714	yyabandon (-842, isc_expec_short);
3715	/* Short integer expected */	3715	/* Short integer expected */
3716	$$ = $1;}	3716	$$ = $1;}
3717	;	3717	;
3718		3718
3719	neg_short_integer : NUMBER	3719	neg_short_integer : NUMBER
3720	{ if ((SLONG) $1 > SHRT_NEG_MAX)	3720	{ if ((SLONG)(IPTR) $1 > SHRT_NEG_MAX)
3721	yyabandon (-842, isc_expec_short);	3721	yyabandon (-842, isc_expec_short);
3722	/* Short integer expected */	3722	/* Short integer expected */
3723	$$ = $1;}	3723	$$ = $1;}
3724	;	3724	;
3725		3725
3726	pos_short_integer : nonneg_short_integer	3726	pos_short_integer : nonneg_short_integer
3727	{ if ((SLONG) $1 == 0)	3727	{ if ((SLONG)(IPTR) $1 == 0)
3728	yyabandon (-842, isc_expec_positive);	3728	yyabandon (-842, isc_expec_positive);
3729	/* Positive number expected */	3729	/* Positive number expected */
3730	$$ = $1;}	3730	$$ = $1;}
3731	;	3731	;
3732		3732
3733	unsigned_short_integer : NUMBER	3733	unsigned_short_integer : NUMBER
3734	{ if ((SLONG) $1 > SHRT_UNSIGNED_MAX)	3734	{ if ((SLONG)(IPTR) $1 > SHRT_UNSIGNED_MAX)
3735	yyabandon (-842, isc_expec_ushort);	3735	yyabandon (-842, isc_expec_ushort);
3736	/* Unsigned short integer expected */	3736	/* Unsigned short integer expected */
3737	$$ = $1;}	3737	$$ = $1;}
Lines 3739-3745 Link Here
3739		3739
3740	signed_long_integer : long_integer	3740	signed_long_integer : long_integer
3741	\| '-' long_integer	3741	\| '-' long_integer
3742	{ $$ = (DSQL_NOD) - (SLONG) $2; }	3742	{ $$ = (DSQL_NOD) - (SLONG)(IPTR) $2; }
3743	;	3743	;
3744		3744
3745	long_integer : NUMBER	3745	long_integer : NUMBER
Lines 3820-3833 Link Here
3820		3820
3821	string_value_function : SUBSTRING '(' value FROM pos_short_integer ')'	3821	string_value_function : SUBSTRING '(' value FROM pos_short_integer ')'
3822	{ $$ = make_node (nod_substr, e_substr_count, $3,	3822	{ $$ = make_node (nod_substr, e_substr_count, $3,
3823	MAKE_constant ((STR) ((SLONG)($5) - 1), CONSTANT_SLONG),	3823	MAKE_constant ((STR) ((SLONG)(IPTR)($5) - 1), CONSTANT_SLONG),
3824	MAKE_constant ((STR) SHRT_POS_MAX, CONSTANT_SLONG)); }	3824	MAKE_constant ((STR) SHRT_POS_MAX, CONSTANT_SLONG)); }
3825	/* CVC: It was easier to provide a constant with maximum value if the	3825	/* CVC: It was easier to provide a constant with maximum value if the
3826	third parameter -length- is ommitted than to chase and fix the functions	3826	third parameter -length- is ommitted than to chase and fix the functions
3827	that treat nod_substr as an aggregate and do not expect NULL arguments. */	3827	that treat nod_substr as an aggregate and do not expect NULL arguments. */
3828	\| SUBSTRING '(' value FROM pos_short_integer FOR nonneg_short_integer ')'	3828	\| SUBSTRING '(' value FROM pos_short_integer FOR nonneg_short_integer ')'
3829	{ $$ = make_node (nod_substr, e_substr_count, $3,	3829	{ $$ = make_node (nod_substr, e_substr_count, $3,
3830	MAKE_constant ((STR) ((SLONG)($5) - 1), CONSTANT_SLONG),	3830	MAKE_constant ((STR) ((SLONG)(IPTR)($5) - 1), CONSTANT_SLONG),
3831	MAKE_constant ((STR) ($7), CONSTANT_SLONG)); }	3831	MAKE_constant ((STR) ($7), CONSTANT_SLONG)); }
3832	\| KW_UPPER '(' value ')'	3832	\| KW_UPPER '(' value ')'
3833	{ $$ = make_node (nod_upcase, 1, $3); }	3833	{ $$ = make_node (nod_upcase, 1, $3); }
Lines 4960-4966 Link Here
4960		4960
4961	CHECK_BOUND(p);	4961	CHECK_BOUND(p);
4962	*p = 0;	4962	*p = 0;
4963	sym = HSHD_lookup (NULL_PTR, (TEXT *) string, (SSHORT)(p - string), SYM_keyword, parser_version);	4963	sym = HSHD_lookup (NULL_PTR, (TEXT *) string, (SSHORT)(size_t)(p - string), SYM_keyword, parser_version);
4964	if (sym)	4964	if (sym)
4965	{	4965	{
4966	/* 13 June 2003. Nickolay Samofatov	4966	/* 13 June 2003. Nickolay Samofatov

Lines 2151-2157 Link Here

(-)firebird-1.5.3.4870.old/src/jrd/rse.cpp (-8 / +8 lines)
2151	}	2151	}
2152		2152
2153	desc = msg_format->fmt_desc[msg_format->fmt_count - 1];	2153	desc = msg_format->fmt_desc[msg_format->fmt_count - 1];
2154	desc.dsc_address = (UCHAR *) (om + (int) desc.dsc_address);	2154	desc.dsc_address = (UCHAR *) (om + (int) (IPTR) desc.dsc_address);
2155	eos_desc.dsc_dtype = dtype_short;	2155	eos_desc.dsc_dtype = dtype_short;
2156	eos_desc.dsc_scale = 0;	2156	eos_desc.dsc_scale = 0;
2157	eos_desc.dsc_length = sizeof(SSHORT);	2157	eos_desc.dsc_length = sizeof(SSHORT);
Lines 2959-2965 Link Here
2959	for (item = map->smb_rpt; item < end_item; item++) {	2959	for (item = map->smb_rpt; item < end_item; item++) {
2960	flag = *(data + item->smb_flag_offset);	2960	flag = *(data + item->smb_flag_offset);
2961	from = item->smb_desc;	2961	from = item->smb_desc;
2962	from.dsc_address = data + (ULONG) from.dsc_address;	2962	from.dsc_address = data + (ULONG) (IPTR) from.dsc_address;
2963	if ((node = item->smb_node) && node->nod_type != nod_field)	2963	if ((node = item->smb_node) && node->nod_type != nod_field)
2964	continue;	2964	continue;
2965		2965
Lines 3211-3217 Link Here
3211	end_item = map->smb_rpt + map->smb_count;	3211	end_item = map->smb_rpt + map->smb_count;
3212	for (item = map->smb_rpt; item < end_item; item++) {	3212	for (item = map->smb_rpt; item < end_item; item++) {
3213	to = item->smb_desc;	3213	to = item->smb_desc;
3214	to.dsc_address = data + (ULONG) to.dsc_address;	3214	to.dsc_address = data + (ULONG) (IPTR) to.dsc_address;
3215	flag = FALSE;	3215	flag = FALSE;
3216	if (item->smb_node) {	3216	if (item->smb_node) {
3217	from = EVL_expr(tdbb, item->smb_node);	3217	from = EVL_expr(tdbb, item->smb_node);
Lines 3301-3312 Link Here
3301	desc2.dsc_flags = 0;	3301	desc2.dsc_flags = 0;
3302	desc2.dsc_address = (UCHAR *) & indicator;	3302	desc2.dsc_address = (UCHAR *) & indicator;
3303	desc1 = *flag_desc;	3303	desc1 = *flag_desc;
3304	desc1.dsc_address = msg + (int) flag_desc->dsc_address;	3304	desc1.dsc_address = msg + (int) (IPTR) flag_desc->dsc_address;
3305	MOV_move(&desc1, &desc2);	3305	MOV_move(&desc1, &desc2);
3306	if (indicator) {	3306	if (indicator) {
3307	SET_NULL(record, to_id);	3307	SET_NULL(record, to_id);
3308	l = to_desc->dsc_length;	3308	l = to_desc->dsc_length;
3309	p = record->rec_data + (int) to_desc->dsc_address;	3309	p = record->rec_data + (int) (IPTR) to_desc->dsc_address;
3310	switch (to_desc->dsc_dtype) {	3310	switch (to_desc->dsc_dtype) {
3311	case dtype_text:	3311	case dtype_text:
3312	/* YYY - not necessarily the right thing to do */	3312	/* YYY - not necessarily the right thing to do */
Lines 3336-3344 Link Here
3336	else {	3336	else {
3337	CLEAR_NULL(record, to_id);	3337	CLEAR_NULL(record, to_id);
3338	desc1 = *from_desc;	3338	desc1 = *from_desc;
3339	desc1.dsc_address = msg + (int) desc1.dsc_address;	3339	desc1.dsc_address = msg + (int) (IPTR) desc1.dsc_address;
3340	desc2 = *to_desc;	3340	desc2 = *to_desc;
3341	desc2.dsc_address = record->rec_data + (int) desc2.dsc_address;	3341	desc2.dsc_address = record->rec_data + (int) (IPTR) desc2.dsc_address;
3342	if (!DSC_EQUIV((&desc1), (&desc2)))	3342	if (!DSC_EQUIV((&desc1), (&desc2)))
3343	MOV_move(&desc1, &desc2);	3343	MOV_move(&desc1, &desc2);
3344		3344
Lines 3817-3823 Link Here
3817	if (!sfb_->sfb_file_name) {	3817	if (!sfb_->sfb_file_name) {
3818	TEXT file_name[128];	3818	TEXT file_name[128];
3819		3819
3820	sfb_->sfb_file = (int) gds__temp_file(FALSE, SCRATCH, file_name);	3820	sfb_->sfb_file = (int) (IPTR) gds__temp_file(FALSE, SCRATCH, file_name);
3821	if (sfb_->sfb_file == -1)	3821	if (sfb_->sfb_file == -1)
3822	SORT_error(tdbb->tdbb_status_vector, sfb_, "open", isc_io_error,	3822	SORT_error(tdbb->tdbb_status_vector, sfb_, "open", isc_io_error,
3823	errno);	3823	errno);

Lines 200-209 Link Here

(-)firebird-1.5.3.4870.old/src/qli/eval.cpp (-4 / +4 lines)
200		200
201	if (node->nod_type == nod_rpt_average && node->nod_arg[e_stt_default])	201	if (node->nod_type == nod_rpt_average && node->nod_arg[e_stt_default])
202	if (node->nod_desc.dsc_dtype == dtype_long)	202	if (node->nod_desc.dsc_dtype == dtype_long)
203	(SLONG ) node->nod_desc.dsc_address /= (SLONG) node->	203	(SLONG ) node->nod_desc.dsc_address /= (SLONG) (IPTR) node->
204	nod_arg[e_stt_default];	204	nod_arg[e_stt_default];
205	else	205	else
206	(double ) node->nod_desc.dsc_address /= (SLONG) node->	206	(double ) node->nod_desc.dsc_address /= (SLONG) (IPTR) node->
207	nod_arg[e_stt_default];	207	nod_arg[e_stt_default];
208	}	208	}
209		209
Lines 241-247 Link Here
241		241
242	/* If this is the first value, just move it in. */	242	/* If this is the first value, just move it in. */
243		243
244	count = (SLONG) node->nod_arg[e_stt_default] + 1;	244	count = (SLONG) (IPTR) node->nod_arg[e_stt_default] + 1;
245	if (count == 1) {	245	if (count == 1) {
246	if (desc2->dsc_missing)	246	if (desc2->dsc_missing)
247	desc1->dsc_missing = DSC_missing;	247	desc1->dsc_missing = DSC_missing;
Lines 374-380 Link Here
374	case nod_rpt_min:	374	case nod_rpt_min:
375	case nod_rpt_total:	375	case nod_rpt_total:
376	case nod_rpt_average:	376	case nod_rpt_average:
377	if (!(SLONG) node->nod_arg[e_stt_default])	377	if (!(SLONG) (IPTR) node->nod_arg[e_stt_default])
378	desc->dsc_missing = DSC_missing;	378	desc->dsc_missing = DSC_missing;
379		379
380	case nod_rpt_count:	380	case nod_rpt_count:

Lines 1524-1530 Link Here

(-)firebird-1.5.3.4870.old/src/qli/parse.cpp (-3 / +3 lines)
1524	IBERROR(176); /* Msg176 No statements issued yet */	1524	IBERROR(176); /* Msg176 No statements issued yet */
1525		1525
1526	if (MATCH(KW_ASTERISK))	1526	if (MATCH(KW_ASTERISK))
1527	LEX_edit((SLONG) 0, (SLONG) statement_list->lls_object);	1527	LEX_edit((SLONG) 0, (SLONG) (IPTR) statement_list->lls_object);
1528	else {	1528	else {
1529	if (KEYWORD(KW_SEMI))	1529	if (KEYWORD(KW_SEMI))
1530	l = 1;	1530	l = 1;
Lines 1534-1540 Link Here
1534	for (start = stop = statement_list;	1534	for (start = stop = statement_list;
1535	l && start->lls_next; l--, start = start->lls_next);	1535	l && start->lls_next; l--, start = start->lls_next);
1536	command_end();	1536	command_end();
1537	LEX_edit((SLONG) start->lls_object, (SLONG) stop->lls_object);	1537	LEX_edit((SLONG) (IPTR) start->lls_object, (SLONG) (IPTR) stop->lls_object);
1538	}	1538	}
1539	}	1539	}
1540	#ifdef PYXIS	1540	#ifdef PYXIS
Lines 2925-2931 Link Here
2925	node->syn_arg[0] = INT_CAST 1;	2925	node->syn_arg[0] = INT_CAST 1;
2926	if (op == nod_column \|\| QLI_token->tok_type == tok_number)	2926	if (op == nod_column \|\| QLI_token->tok_type == tok_number)
2927	node->syn_arg[0] = INT_CAST parse_ordinal();	2927	node->syn_arg[0] = INT_CAST parse_ordinal();
2928	if ((op == nod_skip) && ((int) node->syn_arg[0] < 1))	2928	if ((op == nod_skip) && ((int) (IPTR) node->syn_arg[0] < 1))
2929	SYNTAX_ERROR(478); /* Msg478 number > 0 */	2929	SYNTAX_ERROR(478); /* Msg478 number > 0 */
2930	}	2930	}
2931	LLS_PUSH(node, &stack);	2931	LLS_PUSH(node, &stack);