UCHAR* MSC_alloc(int size)
{
size = FB_ALIGN(size, FB_ALIGNMENT);
if (!space || size > space->spc_remaining)
{
const int n = MAX(size, 4096);
gpre_space* next = (gpre_space*) gds__alloc((SLONG) (n + sizeof(gpre_space)));
if (!next)
CPR_error("virtual memory exhausted");
#ifdef DEBUG_GDS_ALLOC
// For V4.0 we don't care about gpre specific memory leaks
gds_alloc_flag_unfreed(next);
#endif
next->spc_next = space;
next->spc_remaining = n;
space = next;
}
space->spc_remaining -= size;
UCHAR* blk = ((UCHAR*) space + sizeof(gpre_space) + space->spc_remaining);
memset(blk, 0, size);
return blk;
}
static void make_port( const gpre_port* port, int column)
{
printa(column, "struct {");
for (const ref* reference = port->por_references; reference; reference = reference->ref_next)
{
align(column + INDENT);
const gpre_fld* field = reference->ref_field;
const gpre_sym* symbol = field->fld_symbol;
const TEXT* name = symbol->sym_string;
const char* fmtstr = NULL;
switch (field->fld_dtype)
{
case dtype_short:
fmtstr = " SSHORT jrd_%d;\t// %s ";
break;
case dtype_long:
fmtstr = " SLONG jrd_%d;\t// %s ";
break;
// Begin sql date/time/timestamp
case dtype_sql_date:
fmtstr = " ISC_DATE jrd_%d;\t// %s ";
break;
case dtype_sql_time:
fmtstr = " ISC_TIME jrd_%d;\t// %s ";
break;
case dtype_timestamp:
fmtstr = " ISC_TIMESTAMP jrd_%d;\t// %s ";
break;
// End sql date/time/timestamp
case dtype_int64:
fmtstr = " ISC_INT64 jrd_%d;\t// %s ";
break;
case dtype_quad:
fmtstr = " ISC_QUAD jrd_%d;\t// %s ";
break;
case dtype_blob:
fmtstr = " bid jrd_%d;\t// %s ";
break;
case dtype_cstring:
case dtype_text:
fprintf(gpreGlob.out_file, " TEXT jrd_%d [%d];\t// %s ",
reference->ref_ident, field->fld_length, name);
break;
case dtype_real:
fmtstr = " float jrd_%d;\t// %s ";
break;
case dtype_double:
fmtstr = " double jrd_%d;\t// %s ";
break;
case dtype_boolean:
fmtstr = " UCHAR jrd_%d;\t// %s ";
break;
default:
{
TEXT s[ERROR_LENGTH];
fb_utils::snprintf(s, sizeof(s), "datatype %d unknown for field %s, msg %d",
field->fld_dtype, name, port->por_msg_number);
CPR_error(s);
return;
}
}
if (fmtstr)
fprintf(gpreGlob.out_file, fmtstr, reference->ref_ident, name);
}
align(column);
fprintf(gpreGlob.out_file, "} jrd_%"ULONGFORMAT";", port->por_ident);
}
void PATTERN_expand( USHORT column, const TEXT* pattern, PAT* args)
{
// CVC: kudos to the programmer that had chosen variables with the same
// names that structs in gpre.h and with type char* if not enough.
// Renamed ref to lang_ref and val to lang_val.
const TEXT* lang_ref = "";
const TEXT* refend = "";
const TEXT* lang_val = "";
const TEXT* valend = "";
if ((gpreGlob.sw_language == lang_c) || (isLangCpp(gpreGlob.sw_language)))
{
lang_ref = "&";
refend = "";
}
else if (gpreGlob.sw_language == lang_pascal)
{
lang_ref = "%%REF ";
refend = "";
}
else if (gpreGlob.sw_language == lang_cobol)
{
lang_ref = "BY REFERENCE ";
refend = "";
lang_val = "BY VALUE ";
valend = "";
}
else if (gpreGlob.sw_language == lang_fortran)
{
#if (defined AIX || defined AIX_PPC)
lang_ref = "%REF(";
refend = ")";
lang_val = "%VAL(";
valend = ")";
#endif
}
TEXT buffer[512];
TEXT* p = buffer;
*p++ = '\n';
bool sw_gen = true;
for (USHORT n = column; n; --n)
*p++ = ' ';
SSHORT value; // value needs to be signed since some of the
// values printed out are signed.
SLONG long_value;
TEXT c;
while (c = *pattern++)
{
if (c != '%')
{
if (sw_gen)
{
*p++ = c;
if ((c == '\n') && (*pattern))
for (USHORT n = column; n; --n)
*p++ = ' ';
}
continue;
}
bool sw_ident = false;
const TEXT* string = NULL;
const ref* reference = NULL;
#ifdef GPRE_ADA
bool handle_flag = false;
#endif
bool long_flag = false;
const ops* oper_iter;
for (oper_iter = operators; oper_iter->ops_type != NL; oper_iter++)
{
if (oper_iter->ops_string[0] == pattern[0] && oper_iter->ops_string[1] == pattern[1])
{
break;
}
}
pattern += 2;
switch (oper_iter->ops_type)
{
case IF:
sw_gen = args->pat_condition;
continue;
case EL:
sw_gen = !sw_gen;
continue;
case EN:
sw_gen = true;
continue;
case RH:
#ifdef GPRE_ADA
handle_flag = true;
#endif
string = args->pat_request->req_handle;
break;
case RL:
string = args->pat_request->req_request_level;
break;
case RS:
value = args->pat_request->req_length;
break;
case RT:
#ifdef GPRE_ADA
handle_flag = true;
#endif
string = args->pat_request->req_trans;
break;
case RI:
long_value = args->pat_request->req_ident;
long_flag = true;
sw_ident = true;
break;
case DH:
#ifdef GPRE_ADA
handle_flag = true;
#endif
string = args->pat_database->dbb_name->sym_string;
break;
case DF:
string = args->pat_database->dbb_filename;
break;
case PN:
value = args->pat_port->por_msg_number;
break;
case PL:
value = args->pat_port->por_length;
break;
case PI:
long_value = args->pat_port->por_ident;
long_flag = true;
sw_ident = true;
break;
case QN:
value = args->pat_port2->por_msg_number;
break;
case QL:
value = args->pat_port2->por_length;
break;
case QI:
long_value = args->pat_port2->por_ident;
long_flag = true;
sw_ident = true;
break;
case BH:
long_value = args->pat_blob->blb_ident;
long_flag = true;
sw_ident = true;
break;
case I1:
long_value = args->pat_ident1;
long_flag = true;
sw_ident = true;
break;
case I2:
long_value = args->pat_ident2;
long_flag = true;
sw_ident = true;
break;
case S1:
string = args->pat_string1;
break;
case S2:
string = args->pat_string2;
break;
case S3:
string = args->pat_string3;
break;
case S4:
string = args->pat_string4;
break;
case S5:
string = args->pat_string5;
break;
case S6:
string = args->pat_string6;
break;
case S7:
string = args->pat_string7;
break;
case V1:
string = args->pat_vector1;
break;
case V2:
string = args->pat_vector2;
break;
case N1:
value = args->pat_value1;
break;
case N2:
value = args->pat_value2;
break;
case N3:
value = args->pat_value3;
break;
case N4:
value = args->pat_value4;
break;
case L1:
long_value = args->pat_long1;
long_flag = true;
break;
case L2:
long_value = args->pat_long2;
long_flag = true;
break;
case RF:
string = lang_ref;
break;
case RE:
string = refend;
break;
case VF:
string = lang_val;
break;
case VE:
string = valend;
break;
case FR:
reference = args->pat_reference;
break;
default:
sprintf(buffer, "Unknown substitution \"%c%c\"", pattern[-2], pattern[-1]);
CPR_error(buffer);
continue;
}
if (!sw_gen)
continue;
if (string)
{
#ifdef GPRE_ADA
if (handle_flag && (gpreGlob.sw_language == lang_ada))
{
for (const TEXT* q = gpreGlob.ada_package; *q;)
*p++ = *q++;
}
#endif
while (*string)
*p++ = *string++;
continue;
}
if (sw_ident)
{
if (long_flag)
sprintf(p, gpreGlob.long_ident_pattern, long_value);
else
sprintf(p, gpreGlob.ident_pattern, value);
}
else if (reference)
{
if (!reference->ref_port)
sprintf(p, gpreGlob.ident_pattern, reference->ref_ident);
else
{
TEXT temp1[16], temp2[16];
sprintf(temp1, gpreGlob.ident_pattern, reference->ref_port->por_ident);
sprintf(temp2, gpreGlob.ident_pattern, reference->ref_ident);
switch (gpreGlob.sw_language)
{
case lang_fortran:
case lang_cobol:
strcpy(p, temp2);
break;
default:
sprintf(p, "%s.%s", temp1, temp2);
}
}
}
else if (long_flag) {
sprintf(p, "%" SLONGFORMAT, long_value);
}
else {
sprintf(p, "%d", value);
}
while (*p)
p++;
}
*p = 0;
#if (defined GPRE_ADA || defined GPRE_COBOL || defined GPRE_FORTRAN)
switch (gpreGlob.sw_language)
{
#ifdef GPRE_ADA
// Ada lines can be up to 120 characters long. ADA_print_buffer
// handles this problem and ensures that GPRE output is <=120 characters.
case lang_ada:
ADA_print_buffer(buffer, 0);
break;
#endif
#ifdef GPRE_COBOL
// COBOL lines can be up to 72 characters long. COB_print_buffer
// handles this problem and ensures that GPRE output is <= 72 characters.
case lang_cobol:
COB_print_buffer(buffer, true);
break;
#endif
#ifdef GPRE_FORTRAN
// In FORTRAN, characters beyond column 72 are ignored. FTN_print_buffer
// handles this problem and ensures that GPRE output does not exceed this
// limit.
case lang_fortran:
FTN_print_buffer(buffer);
break;
#endif
default:
fprintf(gpreGlob.out_file, "%s", buffer);
break;
}
#else
fprintf(gpreGlob.out_file, "%s", buffer);
#endif
}
