firebird/firebird-mirror
firebird/firebird-mirror
8
0
Fork 1
mirror of https://github.com/FirebirdSQL/firebird.git synced 2025-01-23 12:43:03 +01:00
Code Issues

Cleanup: style, get rid of typedef needed by plain C, other C++ legacy declarations, etc. First pass.

Browse Source
This commit is contained in:
robocop 2008-12-25 07:46:53 +00:00
parent 11e63a5dd1
commit 1214fcdbd8
34 changed files with 1001 additions and 1157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

656
src/gpre/ada.cpp
View File

File diff suppressed because it is too large Load Diff

18
src/gpre/c_cxx.cpp
View File

@ -1981,17 +1981,17 @@ static void gen_erase( const act* action, int column)
static SSHORT gen_event_block( const act* action)
{
GPRE_NOD init = (GPRE_NOD) action->act_object;
gpre_nod* init = (gpre_nod*) action->act_object;
gpre_sym* event_name = (gpre_sym*) init->nod_arg[0];
int ident = CMP_next_ident();
init->nod_arg[2] = (GPRE_NOD)(IPTR)ident;
init->nod_arg[2] = (gpre_nod*)(IPTR)ident;
printa(0, "static %schar\n *isc_%da, *isc_%db;", CONST_STR, ident,
ident);
printa(0, "static short\n isc_%dl;", ident);
GPRE_NOD list = init->nod_arg[1];
gpre_nod* list = init->nod_arg[1];
return list->nod_count;
}
@ -2014,8 +2014,8 @@ static void gen_event_init( const act* action, int column)
begin(column);
begin(column);
GPRE_NOD init = (GPRE_NOD) action->act_object;
GPRE_NOD event_list = init->nod_arg[1];
gpre_nod* init = (gpre_nod*) action->act_object;
gpre_nod* event_list = init->nod_arg[1];
PAT args;
args.pat_database = (DBB) init->nod_arg[3];
@ -2085,7 +2085,7 @@ static void gen_event_wait( const act* action, int column)
int ident = -1;
for (gpre_lls* stack_ptr = gpreGlob.events; stack_ptr; stack_ptr = stack_ptr->lls_next) {
const act* event_action = (const act*) stack_ptr->lls_object;
GPRE_NOD event_init = (GPRE_NOD) event_action->act_object;
gpre_nod* event_init = (gpre_nod*) event_action->act_object;
gpre_sym* stack_name = (gpre_sym*) event_init->nod_arg[0];
if (!strcmp(event_name->sym_string, stack_name->sym_string)) {
ident = (IPTR) event_init->nod_arg[2];
@ -2136,7 +2136,7 @@ static void gen_fetch( const act* action, int column)
for (reference = port->por_references; reference;
reference = reference->ref_next)
{
VAL value = reference->ref_values;
gpre_value* value = reference->ref_values;
reference->ref_value = value->val_value;
reference->ref_values = value->val_next;
}
@ -2189,7 +2189,7 @@ static void gen_fetch( const act* action, int column)
column += INDENT;
begin(column);
GPRE_NOD var_list = (GPRE_NOD) action->act_object;
gpre_nod* var_list = (gpre_nod*) action->act_object;
if (var_list)
for (int i = 0; i < var_list->nod_count; i++) {
align(column);
@ -3135,7 +3135,7 @@ static void gen_select( const act* action, int column)
column += INDENT;
begin(column);
GPRE_NOD var_list = (GPRE_NOD) action->act_object;
gpre_nod* var_list = (gpre_nod*) action->act_object;
if (var_list)
for (int i = 0; i < var_list->nod_count; i++) {
align(column);

45
src/gpre/cmd.cpp
View File

@ -80,14 +80,14 @@ static void create_trg_firing_cond(gpre_req*, const cnstrt*);
static void create_trigger(gpre_req*, const act*, gpre_trg*, pfn_local_trigger_cb);
static void create_upd_cascade_trg(gpre_req*, const act*, CNSTRT);
static bool create_view(gpre_req*, act*);
static void create_view_trigger(gpre_req*, const act*, gpre_trg*, GPRE_NOD, gpre_ctx**, GPRE_NOD);
static void create_view_trigger(gpre_req*, const act*, gpre_trg*, gpre_nod*, gpre_ctx**, gpre_nod*);
static void declare_filter(gpre_req*, const act*);
static void declare_udf(gpre_req*, const act*);
static void get_referred_fields(const act*, CNSTRT);
static void grant_revoke_privileges(gpre_req*, const act*);
static void init_field_struct(gpre_fld*);
static void put_array_info(gpre_req*, const gpre_fld*);
static void put_blr(gpre_req*, USHORT, GPRE_NOD, pfn_local_trigger_cb);
static void put_blr(gpre_req*, USHORT, gpre_nod*, pfn_local_trigger_cb);
static void put_computed_blr(gpre_req*, const gpre_fld*);
static void put_computed_source(gpre_req*, const gpre_fld*);
static void put_cstring(gpre_req*, USHORT, const TEXT*);
@ -97,9 +97,9 @@ static void put_numeric(gpre_req*, USHORT, SSHORT);
static void put_short_cstring(gpre_req*, USHORT, const TEXT*);
static void put_string(gpre_req*, USHORT, const TEXT*, USHORT);
static void put_symbol(gpre_req*, int, const gpre_sym*);
static void put_trigger_blr(gpre_req*, USHORT, GPRE_NOD, pfn_local_trigger_cb);
static void put_trigger_blr(gpre_req*, USHORT, gpre_nod*, pfn_local_trigger_cb);
static void put_view_trigger_blr(gpre_req*, const gpre_rel*, USHORT, gpre_trg*,
GPRE_NOD, gpre_ctx**, GPRE_NOD);
gpre_nod*, gpre_ctx**, gpre_nod*);
static void replace_field_names(gpre_nod* const, const gpre_nod* const,
gpre_fld* const, bool, gpre_ctx**);
static void set_statistics(gpre_req*, const act*);
@ -266,7 +266,7 @@ static void add_cache( gpre_req* request, const act* action, dbb* database)
{
TEXT file_name[254]; // CVC: Maybe MAXPATHLEN?
const fil* file = database->dbb_cache_file;
const gpre_file* file = database->dbb_cache_file;
const SSHORT l = MIN((strlen(file->fil_name)), (sizeof(file_name) - 1));
strncpy(file_name, file->fil_name, l);
@ -286,7 +286,7 @@ static void add_cache( gpre_req* request, const act* action, dbb* database)
static void alter_database( gpre_req* request, act* action)
{
FIL file, next;
gpre_file* file;
dbb* db = (DBB) action->act_object;
@ -294,7 +294,8 @@ static void alter_database( gpre_req* request, act* action)
// Reverse the order of files (parser left them backwards)
FIL files = db->dbb_files;
gpre_file* next;
gpre_file* files = db->dbb_files;
for (file = files, files = NULL; file; file = next) {
next = file->fil_next;
file->fil_next = files;
@ -1445,10 +1446,11 @@ static void create_database_modify_dyn( gpre_req* request, act* action)
request->add_byte(isc_dyn_mod_database);
gpre_file* file;
// Reverse the order of files (parser left them backwards)
FIL files = db->dbb_files;
FIL file, next;
gpre_file* files = db->dbb_files;
gpre_file* next;
for (file = files, files = NULL; file; file = next) {
next = file->fil_next;
file->fil_next = files;
@ -1600,10 +1602,11 @@ static void create_index( gpre_req* request, const ind* index)
static void create_shadow( gpre_req* request, act* action)
{
fil* files = (FIL) action->act_object;
gpre_file* files = (gpre_file*) action->act_object;
gpre_file* file;
// Reverse the order of files (parser left them backwards)
FIL file, next;
gpre_file* next;
for (file = files, files = NULL; file; file = next) {
next = file->fil_next;
file->fil_next = files;
@ -1748,7 +1751,7 @@ static bool create_view(gpre_req* request,
// write out blr
put_blr(request, isc_dyn_view_blr, (GPRE_NOD) relation->rel_view_rse,
put_blr(request, isc_dyn_view_blr, (gpre_nod*) relation->rel_view_rse,
reinterpret_cast<pfn_local_trigger_cb>(CME_rse));
// write out view source
@ -1896,8 +1899,8 @@ static bool create_view(gpre_req* request,
new_view_ref->ref_context = contexts[1];
new_view_ref->ref_field = view_ref->ref_field =
(field) ? field : fld;
gpre_nod* view_field = MSC_unary(nod_field, (GPRE_NOD) view_ref);
gpre_nod* new_view_field = MSC_unary(nod_field, (GPRE_NOD) new_view_ref);
gpre_nod* view_field = MSC_unary(nod_field, (gpre_nod*) view_ref);
gpre_nod* new_view_field = MSC_unary(nod_field, (gpre_nod*) new_view_ref);
gpre_nod* anull_node = MSC_unary(nod_missing, view_field);
gpre_nod* bnull_node = MSC_unary(nod_missing, value);
@ -1926,7 +1929,7 @@ static bool create_view(gpre_req* request,
gpre_nod* set_list = MSC_node(nod_list, count);
ptr = set_list->nod_arg + count;
while (stack)
*--ptr = (GPRE_NOD) MSC_pop(&stack);
*--ptr = (gpre_nod*) MSC_pop(&stack);
// Modify the context of fields in boolean to be that of the
// sub-relation.
@ -1945,7 +1948,7 @@ static bool create_view(gpre_req* request,
// "update violates CHECK constraint on view"
trigger->trg_message = NULL;
trigger->trg_boolean = (GPRE_NOD) select;
trigger->trg_boolean = (gpre_nod*) select;
create_view_trigger(request, action, trigger, view_boolean, contexts,
set_list);
@ -1974,7 +1977,7 @@ static void create_view_trigger(gpre_req* request,
const act* action,
gpre_trg* trigger,
gpre_nod* view_boolean,
gpre_ctx** contexts, GPRE_NOD set_list)
gpre_ctx** contexts, gpre_nod* set_list)
{
const gpre_rel* relation = (gpre_rel*) action->act_object;
@ -2013,7 +2016,7 @@ static void create_view_trigger(gpre_req* request,
static void declare_filter( gpre_req* request, const act* action)
{
const fltr* filter = (FLTR) action->act_object;
const gpre_filter* filter = (gpre_filter*) action->act_object;
put_cstring(request, isc_dyn_def_filter, filter->fltr_name);
put_numeric(request, isc_dyn_filter_in_subtype, filter->fltr_input_type);
put_numeric(request, isc_dyn_filter_out_subtype,
@ -2319,7 +2322,7 @@ static void put_array_info( gpre_req* request, const gpre_fld* field)
//
static void put_blr(gpre_req* request,
USHORT blr_operator, GPRE_NOD node, pfn_local_trigger_cb routine)
USHORT blr_operator, gpre_nod* node, pfn_local_trigger_cb routine)
{
request->add_byte(blr_operator);
const USHORT offset = request->req_blr - request->req_base;
@ -2681,7 +2684,7 @@ static void put_symbol(gpre_req* request, int ddl_operator,
static void put_trigger_blr(gpre_req* request,
USHORT blr_operator,
GPRE_NOD node, pfn_local_trigger_cb routine)
gpre_nod* node, pfn_local_trigger_cb routine)
{
request->add_byte(blr_operator);
const USHORT offset = request->req_blr - request->req_base;
@ -2723,7 +2726,7 @@ static void put_view_trigger_blr(gpre_req* request,
const gpre_rel* relation,
USHORT blr_operator,
gpre_trg* trigger,
GPRE_NOD view_boolean, gpre_ctx** contexts, GPRE_NOD set_list)
gpre_nod* view_boolean, gpre_ctx** contexts, gpre_nod* set_list)
{
gpre_rse* node = (gpre_rse*) trigger->trg_boolean;
request->add_byte(blr_operator);

30
src/gpre/cme.cpp
View File

@ -46,15 +46,15 @@
#include "../jrd/misc_func_ids.h"
#include "../jrd/align.h"
static void cmp_array(GPRE_NOD, gpre_req*);
static void cmp_array_element(GPRE_NOD, gpre_req*);
static void cmp_cast(GPRE_NOD, gpre_req*);
static void cmp_array(gpre_nod*, gpre_req*);
static void cmp_array_element(gpre_nod*, gpre_req*);
static void cmp_cast(gpre_nod*, gpre_req*);
static void cmp_field(const gpre_nod*, gpre_req*);
static void cmp_literal(const gpre_nod*, gpre_req*);
static void cmp_map(MAP, gpre_req*);
static void cmp_plan(const gpre_nod*, gpre_req*);
static void cmp_sdl_dtype(const gpre_fld*, REF);
static void cmp_udf(GPRE_NOD, gpre_req*);
static void cmp_udf(gpre_nod*, gpre_req*);
static void cmp_value(const gpre_nod*, gpre_req*);
static void get_dtype_of_case(const gpre_nod*, gpre_fld*);
static void get_dtype_of_list(const gpre_nod*, gpre_fld*);
@ -78,7 +78,7 @@ static bool debug_on;
struct op_table
{
enum nod_t op_type;
nod_t op_type;
UCHAR op_blr;
};
@ -164,7 +164,7 @@ static inline bool is_date_and_time(const USHORT d1, const USHORT d2)
// Compile a random expression.
//
void CME_expr(GPRE_NOD node, gpre_req* request)
void CME_expr(gpre_nod* node, gpre_req* request)
{
gpre_ctx* context;
gpre_fld field;
@ -272,7 +272,7 @@ void CME_expr(GPRE_NOD node, gpre_req* request)
// ** Begin date/time/timestamp support *
case nod_extract:
request->add_byte(blr_extract);
switch ((KWWORDS) (IPTR) node->nod_arg[0])
switch ((kwwords_t) (IPTR) node->nod_arg[0])
{
case KW_YEAR:
request->add_byte(blr_extract_year);
@ -609,7 +609,7 @@ void CME_get_dtype(const gpre_nod* node, gpre_fld* f)
// ** Begin date/time/timestamp support *
case nod_extract:
{
KWWORDS kw_word = (KWWORDS) (IPTR) node->nod_arg[0];
kwwords_t kw_word = (kwwords_t) (IPTR) node->nod_arg[0];
CME_get_dtype(node->nod_arg[1], f);
switch (f->fld_dtype)
{
@ -1222,7 +1222,7 @@ void CME_rse(gpre_rse* selection, gpre_req* request)
{
SSHORT i;
if (selection->rse_join_type == (NOD_T) 0)
if (selection->rse_join_type == nod_nothing)
{
if ((selection->rse_flags & RSE_singleton) &&
!(request->req_database->dbb_flags & DBB_v3))
@ -1338,7 +1338,7 @@ void CME_rse(gpre_rse* selection, gpre_req* request)
cmp_plan(temp, request);
}
if (selection->rse_join_type != (NOD_T) 0
if (selection->rse_join_type != nod_nothing
&& selection->rse_join_type != nod_join_inner)
{
request->add_byte(blr_join_type);
@ -1384,7 +1384,7 @@ void CME_rse(gpre_rse* selection, gpre_req* request)
// out sdl (slice description language)
//
static void cmp_array( GPRE_NOD node, gpre_req* request)
static void cmp_array( gpre_nod* node, gpre_req* request)
{
CMP_check(request, 0);
@ -1464,7 +1464,7 @@ static void cmp_array( GPRE_NOD node, gpre_req* request)
// from an gpre_rse and output blr for this reference
//
static void cmp_array_element( GPRE_NOD node, gpre_req* request)
static void cmp_array_element( gpre_nod* node, gpre_req* request)
{
request->add_byte(blr_index);
@ -1483,7 +1483,7 @@ static void cmp_array_element( GPRE_NOD node, gpre_req* request)
//
//
static void cmp_cast( GPRE_NOD node, gpre_req* request)
static void cmp_cast( gpre_nod* node, gpre_req* request)
{
request->add_byte(blr_cast);
@ -1780,7 +1780,7 @@ static void cmp_plan(const gpre_nod* plan_expression, gpre_req* request)
gpre_nod* const* ptr = list->nod_arg;
for (gpre_nod* const* const end = ptr + list->nod_count; ptr < end; ptr++)
{
GPRE_NOD node = *ptr;
gpre_nod* node = *ptr;
if (node->nod_type == nod_plan_expr)
{
cmp_plan(node, request);
@ -1944,7 +1944,7 @@ static void cmp_sdl_dtype( const gpre_fld* field, REF reference)
// Compile a reference to a user defined function.
//
static void cmp_udf( GPRE_NOD node, gpre_req* request)
static void cmp_udf( gpre_nod* node, gpre_req* request)
{
const udf* an_udf = (udf*) node->nod_arg[1];
request->add_byte(blr_function);

2
src/gpre/cme_proto.h
View File

@ -24,7 +24,7 @@
#ifndef GPRE_CME_PROTO_H
#define GPRE_CME_PROTO_H
void CME_expr(GPRE_NOD, gpre_req*);
void CME_expr(gpre_nod*, gpre_req*);
void CME_get_dtype(const gpre_nod*, gpre_fld*);
void CME_relation(gpre_ctx*, gpre_req*);
void CME_rse(gpre_rse*, gpre_req*);

29
src/gpre/cmp.cpp
View File

@ -44,7 +44,7 @@
static void cmp_any(gpre_req*);
static void cmp_assignment(GPRE_NOD, gpre_req*);
static void cmp_assignment(gpre_nod*, gpre_req*);
static void cmp_blob(blb*, bool);
static void cmp_blr(gpre_req*);
static void cmp_erase(act*, gpre_req*);
@ -70,7 +70,8 @@ static void make_receive(gpre_port*, gpre_req*);
static void make_send(gpre_port*, gpre_req*);
static void update_references(REF);
static GPRE_NOD lit0, lit1;
static gpre_nod* lit0;
static gpre_nod* lit1;
static gpre_fld* eof_field;
static gpre_fld* count_field;
static gpre_fld* slack_byte_field;
@ -155,11 +156,11 @@ void CMP_compile_request( gpre_req* request)
slack_byte_field = MET_make_field(gpreGlob.slack_name, dtype_text, 1, false);
reference = (REF) MSC_alloc(REF_LEN);
reference->ref_value = "0";
lit0 = MSC_unary(nod_literal, (GPRE_NOD) reference);
lit0 = MSC_unary(nod_literal, (gpre_nod*) reference);
reference = (REF) MSC_alloc(REF_LEN);
reference->ref_value = "1";
lit1 = MSC_unary(nod_literal, (GPRE_NOD) reference);
lit1 = MSC_unary(nod_literal, (gpre_nod*) reference);
}
// Handle different request types differently
@ -341,7 +342,7 @@ void CMP_external_field( gpre_req* request, const gpre_fld* field)
// called at most once per module.
//
void CMP_init(void)
void CMP_init()
{
lit0 = lit1 = NULL;
@ -355,7 +356,7 @@ void CMP_init(void)
// Give out next identifier.
//
ULONG CMP_next_ident(void)
ULONG CMP_next_ident()
{
return next_ident++;
}
@ -500,7 +501,7 @@ static void cmp_any( gpre_req* request)
request->add_byte(blr_any);
CME_rse(request->req_rse, request);
gpre_nod* value = MSC_unary(nod_value, (GPRE_NOD) port->por_references);
gpre_nod* value = MSC_unary(nod_value, (gpre_nod*) port->por_references);
// Make a send to signal end of file
@ -530,7 +531,7 @@ static void cmp_any( gpre_req* request)
// Compile a build assignment statement.
//
static void cmp_assignment( GPRE_NOD node, gpre_req* request)
static void cmp_assignment( gpre_nod* node, gpre_req* request)
{
CMP_check(request, 0);
request->add_byte(blr_assignment);
@ -697,7 +698,7 @@ static void cmp_erase( act* action, gpre_req* request)
static void cmp_fetch( act* action)
{
gpre_nod* list = (GPRE_NOD) action->act_object;
gpre_nod* list = (gpre_nod*) action->act_object;
if (!list)
return;
@ -907,11 +908,11 @@ static void cmp_for( gpre_req* request)
if (reference->ref_expr)
CME_expr(reference->ref_expr, request);
else {
field->nod_arg[0] = (GPRE_NOD) reference;
field->nod_arg[0] = (gpre_nod*) reference;
CME_expr(field, request);
}
}
value->nod_arg[0] = (GPRE_NOD) reference;
value->nod_arg[0] = (gpre_nod*) reference;
CME_expr(value, request);
}
request->add_byte(blr_end);
@ -948,7 +949,7 @@ static void cmp_for( gpre_req* request)
make_send(port, request);
request->add_byte(blr_assignment);
CME_expr(lit0, request);
value->nod_arg[0] = (GPRE_NOD) request->req_eof;
value->nod_arg[0] = (gpre_nod*) request->req_eof;
CME_expr(value, request);
request->add_byte(blr_end);
@ -973,7 +974,7 @@ static void cmp_loop( gpre_req* request)
reference = reference->ref_next)
{
if (reference->ref_field == count_field)
counter->nod_arg[0] = (GPRE_NOD) reference;
counter->nod_arg[0] = (gpre_nod*) reference;
}
request->add_byte(blr_assignment);
@ -1117,7 +1118,7 @@ static void cmp_procedure( gpre_req* request)
ref* reference = request->req_references;
if (reference) {
for (gpre_lls** list = &outputs; reference; reference = reference->ref_next) {
MSC_push((GPRE_NOD) reference, list);
MSC_push((gpre_nod*) reference, list);
list = &(*list)->lls_next;
}
}

4
src/gpre/cmp_proto.h
View File

@ -27,8 +27,8 @@
void CMP_check(gpre_req*, SSHORT);
void CMP_compile_request(gpre_req*);
void CMP_external_field(gpre_req*, const gpre_fld*);
void CMP_init(void);
ULONG CMP_next_ident(void);
void CMP_init();
ULONG CMP_next_ident();
void CMP_stuff_symbol(gpre_req*, const gpre_sym*);
void CMP_t_start(gpre_tra*);

20
src/gpre/cob.cpp
View File

@ -217,7 +217,7 @@ static TEXT* gen_name(TEXT* const, const ref*, bool);
static void gen_on_error (const act*);
static void gen_procedure (const act*);
static void gen_put_segment (const act*);
static void gen_raw (const UCHAR*, enum req_t, int, int);
static void gen_raw (const UCHAR*, req_t, int, int);
static void gen_ready (const act*);
static void gen_receive (const act*, const gpre_port*);
static void gen_release (const act*);
@ -2255,10 +2255,10 @@ static void gen_erase( const act* action)
static SSHORT gen_event_block( const act* action)
{
gpre_nod* init = (GPRE_NOD) action->act_object;
gpre_nod* init = (gpre_nod*) action->act_object;
int ident = CMP_next_ident();
init->nod_arg[2] = (GPRE_NOD) (IPTR) ident;
init->nod_arg[2] = (gpre_nod*) (IPTR) ident;
printa(names[COLUMN_0], false, "01 %s%dA PIC S9(9) USAGE COMP.",
names[isc_a_pos], ident);
@ -2292,7 +2292,7 @@ static void gen_event_init( const act* action)
const TEXT *pattern3 =
"CALL \"%S3\" USING %S5, %VF%S4%N1L%VE, %VF%S4%N1A%VE, %VF%S4%N1B%VE";
const gpre_nod* init = (GPRE_NOD) action->act_object;
const gpre_nod* init = (gpre_nod*) action->act_object;
const gpre_nod* event_list = init->nod_arg[1];
const SSHORT column = strlen(names[COLUMN]);
@ -2368,7 +2368,7 @@ static void gen_event_wait( const act* action)
for (const gpre_lls* stack_ptr = gpreGlob.events; stack_ptr; stack_ptr = stack_ptr->lls_next)
{
const act* event_action = (const act*) stack_ptr->lls_object;
const gpre_nod* event_init = (GPRE_NOD) event_action->act_object;
const gpre_nod* event_init = (gpre_nod*) event_action->act_object;
const gpre_sym* stack_name = (gpre_sym*) event_init->nod_arg[0];
if (!strcmp(event_name->sym_string, stack_name->sym_string)) {
ident = (int) (IPTR) event_init->nod_arg[2];
@ -2425,7 +2425,7 @@ static void gen_fetch( const act* action)
for (reference = port->por_references; reference;
reference = reference->ref_next)
{
VAL value = reference->ref_values;
gpre_value* value = reference->ref_values;
reference->ref_value = value->val_value;
reference->ref_values = value->val_next;
}
@ -2467,7 +2467,7 @@ static void gen_fetch( const act* action)
printa(names[COLUMN], false,
"IF %s NOT = 0 THEN", gen_name(s, request->req_eof, true));
printa(names[COLUMN], false, "MOVE 0 TO SQLCODE");
if (gpre_nod* var_list = (GPRE_NOD) action->act_object)
if (gpre_nod* var_list = (gpre_nod*) action->act_object)
for (int i = 0; i < var_list->nod_count; i++) {
asgn_to(action, (REF) var_list->nod_arg[i]);
}
@ -2914,9 +2914,7 @@ static void gen_put_segment( const act* action)
// Generate BLR in raw, numeric form. Ughly but dense.
//
static void gen_raw(
const UCHAR* blr,
enum req_t request_type, int request_length, int ident)
static void gen_raw(const UCHAR* blr, req_t request_type, int request_length, int ident)
{
union {
UCHAR bytewise_blr[4];
@ -3449,7 +3447,7 @@ static void gen_select( const act* action)
gen_receive(action, port);
printa(names[COLUMN], false, "IF %s NOT = 0 THEN", name);
gpre_nod* var_list = (GPRE_NOD) action->act_object;
gpre_nod* var_list = (gpre_nod*) action->act_object;
if (var_list)
for (int i = 0; i < var_list->nod_count; i++) {
asgn_to(action, (REF) var_list->nod_arg[i]);

12
src/gpre/dyntable.cpp
View File

@ -24,7 +24,6 @@
//
//____________________________________________________________
//
// $Id: dyntable.cpp,v 1.11 2008-12-05 01:19:48 asfernandes Exp $
//
// CVC: Strange, this file is only referenced in a MacOsX project and gpre
// works directly with dyntable.h.
@ -35,10 +34,12 @@
#define NODE(dyn) {dyn, "dyn"},
struct dyn {
struct dyn
{
SSHORT dyn_value;
const char* dyn_string;
} dyn_table[] = {
} dyn_table[] =
{
NODE(gds__dyn_begin)
NODE(gds__dyn_end)
NODE(gds__dyn_if)
@ -132,18 +133,19 @@ int main()
max = 0;
for (const dyn* item = dyn_table; item->dyn_string; item++) {
if (table[item->dyn_value])
fprintf(stderr, "%s (%d) is duplicate\n",
item->dyn_string, item->dyn_value);
fprintf(stderr, "%s (%d) is duplicate\n", item->dyn_string, item->dyn_value);
table[item->dyn_value] = item->dyn_string;
if (item->dyn_value > max)
max = item->dyn_value;
}
for (int dyn_iter = 0; dyn_iter <= max; dyn_iter++)
{
if (table[dyn_iter])
printf(" \"%s\",\n", table[dyn_iter]);
else
printf(" NULL,\n");
}
return 0;
}

128
src/gpre/exp.cpp
View File

@ -47,34 +47,36 @@
const int ZERO_BASED = 0;
const int ONE_BASED = 1;
static bool check_relation(void);
static GPRE_NOD lookup_field(gpre_ctx*);
static GPRE_NOD make_and(GPRE_NOD, GPRE_NOD);
static GPRE_NOD make_list(gpre_lls*);
static GPRE_NOD normalize_index(dim*, GPRE_NOD, USHORT);
static GPRE_NOD par_and(gpre_req*);
static GPRE_NOD par_array(gpre_req*, gpre_fld*, bool, bool);
static GPRE_NOD par_boolean(gpre_req*);
static GPRE_NOD par_field(gpre_req*);
static GPRE_NOD par_multiply(gpre_req*, gpre_fld*);
static GPRE_NOD par_native_value(gpre_req*, gpre_fld*);
static GPRE_NOD par_not(gpre_req*);
static GPRE_NOD par_over(gpre_ctx*);
static GPRE_NOD par_primitive_value(gpre_req*, gpre_fld*);
static GPRE_NOD par_relational(gpre_req*);
static GPRE_NOD par_udf(gpre_req*, USHORT, gpre_fld*);
static GPRE_NOD par_value(gpre_req*, gpre_fld*);
static bool check_relation();
static gpre_nod* lookup_field(gpre_ctx*);
static gpre_nod* make_and(gpre_nod*, gpre_nod*);
static gpre_nod* make_list(gpre_lls*);
static gpre_nod* normalize_index(dim*, gpre_nod*, USHORT);
static gpre_nod* par_and(gpre_req*);
static gpre_nod* par_array(gpre_req*, gpre_fld*, bool, bool);
static gpre_nod* par_boolean(gpre_req*);
static gpre_nod* par_field(gpre_req*);
static gpre_nod* par_multiply(gpre_req*, gpre_fld*);
static gpre_nod* par_native_value(gpre_req*, gpre_fld*);
static gpre_nod* par_not(gpre_req*);
static gpre_nod* par_over(gpre_ctx*);
static gpre_nod* par_primitive_value(gpre_req*, gpre_fld*);
static gpre_nod* par_relational(gpre_req*);
static gpre_nod* par_udf(gpre_req*, USHORT, gpre_fld*);
static gpre_nod* par_value(gpre_req*, gpre_fld*);
static gpre_fld* global_count_field;
static gpre_fld* global_subscript_field;
struct rel_ops {
enum nod_t rel_op;
enum kwwords rel_kw;
struct rel_ops
{
nod_t rel_op;
kwwords_t rel_kw;
SSHORT rel_args;
};
static const rel_ops relops[] = {
static const rel_ops relops[] =
{
{ nod_eq, KW_EQ, 2 },
{ nod_eq, KW_EQUALS, 2 },
{ nod_equiv, KW_EQUIV, 2 },
@ -92,12 +94,14 @@ static const rel_ops relops[] = {
{ nod_any, KW_none, 0}
};
struct dtypes {
enum kwwords dtype_keyword;
struct dtypes
{
kwwords_t dtype_keyword;
USHORT dtype_dtype;
};
static const dtypes data_types[] = {
static const dtypes data_types[] =
{
{ KW_CHAR, dtype_text },
{ KW_VARYING, dtype_varying },
{ KW_STRING, dtype_cstring },
@ -116,7 +120,7 @@ static const dtypes data_types[] = {
// Parse array subscript.
//
GPRE_NOD EXP_array(gpre_req* request, gpre_fld* field, bool subscript_flag, bool sql_flag)
gpre_nod* EXP_array(gpre_req* request, gpre_fld* field, bool subscript_flag, bool sql_flag)
{
return par_array(request, field, subscript_flag, sql_flag);
}
@ -306,7 +310,7 @@ void EXP_left_paren(const TEXT* string)
// Parse a native literal constant value.
//
GPRE_NOD EXP_literal(void)
gpre_nod* EXP_literal()
{
switch (gpreGlob.sw_sql_dialect) {
case 1:
@ -319,7 +323,7 @@ GPRE_NOD EXP_literal(void)
}
ref* reference = (REF) MSC_alloc(REF_LEN);
gpre_nod* node = MSC_unary(nod_literal, (GPRE_NOD) reference);
gpre_nod* node = MSC_unary(nod_literal, (gpre_nod*) reference);
if (isQuoted(gpreGlob.token_global.tok_type)) {
TEXT* string = (TEXT *) MSC_alloc(gpreGlob.token_global.tok_length + 3);
reference->ref_value = string;
@ -614,7 +618,7 @@ REF EXP_post_field(gpre_fld* field, gpre_ctx* context, bool null_flag)
// and return FALSE.
//
bool EXP_match_paren(void)
bool EXP_match_paren()
{
if (MSC_match(KW_RIGHT_PAREN))
return true;
@ -629,7 +633,7 @@ bool EXP_match_paren(void)
// Parse and look up a qualified relation name.
//
gpre_rel* EXP_relation(void)
gpre_rel* EXP_relation()
{
if (!gpreGlob.isc_databases)
PAR_error("no database for operation");
@ -772,7 +776,7 @@ gpre_rse* EXP_rse(gpre_req* request, gpre_sym* initial_symbol)
}
gpre_nod* item = par_value(request, 0);
count++;
MSC_push((GPRE_NOD) (IPTR) ((direction) ? 1 : 0), &directions);
MSC_push((gpre_nod*) (IPTR) ((direction) ? 1 : 0), &directions);
if (insensitive) {
gpre_nod* upcase = MSC_node(nod_upcase, 1);
upcase->nod_arg[0] = item;
@ -788,8 +792,8 @@ gpre_rse* EXP_rse(gpre_req* request, gpre_sym* initial_symbol)
sort->nod_count = count;
gpre_nod** ptr = sort->nod_arg + count * 2;
while (--count >= 0) {
*--ptr = (GPRE_NOD) MSC_pop(&items);
*--ptr = (GPRE_NOD) MSC_pop(&directions);
*--ptr = (gpre_nod*) MSC_pop(&items);
*--ptr = (gpre_nod*) MSC_pop(&directions);
}
}
@ -811,7 +815,7 @@ gpre_rse* EXP_rse(gpre_req* request, gpre_sym* initial_symbol)
sort->nod_count = count;
gpre_nod** ptr = sort->nod_arg + count;
while (--count >= 0)
*--ptr = (GPRE_NOD) MSC_pop(&items);
*--ptr = (gpre_nod*) MSC_pop(&items);
}
else
break;
@ -858,10 +862,10 @@ void EXP_rse_cleanup( gpre_rse* rs)
// Parse a subscript value. This is called by PAR\par_slice.
//
GPRE_NOD EXP_subscript(gpre_req* request)
gpre_nod* EXP_subscript(gpre_req* request)
{
ref* reference = (REF) MSC_alloc(REF_LEN);
gpre_nod* node = MSC_unary(nod_value, (GPRE_NOD) reference);
gpre_nod* node = MSC_unary(nod_value, (gpre_nod*) reference);
// Special case literals
@ -890,7 +894,7 @@ GPRE_NOD EXP_subscript(gpre_req* request)
// Check current token for either a relation or database name.
//
static bool check_relation(void)
static bool check_relation()
{
// The current token is (i.e. should be) either a relation
// name or a database name. If it's a database name, search
@ -917,7 +921,7 @@ static bool check_relation(void)
// block) for field.
//
static GPRE_NOD lookup_field(gpre_ctx* context)
static gpre_nod* lookup_field(gpre_ctx* context)
{
SQL_resolve_identifier("<Field Name>", NULL, NAME_SIZE);
gpre_fld* field = MET_field(context->ctx_relation, gpreGlob.token_global.tok_string);
@ -928,7 +932,7 @@ static GPRE_NOD lookup_field(gpre_ctx* context)
reference->ref_field = field;
reference->ref_context = context;
return MSC_unary(nod_field, (GPRE_NOD) reference);
return MSC_unary(nod_field, (gpre_nod*) reference);
}
@ -939,7 +943,7 @@ static GPRE_NOD lookup_field(gpre_ctx* context)
// If both are null, return null.
//
static GPRE_NOD make_and( GPRE_NOD node1, GPRE_NOD node2)
static gpre_nod* make_and( gpre_nod* node1, gpre_nod* node2)
{
if (!node1)
return node2;
@ -956,7 +960,7 @@ static GPRE_NOD make_and( GPRE_NOD node1, GPRE_NOD node2)
// Make a generic variable length node from a stack.
//
static GPRE_NOD make_list( gpre_lls* stack)
static gpre_nod* make_list( gpre_lls* stack)
{
USHORT count = 0;
for (const gpre_lls* temp = stack; temp; temp = temp->lls_next)
@ -980,7 +984,7 @@ static GPRE_NOD make_list( gpre_lls* stack)
// in the user's program.
//
static GPRE_NOD normalize_index( dim* dimension, GPRE_NOD user_index, USHORT array_base)
static gpre_nod* normalize_index( dim* dimension, gpre_nod* user_index, USHORT array_base)
{
TEXT string[33];
bool negate = false;
@ -1006,7 +1010,7 @@ static GPRE_NOD normalize_index( dim* dimension, GPRE_NOD user_index, USHORT arr
char* tmp = (TEXT *) MSC_alloc(strlen(string));
reference->ref_value = tmp;
strcpy(tmp, string);
gpre_nod* adjustment_node = MSC_unary(nod_literal, (GPRE_NOD) reference);
gpre_nod* adjustment_node = MSC_unary(nod_literal, (gpre_nod*) reference);
gpre_nod* negate_node;
if (negate)
@ -1025,7 +1029,7 @@ static GPRE_NOD normalize_index( dim* dimension, GPRE_NOD user_index, USHORT arr
// Parse a boolean AND.
//
static GPRE_NOD par_and( gpre_req* request)
static gpre_nod* par_and( gpre_req* request)
{
gpre_nod* expr1 = par_not(request);
@ -1043,7 +1047,7 @@ static GPRE_NOD par_and( gpre_req* request)
// in an gpre_rse.
//
static GPRE_NOD par_array(gpre_req* request,
static gpre_nod* par_array(gpre_req* request,
gpre_fld* field, bool subscript_flag, bool sql_flag)
{
bool paren = false;
@ -1138,7 +1142,7 @@ static GPRE_NOD par_array(gpre_req* request,
// an OR node or anything of lower precedence.
//
static GPRE_NOD par_boolean( gpre_req* request)
static gpre_nod* par_boolean( gpre_req* request)
{
gpre_nod* expr1 = par_and(request);
@ -1154,7 +1158,7 @@ static GPRE_NOD par_boolean( gpre_req* request)
// Parse a field reference. Anything else is an error.
//
static GPRE_NOD par_field( gpre_req* request)
static gpre_nod* par_field( gpre_req* request)
{
const gpre_sym* symbol = gpreGlob.token_global.tok_symbol;
if (!symbol)
@ -1204,7 +1208,7 @@ static GPRE_NOD par_field( gpre_req* request)
reference->ref_context = context;
if (node->nod_type == nod_array)
reference->ref_flags |= REF_array_elem;
node->nod_arg[0] = (GPRE_NOD) reference;
node->nod_arg[0] = (gpre_nod*) reference;
}
else {
/* Field wants to straddle two gpreGlob.requests. We need to do
@ -1220,7 +1224,7 @@ static GPRE_NOD par_field( gpre_req* request)
value_reference->ref_source = reference;
node->nod_type = nod_value;
node->nod_arg[0] = (GPRE_NOD) value_reference;
node->nod_arg[0] = (gpre_nod*) value_reference;
}
if (upcase_flag) {
@ -1239,12 +1243,12 @@ static GPRE_NOD par_field( gpre_req* request)
// precedence operator plus/minus.
//
static GPRE_NOD par_multiply( gpre_req* request, gpre_fld* field)
static gpre_nod* par_multiply( gpre_req* request, gpre_fld* field)
{
gpre_nod* node = par_primitive_value(request, field);
while (true) {
enum nod_t nod_type;
nod_t nod_type;
if (MSC_match(KW_ASTERISK))
nod_type = nod_times;
else if (MSC_match(KW_SLASH))
@ -1263,7 +1267,7 @@ static GPRE_NOD par_multiply( gpre_req* request, gpre_fld* field)
// Parse a native C value.
//
static GPRE_NOD par_native_value( gpre_req* request, gpre_fld* field)
static gpre_nod* par_native_value( gpre_req* request, gpre_fld* field)
{
TEXT s[64];
@ -1277,7 +1281,7 @@ static GPRE_NOD par_native_value( gpre_req* request, gpre_fld* field)
}
ref* reference = (REF) MSC_alloc(REF_LEN);
gpre_nod* node = MSC_unary(nod_value, (GPRE_NOD) reference);
gpre_nod* node = MSC_unary(nod_value, (gpre_nod*) reference);
// Handle general native value references. Since these values will need
// to be exported to the database system, make sure there is a reference
@ -1303,7 +1307,7 @@ static GPRE_NOD par_native_value( gpre_req* request, gpre_fld* field)
// Parse either a boolean NOT or a boolean parenthetical.
//
static GPRE_NOD par_not( gpre_req* request)
static gpre_nod* par_not( gpre_req* request)
{
if (MSC_match(KW_LEFT_PAREN)) {
gpre_nod* anode = par_boolean(request);
@ -1327,7 +1331,7 @@ static GPRE_NOD par_not( gpre_req* request)
// Parse the substance of an OVER clause (but not the leading keyword).
//
static GPRE_NOD par_over( gpre_ctx* context)
static gpre_nod* par_over( gpre_ctx* context)
{
TEXT s[64];
@ -1365,7 +1369,7 @@ static GPRE_NOD par_over( gpre_ctx* context)
// precedence operator plus/minus.
//
static GPRE_NOD par_primitive_value( gpre_req* request, gpre_fld* field)
static gpre_nod* par_primitive_value( gpre_req* request, gpre_fld* field)
{
if (MSC_match(KW_MINUS))
return MSC_unary(nod_negate, par_primitive_value(request, field));
@ -1417,12 +1421,12 @@ static GPRE_NOD par_primitive_value( gpre_req* request, gpre_fld* field)
// Parse a relational expression.
//
static GPRE_NOD par_relational( gpre_req* request)
static gpre_nod* par_relational( gpre_req* request)
{
if (MSC_match(KW_ANY)) {
gpre_nod* expr = MSC_node(nod_any, 1);
expr->nod_count = 0;
expr->nod_arg[0] = (GPRE_NOD) EXP_rse(request, 0);
expr->nod_arg[0] = (gpre_nod*) EXP_rse(request, 0);
EXP_rse_cleanup((gpre_rse*) expr->nod_arg[0]);
return expr;
}
@ -1430,7 +1434,7 @@ static GPRE_NOD par_relational( gpre_req* request)
if (MSC_match(KW_UNIQUE)) {
gpre_nod* expr = MSC_node(nod_unique, 1);
expr->nod_count = 0;
expr->nod_arg[0] = (GPRE_NOD) EXP_rse(request, 0);
expr->nod_arg[0] = (gpre_nod*) EXP_rse(request, 0);
EXP_rse_cleanup((gpre_rse*) expr->nod_arg[0]);
return expr;
}
@ -1523,7 +1527,7 @@ static GPRE_NOD par_relational( gpre_req* request)
// complain bitterly.
//
static GPRE_NOD par_udf( gpre_req* request, USHORT type, gpre_fld* field)
static gpre_nod* par_udf( gpre_req* request, USHORT type, gpre_fld* field)
{
if (!request)
return NULL;
@ -1538,7 +1542,7 @@ static GPRE_NOD par_udf( gpre_req* request, USHORT type, gpre_fld* field)
{
gpre_nod* node = MSC_node(nod_udf, 2);
node->nod_count = 1;
node->nod_arg[1] = (GPRE_NOD) new_udf;
node->nod_arg[1] = (gpre_nod*) new_udf;
PAR_get_token();
if (!MSC_match(KW_LEFT_PAREN))
EXP_left_paren(0);
@ -1563,12 +1567,12 @@ static GPRE_NOD par_udf( gpre_req* request, USHORT type, gpre_fld* field)
// precedence operator plus/minus.
//
static GPRE_NOD par_value( gpre_req* request, gpre_fld* field)
static gpre_nod* par_value( gpre_req* request, gpre_fld* field)
{
gpre_nod* node = par_multiply(request, field);
while (true) {
enum nod_t nod_type;
nod_t nod_type;
if (MSC_match(KW_PLUS))
nod_type = nod_plus;
else if (MSC_match(KW_MINUS))

10
src/gpre/exp_proto.h
View File

@ -24,19 +24,19 @@
#ifndef GPRE_EXP_PROTO_H
#define GPRE_EXP_PROTO_H
GPRE_NOD EXP_array(gpre_req*, gpre_fld*, bool, bool);
gpre_nod* EXP_array(gpre_req*, gpre_fld*, bool, bool);
gpre_fld* EXP_cast(gpre_fld*);
gpre_ctx* EXP_context(gpre_req*, gpre_sym*);
gpre_fld* EXP_field(gpre_ctx**);
void EXP_left_paren(const TEXT*);
GPRE_NOD EXP_literal(void);
gpre_nod* EXP_literal();
void EXP_post_array(REF);
REF EXP_post_field(gpre_fld*, gpre_ctx*, bool);
bool EXP_match_paren(void);
gpre_rel* EXP_relation(void);
bool EXP_match_paren();
gpre_rel* EXP_relation();
gpre_rse* EXP_rse(gpre_req*, gpre_sym*);
void EXP_rse_cleanup(gpre_rse*);
GPRE_NOD EXP_subscript(gpre_req*);
gpre_nod* EXP_subscript(gpre_req*);
SLONG EXP_SLONG_ordinal(bool);
SINT64 EXP_SINT64_ordinal(bool);
SSHORT EXP_SSHORT_ordinal(bool);

39
src/gpre/ftn.cpp
View File

@ -89,7 +89,7 @@ static void gen_dyn_open (const act*);
static void gen_dyn_prepare (const act*);
static void gen_emodify (const act*);
static void gen_estore (const act*);
static void gen_end_fetch (void);
static void gen_end_fetch ();
static void gen_endfor (const act*);
static void gen_erase (const act*);
static SSHORT gen_event_block (const act*);
@ -109,7 +109,7 @@ static void gen_put_segment (const act*);
/* RRK_?: the following prototype is differnet from C stuff */
static void gen_raw(const UCHAR*, enum req_t, int, int, int);
static void gen_raw(const UCHAR*, req_t, int, int, int);
static void gen_ready (const act*);
static void gen_receive (const act*, const gpre_port*);
@ -143,7 +143,7 @@ static TEXT* make_name (TEXT* const, const gpre_sym*);
static void make_ok_test (const act*, const gpre_req*);
static void make_port (const gpre_port*);
static void make_ready (DBB, const TEXT*, const TEXT*, const gpre_req*);
static USHORT next_label (void);
static USHORT next_label ();
static void printa(const TEXT*, const TEXT*, ...);
#ifdef NOT_USED_OR_REPLACED
static void printb(const TEXT*, ...);
@ -579,7 +579,7 @@ void FTN_action(const act* action, int column)
// all databases not declared as extern
//
void FTN_fini(void)
void FTN_fini()
{
if (!gpreGlob.global_db_count)
return;
@ -2050,7 +2050,7 @@ static void gen_estore(const act* action)
// the AT_END clause.
//
static void gen_end_fetch(void)
static void gen_end_fetch()
{
printa(COLUMN, "END IF");
}
@ -2093,16 +2093,16 @@ static void gen_erase(const act* action)
static SSHORT gen_event_block(const act* action)
{
GPRE_NOD init = (GPRE_NOD) action->act_object;
gpre_nod* init = (gpre_nod*) action->act_object;
int ident = CMP_next_ident();
init->nod_arg[2] = (GPRE_NOD) ident;
init->nod_arg[2] = (gpre_nod*) ident;
printa(COLUMN, "INTEGER*4 isc_%dA", ident);
printa(COLUMN, "INTEGER*4 isc_%dB", ident);
printa(COLUMN, "INTEGER*2 isc_%dL", ident);
GPRE_NOD list = init->nod_arg[1];
gpre_nod* list = init->nod_arg[1];
return list->nod_count;
}
@ -2127,8 +2127,8 @@ static void gen_event_init(const act* action)
const TEXT* pattern3 =
"CALL %S2 (ISC_EVENTS, %VFISC_%N1L%VE, %VFISC_%N1A%VE, %VFISC_%N1B%VE)";
GPRE_NOD init = (GPRE_NOD) action->act_object;
GPRE_NOD event_list = init->nod_arg[1];
gpre_nod* init = (gpre_nod*) action->act_object;
gpre_nod* event_list = init->nod_arg[1];
PAT args;
args.pat_database = (DBB) init->nod_arg[3];
@ -2144,11 +2144,11 @@ static void gen_event_init(const act* action)
TEXT variable[MAX_REF_SIZE];
SSHORT count = 0;
GPRE_NOD* ptr = event_list->nod_arg;
for (GPRE_NOD* end = ptr + event_list->nod_count; ptr < end; ptr++)
gpre_nod** ptr = event_list->nod_arg;
for (gpre_nod** const end = ptr + event_list->nod_count; ptr < end; ptr++)
{
count++;
GPRE_NOD node = *ptr;
gpre_nod* node = *ptr;
if (node->nod_type == nod_field) {
const ref* reference = (const ref*) node->nod_arg[0];
gen_name(variable, reference, true);
@ -2205,7 +2205,7 @@ static void gen_event_wait(const act* action)
DBB database = NULL;
for (gpre_lls* stack_ptr = gpreGlob.events; stack_ptr; stack_ptr = stack_ptr->lls_next) {
const act* event_action = (const act*) stack_ptr->lls_object;
GPRE_NOD event_init = (GPRE_NOD) event_action->act_object;
gpre_nod* event_init = (gpre_nod*) event_action->act_object;
const gpre_sym* stack_name = (const gpre_sym*) event_init->nod_arg[0];
if (!strcmp(event_name->sym_string, stack_name->sym_string)) {
ident = (int) event_init->nod_arg[2];
@ -2259,7 +2259,7 @@ static void gen_fetch(const act* action)
gen_name(s, request->req_eof, true));
printa(COLUMN, "SQLCODE = 0");
GPRE_NOD var_list = (GPRE_NOD) action->act_object;
gpre_nod* var_list = (gpre_nod*) action->act_object;
if (var_list) {
for (int i = 0; i < var_list->nod_count; i++) {
asgn_to(action, (const ref*) var_list->nod_arg[i]);
@ -2651,10 +2651,7 @@ static void gen_put_segment(const act* action)
// Generate BLR in raw, numeric form. Ughly but dense.
//
static void gen_raw(
const UCHAR* blr,
enum req_t request_type,
int request_length, int begin_c, int end_c)
static void gen_raw(const UCHAR* blr, req_t request_type, int request_length, int begin_c, int end_c)
{
union {
UCHAR bytewise_blr[4];
@ -3181,7 +3178,7 @@ static void gen_select(const act* action)
printa(COLUMN, "IF (SQLCODE .EQ. 0) THEN");
gen_receive(action, port);
printa(COLUMN, "IF (%s .NE. 0) THEN", name);
GPRE_NOD var_list = (GPRE_NOD) action->act_object;
gpre_nod* var_list = (gpre_nod*) action->act_object;
if (var_list)
{
for (int i = 0; i < var_list->nod_count; ++i)
@ -3944,7 +3941,7 @@ static void make_ready( DBB db, const TEXT* filename, const TEXT* vector,
// label as used.
//
static USHORT next_label(void)
static USHORT next_label()
{
UCHAR* byte = gpreGlob.fortran_labels;
while (*byte == 255)

14
src/gpre/gpre.cpp
View File

@ -1077,7 +1077,7 @@ TOK CPR_eol_token()
gpreGlob.token_global.tok_white_space = 0;
gpreGlob.token_global.tok_position = position;
gpreGlob.token_global.tok_symbol = HSH_lookup(gpreGlob.token_global.tok_string);
gpreGlob.token_global.tok_keyword = (KWWORDS) gpreGlob.token_global.tok_symbol->sym_keyword;
gpreGlob.token_global.tok_keyword = (kwwords_t) gpreGlob.token_global.tok_symbol->sym_keyword;
if (sw_trace)
puts(gpreGlob.token_global.tok_string);
@ -2006,7 +2006,7 @@ static TOK get_token()
gpreGlob.token_global.tok_white_space = 0;
gpreGlob.token_global.tok_position = start_position + 1;
gpreGlob.token_global.tok_symbol = HSH_lookup(gpreGlob.token_global.tok_string);
gpreGlob.token_global.tok_keyword = (KWWORDS) gpreGlob.token_global.tok_symbol->sym_keyword;
gpreGlob.token_global.tok_keyword = (kwwords_t) gpreGlob.token_global.tok_symbol->sym_keyword;
return &gpreGlob.token_global;
}
}
@ -2214,7 +2214,7 @@ static TOK get_token()
else
gpreGlob.token_global.tok_symbol = symbol = NULL;
if (symbol && symbol->sym_type == SYM_keyword)
gpreGlob.token_global.tok_keyword = (KWWORDS) symbol->sym_keyword;
gpreGlob.token_global.tok_keyword = (kwwords_t) symbol->sym_keyword;
else
gpreGlob.token_global.tok_keyword = KW_none;
}
@ -2222,14 +2222,14 @@ static TOK get_token()
if (!gpreGlob.override_case) {
gpreGlob.token_global.tok_symbol = symbol = HSH_lookup2(gpreGlob.token_global.tok_string);
if (symbol && symbol->sym_type == SYM_keyword)
gpreGlob.token_global.tok_keyword = (KWWORDS) symbol->sym_keyword;
gpreGlob.token_global.tok_keyword = (kwwords_t) symbol->sym_keyword;
else
gpreGlob.token_global.tok_keyword = KW_none;
}
else {
gpreGlob.token_global.tok_symbol = symbol = HSH_lookup(gpreGlob.token_global.tok_string);
if (symbol && symbol->sym_type == SYM_keyword)
gpreGlob.token_global.tok_keyword = (KWWORDS) symbol->sym_keyword;
gpreGlob.token_global.tok_keyword = (kwwords_t) symbol->sym_keyword;
else
gpreGlob.token_global.tok_keyword = KW_none;
gpreGlob.override_case = false;
@ -2238,7 +2238,7 @@ static TOK get_token()
else {
gpreGlob.token_global.tok_symbol = symbol = HSH_lookup(gpreGlob.token_global.tok_string);
if (symbol && symbol->sym_type == SYM_keyword)
gpreGlob.token_global.tok_keyword = (KWWORDS) symbol->sym_keyword;
gpreGlob.token_global.tok_keyword = (kwwords_t) symbol->sym_keyword;
else
gpreGlob.token_global.tok_keyword = KW_none;
}
@ -2255,7 +2255,7 @@ static TOK get_token()
{
gpreGlob.token_global.tok_symbol = symbol = HSH_lookup2(gpreGlob.token_global.tok_string);
if (symbol && symbol->sym_type == SYM_keyword)
gpreGlob.token_global.tok_keyword = (KWWORDS) symbol->sym_keyword;
gpreGlob.token_global.tok_keyword = (kwwords_t) symbol->sym_keyword;
else
gpreGlob.token_global.tok_keyword = KW_none;
}

127
src/gpre/gpre.h
View File

@ -150,7 +150,8 @@ bool isAnsiCobol(cob_t dialect);
/* Structure used by Fortran and Basic to determine whether or not
an array has been declared in a subroutine. */
struct adl {
struct adl
{
ULONG adl_gds_ident; /* Identifier of array for which Gpre has
generated a declaration in main or a
subroutine */
@ -162,7 +163,8 @@ const size_t ADL_LEN = sizeof(adl);
/* database block data, for generating block data section in fussy fortran */
struct dbd {
struct dbd
{
enum {dbb_size = 128};
TEXT dbb_name[dbb_size]; /* database name */
};
@ -175,7 +177,8 @@ struct dbd {
*
*/
struct dim {
struct dim
{
int dim_number; /* Dimension number i (i=1 to n) */
SLONG dim_lower; /* Lower bound */
SLONG dim_upper; /* Upper bound */
@ -186,14 +189,15 @@ struct dim {
const size_t DIM_LEN = sizeof(dim);
typedef struct fil {
struct gpre_file
{
SLONG fil_length; /* File length in pages */
SLONG fil_start; /* Starting page */
TEXT *fil_name; /* File name */
fil* fil_next; /* next file */
gpre_file* fil_next; /* next file */
USHORT fil_shadow_number; /* shadow number if part of shadow */
USHORT fil_flags;
} *FIL;
};
enum fil_flags_vals {
FIL_manual = 1, // Manual shadow
@ -201,25 +205,27 @@ enum fil_flags_vals {
FIL_conditional = 4 // Conditional shadow
};
const size_t FIL_LEN = sizeof(fil);
const size_t FIL_LEN = sizeof(gpre_file);
/* filter block */
typedef struct fltr {
struct gpre_filter
{
TEXT *fltr_name;
const TEXT *fltr_entry_point;
const TEXT *fltr_module_name;
SSHORT fltr_input_type;
SSHORT fltr_output_type;
} *FLTR;
};
const size_t FLTR_LEN = sizeof(fltr);
const size_t FLTR_LEN = sizeof(gpre_filter);
/* General Syntax node, produced by parser */
typedef enum nod_t {
enum nod_t {
nod_nothing = 0,
nod_field = 1, nod_literal, nod_value,
nod_and, nod_or, nod_not,
nod_eq, nod_equiv, nod_ne, nod_ge,
@ -256,14 +262,15 @@ typedef enum nod_t {
nod_current_role, nod_current_transaction,
nod_coalesce, nod_case, nod_case1,
nod_substring,
nod_LASTNOD /* Leave this debugging GPRE_NOD last */
} NOD_T;
nod_LASTNOD /* Leave this debugging gpre_nod last */
};
typedef struct gpre_nod {
enum nod_t nod_type; /* node type */
struct gpre_nod
{
nod_t nod_type; /* node type */
USHORT nod_count; /* number of sub-items */
gpre_nod* nod_arg[1]; /* argument */
} *GPRE_NOD;
};
inline size_t NOD_LEN(const size_t cnt)
{
@ -321,7 +328,8 @@ enum swe_condition_vals {
/* Text block */
struct gpre_txt {
struct gpre_txt
{
ULONG txt_position;
USHORT txt_length;
};
@ -331,7 +339,8 @@ const size_t TXT_LEN = sizeof(gpre_txt);
/* User name -- used for SQL GRANT/REVOKE */
struct gpre_usn {
struct gpre_usn
{
gpre_usn* usn_next;
SCHAR *usn_name;
USHORT usn_dyn; /* describes the type of user via a dyn-verb,
@ -343,26 +352,29 @@ const size_t USN_LEN = sizeof(gpre_usn);
/* value block, used to store a set of values */
typedef struct val {
val* val_next; /* next value in list */
struct gpre_value
{
gpre_value* val_next; /* next value in list */
const TEXT* val_value; /* value */
} *VAL;
};
const size_t VAL_LEN = sizeof(val);
const size_t VAL_LEN = sizeof(gpre_value);
/* Array information block. Used to hold info about an array field.
Note: the dimension (dim) block used to hold dimension information.
The preferred mechanism is the repeating tail on the array block. */
struct ary {
struct ary
{
USHORT ary_dtype; /* data type of array */
int ary_dimension_count; /* Number of dimensions in this array */
dim* ary_dimension; /* Linked list of range info for each dimension */
SLONG ary_size; /* Size of the array */
ULONG ary_ident; /* Array identifier */
bool ary_declared; /* True if a declaration already was generated */
struct ary_repeat {
struct ary_repeat
{
SLONG ary_lower;
SLONG ary_upper;
} ary_rpt[MAX_ARRAY_DIMENSIONS];
@ -378,7 +390,8 @@ const size_t ARY_LEN = sizeof(ary);
use is to create a trigger for CHECK constraints which always
abort on error */
struct gpre_trg {
struct gpre_trg
{
str* trg_name;
USHORT trg_type; /* Type of trigger */
str* trg_source; /* source for trigger */
@ -526,7 +539,7 @@ struct gpre_rel;
class gpre_req;
class ref;
typedef enum act_t {
enum act_t {
ACT_any,
ACT_alter_database,
ACT_alter_domain,
@ -636,14 +649,14 @@ typedef enum act_t {
ACT_sql_dialect,
ACT_LASTACT /* leave this debugging ACT last */
} ACT_T;
};
/* Action block, used to make action points in source */
struct act {
SLONG act_position; /* position in input stream */
SLONG act_length; /* length to be commented out */
enum act_t act_type; /* type of action */
act_t act_type; /* type of action */
act* act_next; /* next action in request */
act* act_rest; /* remaining actions in module */
act* act_error; /* on-error action (maybe) */
@ -698,7 +711,7 @@ enum sym_t {
struct gpre_sym {
const char* sym_string; /* address of asciz string */
enum sym_t sym_type; /* symbol type */
sym_t sym_type; /* symbol type */
USHORT sym_keyword; /* keyword number, if keyword */
gpre_ctx* sym_object; /* general pointer to object */
gpre_sym* sym_collision; /* collision pointer */
@ -818,12 +831,12 @@ typedef struct dbb {
int dbb_buffersize;
int dbb_users;
ULONG dbb_length; /* Length of database in pages, if known */
fil* dbb_logfiles;
gpre_file* dbb_logfiles;
#ifdef SCROLLABLE_CURSORS
SSHORT dbb_base_level; /* code level of the engine we are talking to */
#endif
fil* dbb_cache_file;
fil* dbb_files;
gpre_file* dbb_cache_file;
gpre_file* dbb_files;
} *DBB;
const size_t DBB_LEN = sizeof(dbb);
@ -919,7 +932,7 @@ struct gpre_rse {
gpre_nod* rse_plan; /* user-specified access plan */
map* rse_map; /* map for aggregates */
gpre_rse* rse_aggregate; /* Aggregate rse */
enum nod_t rse_join_type; /* Join type */
nod_t rse_join_type; /* Join type */
USHORT rse_flags; /* flags */
USHORT rse_count; /* number of relations */
gpre_ctx* rse_context[1]; /* context block */
@ -1065,18 +1078,19 @@ enum fld_flags_vals {
};
typedef enum {
enum fun_t {
FUN_value,
FUN_reference,
FUN_descriptor,
FUN_blob_struct,
FUN_scalar_array
} FUN_T;
};
/* Port block */
struct gpre_port {
struct gpre_port
{
USHORT por_msg_number; /* message number within request */
ULONG por_ident; /* ident in source */
int por_length; /* length of port in bytes */
@ -1090,14 +1104,16 @@ const size_t POR_LEN = sizeof(gpre_port);
/* Slice description block */
struct slc {
struct slc
{
gpre_req* slc_parent_request; /* request for blob id */
gpre_fld* slc_field; /* database array field */
gpre_nod* slc_array; /* user defined array */
ref* slc_field_ref; /* array field reference */
USHORT slc_dimensions; /* dimensions */
USHORT slc_parameters; /* number of parameters */
struct slc_repeat {
struct slc_repeat
{
gpre_nod* slc_lower;
gpre_nod* slc_upper;
} slc_rpt[1];
@ -1131,10 +1147,11 @@ enum req_t {
REQ_LASTREQUEST /* Leave this debugging gpre_req last */
};
class gpre_req {
public:
class gpre_req
{
public:
enum req_t req_type; /* request type */
req_t req_type; /* request type */
ULONG req_ident; /* ident for request handle */
USHORT req_act_flag; /* activity flag ident, if used */
int req_length; /* blr length of request */
@ -1184,21 +1201,26 @@ class gpre_req {
USHORT req_in_subselect; /* processing a subselect clause */
ULONG req_flags;
inline void add_end() {
inline void add_end()
{
*req_blr++ = isc_dyn_end;
}
inline void add_byte(const int byte) {
inline void add_byte(const int byte)
{
*req_blr++ = (SCHAR) (byte);
}
inline void add_word(const int word) {
inline void add_word(const int word)
{
add_byte(word);
add_byte(word >> 8);
}
inline void add_long(const long lg) {
inline void add_long(const long lg)
{
add_word(lg);
add_word(lg >> 16);
}
inline void add_cstring(const char* string) {
inline void add_cstring(const char* string)
{
add_byte(strlen(string));
UCHAR c;
while (c = *string++) {
@ -1248,7 +1270,7 @@ const size_t CTX_LEN = sizeof(gpre_ctx);
/* Field reference */
class ref {
public:
public:
USHORT ref_ident; /* identifier */
USHORT ref_level; /* highest level of access */
@ -1264,7 +1286,7 @@ class ref {
ref* ref_friend; /* value for variable */
gpre_nod* ref_expr; /* expression, if node is expression */
const TEXT* ref_value; /* value string if host language value */
val* ref_values; /* linked list of values */
gpre_value* ref_values; /* linked list of values */
const TEXT* ref_null_value; /* value string if host language value */
UCHAR* ref_sdl; /* Raw slice description language for an array */
UCHAR* ref_sdl_base; /* base of sdl string during generation */
@ -1275,14 +1297,17 @@ class ref {
USHORT ref_flags;
SSHORT ref_ttype; /* Character set type for literals */
inline void add_byte(const int byte) {
inline void add_byte(const int byte)
{
*ref_sdl++ = (UCHAR) byte;
}
inline void add_word(const int word) {
inline void add_word(const int word)
{
add_byte(word);
add_byte(word >> 8);
}
inline void add_long(const long lg) {
inline void add_long(const long lg)
{
add_word(lg);
add_word(lg >> 16);
}

20
src/gpre/gpre_meta.epp
View File

@ -682,7 +682,7 @@ gpre_lls* MET_get_primary_key(dbb* database, const TEXT* relation_name)
*tmp++;
*tmp = '\0';
MSC_push((GPRE_NOD) field_name, ptr_fields);
MSC_push((gpre_nod*) field_name, ptr_fields);
ptr_fields = &(*ptr_fields)->lls_next;
END_FOR
@ -848,21 +848,21 @@ gpre_fld* MET_field(gpre_rel* relation, const char* string)
* Return a list of the fields in a relation
*/
GPRE_NOD MET_fields(gpre_ctx* context)
gpre_nod* MET_fields(gpre_ctx* context)
{
gpre_fld* field;
GPRE_NOD field_node;
gpre_nod* field_node;
REF reference;
gpre_prc* procedure = context->ctx_procedure;
if (procedure) {
GPRE_NOD node = MSC_node(nod_list, procedure->prc_out_count);
gpre_nod* node = MSC_node(nod_list, procedure->prc_out_count);
//count = 0;
for (field = procedure->prc_outputs; field; field = field->fld_next) {
reference = (REF) MSC_alloc(REF_LEN);
reference->ref_field = field;
reference->ref_context = context;
field_node = MSC_unary(nod_field, (GPRE_NOD) reference);
field_node = MSC_unary(nod_field, (gpre_nod*) reference);
node->nod_arg[field->fld_position] = field_node;
//count++;
}
@ -875,13 +875,13 @@ GPRE_NOD MET_fields(gpre_ctx* context)
for (field = relation->rel_fields; field; field = field->fld_next) {
++count;
}
GPRE_NOD anode = MSC_node(nod_list, count);
gpre_nod* anode = MSC_node(nod_list, count);
//count = 0;
for (field = relation->rel_fields; field; field = field->fld_next) {
reference = (REF) MSC_alloc(REF_LEN);
reference->ref_field = field;
reference->ref_context = context;
field_node = MSC_unary(nod_field, (GPRE_NOD) reference);
field_node = MSC_unary(nod_field, (gpre_nod*) reference);
anode->nod_arg[field->fld_position] = field_node;
//count++;
}
@ -907,18 +907,18 @@ GPRE_NOD MET_fields(gpre_ctx* context)
// This code stops at the first blank.
for (p = RFR.RDB$FIELD_NAME; *p && *p != ' '; p++);
*p = 0;
MSC_push((GPRE_NOD) MET_field(relation, RFR.RDB$FIELD_NAME), &stack);
MSC_push((gpre_nod*) MET_field(relation, RFR.RDB$FIELD_NAME), &stack);
count++;
END_FOR;
GPRE_NOD node = MSC_node(nod_list, count);
gpre_nod* node = MSC_node(nod_list, count);
while (stack) {
field = (gpre_fld*) MSC_pop(&stack);
reference = (REF) MSC_alloc(REF_LEN);
reference->ref_field = field;
reference->ref_context = context;
field_node = MSC_unary(nod_field, (GPRE_NOD) reference);
field_node = MSC_unary(nod_field, (gpre_nod*) reference);
node->nod_arg[--count] = field_node;
}

2
src/gpre/gpre_meta.h
View File

@ -28,7 +28,7 @@ gpre_fld* MET_context_field(gpre_ctx*, const char*);
bool MET_database(DBB, bool);
bool MET_domain_lookup(gpre_req*, gpre_fld*, const char*);
gpre_fld* MET_field(gpre_rel*, const char*);
GPRE_NOD MET_fields(gpre_ctx*);
gpre_nod* MET_fields(gpre_ctx*);
void MET_fini(DBB);
const SCHAR* MET_generator(const TEXT*, DBB);
bool MET_get_column_default(const gpre_rel*, const TEXT*, TEXT*, USHORT);

9
src/gpre/gpre_meta_boot.cpp
View File

@ -273,10 +273,11 @@ gpre_fld* MET_field(gpre_rel* relation, const char* string)
* Return a list of the fields in a relation
*/
GPRE_NOD MET_fields(gpre_ctx* context)
gpre_nod* MET_fields(gpre_ctx* context)
{
gpre_fld* field;
GPRE_NOD node, field_node;
gpre_nod* node;
gpre_nod* field_node;
REF reference;
gpre_prc* procedure = context->ctx_procedure;
@ -287,7 +288,7 @@ GPRE_NOD MET_fields(gpre_ctx* context)
reference = (REF) MSC_alloc(REF_LEN);
reference->ref_field = field;
reference->ref_context = context;
field_node = MSC_unary(nod_field, (GPRE_NOD)reference);
field_node = MSC_unary(nod_field, (gpre_nod*) reference);
node->nod_arg[field->fld_position] = field_node;
//count++;
}
@ -306,7 +307,7 @@ GPRE_NOD MET_fields(gpre_ctx* context)
reference = (REF) MSC_alloc(REF_LEN);
reference->ref_field = field;
reference->ref_context = context;
field_node = MSC_unary(nod_field, (GPRE_NOD)reference);
field_node = MSC_unary(nod_field, (gpre_nod*) reference);
node->nod_arg[field->fld_position] = field_node;
//count++;
}

10
src/gpre/gpre_proto.h
View File

@ -26,7 +26,7 @@
#include "../gpre/parse.h"
void CPR_abort(void);
void CPR_abort();
#ifdef DEV_BUILD
void CPR_assert(const TEXT*, int);
#endif
@ -35,12 +35,12 @@ void CPR_end_text(gpre_txt*);
int CPR_error(const TEXT*);
void CPR_exit(int);
void CPR_warn(const TEXT*);
TOK CPR_eol_token(void);
TOK CPR_eol_token();
void CPR_get_text(TEXT*, const gpre_txt*);
void CPR_raw_read(void);
void CPR_raw_read();
void CPR_s_error(const TEXT*);
gpre_txt* CPR_start_text(void);
TOK CPR_token(void);
gpre_txt* CPR_start_text();
TOK CPR_token();
#endif // GPRE_GPRE_PROTO_H

12
src/gpre/hsh.cpp
View File

@ -43,10 +43,12 @@ const int HASH_SIZE = 211;
static gpre_sym* hash_table[HASH_SIZE];
static gpre_sym* key_symbols;
static struct word {
static struct word
{
const char* keyword;
enum kwwords id;
} keywords[] = {
kwwords_t id;
} keywords[] =
{
#include "../gpre/hsh.h"
};
@ -56,7 +58,7 @@ static struct word {
// Release space used by keywords.
//
void HSH_fini(void)
void HSH_fini()
{
while (key_symbols) {
gpre_sym* symbol = key_symbols;
@ -73,7 +75,7 @@ void HSH_fini(void)
// inserting all known keywords.
//
void HSH_init(void)
void HSH_init()
{
//const char *string;

4
src/gpre/hsh_proto.h
View File

@ -24,8 +24,8 @@
#ifndef GPRE_HSH_PROTO_H
#define GPRE_HSH_PROTO_H
void HSH_fini(void);
void HSH_init(void);
void HSH_fini();
void HSH_init();
void HSH_insert(gpre_sym*);
gpre_sym* HSH_lookup(const SCHAR*);
gpre_sym* HSH_lookup2(const SCHAR*);

2
src/gpre/lang_proto.h
View File

@ -34,7 +34,7 @@ void COB_action(const act*, int);
void COB_name_init(bool);
void COB_print_buffer(TEXT*, bool);
void FTN_action(const act*, int);
void FTN_fini(void);
void FTN_fini();
void FTN_print_buffer(TEXT*);
void INT_action(const act*, int);
void INT_CXX_action(const act*, int);

62
src/gpre/msc.cpp
View File

@ -54,12 +54,14 @@
#include "../jrd/gds_proto.h"
typedef struct spc {
spc* spc_next;
struct gpre_space
{
gpre_space* spc_next;
SLONG spc_remaining;
} *SPC;
};
static SPC space, permanent_space;
static gpre_space* space;
static gpre_space* permanent_space;
static gpre_lls* free_lls;
@ -68,7 +70,7 @@ static gpre_lls* free_lls;
// Make an action and link it to a request.
//
act* MSC_action( gpre_req* request, enum act_t type)
act* MSC_action( gpre_req* request, act_t type)
{
act* action = (act*) MSC_alloc(ACT_LEN);
action->act_type = type;
@ -93,7 +95,7 @@ UCHAR* MSC_alloc(int size)
if (!space || size > space->spc_remaining) {
const int n = MAX(size, 4096);
SPC next = (SPC) gds__alloc((SLONG) (n + sizeof(spc)));
gpre_space* next = (gpre_space*) gds__alloc((SLONG) (n + sizeof(gpre_space)));
if (!next)
CPR_error("virtual memory exhausted");
#ifdef DEBUG_GDS_ALLOC
@ -106,7 +108,7 @@ UCHAR* MSC_alloc(int size)
}
space->spc_remaining -= size;
UCHAR* blk = ((UCHAR*) space + sizeof(spc) + space->spc_remaining);
UCHAR* blk = ((UCHAR*) space + sizeof(gpre_space) + space->spc_remaining);
memset(blk, 0, size);
return blk;
@ -124,7 +126,7 @@ UCHAR* MSC_alloc_permanent(int size)
if (!permanent_space || size > permanent_space->spc_remaining) {
const int n = MAX(size, 4096);
SPC next = (SPC) gds__alloc((SLONG) (n + sizeof(spc)));
gpre_space* next = (gpre_space*) gds__alloc((SLONG) (n + sizeof(gpre_space)));
if (!next)
CPR_error("virtual memory exhausted");
#ifdef DEBUG_GDS_ALLOC
@ -137,7 +139,7 @@ UCHAR* MSC_alloc_permanent(int size)
}
permanent_space->spc_remaining -= size;
UCHAR* blk = ((UCHAR*) permanent_space + sizeof(spc) +
UCHAR* blk = ((UCHAR*) permanent_space + sizeof(gpre_space) +
permanent_space->spc_remaining);
memset(blk, 0, size);
@ -150,9 +152,9 @@ UCHAR* MSC_alloc_permanent(int size)
// Make a binary node.
//
GPRE_NOD MSC_binary(NOD_T type, GPRE_NOD arg1, GPRE_NOD arg2)
gpre_nod* MSC_binary(nod_t type, gpre_nod* arg1, gpre_nod* arg2)
{
GPRE_NOD node = MSC_node(type, 2);
gpre_nod* node = MSC_node(type, 2);
node->nod_arg[0] = arg1;
node->nod_arg[1] = arg2;
@ -219,7 +221,7 @@ void MSC_copy_cat(const char* from1, int length1, const char* from2, int length2
// Find a symbol of a particular type.
//
gpre_sym* MSC_find_symbol(gpre_sym* symbol, enum sym_t type)
gpre_sym* MSC_find_symbol(gpre_sym* symbol, sym_t type)
{
for (; symbol; symbol = symbol->sym_homonym)
@ -261,11 +263,11 @@ void MSC_free_request( gpre_req* request)
// allocator.
//
void MSC_init(void)
void MSC_init()
{
free_lls = NULL;
SPC stuff;
gpre_space* stuff;
while (stuff = space) {
space = space->spc_next;
gds__free(stuff);
@ -280,19 +282,19 @@ void MSC_init(void)
// false.
//
bool MSC_match(KWWORDS keyword)
bool MSC_match(kwwords_t keyword)
{
if (gpreGlob.token_global.tok_keyword == KW_none && gpreGlob.token_global.tok_symbol) {
gpre_sym* symbol;
for (symbol = gpreGlob.token_global.tok_symbol->sym_collision; symbol;
symbol = symbol->sym_collision)
symbol = symbol->sym_collision)
{
if ((strcmp(symbol->sym_string, gpreGlob.token_global.tok_string) ==
0) && symbol->sym_keyword != KW_none)
if ((strcmp(symbol->sym_string, gpreGlob.token_global.tok_string) == 0) &&
symbol->sym_keyword != KW_none)
{
gpreGlob.token_global.tok_symbol = symbol;
gpreGlob.token_global.tok_keyword = static_cast < kwwords > (symbol->sym_keyword);
gpreGlob.token_global.tok_keyword = static_cast<kwwords_t>(symbol->sym_keyword);
}
}
}
@ -312,7 +314,7 @@ bool MSC_match(KWWORDS keyword)
// represented on a linked list stack.
//
bool MSC_member(GPRE_NOD object, gpre_lls* stack)
bool MSC_member(gpre_nod* object, gpre_lls* stack)
{
for (; stack; stack = stack->lls_next)
@ -328,9 +330,9 @@ bool MSC_member(GPRE_NOD object, gpre_lls* stack)
// Allocate an initialize a syntax node.
//
GPRE_NOD MSC_node(enum nod_t type, SSHORT count)
gpre_nod* MSC_node(nod_t type, SSHORT count)
{
GPRE_NOD node = (GPRE_NOD) MSC_alloc(NOD_LEN(count));
gpre_nod* node = (gpre_nod*) MSC_alloc(NOD_LEN(count));
node->nod_count = count;
node->nod_type = type;
@ -343,10 +345,10 @@ GPRE_NOD MSC_node(enum nod_t type, SSHORT count)
// Pop an item off a linked list stack. Free the stack node.
//
GPRE_NOD MSC_pop(gpre_lls** pointer)
gpre_nod* MSC_pop(gpre_lls** pointer)
{
gpre_lls* stack = *pointer;
GPRE_NOD node = stack->lls_object;
gpre_nod* node = stack->lls_object;
*pointer = stack->lls_next;
stack->lls_next = free_lls;
@ -361,7 +363,7 @@ GPRE_NOD MSC_pop(gpre_lls** pointer)
// Allocate a new privilege (grant/revoke) block.
//
PRV MSC_privilege_block(void)
PRV MSC_privilege_block()
{
PRV privilege_block = (PRV) MSC_alloc(PRV_LEN);
privilege_block->prv_privileges = PRV_no_privs;
@ -379,7 +381,7 @@ PRV MSC_privilege_block(void)
// Push an arbitrary object onto a linked list stack.
//
void MSC_push( GPRE_NOD object, gpre_lls** pointer)
void MSC_push( gpre_nod* object, gpre_lls** pointer)
{
gpre_lls* stack = free_lls;
if (stack)
@ -418,7 +420,7 @@ REF MSC_reference(REF* link)
// blocks, all linked up and ready to go.
//
gpre_req* MSC_request(enum req_t type)
gpre_req* MSC_request(req_t type)
{
gpre_req* request = (gpre_req*) MSC_alloc(REQ_LEN);
request->req_type = type;
@ -456,7 +458,7 @@ SCHAR* MSC_string(const TEXT* input)
// Allocate and initialize a symbol block.
//
gpre_sym* MSC_symbol(enum sym_t type, const TEXT* string, USHORT length, gpre_ctx* object)
gpre_sym* MSC_symbol(sym_t type, const TEXT* string, USHORT length, gpre_ctx* object)
{
gpre_sym* symbol = (gpre_sym*) MSC_alloc(SYM_LEN + length);
symbol->sym_type = type;
@ -476,9 +478,9 @@ gpre_sym* MSC_symbol(enum sym_t type, const TEXT* string, USHORT length, gpre_ct
// Make a unary node.
//
GPRE_NOD MSC_unary(NOD_T type, GPRE_NOD arg)
gpre_nod* MSC_unary(nod_t type, gpre_nod* arg)
{
GPRE_NOD node = MSC_node(type, 1);
gpre_nod* node = MSC_node(type, 1);
node->nod_arg[0] = arg;
return node;

24
src/gpre/msc_proto.h
View File

@ -26,27 +26,27 @@
#include "../gpre/parse.h"
act* MSC_action(gpre_req*, enum act_t);
act* MSC_action(gpre_req*, act_t);
UCHAR* MSC_alloc(int);
UCHAR* MSC_alloc_permanent(int);
GPRE_NOD MSC_binary(NOD_T, GPRE_NOD, GPRE_NOD);
gpre_nod* MSC_binary(nod_t, gpre_nod*, gpre_nod*);
gpre_ctx* MSC_context(gpre_req*);
void MSC_copy(const char*, int, char*);
void MSC_copy_cat(const char*, int, const char*, int, char*);
gpre_sym* MSC_find_symbol(gpre_sym*, enum sym_t);
gpre_sym* MSC_find_symbol(gpre_sym*, sym_t);
void MSC_free(void*);
void MSC_free_request(gpre_req*);
void MSC_init(void);
bool MSC_match(KWWORDS);
GPRE_NOD MSC_node(enum nod_t, SSHORT);
GPRE_NOD MSC_pop(gpre_lls**);
PRV MSC_privilege_block(void);
void MSC_push(GPRE_NOD, gpre_lls**);
void MSC_init();
bool MSC_match(kwwords_t);
gpre_nod* MSC_node(nod_t, SSHORT);
gpre_nod* MSC_pop(gpre_lls**);
PRV MSC_privilege_block();
void MSC_push(gpre_nod*, gpre_lls**);
REF MSC_reference(REF*);
gpre_req* MSC_request(enum req_t);
gpre_req* MSC_request(req_t);
SCHAR* MSC_string(const TEXT*);
gpre_sym* MSC_symbol(enum sym_t, const TEXT*, USHORT, gpre_ctx*);
GPRE_NOD MSC_unary(NOD_T, GPRE_NOD);
gpre_sym* MSC_symbol(sym_t, const TEXT*, USHORT, gpre_ctx*);
gpre_nod* MSC_unary(nod_t, gpre_nod*);
gpre_usn* MSC_username(SCHAR*, USHORT);
#endif // GPRE_MSC_PROTO_H

106
src/gpre/par.cpp
View File

@ -69,7 +69,7 @@ static act* par_at();
static act* par_based();
static act* par_begin();
static blb* par_blob();
static act* par_blob_action(ACT_T);
static act* par_blob_action(act_t);
static act* par_blob_field();
static act* par_case();
static act* par_clear_handles();
@ -90,19 +90,19 @@ static act* par_left_brace();
static act* par_modify();
static act* par_on();
static act* par_on_error();
static act* par_open_blob(ACT_T, gpre_sym*);
static act* par_open_blob(act_t, gpre_sym*);
static bool par_options(gpre_req*, bool);
static act* par_procedure();
static act* par_ready();
static act* par_returning_values();
static act* par_right_brace();
static act* par_release();
static act* par_slice(ACT_T);
static act* par_slice(act_t);
static act* par_store();
static act* par_start_stream();
static act* par_start_transaction();
static act* par_subroutine();
static act* par_trans(ACT_T);
static act* par_trans(act_t);
static act* par_type();
static act* par_variable();
static act* scan_routine_header();
@ -143,7 +143,7 @@ act* PAR_action(const TEXT* base_dir)
if ((USHORT) gpreGlob.token_global.tok_keyword >= (USHORT) KW_start_actions &&
(USHORT) gpreGlob.token_global.tok_keyword <= (USHORT) KW_end_actions)
{
const enum kwwords keyword = gpreGlob.token_global.tok_keyword;
const kwwords_t keyword = gpreGlob.token_global.tok_keyword;
if (! gpreGlob.sw_no_qli)
{
switch (keyword)
@ -736,8 +736,8 @@ act* PAR_event_init(bool sql)
//SQL_resolve_identifier("<identifier>", req_name, sizeof(req_name));
//strcpy(gpreGlob.token_global.tok_string, req_name); Why? It's already done.
gpre_nod* init = MSC_node(nod_event_init, 4);
init->nod_arg[0] = (GPRE_NOD) PAR_symbol(SYM_dummy);
init->nod_arg[3] = (GPRE_NOD) gpreGlob.isc_databases;
init->nod_arg[0] = (gpre_nod*) PAR_symbol(SYM_dummy);
init->nod_arg[3] = (gpre_nod*) gpreGlob.isc_databases;
act* action = MSC_action(0, ACT_event_init);
action->act_object = (REF) init;
@ -747,7 +747,7 @@ act* PAR_event_init(bool sql)
if (!MSC_match(KW_LEFT_PAREN)) {
gpre_sym* symbol = gpreGlob.token_global.tok_symbol;
if (symbol && (symbol->sym_type == SYM_database))
init->nod_arg[3] = (GPRE_NOD) symbol->sym_object;
init->nod_arg[3] = (gpre_nod*) symbol->sym_object;
else
CPR_s_error("left parenthesis or database handle");
@ -759,7 +759,7 @@ act* PAR_event_init(bool sql)
// eat any number of event strings until a right paren is found,
// pushing the gpreGlob.events onto a stack
GPRE_NOD node;
gpre_nod* node;
gpre_lls* stack = NULL;
int count = 0;
@ -775,14 +775,14 @@ act* PAR_event_init(bool sql)
gpre_fld* field = EXP_field(&context);
ref* reference = EXP_post_field(field, context, false);
node = MSC_node(nod_field, 1);
node->nod_arg[0] = (GPRE_NOD) reference;
node->nod_arg[0] = (gpre_nod*) reference;
}
else {
node = MSC_node(nod_null, 1);
if (sql)
node->nod_arg[0] = (GPRE_NOD) SQL_var_or_string(false);
node->nod_arg[0] = (gpre_nod*) SQL_var_or_string(false);
else
node->nod_arg[0] = (GPRE_NOD) PAR_native_value(false, false);
node->nod_arg[0] = (gpre_nod*) PAR_native_value(false, false);
}
MSC_push(node, &stack);
count++;
@ -795,9 +795,9 @@ act* PAR_event_init(bool sql)
gpre_nod* event_list = init->nod_arg[1] = MSC_node(nod_list, (SSHORT) count);
gpre_nod** ptr = event_list->nod_arg + count;
while (stack)
*--ptr = (GPRE_NOD) MSC_pop(&stack);
*--ptr = (gpre_nod*) MSC_pop(&stack);
MSC_push((GPRE_NOD) action, &gpreGlob.events);
MSC_push((gpre_nod*) action, &gpreGlob.events);
if (!sql)
PAR_end();
@ -893,7 +893,7 @@ void PAR_init()
gpreGlob.cur_routine = MSC_action(0, ACT_routine);
gpreGlob.cur_routine->act_flags |= ACT_main;
MSC_push((GPRE_NOD) gpreGlob.cur_routine, &routine_stack);
MSC_push((gpre_nod*) gpreGlob.cur_routine, &routine_stack);
routine_decl = true;
flag_field = NULL;
@ -928,7 +928,7 @@ TEXT* PAR_native_value(bool array_ref,
**/
if (gpreGlob.sw_sql_dialect == 1) {
if (isQuoted(gpreGlob.token_global.tok_type)) {
//const enum tok_t typ = gpreGlob.token_global.tok_type;
//const tok_t typ = gpreGlob.token_global.tok_type;
gpreGlob.token_global.tok_length += 2;
*string++ = '\"';
gobble(string);
@ -968,11 +968,11 @@ TEXT* PAR_native_value(bool array_ref,
if ((gpreGlob.sw_language == lang_ada) && (gpreGlob.token_global.tok_string[0] == '\'')) {
gobble(string);
}
enum kwwords keyword = gpreGlob.token_global.tok_keyword;
kwwords_t keyword = gpreGlob.token_global.tok_keyword;
if (keyword == KW_LEFT_PAREN) {
int parens = 1;
while (parens) {
const enum tok_t typ = gpreGlob.token_global.tok_type;
const tok_t typ = gpreGlob.token_global.tok_type;
if (isQuoted(typ))
*string++ = (typ == tok_sglquoted) ? '\'' : '\"';
gobble(string);
@ -1144,7 +1144,7 @@ gpre_req* PAR_set_up_dpb_info(rdy* ready, act* action, USHORT buffercount)
// redefined.
//
gpre_sym* PAR_symbol(enum sym_t type)
gpre_sym* PAR_symbol(sym_t type)
{
gpre_sym* symbol;
@ -1325,7 +1325,7 @@ static act* par_array_element()
reference->ref_field = element;
element->fld_symbol = field->fld_symbol;
reference->ref_context = context;
node->nod_arg[0] = (GPRE_NOD) reference;
node->nod_arg[0] = (gpre_nod*) reference;
act* action = MSC_action(request, ACT_variable);
action->act_object = reference;
@ -1463,7 +1463,7 @@ static act* par_based()
case lang_c:
case lang_cxx:
do {
MSC_push((GPRE_NOD) PAR_native_value(false, false),
MSC_push((gpre_nod*) PAR_native_value(false, false),
&based_on->bas_variables);
} while (MSC_match(KW_COMMA));
/*
@ -1566,7 +1566,7 @@ static blb* par_blob()
// Parse a GET_SEGMENT, PUT_SEGMENT, CLOSE_BLOB or CANCEL_BLOB.
//
static act* par_blob_action( ACT_T type)
static act* par_blob_action( act_t type)
{
blb* blob = par_blob();
act* action = MSC_action(blob->blb_request, type);
@ -1594,7 +1594,7 @@ static act* par_blob_field()
blb* blob = par_blob();
ACT_T type;
act_t type;
if (MSC_match(KW_DOT)) {
if (MSC_match(KW_SEGMENT))
type = ACT_segment;
@ -1683,7 +1683,7 @@ static act* par_derived_from()
based_on->bas_variables = (gpre_lls*) MSC_alloc(LLS_LEN);
based_on->bas_variables->lls_next = NULL;
based_on->bas_variables->lls_object =
(GPRE_NOD) PAR_native_value(false, false);
(gpre_nod*) PAR_native_value(false, false);
strcpy(based_on->bas_terminator, gpreGlob.token_global.tok_string);
PAR_get_token();
@ -1859,9 +1859,9 @@ static act* par_end_modify()
change->ref_flags = reference->ref_flags;
gpre_nod* item = MSC_node(nod_assignment, 2);
item->nod_arg[0] = MSC_unary(nod_value, (GPRE_NOD) change);
item->nod_arg[1] = MSC_unary(nod_field, (GPRE_NOD) change);
MSC_push((GPRE_NOD) item, &stack);
item->nod_arg[0] = MSC_unary(nod_value, (gpre_nod*) change);
item->nod_arg[1] = MSC_unary(nod_field, (gpre_nod*) change);
MSC_push((gpre_nod*) item, &stack);
count++;
if (reference->ref_null) {
@ -1873,9 +1873,9 @@ static act* par_end_modify()
change->ref_null = flag;
item = MSC_node(nod_assignment, 2);
item->nod_arg[0] = MSC_unary(nod_value, (GPRE_NOD) flag);
item->nod_arg[1] = MSC_unary(nod_field, (GPRE_NOD) flag);
MSC_push((GPRE_NOD) item, &stack);
item->nod_arg[0] = MSC_unary(nod_value, (gpre_nod*) flag);
item->nod_arg[1] = MSC_unary(nod_field, (gpre_nod*) flag);
MSC_push((gpre_nod*) item, &stack);
count++;
}
}
@ -1888,7 +1888,7 @@ static act* par_end_modify()
gpre_nod** ptr = assignments->nod_arg + count;
while (stack)
*--ptr = (GPRE_NOD) MSC_pop(&stack);
*--ptr = (gpre_nod*) MSC_pop(&stack);
act* action = MSC_action(request, ACT_endmodify);
action->act_object = (REF) modify;
@ -1962,8 +1962,8 @@ static act* par_end_store(bool special)
if (reference->ref_master)
continue;
gpre_nod* item = MSC_node(nod_assignment, 2);
item->nod_arg[0] = MSC_unary(nod_value, (GPRE_NOD) reference);
item->nod_arg[1] = MSC_unary(nod_field, (GPRE_NOD) reference);
item->nod_arg[0] = MSC_unary(nod_value, (gpre_nod*) reference);
item->nod_arg[1] = MSC_unary(nod_field, (gpre_nod*) reference);
assignments->nod_arg[count++] = item;
}
}
@ -1995,9 +1995,9 @@ static act* par_end_store(bool special)
change->ref_flags = reference->ref_flags;
gpre_nod* item = MSC_node(nod_assignment, 2);
item->nod_arg[0] = MSC_unary(nod_field, (GPRE_NOD) change);
item->nod_arg[1] = MSC_unary(nod_value, (GPRE_NOD) change);
MSC_push((GPRE_NOD) item, &stack);
item->nod_arg[0] = MSC_unary(nod_field, (gpre_nod*) change);
item->nod_arg[1] = MSC_unary(nod_value, (gpre_nod*) change);
MSC_push((gpre_nod*) item, &stack);
count++;
}
}
@ -2009,7 +2009,7 @@ static act* par_end_store(bool special)
gpre_nod** ptr = assignments->nod_arg + count;
while (stack)
*--ptr = (GPRE_NOD) MSC_pop(&stack);
*--ptr = (gpre_nod*) MSC_pop(&stack);
}
gpre_ctx* context = request->req_contexts;
@ -2075,7 +2075,7 @@ static act* par_fetch()
PAR_end();
act* action = MSC_action(request, ACT_s_fetch);
MSC_push((GPRE_NOD) action, &cur_fetch);
MSC_push((gpre_nod*) action, &cur_fetch);
return action;
}
@ -2164,7 +2164,7 @@ static act* par_for()
}
act* action = MSC_action(request, ACT_for);
MSC_push((GPRE_NOD) action, &cur_for);
MSC_push((gpre_nod*) action, &cur_for);
request->req_rse = rec_expr;
gpre_ctx* context = rec_expr->rse_context[0];
@ -2238,7 +2238,7 @@ static act* par_modify()
// structure in place to cleanly handle END_MODIFY under error conditions.
upd* modify = (upd*) MSC_alloc(UPD_LEN);
MSC_push((GPRE_NOD) modify, &cur_modify);
MSC_push((gpre_nod*) modify, &cur_modify);
// If the next token isn't a context variable, we can't continue
@ -2312,7 +2312,7 @@ static act* par_on_error()
cur_statement->act_error = action;
action->act_object = (REF) cur_statement;
MSC_push((GPRE_NOD) action, &cur_error);
MSC_push((gpre_nod*) action, &cur_error);
if (cur_statement->act_pair)
cur_statement->act_pair->act_error = action;
@ -2327,7 +2327,7 @@ static act* par_on_error()
// CREATE_BLOB, and blob FOR.
//
static act* par_open_blob( ACT_T act_op, gpre_sym* symbol)
static act* par_open_blob( act_t act_op, gpre_sym* symbol)
{
// If somebody hasn't already parsed up a symbol for us, parse the
// symbol and the mandatory IN now.
@ -2403,7 +2403,7 @@ static act* par_open_blob( ACT_T act_op, gpre_sym* symbol)
action->act_object = (REF) blob;
if (act_op == ACT_blob_for)
MSC_push((GPRE_NOD) action, &cur_for);
MSC_push((gpre_nod*) action, &cur_for);
// Need to eat the semicolon if present
@ -2471,7 +2471,7 @@ static act* par_procedure()
routine_decl = true;
action = scan_routine_header();
if (!(action->act_flags & ACT_decl)) {
MSC_push((GPRE_NOD) gpreGlob.cur_routine, &routine_stack);
MSC_push((gpre_nod*) gpreGlob.cur_routine, &routine_stack);
gpreGlob.cur_routine = action;
}
}
@ -2681,7 +2681,7 @@ static act* par_returning_values()
count++;
}
GPRE_NOD assignments = MSC_node(nod_list, (SSHORT) count);
gpre_nod* assignments = MSC_node(nod_list, (SSHORT) count);
request->req_node = assignments;
count = 0;
@ -2696,9 +2696,9 @@ static act* par_returning_values()
if (reference->ref_master)
continue;
GPRE_NOD item = MSC_node(nod_assignment, 2);
item->nod_arg[0] = MSC_unary(nod_value, (GPRE_NOD) save_ref);
item->nod_arg[1] = MSC_unary(nod_field, (GPRE_NOD) save_ref);
gpre_nod* item = MSC_node(nod_assignment, 2);
item->nod_arg[0] = MSC_unary(nod_value, (gpre_nod*) save_ref);
item->nod_arg[1] = MSC_unary(nod_field, (gpre_nod*) save_ref);
assignments->nod_arg[count++] = item;
}
@ -2726,8 +2726,8 @@ static act* par_returning_values()
// both actions go on the cur_store stack, the store topmost
MSC_push((GPRE_NOD) action, &cur_store);
MSC_push((GPRE_NOD) begin_action, &cur_store);
MSC_push((gpre_nod*) action, &cur_store);
MSC_push((gpre_nod*) begin_action, &cur_store);
return action;
}
@ -2780,7 +2780,7 @@ static act* par_release()
// Handle a GET_SLICE or PUT_SLICE statement.
//
static act* par_slice( ACT_T type)
static act* par_slice( act_t type)
{
gpre_ctx* context;
gpre_fld* field = EXP_field(&context);
@ -2848,7 +2848,7 @@ static act* par_store()
gpre_req* request = MSC_request(REQ_store);
par_options(request, false);
act* action = MSC_action(request, ACT_store);
MSC_push((GPRE_NOD) action, &cur_store);
MSC_push((gpre_nod*) action, &cur_store);
gpre_ctx* context = EXP_context(request, 0);
gpre_rel* relation = context->ctx_relation;
@ -3015,7 +3015,7 @@ static act* par_subroutine()
// prepare, rollback, or save (commit retaining context).
//
static act* par_trans( ACT_T act_op)
static act* par_trans( act_t act_op)
{
act* action = MSC_action(0, act_op);

16
src/gpre/par_proto.h
View File

@ -27,20 +27,20 @@
act* PAR_action(const TEXT*);
SSHORT PAR_blob_subtype(DBB);
act* PAR_database(bool, const TEXT*);
bool PAR_end(void);
bool PAR_end();
void PAR_error(const TEXT*);
act* PAR_event_init(bool);
act* PAR_event_wait(bool);
void PAR_fini(void);
TOK PAR_get_token(void);
void PAR_init(void);
void PAR_fini();
TOK PAR_get_token();
void PAR_init();
TEXT* PAR_native_value(bool, bool);
gpre_fld* PAR_null_field(void);
gpre_fld* PAR_null_field();
void PAR_reserving(USHORT, bool);
gpre_req* PAR_set_up_dpb_info(rdy*, act*, USHORT);
gpre_sym* PAR_symbol(enum sym_t);
void PAR_unwind(void);
void PAR_using_db(void);
gpre_sym* PAR_symbol(sym_t);
void PAR_unwind();
void PAR_using_db();
#endif // GPRE_PAR_PROTO_H

8
src/gpre/parse.h
View File

@ -39,15 +39,15 @@ enum tok_t {
};
typedef struct tok {
enum tok_t tok_type; /* type of token */
gpre_sym* tok_symbol; /* hash block if recognized */
KWWORDS tok_keyword; /* keyword number, if recognized */
tok_t tok_type; /* type of token */
gpre_sym* tok_symbol; /* hash block if recognized */
kwwords_t tok_keyword; /* keyword number, if recognized */
SLONG tok_position; /* byte number in input stream */
USHORT tok_length;
USHORT tok_white_space;
SCHAR tok_string[MAX_SYM_SIZE];
USHORT tok_first; /* first token in a statement */
gpre_sym* tok_charset; /* Character set of token */
gpre_sym* tok_charset; /* Character set of token */
} *TOK;
const size_t TOK_LEN = sizeof(tok);

31
src/gpre/pas.cpp
View File

@ -1490,7 +1490,7 @@ static void gen_dyn_execute( const act* action, int column)
TEXT s[MAX_CURSOR_SIZE];
make_name(s, statement->dyn_cursor_name);
GPRE_NOD var_list;
gpre_nod* var_list;
if (var_list = statement->dyn_using) {
printa(column, "gds__sqlda.sqln = %s;", gpreGlob.sw_dyn_using);
printa(column, "gds__sqlda.sqld = %s;", gpreGlob.sw_dyn_using);
@ -1611,7 +1611,7 @@ static void gen_dyn_open( const act* action, int column)
TEXT s[MAX_CURSOR_SIZE];
gpre_req* request;
gpre_req req_const;
GPRE_NOD var_list;
gpre_nod* var_list;
int i;
DYN statement = (DYN) action->act_object;
@ -1806,13 +1806,14 @@ static void gen_erase( const act* action, int column)
static SSHORT gen_event_block( const act* action)
{
GPRE_NOD init, list;
gpre_nod* init;
gpre_nod* list;
int ident;
init = (GPRE_NOD) action->act_object;
init = (gpre_nod*) action->act_object;
ident = CMP_next_ident();
init->nod_arg[2] = (GPRE_NOD) ident;
init->nod_arg[2] = (gpre_nod*) ident;
printa(INDENT, "gds__%da\t\t: ^char;\t\t(* event parameter block *)",
ident);
@ -1834,7 +1835,11 @@ static SSHORT gen_event_block( const act* action)
static void gen_event_init( const act* action, int column)
{
GPRE_NOD init, event_list, *ptr, *end, node;
gpre_nod* init;
gpre_nod* event_list;
gpre_nod** ptr;
gpre_nod** end;
gpre_nod* node;
const ref* reference;
PAT args;
SSHORT count;
@ -1847,7 +1852,7 @@ static void gen_event_init( const act* action, int column)
begin(column);
begin(column);
init = (GPRE_NOD) action->act_object;
init = (gpre_nod*) action->act_object;
event_list = init->nod_arg[1];
args.pat_database = (DBB) init->nod_arg[3];
@ -1902,7 +1907,7 @@ static void gen_event_init( const act* action, int column)
static void gen_event_wait( const act* action, int column)
{
PAT args;
GPRE_NOD event_init;
gpre_nod* event_init;
gpre_sym* event_name;
gpre_sym* stack_name;
DBB database;
@ -1925,7 +1930,7 @@ static void gen_event_wait( const act* action, int column)
ident = -1;
for (stack_ptr = gpreGlob.events; stack_ptr; stack_ptr = stack_ptr->lls_next) {
event_action = (const act*) stack_ptr->lls_object;
event_init = (GPRE_NOD) event_action->act_object;
event_init = (gpre_nod*) event_action->act_object;
stack_name = (gpre_sym*) event_init->nod_arg[0];
if (!strcmp(event_name->sym_string, stack_name->sym_string)) {
ident = (int) event_init->nod_arg[2];
@ -1966,7 +1971,7 @@ static void gen_event_wait( const act* action, int column)
static void gen_fetch( const act* action, int column)
{
const gpre_req* request;
GPRE_NOD var_list;
gpre_nod* var_list;
int i;
request = action->act_request;
@ -1974,7 +1979,7 @@ static void gen_fetch( const act* action, int column)
#ifdef SCROLLABLE_CURSORS
gpre_port* port;
ref* reference;
VAL value;
gpre_value* value;
const TEXT* direction;
const TEXT* offset;
@ -2039,7 +2044,7 @@ static void gen_fetch( const act* action, int column)
column += INDENT;
begin(column);
if (var_list = (GPRE_NOD) action->act_object)
if (var_list = (gpre_nod*) action->act_object)
for (i = 0; i < var_list->nod_count; i++) {
align(column);
asgn_to(action, reinterpret_cast<ref*>(var_list->nod_arg[i]), column);
@ -2869,7 +2874,7 @@ static void gen_select( const act* action, int column)
column += INDENT;
begin(column);
const gpre_nod* var_list = (GPRE_NOD) action->act_object;
const gpre_nod* var_list = (gpre_nod*) action->act_object;
if (var_list) {
for (int i = 0; i < var_list->nod_count; i++) {
align(column);

9
src/gpre/pat.cpp
View File

@ -36,7 +36,7 @@
#include "../gpre/lang_proto.h"
typedef enum {
enum pat_t {
NL,
RH, RL, RT, RI, RS, // Request handle, level, transaction, ident, length
DH, DF, // Database handle, filename
@ -55,10 +55,11 @@ typedef enum {
QN, QL, QI, // Second port number, port length, port ident
IF, EL, EN, // If, else, end
FR // Field reference
} PAT_T;
};
static const struct ops {
PAT_T ops_type;
static const struct ops
{
pat_t ops_type;
TEXT ops_string[3];
} operators[] =
{

18
src/gpre/rmc.cpp
View File

@ -177,7 +177,7 @@ static TEXT* gen_name(TEXT* const, const ref*, bool);
static void gen_on_error (const act*);
static void gen_procedure (const act*);
static void gen_put_segment (const act*);
static void gen_raw (const UCHAR*, enum req_t, int, int);
static void gen_raw (const UCHAR*, req_t, int, int);
static void gen_ready (const act*);
static void gen_receive (const act*, const gpre_port*);
static void gen_release (const act*);
@ -2440,10 +2440,10 @@ static void gen_erase( const act* action)
static SSHORT gen_event_block( const act* action)
{
gpre_nod* init = (GPRE_NOD) action->act_object;
gpre_nod* init = (gpre_nod*) action->act_object;
int ident = CMP_next_ident();
init->nod_arg[2] = (GPRE_NOD) (IPTR) ident;
init->nod_arg[2] = (gpre_nod*) (IPTR) ident;
printa(COLUMN8, false, "01 %s%dA PIC S9(10) %s.",
names[isc_a_pos], ident, USAGE_BINARY4);
@ -2472,7 +2472,7 @@ static void gen_event_init( const act* action)
const TEXT *pattern3 =
"CALL \"%S3\" USING %S5, %S4%N1L, %S4%N1A, %S4%N1B";
const gpre_nod* init = (GPRE_NOD) action->act_object;
const gpre_nod* init = (gpre_nod*) action->act_object;
const gpre_nod* event_list = init->nod_arg[1];
const SSHORT column = strlen(names[COLUMN]);
@ -2549,7 +2549,7 @@ static void gen_event_wait( const act* action)
for (const gpre_lls* stack_ptr = gpreGlob.events; stack_ptr; stack_ptr = stack_ptr->lls_next)
{
const act* event_action = (const act*) stack_ptr->lls_object;
const gpre_nod* event_init = (GPRE_NOD) event_action->act_object;
const gpre_nod* event_init = (gpre_nod*) event_action->act_object;
const gpre_sym* stack_name = (gpre_sym*) event_init->nod_arg[0];
if (!strcmp(event_name->sym_string, stack_name->sym_string)) {
ident = (int) (IPTR) event_init->nod_arg[2];
@ -2607,7 +2607,7 @@ static void gen_fetch( const act* action)
for (reference = port->por_references; reference;
reference = reference->ref_next)
{
VAL value = reference->ref_values;
gpre_value* value = reference->ref_values;
reference->ref_value = value->val_value;
reference->ref_values = value->val_next;
}
@ -2649,7 +2649,7 @@ static void gen_fetch( const act* action)
printa(names[COLUMN], false,
"IF %s NOT = 0 THEN", gen_name(s, request->req_eof, true));
printa(names[COLUMN], false, "MOVE 0 TO SQLCODE");
if (gpre_nod* var_list = (GPRE_NOD) action->act_object)
if (gpre_nod* var_list = (gpre_nod*) action->act_object)
for (int i = 0; i < var_list->nod_count; i++) {
asgn_to(action, (REF) var_list->nod_arg[i]);
}
@ -3094,7 +3094,7 @@ static void gen_put_segment( const act* action)
static void gen_raw(
const UCHAR* blr,
enum req_t request_type, int request_length, int ident)
req_t request_type, int request_length, int ident)
{
int length = 1;
ULONG ltemp = 0;
@ -3630,7 +3630,7 @@ static void gen_select( const act* action)
gen_receive(action, port);
printa(names[COLUMN], false, "IF %s NOT = 0 THEN", name);
gpre_nod* var_list = (GPRE_NOD) action->act_object;
gpre_nod* var_list = (gpre_nod*) action->act_object;
if (var_list)
for (int i = 0; i < var_list->nod_count; i++) {
asgn_to(action, (REF) var_list->nod_arg[i]);

307
src/gpre/sqe.cpp
View File

@ -67,53 +67,53 @@ struct scope {
USHORT req_in_subselect; // processing a subselect clause
};
static bool compare_expr(GPRE_NOD, GPRE_NOD);
static GPRE_NOD copy_fields(GPRE_NOD, map*);
static GPRE_NOD explode_asterisk(GPRE_NOD, int, gpre_rse*);
static GPRE_NOD explode_asterisk_all(GPRE_NOD, int, gpre_rse*, bool);
static gpre_fld* get_ref(GPRE_NOD);
static GPRE_NOD implicit_any(gpre_req*, GPRE_NOD, enum nod_t, enum nod_t);
static GPRE_NOD merge(GPRE_NOD, GPRE_NOD);
static GPRE_NOD merge_fields(GPRE_NOD, GPRE_NOD, int, bool);
static GPRE_NOD negate(GPRE_NOD);
static void pair(GPRE_NOD, GPRE_NOD);
static gpre_ctx* par_alias_list(gpre_req*, GPRE_NOD);
static bool compare_expr(gpre_nod*, gpre_nod*);
static gpre_nod* copy_fields(gpre_nod*, map*);
static gpre_nod* explode_asterisk(gpre_nod*, int, gpre_rse*);
static gpre_nod* explode_asterisk_all(gpre_nod*, int, gpre_rse*, bool);
static gpre_fld* get_ref(gpre_nod*);
static gpre_nod* implicit_any(gpre_req*, gpre_nod*, nod_t, nod_t);
static gpre_nod* merge(gpre_nod*, gpre_nod*);
static gpre_nod* merge_fields(gpre_nod*, gpre_nod*, int, bool);
static gpre_nod* negate(gpre_nod*);
static void pair(gpre_nod*, gpre_nod*);
static gpre_ctx* par_alias_list(gpre_req*, gpre_nod*);
static gpre_ctx* par_alias(gpre_req*, const TEXT*);
static GPRE_NOD par_and(gpre_req*, USHORT *);
static gpre_nod* par_and(gpre_req*, USHORT *);
static gpre_rel* par_base_table(gpre_req*, const gpre_rel*, const TEXT*);
static GPRE_NOD par_case(gpre_req*);
static GPRE_NOD par_collate(gpre_req*, GPRE_NOD);
static GPRE_NOD par_in(gpre_req*, GPRE_NOD);
static gpre_nod* par_case(gpre_req*);
static gpre_nod* par_collate(gpre_req*, gpre_nod*);
static gpre_nod* par_in(gpre_req*, gpre_nod*);
static gpre_ctx* par_joined_relation(gpre_req*, gpre_ctx*);
static gpre_ctx* par_join_clause(gpre_req*, gpre_ctx*);
static NOD_T par_join_type(void);
static GPRE_NOD par_multiply(gpre_req*, bool, USHORT *, bool *);
static GPRE_NOD par_not(gpre_req*, USHORT *);
static GPRE_NOD par_nullif(gpre_req*);
static nod_t par_join_type();
static gpre_nod* par_multiply(gpre_req*, bool, USHORT *, bool *);
static gpre_nod* par_not(gpre_req*, USHORT *);
static gpre_nod* par_nullif(gpre_req*);
static void par_order(gpre_req*, gpre_rse*, bool, bool);
static GPRE_NOD par_plan(gpre_req*);
static GPRE_NOD par_plan_item(gpre_req*, bool, USHORT *, bool *);
static GPRE_NOD par_primitive_value(gpre_req*, bool, USHORT *, bool *);
static GPRE_NOD par_relational(gpre_req*, USHORT *);
static gpre_rse* par_rse(gpre_req*, GPRE_NOD, bool);
static gpre_nod* par_plan(gpre_req*);
static gpre_nod* par_plan_item(gpre_req*, bool, USHORT *, bool *);
static gpre_nod* par_primitive_value(gpre_req*, bool, USHORT *, bool *);
static gpre_nod* par_relational(gpre_req*, USHORT *);
static gpre_rse* par_rse(gpre_req*, gpre_nod*, bool);
static gpre_rse* par_select(gpre_req*, gpre_rse*);
static GPRE_NOD par_stat(gpre_req*);
static GPRE_NOD par_subscript(gpre_req*);
static GPRE_NOD par_substring(gpre_req*);
static gpre_nod* par_stat(gpre_req*);
static gpre_nod* par_subscript(gpre_req*);
static gpre_nod* par_substring(gpre_req*);
static void par_terminating_parens(USHORT *, USHORT *);
static GPRE_NOD par_udf(gpre_req*);
static GPRE_NOD par_udf_or_field(gpre_req*, bool);
static GPRE_NOD par_udf_or_field_with_collate(gpre_req*, bool, USHORT *, bool *);
static gpre_nod* par_udf(gpre_req*);
static gpre_nod* par_udf_or_field(gpre_req*, bool);
static gpre_nod* par_udf_or_field_with_collate(gpre_req*, bool, USHORT *, bool *);
static void par_update(gpre_rse*, bool, bool);
static GPRE_NOD post_fields(GPRE_NOD, map*);
static GPRE_NOD post_map(GPRE_NOD, MAP);
static GPRE_NOD post_select_list(GPRE_NOD, map*);
static gpre_nod* post_fields(gpre_nod*, map*);
static gpre_nod* post_map(gpre_nod*, MAP);
static gpre_nod* post_select_list(gpre_nod*, map*);
static void pop_scope(gpre_req*, scope*);
static void push_scope(gpre_req*, scope*);
static gpre_fld* resolve(GPRE_NOD, gpre_ctx*, gpre_ctx**, act**);
static bool resolve_fields(GPRE_NOD& fields, gpre_req* request, gpre_rse* selection);
static gpre_fld* resolve(gpre_nod*, gpre_ctx*, gpre_ctx**, act**);
static bool resolve_fields(gpre_nod*& fields, gpre_req* request, gpre_rse* selection);
static gpre_ctx* resolve_asterisk(TOK, gpre_rse*);
static void set_ref(GPRE_NOD, gpre_fld*);
static void set_ref(gpre_nod*, gpre_fld*);
static char* upcase_string(const char*);
static bool validate_references(const gpre_nod*, const gpre_nod*);
@ -121,9 +121,9 @@ static bool validate_references(const gpre_nod*, const gpre_nod*);
struct ops {
enum nod_t rel_op;
enum kwwords rel_kw;
enum nod_t rel_negation;
nod_t rel_op;
kwwords_t rel_kw;
nod_t rel_negation;
};
static const ops rel_ops[] =
@ -144,7 +144,8 @@ static const ops rel_ops[] =
};
#ifdef NOT_USED_OR_REPLACED
static const ops scalar_stat_ops[] = {
static const ops scalar_stat_ops[] =
{
{ nod_count, KW_COUNT, nod_any },
{ nod_max, KW_MAX, nod_any },
{ nod_min, KW_MIN, nod_any },
@ -155,7 +156,8 @@ static const ops scalar_stat_ops[] = {
};
#endif
static const ops stat_ops[] = {
static const ops stat_ops[] =
{
{ nod_agg_count, KW_COUNT, nod_any },
{ nod_agg_max, KW_MAX, nod_any },
{ nod_agg_min, KW_MIN, nod_any },
@ -167,10 +169,11 @@ static const ops stat_ops[] = {
{ nod_ansi_all, KW_none, nod_ansi_all }
};
static const NOD_T relationals[] = {
static const nod_t relationals[] =
{
nod_eq, nod_ne, nod_gt, nod_ge, nod_le, nod_lt, nod_containing,
nod_starting, nod_matches, nod_any, nod_missing, nod_between, nod_like,
nod_and, nod_or, nod_not, nod_ansi_any, nod_ansi_all, (NOD_T) 0
nod_and, nod_or, nod_not, nod_ansi_any, nod_ansi_all, nod_nothing
};
@ -179,7 +182,7 @@ static const NOD_T relationals[] = {
// Parse an OR boolean expression.
//
GPRE_NOD SQE_boolean( gpre_req* request, USHORT * paren_count)
gpre_nod* SQE_boolean( gpre_req* request, USHORT * paren_count)
{
USHORT local_count;
@ -325,10 +328,10 @@ gpre_ctx* SQE_context(gpre_req* request)
// this will be turned into a reference later.
//
GPRE_NOD SQE_field(gpre_req* request,
gpre_nod* SQE_field(gpre_req* request,
bool aster_ok)
{
GPRE_NOD node;
gpre_nod* node;
gpre_req* slice_req;
assert_IS_REQ(request);
@ -384,7 +387,7 @@ GPRE_NOD SQE_field(gpre_req* request,
node = MSC_node(nod_deferred, 3);
node->nod_count = 0;
TOK f_token = (TOK) MSC_alloc(TOK_LEN);
node->nod_arg[0] = (GPRE_NOD) f_token;
node->nod_arg[0] = (gpre_nod*) f_token;
f_token->tok_length = gpreGlob.token_global.tok_length;
SQL_resolve_identifier("<identifier>", f_token->tok_string, f_token->tok_length + 1);
CPR_token();
@ -399,7 +402,7 @@ GPRE_NOD SQE_field(gpre_req* request,
else {
node->nod_arg[1] = node->nod_arg[0];
f_token = (TOK) MSC_alloc(TOK_LEN);
node->nod_arg[0] = (GPRE_NOD) f_token;
node->nod_arg[0] = (gpre_nod*) f_token;
f_token->tok_length = gpreGlob.token_global.tok_length;
SQL_resolve_identifier("<identifier>", f_token->tok_string, f_token->tok_length + 1);
}
@ -437,7 +440,7 @@ GPRE_NOD SQE_field(gpre_req* request,
tail_ptr->slc_lower = MSC_pop(&lower_dim);
tail_ptr->slc_upper = MSC_pop(&upper_dim);
}
node->nod_arg[2] = (GPRE_NOD) slice_req;
node->nod_arg[2] = (gpre_nod*) slice_req;
/* added this to assign the correct nod_count
The nod type is converted to nod_field in SQE_resolve()
@ -449,7 +452,7 @@ GPRE_NOD SQE_field(gpre_req* request,
else {
slice_req = (gpre_req*) MSC_alloc(REQ_LEN);
slice_req->req_type = REQ_slice;
node->nod_arg[2] = (GPRE_NOD) slice_req;
node->nod_arg[2] = (gpre_nod*) slice_req;
}
}
@ -458,7 +461,7 @@ GPRE_NOD SQE_field(gpre_req* request,
gpre_ctx* context;
ref* reference = (REF) MSC_alloc(REF_LEN);
node = MSC_unary(nod_field, (GPRE_NOD) reference);
node = MSC_unary(nod_field, (gpre_nod*) reference);
gpre_sym* symbol = gpreGlob.token_global.tok_symbol;
if (symbol) {
@ -566,7 +569,7 @@ GPRE_NOD SQE_field(gpre_req* request,
node =
EXP_array(request, reference->ref_field,
true, true);
node->nod_arg[0] = (GPRE_NOD) reference;
node->nod_arg[0] = (gpre_nod*) reference;
}
return node;
}
@ -608,7 +611,7 @@ GPRE_NOD SQE_field(gpre_req* request,
node =
EXP_array(request, reference->ref_field, true,
true);
node->nod_arg[0] = (GPRE_NOD) reference;
node->nod_arg[0] = (gpre_nod*) reference;
}
CPR_token();
return node;
@ -654,7 +657,7 @@ GPRE_NOD SQE_field(gpre_req* request,
CPR_token();
if (reference->ref_field->fld_array_info) {
node = EXP_array(request, reference->ref_field, true, true);
node->nod_arg[0] = (GPRE_NOD) reference;
node->nod_arg[0] = (gpre_nod*) reference;
}
if (request->req_map)
return post_map(node, request->req_map);
@ -673,7 +676,7 @@ GPRE_NOD SQE_field(gpre_req* request,
// whole mess in a list node.
//
GPRE_NOD SQE_list(pfn_SQE_list_cb routine,
gpre_nod* SQE_list(pfn_SQE_list_cb routine,
gpre_req* request,
bool aster_ok)
{
@ -691,7 +694,7 @@ GPRE_NOD SQE_list(pfn_SQE_list_cb routine,
gpre_nod** ptr = &list->nod_arg[count];
while (stack)
*--ptr = (GPRE_NOD) MSC_pop(&stack);
*--ptr = (gpre_nod*) MSC_pop(&stack);
return list;
}
@ -798,7 +801,7 @@ REF SQE_parameter(gpre_req* request,
// Procedure called from EXP_array to post the "subscript field".
//
void SQE_post_field( GPRE_NOD input, gpre_fld* field)
void SQE_post_field( gpre_nod* input, gpre_fld* field)
{
if (!input || !field)
return;
@ -856,7 +859,7 @@ void SQE_post_field( GPRE_NOD input, gpre_fld* field)
//
REF SQE_post_reference(gpre_req* request, gpre_fld* field, gpre_ctx* context,
GPRE_NOD node)
gpre_nod* node)
{
REF reference;
@ -919,7 +922,7 @@ REF SQE_post_reference(gpre_req* request, gpre_fld* field, gpre_ctx* context,
// otherwise false.
//
bool SQE_resolve(GPRE_NOD node,
bool SQE_resolve(gpre_nod* node,
gpre_req* request,
gpre_rse* selection)
{
@ -1072,7 +1075,7 @@ bool SQE_resolve(GPRE_NOD node,
node->nod_type = nod_field;
node->nod_arg[0] = (GPRE_NOD) reference;
node->nod_arg[0] = (gpre_nod*) reference;
return false;
}
@ -1109,7 +1112,7 @@ gpre_rse* SQE_select(gpre_req* request,
if (!MSC_match(KW_SELECT))
CPR_s_error("SELECT");
MSC_push((GPRE_NOD) request->req_contexts, &context_stack);
MSC_push((gpre_nod*) request->req_contexts, &context_stack);
request->req_contexts = NULL;
request->req_map = NULL;
gpre_rse* rse2 = par_select(request, rse1);
@ -1121,8 +1124,8 @@ gpre_rse* SQE_select(gpre_req* request,
select->rse_context[0] = context = MSC_context(request);
gpre_nod* node = MSC_node(nod_union, 2);
select->rse_union = node;
node->nod_arg[0] = (GPRE_NOD) rse1;
node->nod_arg[1] = (GPRE_NOD) rse2;
node->nod_arg[0] = (gpre_nod*) rse1;
node->nod_arg[1] = (gpre_nod*) rse2;
map* new_map = (map*) MSC_alloc(sizeof(map));
rse1->rse_map = new_map;
@ -1168,7 +1171,7 @@ gpre_rse* SQE_select(gpre_req* request,
// Parse either of the low precedence operators + and -.
//
GPRE_NOD SQE_value(gpre_req* request,
gpre_nod* SQE_value(gpre_req* request,
bool aster_ok,
USHORT * paren_count,
bool * bool_flag)
@ -1220,7 +1223,7 @@ GPRE_NOD SQE_value(gpre_req* request,
// expression.
//
GPRE_NOD SQE_value_or_null(gpre_req* request,
gpre_nod* SQE_value_or_null(gpre_req* request,
bool aster_ok,
USHORT * paren_count,
bool * bool_flag)
@ -1239,7 +1242,7 @@ GPRE_NOD SQE_value_or_null(gpre_req* request,
// "INDICATOR".
//
GPRE_NOD SQE_variable(gpre_req* request,
gpre_nod* SQE_variable(gpre_req* request,
bool aster_ok,
USHORT * paren_count,
bool * bool_flag)
@ -1270,7 +1273,7 @@ GPRE_NOD SQE_variable(gpre_req* request,
if (MSC_match(KW_COLON))
reference->ref_null_value = PAR_native_value(false, false);
return (GPRE_NOD) reference;
return (gpre_nod*) reference;
}
@ -1280,8 +1283,8 @@ GPRE_NOD SQE_variable(gpre_req* request,
// return TRUE, otherwise FALSE.
//
static bool compare_expr(GPRE_NOD node1,
GPRE_NOD node2)
static bool compare_expr(gpre_nod* node1,
gpre_nod* node2)
{
REF ref1, ref2;
@ -1328,7 +1331,7 @@ static bool compare_expr(GPRE_NOD node1,
// Copy a field list for a SELECT against an artificial context.
//
static GPRE_NOD copy_fields( GPRE_NOD fields, map* fields_map)
static gpre_nod* copy_fields( gpre_nod* fields, map* fields_map)
{
assert_IS_NOD(fields);
@ -1346,7 +1349,7 @@ static GPRE_NOD copy_fields( GPRE_NOD fields, map* fields_map)
// Expand an '*' in a field list to the corresponding fields.
//
static GPRE_NOD explode_asterisk( GPRE_NOD fields, int n, gpre_rse* selection)
static gpre_nod* explode_asterisk( gpre_nod* fields, int n, gpre_rse* selection)
{
TEXT s[ERROR_LENGTH];
@ -1381,7 +1384,7 @@ static GPRE_NOD explode_asterisk( GPRE_NOD fields, int n, gpre_rse* selection)
// in the context list.
//
static GPRE_NOD explode_asterisk_all(GPRE_NOD fields,
static gpre_nod* explode_asterisk_all(gpre_nod* fields,
int n,
gpre_rse* selection,
bool replace)
@ -1410,7 +1413,7 @@ static GPRE_NOD explode_asterisk_all(GPRE_NOD fields,
// field for determining the data type of a host variable.
//
static gpre_fld* get_ref( GPRE_NOD expr)
static gpre_fld* get_ref( gpre_nod* expr)
{
gpre_fld* field;
@ -1486,12 +1489,12 @@ static gpre_fld* get_ref( GPRE_NOD expr)
// map.
//
static GPRE_NOD implicit_any(gpre_req* request,
GPRE_NOD value,
enum nod_t comparison,
enum nod_t any_all)
static gpre_nod* implicit_any(gpre_req* request,
gpre_nod* value,
nod_t comparison,
nod_t any_all)
{
GPRE_NOD node;
gpre_nod* node;
scope previous_scope;
assert_IS_REQ(request);
@ -1534,12 +1537,12 @@ static GPRE_NOD implicit_any(gpre_req* request,
else
node = MSC_node(nod_any, 1);
node->nod_count = 0;
node->nod_arg[0] = (GPRE_NOD) selection;
node->nod_arg[0] = (gpre_nod*) selection;
}
else {
gpre_nod* node2 = MSC_node(nod_via, 3);
node2->nod_count = 0;
node2->nod_arg[0] = (GPRE_NOD) selection;
node2->nod_arg[0] = (gpre_nod*) selection;
node2->nod_arg[2] = MSC_node(nod_null, 0);
node2->nod_arg[1] = value2;
node = MSC_binary(comparison, value, node2);
@ -1557,7 +1560,7 @@ static GPRE_NOD implicit_any(gpre_req* request,
else
node = MSC_node(nod_any, 1);
node->nod_count = 0;
node->nod_arg[0] = (GPRE_NOD) selection;
node->nod_arg[0] = (gpre_nod*) selection;
}
EXP_rse_cleanup(selection);
@ -1574,7 +1577,7 @@ static GPRE_NOD implicit_any(gpre_req* request,
// Merge two (possibly null) booleans into a single conjunct.
//
static GPRE_NOD merge( GPRE_NOD expr1, GPRE_NOD expr2)
static gpre_nod* merge( gpre_nod* expr1, gpre_nod* expr2)
{
if (!expr1)
@ -1598,8 +1601,8 @@ static GPRE_NOD merge( GPRE_NOD expr1, GPRE_NOD expr2)
// after the nth entry.
//
static GPRE_NOD merge_fields(GPRE_NOD fields_1,
GPRE_NOD fields_2,
static gpre_nod* merge_fields(gpre_nod* fields_1,
gpre_nod* fields_2,
int n,
bool replace)
{
@ -1641,7 +1644,7 @@ static GPRE_NOD merge_fields(GPRE_NOD fields_1,
// Construct negation of expression.
//
static GPRE_NOD negate( GPRE_NOD expr)
static gpre_nod* negate( gpre_nod* expr)
{
assert_IS_NOD(expr);
@ -1658,7 +1661,7 @@ static GPRE_NOD negate( GPRE_NOD expr)
// host language variable.
//
static void pair( GPRE_NOD expr1, GPRE_NOD expr2)
static void pair( gpre_nod* expr1, gpre_nod* expr2)
{
assert_IS_NOD(expr1);
assert_IS_NOD(expr2);
@ -1706,7 +1709,7 @@ static void pair( GPRE_NOD expr1, GPRE_NOD expr2)
// view stack are those used in the view definition.
//
static gpre_ctx* par_alias_list( gpre_req* request, GPRE_NOD alias_list)
static gpre_ctx* par_alias_list( gpre_req* request, gpre_nod* alias_list)
{
assert_IS_REQ(request);
assert_IS_NOD(alias_list);
@ -1889,11 +1892,11 @@ static gpre_rel* par_base_table( gpre_req* request, const gpre_rel* relation,
// In this case nod_arg[0] = value0, nod_arg[1] = test_value1, nod_arg[2] = match_value1, ...,
// nod_arg[n] = else_value
//
static GPRE_NOD par_case(gpre_req* request)
static gpre_nod* par_case(gpre_req* request)
{
gpre_lls* stack = NULL;
int count = 0;
NOD_T nod_type;
nod_t nod_type;
if (MSC_match(KW_WHEN))
{
@ -1969,7 +1972,7 @@ static GPRE_NOD par_case(gpre_req* request)
// Parse an AND boolean expression.
//
static GPRE_NOD par_and( gpre_req* request, USHORT * paren_count)
static gpre_nod* par_and( gpre_req* request, USHORT * paren_count)
{
assert_IS_REQ(request);
@ -1986,7 +1989,7 @@ static GPRE_NOD par_and( gpre_req* request, USHORT * paren_count)
//
//
static GPRE_NOD par_collate( gpre_req* request, GPRE_NOD arg)
static gpre_nod* par_collate( gpre_req* request, gpre_nod* arg)
{
assert_IS_REQ(request);
assert_IS_NOD(arg);
@ -1995,7 +1998,7 @@ static GPRE_NOD par_collate( gpre_req* request, GPRE_NOD arg)
node->nod_count = 1;
node->nod_arg[0] = arg;
gpre_fld* field = (gpre_fld*) MSC_alloc(FLD_LEN);
node->nod_arg[1] = (GPRE_NOD) field;
node->nod_arg[1] = (gpre_nod*) field;
CME_get_dtype(arg, field);
if (field->fld_dtype > dtype_any_text) {
// cast expression to VARYING with implementation-defined
@ -2025,9 +2028,9 @@ static GPRE_NOD par_collate( gpre_req* request, GPRE_NOD arg)
// <value> IN (SELECT <column> <from_nonsense>)
//
static GPRE_NOD par_in( gpre_req* request, GPRE_NOD value)
static gpre_nod* par_in( gpre_req* request, gpre_nod* value)
{
GPRE_NOD node;
gpre_nod* node;
SCHAR s[ERROR_LENGTH];
assert_IS_REQ(request);
@ -2106,8 +2109,8 @@ static gpre_ctx* par_join_clause( gpre_req* request, gpre_ctx* context1)
{
assert_IS_REQ(request);
const NOD_T join_type = par_join_type();
if (join_type == (NOD_T) 0)
const nod_t join_type = par_join_type();
if (join_type == nod_nothing)
return context1;
gpre_ctx* context2 = par_joined_relation(request, context1);
@ -2138,9 +2141,9 @@ static gpre_ctx* par_join_clause( gpre_req* request, gpre_ctx* context1)
// Parse a join type.
//
static NOD_T par_join_type(void)
static nod_t par_join_type()
{
NOD_T nod_type;
nod_t nod_type;
if (MSC_match(KW_INNER))
nod_type = nod_join_inner;
@ -2153,7 +2156,7 @@ static NOD_T par_join_type(void)
else if (MSC_match(KW_JOIN))
return nod_join_inner;
else
return (NOD_T) 0;
return nod_nothing;
if (nod_type != nod_join_inner)
MSC_match(KW_OUTER);
@ -2170,7 +2173,7 @@ static NOD_T par_join_type(void)
// Parse either of the high precedence operators * and /.
//
static GPRE_NOD par_multiply(gpre_req* request,
static gpre_nod* par_multiply(gpre_req* request,
bool aster_ok,
USHORT * paren_count,
bool * bool_flag)
@ -2183,8 +2186,8 @@ static GPRE_NOD par_multiply(gpre_req* request,
if (gpreGlob.token_global.tok_keyword == KW_COLLATE)
return par_collate(request, node);
GPRE_NOD arg;
enum nod_t nod_type;
gpre_nod* arg;
nod_t nod_type;
while (true) {
if (MSC_match(KW_ASTERISK))
nod_type = nod_times;
@ -2206,14 +2209,14 @@ static GPRE_NOD par_multiply(gpre_req* request,
// Parse an NOT boolean expression.
//
static GPRE_NOD par_not( gpre_req* request, USHORT * paren_count)
static gpre_nod* par_not( gpre_req* request, USHORT * paren_count)
{
assert_IS_REQ(request);
if (MSC_match(KW_NOT))
return negate(par_not(request, paren_count));
enum nod_t type = (enum nod_t) 0;
nod_t type = nod_nothing;
if (MSC_match(KW_EXISTS))
type = nod_any;
@ -2238,7 +2241,7 @@ static GPRE_NOD par_not( gpre_req* request, USHORT * paren_count)
gpre_nod* node = MSC_node(type, 1);
node->nod_count = 0;
gpre_rse* selection = par_rse(request, 0, false);
node->nod_arg[0] = (GPRE_NOD) selection;
node->nod_arg[0] = (gpre_nod*) selection;
if (field) {
SQE_resolve(field, 0, selection);
gpre_nod* expr = MSC_unary(nod_missing, field);
@ -2261,7 +2264,7 @@ static GPRE_NOD par_not( gpre_req* request, USHORT * paren_count)
// CASE exp1 WHEN exp2 THEN NULL ELSE exp1 END, so
// we generate a nod_case1 node.
static GPRE_NOD par_nullif(gpre_req* request)
static gpre_nod* par_nullif(gpre_req* request)
{
gpre_nod* node = MSC_node(nod_case1, 4);
EXP_left_paren(0);
@ -2288,7 +2291,7 @@ static void par_order(gpre_req* request,
bool union_f,
bool view_flag)
{
GPRE_NOD sort;
gpre_nod* sort;
map* request_map;
USHORT i;
@ -2328,7 +2331,7 @@ static void par_order(gpre_req* request,
else if (MSC_match(KW_DESCENDING))
direction = TRUE;
count++;
MSC_push((GPRE_NOD)(IPTR)direction, &directions);
MSC_push((gpre_nod*)(IPTR)direction, &directions);
MSC_push(sort, &items);
if (!MSC_match(KW_COMMA))
break;
@ -2339,8 +2342,8 @@ static void par_order(gpre_req* request,
gpre_nod** ptr = sort->nod_arg + count * 2;
while (items) {
*--ptr = (GPRE_NOD) MSC_pop(&items);
*--ptr = (GPRE_NOD) MSC_pop(&directions);
*--ptr = (gpre_nod*) MSC_pop(&items);
*--ptr = (gpre_nod*) MSC_pop(&directions);
}
}
@ -2351,13 +2354,13 @@ static void par_order(gpre_req* request,
// for a query as part of a select expression.
//
static GPRE_NOD par_plan( gpre_req* request)
static gpre_nod* par_plan( gpre_req* request)
{
assert_IS_REQ(request);
// parse the join type
NOD_T nod_type;
nod_t nod_type;
if (MSC_match(KW_JOIN))
nod_type = nod_join;
else if (MSC_match(KW_MERGE))
@ -2392,7 +2395,7 @@ static GPRE_NOD par_plan( gpre_req* request)
// access plan.
//
static GPRE_NOD par_plan_item(gpre_req* request,
static gpre_nod* par_plan_item(gpre_req* request,
bool aster_ok,
USHORT * paren_count,
bool * bool_flag)
@ -2421,7 +2424,7 @@ static GPRE_NOD par_plan_item(gpre_req* request,
break;
}
MSC_push((GPRE_NOD) upcase_string(gpreGlob.token_global.tok_string), &stack);
MSC_push((gpre_nod*) upcase_string(gpreGlob.token_global.tok_string), &stack);
PAR_get_token();
}
@ -2432,7 +2435,7 @@ static GPRE_NOD par_plan_item(gpre_req* request,
gpre_nod* alias_list = MSC_node(nod_list, (SSHORT) count);
for (ptr = &alias_list->nod_arg[count]; stack;)
*--ptr = (GPRE_NOD) MSC_pop(&stack);
*--ptr = (gpre_nod*) MSC_pop(&stack);
// lookup the contexts for the aliases
@ -2452,7 +2455,7 @@ static GPRE_NOD par_plan_item(gpre_req* request,
if (gpreGlob.token_global.tok_type != tok_ident)
CPR_s_error("<index name>");
access_type->nod_arg[0] = (GPRE_NOD) upcase_string(gpreGlob.token_global.tok_string);
access_type->nod_arg[0] = (gpre_nod*) upcase_string(gpreGlob.token_global.tok_string);
PAR_get_token();
}
else if (gpreGlob.token_global.tok_keyword == KW_INDEX) {
@ -2464,7 +2467,7 @@ static GPRE_NOD par_plan_item(gpre_req* request,
stack = NULL;
for (count = 0; gpreGlob.token_global.tok_type == tok_ident;) {
MSC_push((GPRE_NOD) upcase_string(gpreGlob.token_global.tok_string), &stack);
MSC_push((gpre_nod*) upcase_string(gpreGlob.token_global.tok_string), &stack);
PAR_get_token();
count++;
@ -2478,7 +2481,7 @@ static GPRE_NOD par_plan_item(gpre_req* request,
gpre_nod* index_list = MSC_node(nod_list, (SSHORT) count);
access_type->nod_arg[0] = index_list;
for (ptr = &index_list->nod_arg[count]; stack;)
*--ptr = (GPRE_NOD) MSC_pop(&stack);
*--ptr = (gpre_nod*) MSC_pop(&stack);
if (!EXP_match_paren())
return NULL;
@ -2494,7 +2497,7 @@ static GPRE_NOD par_plan_item(gpre_req* request,
plan_item->nod_count = 2;
plan_item->nod_arg[0] = alias_list;
plan_item->nod_arg[1] = access_type;
plan_item->nod_arg[2] = (GPRE_NOD) context;
plan_item->nod_arg[2] = (gpre_nod*) context;
return plan_item;
}
@ -2515,7 +2518,7 @@ static GPRE_NOD par_plan_item(gpre_req* request,
// user defined function
//
static GPRE_NOD par_primitive_value(gpre_req* request,
static gpre_nod* par_primitive_value(gpre_req* request,
bool aster_ok,
USHORT * paren_count,
bool * bool_flag)
@ -2654,7 +2657,7 @@ static GPRE_NOD par_primitive_value(gpre_req* request,
return NULL;
}
ref* reference = (REF) SQE_variable(request, false, NULL, NULL);
node = MSC_unary(nod_value, (GPRE_NOD) reference);
node = MSC_unary(nod_value, (gpre_nod*) reference);
reference->ref_next = request->req_values;
request->req_values = reference;
return node;
@ -2675,7 +2678,7 @@ static GPRE_NOD par_primitive_value(gpre_req* request,
// anything that makes sense until now
{
// ** Begin date/time/timestamp support *
const KWWORDS kw_word = gpreGlob.token_global.tok_keyword;
const kwwords_t kw_word = gpreGlob.token_global.tok_keyword;
if (MSC_match(KW_DATE) || MSC_match(KW_TIME) || MSC_match(KW_TIMESTAMP)) {
gpreGlob.token_global.tok_keyword = kw_word;
@ -2696,7 +2699,7 @@ static GPRE_NOD par_primitive_value(gpre_req* request,
// Parse relational expression.
//
static GPRE_NOD par_relational(gpre_req* request,
static gpre_nod* par_relational(gpre_req* request,
USHORT * paren_count)
{
assert_IS_REQ(request);
@ -2707,7 +2710,7 @@ static GPRE_NOD par_relational(gpre_req* request,
return expr1;
if (gpreGlob.token_global.tok_keyword == KW_SEMI_COLON)
{
for (const NOD_T* relational_ops = relationals; *relational_ops != (NOD_T) 0;
for (const nod_t* relational_ops = relationals; *relational_ops != nod_nothing;
relational_ops++)
{
if (expr1->nod_type == *relational_ops)
@ -2721,7 +2724,7 @@ static GPRE_NOD par_relational(gpre_req* request,
// Check for one of the binary operators
GPRE_NOD node;
gpre_nod* node;
if (MSC_match(KW_IN))
node = par_in(request, expr1);
else if (MSC_match(KW_BETWEEN)) {
@ -2766,8 +2769,8 @@ static GPRE_NOD par_relational(gpre_req* request,
if (MSC_match(op->rel_kw))
break;
if ((int) op->rel_kw == (int) KW_none) {
for (const NOD_T* relational_ops = relationals;
*relational_ops != (NOD_T) 0; relational_ops++)
for (const nod_t* relational_ops = relationals;
*relational_ops != nod_nothing; relational_ops++)
{
if (expr1->nod_type == *relational_ops)
return expr1;
@ -2806,7 +2809,7 @@ static GPRE_NOD par_relational(gpre_req* request,
// Out of alphabetical order.
static bool resolve_fields(GPRE_NOD& fields,
static bool resolve_fields(gpre_nod*& fields,
gpre_req* request,
gpre_rse* selection)
{
@ -2859,7 +2862,7 @@ static bool resolve_fields(GPRE_NOD& fields,
//
static gpre_rse* par_rse(gpre_req* request,
GPRE_NOD fields,
gpre_nod* fields,
bool distinct)
{
gpre_lls* stack = NULL;
@ -2876,7 +2879,7 @@ static gpre_rse* par_rse(gpre_req* request,
gpre_ctx* context;
do {
if (context = par_joined_relation(request, NULL)) {
MSC_push((GPRE_NOD) context, &stack);
MSC_push((gpre_nod*) context, &stack);
count++;
}
else
@ -3035,7 +3038,7 @@ static gpre_rse* par_select( gpre_req* request, gpre_rse* union_rse)
// has already eaten the SELECT on the front.
//
static GPRE_NOD par_stat( gpre_req* request)
static gpre_nod* par_stat( gpre_req* request)
{
assert_IS_REQ(request);
@ -3060,7 +3063,7 @@ static GPRE_NOD par_stat( gpre_req* request)
gpre_nod* node = MSC_node(nod_via, 3);
node->nod_count = 0;
node->nod_arg[0] = (GPRE_NOD) select;
node->nod_arg[0] = (gpre_nod*) select;
node->nod_arg[2] = MSC_node(nod_null, 0);
node->nod_arg[1] = item;
@ -3077,12 +3080,12 @@ static GPRE_NOD par_stat( gpre_req* request)
// Parse a subscript value.
//
static GPRE_NOD par_subscript( gpre_req* request)
static gpre_nod* par_subscript( gpre_req* request)
{
assert_IS_REQ(request);
ref* reference = (REF) MSC_alloc(REF_LEN);
gpre_nod* node = MSC_unary(nod_value, (GPRE_NOD) reference);
gpre_nod* node = MSC_unary(nod_value, (gpre_nod*) reference);
// Special case literals
@ -3112,7 +3115,7 @@ static GPRE_NOD par_subscript( gpre_req* request)
//
// Parse the SUBSTRING built-in function
//
static GPRE_NOD par_substring(gpre_req* request)
static gpre_nod* par_substring(gpre_req* request)
{
gpre_nod* node = MSC_node(nod_substring, 3);
EXP_left_paren(0);
@ -3144,7 +3147,7 @@ static GPRE_NOD par_substring(gpre_req* request)
// No FOR clause given, fake up a numeric literal of 32767 (the max length
// of a VarChar) to force copying to end of string.
ref* reference1 = (ref*) MSC_alloc(REF_LEN);
node->nod_arg[2] = MSC_unary(nod_literal, (GPRE_NOD) reference1);
node->nod_arg[2] = MSC_unary(nod_literal, (gpre_nod*) reference1);
string = (TEXT*) MSC_alloc(6);
MSC_copy("32767", 5, (char*) string);
reference1->ref_value = string;
@ -3177,7 +3180,7 @@ static void par_terminating_parens(
// complain bitterly.
//
static GPRE_NOD par_udf( gpre_req* request)
static gpre_nod* par_udf( gpre_req* request)
{
if (!request)
return NULL;
@ -3189,7 +3192,7 @@ static GPRE_NOD par_udf( gpre_req* request)
if ((isQuoted(gpreGlob.token_global.tok_type)) || gpreGlob.token_global.tok_type == tok_ident)
SQL_resolve_identifier("<Udf Name>", NULL, NAME_SIZE);
GPRE_NOD node;
gpre_nod* node;
USHORT local_count;
udf* an_udf;
@ -3228,7 +3231,7 @@ static GPRE_NOD par_udf( gpre_req* request)
node = MSC_node(nod_udf, 2);
node->nod_count = 1;
node->nod_arg[1] = (GPRE_NOD) an_udf;
node->nod_arg[1] = (gpre_nod*) an_udf;
PAR_get_token();
EXP_left_paren(0);
if (!(gpreGlob.token_global.tok_keyword == KW_RIGHT_PAREN)) {
@ -3248,7 +3251,7 @@ static GPRE_NOD par_udf( gpre_req* request)
}
}
else {
node->nod_arg[0] = (GPRE_NOD) 0;
node->nod_arg[0] = (gpre_nod*) 0;
node->nod_count = 0;
}
local_count = 1;
@ -3266,7 +3269,7 @@ static GPRE_NOD par_udf( gpre_req* request)
node->nod_count = 1;
EXP_left_paren(0);
SQL_resolve_identifier("<Generator Name>", gen_name, NAME_SIZE);
node->nod_arg[1] = (GPRE_NOD) gen_name;
node->nod_arg[1] = (gpre_nod*) gen_name;
PAR_get_token();
if (!MSC_match(KW_COMMA))
CPR_s_error("<comma>");
@ -3312,7 +3315,7 @@ static GPRE_NOD par_udf( gpre_req* request)
if (MSC_match(KW_EXTRACT)) {
node = MSC_node(nod_extract, 2);
EXP_left_paren(0);
KWWORDS kw_word = gpreGlob.token_global.tok_keyword;
kwwords_t kw_word = gpreGlob.token_global.tok_keyword;
if (MSC_match(KW_YEAR) || MSC_match(KW_MONTH) || MSC_match(KW_DAY) ||
MSC_match(KW_HOUR) || MSC_match(KW_MINUTE) || MSC_match(KW_SECOND) ||
MSC_match(KW_WEEKDAY) || MSC_match(KW_YEARDAY))
@ -3357,7 +3360,7 @@ static GPRE_NOD par_udf( gpre_req* request)
if (!MSC_match(KW_AS))
CPR_s_error("AS");
gpre_fld* field = (gpre_fld*) MSC_alloc(FLD_LEN);
node->nod_arg[1] = (GPRE_NOD) field;
node->nod_arg[1] = (gpre_nod*) field;
SQL_par_field_dtype(request, field, false);
SQL_par_field_collate(request, field);
SQL_adjust_field_dtype(field);
@ -3403,7 +3406,7 @@ static GPRE_NOD par_udf( gpre_req* request)
// Parse a user defined function or a field name.
//
static GPRE_NOD par_udf_or_field(gpre_req* request,
static gpre_nod* par_udf_or_field(gpre_req* request,
bool aster_ok)
{
assert_IS_REQ(request);
@ -3422,7 +3425,7 @@ static GPRE_NOD par_udf_or_field(gpre_req* request,
// Allow the collate clause to follow.
//
static GPRE_NOD par_udf_or_field_with_collate(gpre_req* request,
static gpre_nod* par_udf_or_field_with_collate(gpre_req* request,
bool aster_ok,
USHORT * paren_count,
bool * bool_flag)
@ -3485,7 +3488,7 @@ static void par_update(gpre_rse *select, bool have_union, bool view_flag)
// not the computations around them.
//
static GPRE_NOD post_fields( GPRE_NOD node, map* to_map)
static gpre_nod* post_fields( gpre_nod* node, map* to_map)
{
assert_IS_NOD(node);
@ -3549,7 +3552,7 @@ static GPRE_NOD post_fields( GPRE_NOD node, map* to_map)
// than the expression itself).
//
static GPRE_NOD post_map( GPRE_NOD node, map* to_map)
static gpre_nod* post_map( gpre_nod* node, map* to_map)
{
MEL element;
@ -3566,7 +3569,7 @@ static GPRE_NOD post_map( GPRE_NOD node, map* to_map)
for (element = to_map->map_elements; element; element = element->mel_next)
if (compare_expr(node, element->mel_expr))
return MSC_unary(nod_map_ref, (GPRE_NOD) element);
return MSC_unary(nod_map_ref, (gpre_nod*) element);
// We need to make up a new map reference
@ -3579,7 +3582,7 @@ static GPRE_NOD post_map( GPRE_NOD node, map* to_map)
// Make up a reference to the map element
return MSC_unary(nod_map_ref, (GPRE_NOD) element);
return MSC_unary(nod_map_ref, (gpre_nod*) element);
}
@ -3592,7 +3595,7 @@ static GPRE_NOD post_map( GPRE_NOD node, map* to_map)
// a UNION. See BUG_8021 & BUG_8000 for examples.
//
static GPRE_NOD post_select_list( GPRE_NOD fields, map* to_map)
static gpre_nod* post_select_list( gpre_nod* fields, map* to_map)
{
assert_IS_NOD(fields);
@ -3659,7 +3662,7 @@ static void push_scope(gpre_req* request, scope* save_scope)
//
static gpre_fld* resolve(
GPRE_NOD node,
gpre_nod* node,
gpre_ctx* context, gpre_ctx** found_context, act** slice_action)
{
gpre_fld* field;
@ -3828,7 +3831,7 @@ static gpre_ctx* resolve_asterisk( TOK q_token, gpre_rse* selection)
// Set field reference for any host variables in expr to field_ref.
//
static void set_ref( GPRE_NOD expr, gpre_fld* field_ref)
static void set_ref( gpre_nod* expr, gpre_fld* field_ref)
{
assert_IS_NOD(expr);

18
src/gpre/sqe_proto.h
View File

@ -24,19 +24,19 @@
#ifndef GPRE_SQE_PROTO_H
#define GPRE_SQE_PROTO_H
typedef GPRE_NOD (*pfn_SQE_list_cb) (gpre_req*, bool, USHORT*, bool*);
typedef gpre_nod* (*pfn_SQE_list_cb) (gpre_req*, bool, USHORT*, bool*);
GPRE_NOD SQE_boolean(gpre_req*, USHORT*);
gpre_nod* SQE_boolean(gpre_req*, USHORT*);
gpre_ctx* SQE_context(gpre_req*);
GPRE_NOD SQE_field(gpre_req*, bool);
GPRE_NOD SQE_list(pfn_SQE_list_cb, gpre_req*, bool);
gpre_nod* SQE_field(gpre_req*, bool);
gpre_nod* SQE_list(pfn_SQE_list_cb, gpre_req*, bool);
REF SQE_parameter(gpre_req*, bool);
void SQE_post_field(GPRE_NOD, gpre_fld*);
REF SQE_post_reference(gpre_req*, gpre_fld*, gpre_ctx*, GPRE_NOD);
bool SQE_resolve(GPRE_NOD, gpre_req*, gpre_rse*);
void SQE_post_field(gpre_nod*, gpre_fld*);
REF SQE_post_reference(gpre_req*, gpre_fld*, gpre_ctx*, gpre_nod*);
bool SQE_resolve(gpre_nod*, gpre_req*, gpre_rse*);
gpre_rse* SQE_select(gpre_req*, bool);
GPRE_NOD SQE_value(gpre_req*, bool, USHORT*, bool*);
GPRE_NOD SQE_variable(gpre_req*, bool, USHORT*, bool*);
gpre_nod* SQE_value(gpre_req*, bool, USHORT*, bool*);
gpre_nod* SQE_variable(gpre_req*, bool, USHORT*, bool*);
#endif // GPRE_SQE_PROTO_H

360
src/gpre/sql.cpp
View File

File diff suppressed because it is too large Load Diff

2
src/gpre/sql_proto.h
View File

@ -27,7 +27,7 @@
act* SQL_action(const TEXT*);
void SQL_adjust_field_dtype(gpre_fld*);
void SQL_dialect1_bad_type(USHORT);
void SQL_init(void);
void SQL_init();
void SQL_par_field_collate(gpre_req*, gpre_fld*);
void SQL_par_field_dtype(gpre_req*, gpre_fld*, bool);
gpre_prc* SQL_procedure(gpre_req*, const TEXT*, const TEXT*, const TEXT*, bool);

4
src/gpre/words.h
View File

@ -19,7 +19,7 @@
* Stephen W. Boyd - Added support for new features.
*/
typedef enum kwwords {
enum kwwords_t {
KW_none = 0,
KW_start_actions,
KW_ACTIVE,
@ -327,4 +327,4 @@ typedef enum kwwords {
KW_THEN,
KW_SUBSTRING,
KW_max
} KWWORDS;
};