INLINE void generate_table_row_by_value(w128_t table_row[], void(*gen_function)(w128_t&, int, int), const w128_t& value){
w128_t x;
for (int i = 0; i < MAX_BIT_PARTS; i++) {
gen_function(x, i, ACCESS_128_VALUE_8(value, i));
table_row[i] = x;
}
}
INLINE void generate_table_row(w128_t table[][256], void(*gen_function)(w128_t&, int, int), int row){
w128_t x;
for (int i = 0; i < MAX_BIT_PARTS; i++) {
gen_function(x, i, row);
table[i][row] = x;
}
}
block gen_lambda(block body) {
return gen_function("@lambda", gen_noop(), body);
}
static void gen_expression(qli_nod* node, qli_req* request)
{
/**************************************
*
* g e n _ e x p r e s s i o n
*
**************************************
*
* Functional description
* Generate the BLR for a boolean or value expression.
*
**************************************/
USHORT operatr = 0;
qli_rlb* rlb = 0;
if (node->nod_flags & NOD_local)
{
request = NULL;
//return;
}
else if (request)
rlb = CHECK_RLB(request->req_blr);
switch (node->nod_type)
{
case nod_any:
gen_any(node, request);
return;
case nod_unique:
if (request)
{
STUFF(blr_unique);
gen_rse(node->nod_arg[e_any_rse], request);
}
return;
case nod_constant:
if (request)
gen_literal(&node->nod_desc, request);
return;
case nod_field:
gen_field(node, request);
return;
case nod_format:
gen_expression(node->nod_arg[e_fmt_value], request);
return;
case nod_map:
{
qli_map* map = (qli_map*) node->nod_arg[e_map_map];
const qli_ctx* context = (qli_ctx*) node->nod_arg[e_map_context];
if (context->ctx_request != request && map->map_node->nod_type == nod_field)
{
gen_field(map->map_node, request);
return;
}
STUFF(blr_fid);
STUFF(context->ctx_context);
STUFF_WORD(map->map_position);
return;
}
case nod_eql:
operatr = blr_eql;
break;
case nod_neq:
operatr = blr_neq;
break;
case nod_gtr:
operatr = blr_gtr;
break;
case nod_geq:
operatr = blr_geq;
break;
case nod_leq:
operatr = blr_leq;
break;
case nod_lss:
operatr = blr_lss;
break;
case nod_containing:
operatr = blr_containing;
break;
case nod_matches:
operatr = blr_matching;
break;
case nod_sleuth:
operatr = blr_matching2;
break;
case nod_like:
operatr = (node->nod_count == 2) ? blr_like : blr_ansi_like;
break;
case nod_starts:
operatr = blr_starting;
break;
case nod_missing:
operatr = blr_missing;
break;
case nod_between:
operatr = blr_between;
break;
case nod_and:
operatr = blr_and;
break;
case nod_or:
operatr = blr_or;
break;
case nod_not:
operatr = blr_not;
break;
case nod_add:
operatr = blr_add;
break;
case nod_subtract:
operatr = blr_subtract;
break;
case nod_multiply:
operatr = blr_multiply;
break;
case nod_divide:
operatr = blr_divide;
break;
case nod_negate:
operatr = blr_negate;
break;
case nod_concatenate:
operatr = blr_concatenate;
break;
case nod_substr:
operatr = blr_substring;
break;
case nod_function:
gen_function(node, request);
return;
case nod_agg_average:
case nod_agg_count:
case nod_agg_max:
case nod_agg_min:
case nod_agg_total:
case nod_average:
case nod_count:
case nod_max:
case nod_min:
case nod_total:
case nod_from:
gen_statistical(node, request);
return;
case nod_rpt_average:
case nod_rpt_count:
case nod_rpt_max:
case nod_rpt_min:
case nod_rpt_total:
case nod_running_total:
case nod_running_count:
if (node->nod_arg[e_stt_value])
gen_expression(node->nod_arg[e_stt_value], request);
if (node->nod_export)
gen_parameter(node->nod_export, request);
request = NULL;
break;
case nod_prompt:
case nod_variable:
if (node->nod_export)
gen_parameter(node->nod_export, request);
return;
case nod_edit_blob:
case nod_reference:
return;
case nod_null:
operatr = blr_null;
break;
case nod_user_name:
operatr = blr_user_name;
break;
case nod_upcase:
operatr = blr_upcase;
break;
case nod_lowcase:
operatr = blr_lowcase;
break;
default:
if (request && node->nod_export)
{
gen_parameter(node->nod_export, request);
return;
}
ERRQ_bugcheck(353); // Msg353 gen_expression: not understood
}
if (request)
{
rlb = CHECK_RLB(request->req_blr);
STUFF(operatr);
}
qli_nod** ptr = node->nod_arg;
for (qli_nod** const end = ptr + node->nod_count; ptr < end; ptr++)
gen_expression(*ptr, request);
if (!node->nod_desc.dsc_address && node->nod_desc.dsc_length)
CMP_alloc_temp(node);
}