Mirrors/miller
1
0
Fork 0
mirror of https://github.com/johnkerl/miller.git synced 2026-07-19 09:24:14 +00:00
Code Issues Projects Releases Wiki Activity

mapper arg-bagging (big diff)

Browse source
This commit is contained in:
John Kerl 2016-05-16 16:29:57 -07:00
parent c3edf3ddf2
commit e80876d18c
11 changed files with 527 additions and 837 deletions
Download patch file Download diff file Expand all files Collapse all files

2
c/Makefile.no-autoconfig
View file

@ -210,6 +210,8 @@ TEST_RVAL_EVALUATORS_SRCS = \
containers/lrec.c \
containers/lhmsv.c \
containers/mlhmmv.c \
containers/lhmsmv.c \
containers/bind_stack.c \
mapping/rval_expr_evaluators.c \
mapping/rval_func_evaluators.c \
mapping/rval_list_evaluators.c \

13
c/mapping/mapper_filter.c
View file

@ -173,8 +173,17 @@ static sllv_t* mapper_filter_process(lrec_t* pinrec, context_t* pctx, void* pvst
lhmsv_t* ptyped_overlay = lhmsv_alloc();
sllv_t* rv = NULL;
mv_t val = pstate->pevaluator->pprocess_func(pinrec, ptyped_overlay, pstate->poosvars,
NULL, pctx, pstate->pevaluator->pvstate);
variables_t variables = (variables_t) {
.pinrec = pinrec,
.ptyped_overlay = ptyped_overlay,
.poosvars = pstate->poosvars,
.ppregex_captures = NULL,
.pctx = pctx,
.pbind_stack = NULL,
};
mv_t val = pstate->pevaluator->pprocess_func(pstate->pevaluator->pvstate, &variables);
if (mv_is_null(&val)) {
lrec_free(pinrec);
} else {

54
c/mapping/mapper_put.c
View file

@ -245,17 +245,44 @@ static sllv_t* mapper_put_process(lrec_t* pinrec, context_t* pctx, void* pvstate
sllv_t* poutrecs = sllv_alloc();
int emit_rec = TRUE;
// xxx
// return (mv_t) {.type = MT_BOOL, .free_flags = NO_FREE, .u.boolv = b};
//typedef struct _variables_t {
// lrec_t* pinrec;
// lhmsv_t* ptyped_overlay;
// mlhmmv_t* poosvars;
// string_array_t** ppregex_captures;
// context_t* pctx;
// bind_stack_t* pbind_stack;
//} variables_t;
if (pstate->at_begin) {
mlr_dsl_cst_handle(pstate->pcst->pbegin_statements,
pstate->poosvars, NULL, NULL, &pregex_captures, pctx, &emit_rec, poutrecs,
pstate->oosvar_flatten_separator, pstate->pbind_stack);
variables_t variables = (variables_t) {
.pinrec = NULL,
.ptyped_overlay = NULL,
.poosvars = pstate->poosvars,
.ppregex_captures = &pregex_captures,
.pctx = pctx,
.pbind_stack = pstate->pbind_stack,
};
mlr_dsl_cst_handle(pstate->pcst->pbegin_statements, &variables,
&emit_rec, poutrecs, pstate->oosvar_flatten_separator);
pstate->at_begin = FALSE;
}
if (pinrec == NULL) { // End of input stream
mlr_dsl_cst_handle(pstate->pcst->pend_statements,
pstate->poosvars, NULL, NULL, &pregex_captures, pctx, &emit_rec, poutrecs,
pstate->oosvar_flatten_separator, pstate->pbind_stack);
variables_t variables = (variables_t) {
.pinrec = NULL,
.ptyped_overlay = NULL,
.poosvars = pstate->poosvars,
.ppregex_captures = &pregex_captures,
.pctx = pctx,
.pbind_stack = pstate->pbind_stack,
};
mlr_dsl_cst_handle(pstate->pcst->pend_statements, &variables,
&emit_rec, poutrecs, pstate->oosvar_flatten_separator);
string_array_free(pregex_captures);
sllv_append(poutrecs, NULL);
@ -265,9 +292,18 @@ static sllv_t* mapper_put_process(lrec_t* pinrec, context_t* pctx, void* pvstate
lhmsv_t* ptyped_overlay = lhmsv_alloc();
emit_rec = TRUE;
mlr_dsl_cst_handle(pstate->pcst->pmain_statements,
pstate->poosvars, pinrec, ptyped_overlay, &pregex_captures, pctx, &emit_rec, poutrecs,
pstate->oosvar_flatten_separator, pstate->pbind_stack);
variables_t variables = (variables_t) {
.pinrec = pinrec,
.ptyped_overlay = ptyped_overlay,
.poosvars = pstate->poosvars,
.ppregex_captures = &pregex_captures,
.pctx = pctx,
.pbind_stack = pstate->pbind_stack,
};
mlr_dsl_cst_handle(pstate->pcst->pmain_statements, &variables,
&emit_rec, poutrecs, pstate->oosvar_flatten_separator);
if (emit_rec && pstate->outer_filter) {
// Write the output fields from the typed overlay back to the lrec.

704
c/mapping/mlr_dsl_cst.c
View file

File diff suppressed because it is too large Load diff

28
c/mapping/mlr_dsl_cst.h
View file

@ -49,15 +49,10 @@ struct _mlr_dsl_cst_statement_t;
typedef void mlr_dsl_cst_node_handler_func_t(
struct _mlr_dsl_cst_statement_t* pnode,
mlhmmv_t* poosvars,
lrec_t* pinrec,
lhmsv_t* ptyped_overlay,
string_array_t** ppregex_captures,
context_t* pctx,
int* pshould_emit_rec,
sllv_t* poutrecs,
char* oosvar_flatten_separator,
bind_stack_t* pbind_stack);
variables_t* pvars,
int* pshould_emit_rec, // xxx bag up the rest as cst bag ...
sllv_t* poutrecs,
char* oosvar_flatten_separator);
// Most statements have one item, except emit and unset.
typedef struct _mlr_dsl_cst_statement_vararg_t {
@ -122,15 +117,10 @@ mlr_dsl_cst_t* mlr_dsl_cst_alloc(mlr_dsl_ast_t* past, int type_inferencing);
void mlr_dsl_cst_free(mlr_dsl_cst_t* pcst);
void mlr_dsl_cst_handle(
sllv_t* pcst_statements, // begin/main/end
mlhmmv_t* poosvars,
lrec_t* pinrec,
lhmsv_t* ptyped_overlay,
string_array_t** ppregex_captures,
context_t* pctx,
int* pshould_emit_rec,
sllv_t* poutrecs,
char* oosvar_flatten_separator,
bind_stack_t* pbind_stack);
sllv_t* pcst_statements, // begin/main/end
variables_t* pvars,
int* pshould_emit_rec,
sllv_t* poutrecs,
char* oosvar_flatten_separator);
#endif // MLR_DSL_CST_H

12
c/mapping/rval_evaluator.h
View file

@ -38,22 +38,16 @@
struct _rval_evaluator_t; // forward reference for method declarations
typedef struct _rval_expr_data_t {
typedef struct _variables_t {
lrec_t* pinrec;
lhmsv_t* ptyped_overlay;
mlhmmv_t* poosvars;
string_array_t** ppregex_captures;
context_t* pctx;
bind_stack_t* pbind_stack;
} rval_expr_data_t;
} variables_t;
typedef mv_t rval_evaluator_process_func_t(
lrec_t* pinrec,
lhmsv_t* ptyped_overlay,
mlhmmv_t* poosvars,
string_array_t** ppregex_captures,
context_t* pctx,
void* pvstate);
typedef mv_t rval_evaluator_process_func_t(void* pvstate, variables_t* pvars);
typedef void rval_evaluator_free_func_t(struct _rval_evaluator_t*);

9
c/mapping/rval_evaluators.h
View file

@ -170,13 +170,6 @@ rval_evaluator_t* rval_evaluator_alloc_from_x_srs_func(mv_ternary_arg2_regex_fun
// rval_list_evaluators.c
// Nominally for oosvar multikeys.
sllmv_t* evaluate_list(
sllv_t* pevaluators,
lrec_t* pinrec,
lhmsv_t* ptyped_overlay,
mlhmmv_t* poosvars,
string_array_t** ppregex_captures,
context_t* pctx,
int* pall_non_null_or_error);
sllmv_t* evaluate_list(sllv_t* pevaluators, variables_t* pvars, int* pall_non_null_or_error);
#endif // LREC_FEVALUATORS_H

111
c/mapping/rval_expr_evaluators.c
View file

@ -151,19 +151,17 @@ typedef struct _rval_evaluator_field_name_state_t {
char* field_name;
} rval_evaluator_field_name_state_t;
static mv_t rval_evaluator_field_name_func_string_only(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
static mv_t rval_evaluator_field_name_func_string_only(void* pvstate, variables_t* pvars) {
rval_evaluator_field_name_state_t* pstate = pvstate;
// See comments in rval_evaluator.h and mapper_put.c regarding the typed-overlay map.
mv_t* poverlay = lhmsv_get(ptyped_overlay, pstate->field_name);
mv_t* poverlay = lhmsv_get(pvars->ptyped_overlay, pstate->field_name);
if (poverlay != NULL) {
// The lrec-evaluator logic will free its inputs and allocate new outputs, so we must copy
// a value here to feed into that. Otherwise the typed-overlay map would have its contents
// freed out from underneath it by the evaluator functions.
return mv_copy(poverlay);
} else {
char* string = lrec_get(prec, pstate->field_name);
char* string = lrec_get(pvars->pinrec, pstate->field_name);
if (string == NULL) {
return mv_absent();
} else if (*string == 0) {
@ -175,19 +173,17 @@ static mv_t rval_evaluator_field_name_func_string_only(lrec_t* prec, lhmsv_t* pt
}
}
static mv_t rval_evaluator_field_name_func_string_float(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
static mv_t rval_evaluator_field_name_func_string_float(void* pvstate, variables_t* pvars) {
rval_evaluator_field_name_state_t* pstate = pvstate;
// See comments in rval_evaluator.h and mapper_put.c regarding the typed-overlay map.
mv_t* poverlay = lhmsv_get(ptyped_overlay, pstate->field_name);
mv_t* poverlay = lhmsv_get(pvars->ptyped_overlay, pstate->field_name);
if (poverlay != NULL) {
// The lrec-evaluator logic will free its inputs and allocate new outputs, so we must copy
// a value here to feed into that. Otherwise the typed-overlay map would have its contents
// freed out from underneath it by the evaluator functions.
return mv_copy(poverlay);
} else {
char* string = lrec_get(prec, pstate->field_name);
char* string = lrec_get(pvars->pinrec, pstate->field_name);
if (string == NULL) {
return mv_absent();
} else if (*string == 0) {
@ -204,18 +200,17 @@ static mv_t rval_evaluator_field_name_func_string_float(lrec_t* prec, lhmsv_t* p
}
}
static mv_t rval_evaluator_field_name_func_string_float_int(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate) {
static mv_t rval_evaluator_field_name_func_string_float_int(void* pvstate, variables_t* pvars) {
rval_evaluator_field_name_state_t* pstate = pvstate;
// See comments in rval_evaluator.h and mapper_put.c regarding the typed-overlay map.
mv_t* poverlay = lhmsv_get(ptyped_overlay, pstate->field_name);
mv_t* poverlay = lhmsv_get(pvars->ptyped_overlay, pstate->field_name);
if (poverlay != NULL) {
// The lrec-evaluator logic will free its inputs and allocate new outputs, so we must copy
// a value here to feed into that. Otherwise the typed-overlay map would have its contents
// freed out from underneath it by the evaluator functions.
return mv_copy(poverlay);
} else {
char* string = lrec_get(prec, pstate->field_name);
char* string = lrec_get(pvars->pinrec, pstate->field_name);
if (string == NULL) {
return mv_absent();
} else if (*string == 0) {
@ -274,12 +269,10 @@ typedef struct _rval_evaluator_oosvar_name_state_t {
sllmv_t* pmvkeys;
} rval_evaluator_oosvar_name_state_t;
mv_t rval_evaluator_oosvar_name_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_oosvar_name_func(void* pvstate, variables_t* pvars) {
rval_evaluator_oosvar_name_state_t* pstate = pvstate;
int error = 0;
mv_t* pval = mlhmmv_get_terminal(poosvars, pstate->pmvkeys, &error);
mv_t* pval = mlhmmv_get_terminal(pvars->poosvars, pstate->pmvkeys, &error);
if (pval != NULL) {
// The lrec-evaluator logic will free its inputs and allocate new outputs, so we must copy a value here to feed
// into that. Otherwise the typed-overlay map in mapper_put would have its contents freed out from underneath it
@ -322,19 +315,16 @@ typedef struct _rval_evaluator_oosvar_level_keys_state_t {
sllv_t* poosvar_rhs_keylist_evaluators;
} rval_evaluator_oosvar_level_keys_state_t;
mv_t rval_evaluator_oosvar_level_keys_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_oosvar_level_keys_func(void* pvstate, variables_t* pvars) {
rval_evaluator_oosvar_level_keys_state_t* pstate = pvstate;
int all_non_null_or_error = TRUE;
sllmv_t* pmvkeys = evaluate_list(pstate->poosvar_rhs_keylist_evaluators,
prec, ptyped_overlay, poosvars, ppregex_captures, pctx, &all_non_null_or_error);
sllmv_t* pmvkeys = evaluate_list(pstate->poosvar_rhs_keylist_evaluators, pvars, &all_non_null_or_error);
mv_t rv = mv_absent();
if (all_non_null_or_error) {
int error = 0;
mv_t* pval = mlhmmv_get_terminal(poosvars, pmvkeys, &error);
mv_t* pval = mlhmmv_get_terminal(pvars->poosvars, pmvkeys, &error);
if (pval != NULL) {
if (pval->type == MT_STRING && *pval->u.strv == 0)
rv = mv_empty();
@ -431,24 +421,20 @@ typedef struct _rval_evaluator_strnum_literal_state_t {
mv_t literal;
} rval_evaluator_strnum_literal_state_t;
mv_t rval_evaluator_non_string_literal_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_non_string_literal_func(void* pvstate, variables_t* pvars) {
rval_evaluator_strnum_literal_state_t* pstate = pvstate;
return pstate->literal;
}
mv_t rval_evaluator_string_literal_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_string_literal_func(void* pvstate, variables_t* pvars) {
rval_evaluator_strnum_literal_state_t* pstate = pvstate;
char* input = pstate->literal.u.strv;
if (ppregex_captures == NULL || *ppregex_captures == NULL) {
if (pvars->ppregex_captures == NULL || *pvars->ppregex_captures == NULL) {
return mv_from_string_no_free(input);
} else {
int was_allocated = FALSE;
char* output = interpolate_regex_captures(input, *ppregex_captures, &was_allocated);
char* output = interpolate_regex_captures(input, *pvars->ppregex_captures, &was_allocated);
if (was_allocated)
return mv_from_string_with_free(output);
else
@ -523,9 +509,7 @@ typedef struct _rval_evaluator_string_state_t {
char* string;
} rval_evaluator_string_state_t;
mv_t rval_evaluator_string_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_string_func(void* pvstate, variables_t* pvars) {
rval_evaluator_string_state_t* pstate = pvstate;
return mv_from_string_no_free(pstate->string);
}
@ -553,9 +537,7 @@ typedef struct _rval_evaluator_boolean_literal_state_t {
mv_t literal;
} rval_evaluator_boolean_literal_state_t;
mv_t rval_evaluator_boolean_literal_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_boolean_literal_func(void* pvstate, variables_t* pvars) {
rval_evaluator_boolean_literal_state_t* pstate = pvstate;
return pstate->literal;
}
@ -616,13 +598,10 @@ typedef struct _rval_evaluator_environment_state_t {
rval_evaluator_t* pname_evaluator;
} rval_evaluator_environment_state_t;
mv_t rval_evaluator_environment_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_environment_func(void* pvstate, variables_t* pvars) {
rval_evaluator_environment_state_t* pstate = pvstate;
mv_t mvname = pstate->pname_evaluator->pprocess_func(prec, ptyped_overlay,
poosvars, ppregex_captures, pctx, pstate->pname_evaluator->pvstate);
mv_t mvname = pstate->pname_evaluator->pprocess_func(pstate->pname_evaluator->pvstate, pvars);
if (mv_is_null(&mvname)) {
return mv_absent();
}
@ -664,10 +643,8 @@ rval_evaluator_t* rval_evaluator_alloc_from_environment(mlr_dsl_ast_node_t* pnod
}
// ================================================================
mv_t rval_evaluator_NF_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
return mv_from_int(prec->field_count);
mv_t rval_evaluator_NF_func(void* pvstate, variables_t* pvars) {
return mv_from_int(pvars->pinrec->field_count);
}
static void rval_evaluator_NF_free(rval_evaluator_t* pevaluator) {
free(pevaluator);
@ -681,10 +658,8 @@ rval_evaluator_t* rval_evaluator_alloc_from_NF() {
}
// ----------------------------------------------------------------
mv_t rval_evaluator_NR_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
return mv_from_int(pctx->nr);
mv_t rval_evaluator_NR_func(void* pvstate, variables_t* pvars) {
return mv_from_int(pvars->pctx->nr);
}
static void rval_evaluator_NR_free(rval_evaluator_t* pevaluator) {
free(pevaluator);
@ -698,10 +673,8 @@ rval_evaluator_t* rval_evaluator_alloc_from_NR() {
}
// ----------------------------------------------------------------
mv_t rval_evaluator_FNR_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
return mv_from_int(pctx->fnr);
mv_t rval_evaluator_FNR_func(void* pvstate, variables_t* pvars) {
return mv_from_int(pvars->pctx->fnr);
}
static void rval_evaluator_FNR_free(rval_evaluator_t* pevaluator) {
free(pevaluator);
@ -715,10 +688,8 @@ rval_evaluator_t* rval_evaluator_alloc_from_FNR() {
}
// ----------------------------------------------------------------
mv_t rval_evaluator_FILENAME_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
return mv_from_string_no_free(pctx->filename);
mv_t rval_evaluator_FILENAME_func(void* pvstate, variables_t* pvars) {
return mv_from_string_no_free(pvars->pctx->filename);
}
static void rval_evaluator_FILENAME_free(rval_evaluator_t* pevaluator) {
free(pevaluator);
@ -733,10 +704,8 @@ rval_evaluator_t* rval_evaluator_alloc_from_FILENAME() {
}
// ----------------------------------------------------------------
mv_t rval_evaluator_FILENUM_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
return mv_from_int(pctx->filenum);
mv_t rval_evaluator_FILENUM_func(void* pvstate, variables_t* pvars) {
return mv_from_int(pvars->pctx->filenum);
}
static void rval_evaluator_FILENUM_free(rval_evaluator_t* pevaluator) {
free(pevaluator);
@ -750,9 +719,7 @@ rval_evaluator_t* rval_evaluator_alloc_from_FILENUM() {
}
// ----------------------------------------------------------------
mv_t rval_evaluator_PI_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_PI_func(void* pvstate, variables_t* pvars) {
return mv_from_float(M_PI);
}
static void rval_evaluator_PI_free(rval_evaluator_t* pevaluator) {
@ -767,9 +734,7 @@ rval_evaluator_t* rval_evaluator_alloc_from_PI() {
}
// ----------------------------------------------------------------
mv_t rval_evaluator_E_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_E_func(void* pvstate, variables_t* pvars) {
return mv_from_float(M_E);
}
static void rval_evaluator_E_free(rval_evaluator_t* pevaluator) {
@ -801,9 +766,7 @@ typedef struct _rval_evaluator_from_bound_variable_state_t {
char* variable_name;
} rval_evaluator_from_bound_variable_state_t;
mv_t rval_evaluator_from_bound_variable_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_from_bound_variable_func(void* pvstate, variables_t* pvars) {
rval_evaluator_from_bound_variable_state_t* pstate = pvstate;
return mv_from_string_no_free(pstate->variable_name); // xxx stub
}
@ -832,9 +795,7 @@ typedef struct _rval_evaluator_mv_state_t {
mv_t literal;
} rval_evaluator_mv_state_t;
mv_t rval_evaluator_mv_process(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_mv_process(void* pvstate, variables_t* pvars) {
rval_evaluator_mv_state_t* pstate = pvstate;
return mv_copy(&pstate->literal);

258
c/mapping/rval_func_evaluators.c
View file

@ -458,12 +458,9 @@ typedef struct _rval_evaluator_b_b_state_t {
rval_evaluator_t* parg1;
} rval_evaluator_b_b_state_t;
mv_t rval_evaluator_b_b_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_b_b_func(void* pvstate, variables_t* pvars) {
rval_evaluator_b_b_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
if (val1.type != MT_BOOL)
@ -499,13 +496,10 @@ typedef struct _rval_evaluator_b_bb_state_t {
// This is different from most of the lrec-evaluator functions in that it does short-circuiting:
// since is logical AND, the LHS is not evaluated if the RHS is false.
mv_t rval_evaluator_b_bb_and_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_b_bb_and_func(void* pvstate, variables_t* pvars) {
rval_evaluator_b_bb_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
EMPTY_OR_ERROR_OUT_FOR_NUMBERS(val1);
if (val1.type == MT_BOOL) {
if (val1.u.boolv == FALSE)
@ -514,8 +508,7 @@ mv_t rval_evaluator_b_bb_and_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_
return mv_error();
}
mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg2->pvstate);
mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
EMPTY_OR_ERROR_OUT_FOR_NUMBERS(val2);
if (val2.type == MT_BOOL) {
return val2;
@ -528,13 +521,10 @@ mv_t rval_evaluator_b_bb_and_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_
// This is different from most of the lrec-evaluator functions in that it does short-circuiting:
// since is logical OR, the LHS is not evaluated if the RHS is true.
mv_t rval_evaluator_b_bb_or_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_b_bb_or_func(void* pvstate, variables_t* pvars) {
rval_evaluator_b_bb_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
EMPTY_OR_ERROR_OUT_FOR_NUMBERS(val1);
if (val1.type == MT_BOOL) {
if (val1.u.boolv == TRUE)
@ -543,8 +533,7 @@ mv_t rval_evaluator_b_bb_or_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t
return mv_error();
}
mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg2->pvstate);
mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
EMPTY_OR_ERROR_OUT_FOR_NUMBERS(val2);
if (val2.type == MT_BOOL) {
return val2;
@ -555,20 +544,16 @@ mv_t rval_evaluator_b_bb_or_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t
}
}
mv_t rval_evaluator_b_bb_xor_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_b_bb_xor_func(void* pvstate, variables_t* pvars) {
rval_evaluator_b_bb_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
EMPTY_OR_ERROR_OUT_FOR_NUMBERS(val1);
if (val1.type != MT_BOOL && val1.type != MT_ABSENT) {
return mv_error();
}
mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg2->pvstate);
mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
EMPTY_OR_ERROR_OUT_FOR_NUMBERS(val2);
if (val2.type == MT_BOOL) {
if (val1.type == MT_BOOL)
@ -634,11 +619,8 @@ typedef struct _rval_evaluator_x_z_state_t {
mv_zary_func_t* pfunc;
} rval_evaluator_x_z_state_t;
mv_t rval_evaluator_x_z_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_x_z_func(void* pvstate, variables_t* pvars) {
rval_evaluator_x_z_state_t* pstate = pvstate;
return pstate->pfunc();
}
static void rval_evaluator_x_z_free(rval_evaluator_t* pevaluator) {
@ -663,12 +645,9 @@ typedef struct _rval_evaluator_f_f_state_t {
rval_evaluator_t* parg1;
} rval_evaluator_f_f_state_t;
mv_t rval_evaluator_f_f_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_f_f_func(void* pvstate, variables_t* pvars) {
rval_evaluator_f_f_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
mv_set_float_nullable(&val1);
NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
@ -703,13 +682,10 @@ typedef struct _rval_evaluator_x_n_state_t {
rval_evaluator_t* parg1;
} rval_evaluator_x_n_state_t;
mv_t rval_evaluator_x_n_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_x_n_func(void* pvstate, variables_t* pvars) {
rval_evaluator_x_n_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
mv_set_number_nullable(&val1);
NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
@ -741,12 +717,9 @@ typedef struct _rval_evaluator_i_i_state_t {
rval_evaluator_t* parg1;
} rval_evaluator_i_i_state_t;
mv_t rval_evaluator_i_i_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_i_i_func(void* pvstate, variables_t* pvars) {
rval_evaluator_i_i_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
mv_set_int_nullable(&val1);
NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
@ -780,17 +753,13 @@ typedef struct _rval_evaluator_f_ff_state_t {
rval_evaluator_t* parg2;
} rval_evaluator_f_ff_state_t;
mv_t rval_evaluator_f_ff_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_f_ff_func(void* pvstate, variables_t* pvars) {
rval_evaluator_f_ff_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
mv_set_float_nullable(&val1);
NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg2->pvstate);
mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
mv_set_float_nullable(&val2);
NULL_OR_ERROR_OUT_FOR_NUMBERS(val2);
@ -827,14 +796,10 @@ typedef struct _rval_evaluator_x_xx_state_t {
rval_evaluator_t* parg2;
} rval_evaluator_x_xx_state_t;
mv_t rval_evaluator_x_xx_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_x_xx_func(void* pvstate, variables_t* pvars) {
rval_evaluator_x_xx_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg2->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
// nullities handled by full disposition matrices
return pstate->pfunc(&val1, &val2);
@ -874,16 +839,12 @@ typedef struct _rval_evaluator_x_xx_nullable_state_t {
rval_evaluator_t* parg2;
} rval_evaluator_x_xx_nullable_state_t;
mv_t rval_evaluator_x_xx_nullable_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_x_xx_nullable_func(void* pvstate, variables_t* pvars) {
rval_evaluator_x_xx_nullable_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
mv_set_number_nullable(&val1);
mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg2->pvstate);
mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
mv_set_number_nullable(&val2);
return pstate->pfunc(&val1, &val2);
@ -920,22 +881,17 @@ typedef struct _rval_evaluator_f_fff_state_t {
rval_evaluator_t* parg3;
} rval_evaluator_f_fff_state_t;
mv_t rval_evaluator_f_fff_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_f_fff_func(void* pvstate, variables_t* pvars) {
rval_evaluator_f_fff_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
mv_set_float_nullable(&val1);
NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg2->pvstate);
mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
mv_set_float_nullable(&val2);
NULL_OR_ERROR_OUT_FOR_NUMBERS(val2);
mv_t val3 = pstate->parg3->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg3->pvstate);
mv_t val3 = pstate->parg3->pprocess_func(pstate->parg3->pvstate, pvars);
mv_set_float_nullable(&val3);
NULL_OR_ERROR_OUT_FOR_NUMBERS(val3);
@ -974,19 +930,15 @@ typedef struct _rval_evaluator_i_ii_state_t {
rval_evaluator_t* parg2;
} rval_evaluator_i_ii_state_t;
mv_t rval_evaluator_i_ii_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_i_ii_func(void* pvstate, variables_t* pvars) {
rval_evaluator_i_ii_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
mv_set_int_nullable(&val1);
NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
if (val1.type != MT_INT)
return mv_error();
mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg2->pvstate);
mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
mv_set_int_nullable(&val2);
NULL_OR_ERROR_OUT_FOR_NUMBERS(val2);
if (val2.type != MT_INT)
@ -1026,26 +978,21 @@ typedef struct _rval_evaluator_i_iii_state_t {
rval_evaluator_t* parg3;
} rval_evaluator_i_iii_state_t;
mv_t rval_evaluator_i_iii_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_i_iii_func(void* pvstate, variables_t* pvars) {
rval_evaluator_i_iii_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
mv_set_int_nullable(&val1);
NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
if (val1.type != MT_INT)
return mv_error();
mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg2->pvstate);
mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
mv_set_int_nullable(&val2);
NULL_OR_ERROR_OUT_FOR_NUMBERS(val2);
if (val2.type != MT_INT)
return mv_error();
mv_t val3 = pstate->parg3->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg3->pvstate);
mv_t val3 = pstate->parg3->pprocess_func(pstate->parg3->pvstate, pvars);
mv_set_int_nullable(&val3);
NULL_OR_ERROR_OUT_FOR_NUMBERS(val3);
if (val3.type != MT_INT)
@ -1086,20 +1033,15 @@ typedef struct _rval_evaluator_ternop_state_t {
rval_evaluator_t* parg3;
} rval_evaluator_ternop_state_t;
mv_t rval_evaluator_ternop_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_ternop_func(void* pvstate, variables_t* pvars) {
rval_evaluator_ternop_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
mv_set_boolean_strict(&val1);
return val1.u.boolv
? pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg2->pvstate)
: pstate->parg3->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg3->pvstate);
? pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars)
: pstate->parg3->pprocess_func(pstate->parg3->pvstate, pvars);
}
static void rval_evaluator_ternop_free(rval_evaluator_t* pevaluator) {
rval_evaluator_ternop_state_t* pstate = pevaluator->pvstate;
@ -1131,12 +1073,9 @@ typedef struct _rval_evaluator_s_s_state_t {
rval_evaluator_t* parg1;
} rval_evaluator_s_s_state_t;
mv_t rval_evaluator_s_s_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_s_s_func(void* pvstate, variables_t* pvars) {
rval_evaluator_s_s_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
NULL_OR_ERROR_OUT_FOR_STRINGS(val1);
if (!mv_is_string_or_empty(&val1))
return mv_error();
@ -1169,12 +1108,9 @@ typedef struct _rval_evaluator_s_f_state_t {
rval_evaluator_t* parg1;
} rval_evaluator_s_f_state_t;
mv_t rval_evaluator_s_f_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_s_f_func(void* pvstate, variables_t* pvars) {
rval_evaluator_s_f_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
mv_set_float_nullable(&val1);
NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
@ -1207,12 +1143,9 @@ typedef struct _rval_evaluator_s_i_state_t {
rval_evaluator_t* parg1;
} rval_evaluator_s_i_state_t;
mv_t rval_evaluator_s_i_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_s_i_func(void* pvstate, variables_t* pvars) {
rval_evaluator_s_i_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
mv_set_int_nullable(&val1);
NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
@ -1245,12 +1178,9 @@ typedef struct _rval_evaluator_f_s_state_t {
rval_evaluator_t* parg1;
} rval_evaluator_f_s_state_t;
mv_t rval_evaluator_f_s_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_f_s_func(void* pvstate, variables_t* pvars) {
rval_evaluator_f_s_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
NULL_OR_ERROR_OUT_FOR_STRINGS(val1);
if (!mv_is_string_or_empty(&val1))
return mv_error();
@ -1283,12 +1213,9 @@ typedef struct _rval_evaluator_i_s_state_t {
rval_evaluator_t* parg1;
} rval_evaluator_i_s_state_t;
mv_t rval_evaluator_i_s_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_i_s_func(void* pvstate, variables_t* pvars) {
rval_evaluator_i_s_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
NULL_OR_ERROR_OUT_FOR_STRINGS(val1);
if (!mv_is_string_or_empty(&val1))
return mv_error();
@ -1321,12 +1248,9 @@ typedef struct _rval_evaluator_x_x_state_t {
rval_evaluator_t* parg1;
} rval_evaluator_x_x_state_t;
mv_t rval_evaluator_x_x_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_x_x_func(void* pvstate, variables_t* pvars) {
rval_evaluator_x_x_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
// nullity handled by full disposition matrices
return pstate->pfunc(&val1);
@ -1358,17 +1282,13 @@ typedef struct _rval_evaluator_x_ns_state_t {
rval_evaluator_t* parg2;
} rval_evaluator_x_ns_state_t;
mv_t rval_evaluator_x_ns_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_x_ns_func(void* pvstate, variables_t* pvars) {
rval_evaluator_x_ns_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
mv_set_number_nullable(&val1);
NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg2->pvstate);
mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
NULL_OR_ERROR_OUT_FOR_STRINGS(val2);
if (!mv_is_string_or_empty(&val2)) {
mv_free(&val1);
@ -1408,18 +1328,14 @@ typedef struct _rval_evaluator_x_ss_state_t {
rval_evaluator_t* parg2;
} rval_evaluator_x_ss_state_t;
mv_t rval_evaluator_x_ss_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_x_ss_func(void* pvstate, variables_t* pvars) {
rval_evaluator_x_ss_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
NULL_OR_ERROR_OUT_FOR_STRINGS(val1);
if (!mv_is_string_or_empty(&val1))
return mv_error();
mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg2->pvstate);
mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
NULL_OR_ERROR_OUT_FOR_STRINGS(val2);
if (!mv_is_string_or_empty(&val2))
return mv_error();
@ -1457,22 +1373,18 @@ typedef struct _rval_evaluator_x_ssc_state_t {
rval_evaluator_t* parg2;
} rval_evaluator_x_ssc_state_t;
mv_t rval_evaluator_x_ssc_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_x_ssc_func(void* pvstate, variables_t* pvars) {
rval_evaluator_x_ssc_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
NULL_OR_ERROR_OUT_FOR_STRINGS(val1);
if (!mv_is_string_or_empty(&val1))
return mv_error();
mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg2->pvstate);
mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
NULL_OR_ERROR_OUT_FOR_STRINGS(val2);
if (!mv_is_string_or_empty(&val2))
return mv_error();
return pstate->pfunc(&val1, &val2, ppregex_captures);
return pstate->pfunc(&val1, &val2, pvars->ppregex_captures);
}
static void rval_evaluator_x_ssc_free(rval_evaluator_t* pevaluator) {
rval_evaluator_x_ssc_state_t* pstate = pevaluator->pvstate;
@ -1506,18 +1418,15 @@ typedef struct _rval_evaluator_x_sr_state_t {
string_builder_t* psb;
} rval_evaluator_x_sr_state_t;
mv_t rval_evaluator_x_sr_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_x_sr_func(void* pvstate, variables_t* pvars) {
rval_evaluator_x_sr_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
NULL_OR_ERROR_OUT_FOR_STRINGS(val1);
if (!mv_is_string_or_empty(&val1))
return mv_error();
return pstate->pfunc(&val1, &pstate->regex, pstate->psb, ppregex_captures);
return pstate->pfunc(&val1, &pstate->regex, pstate->psb, pvars->ppregex_captures);
}
static void rval_evaluator_x_sr_free(rval_evaluator_t* pevaluator) {
rval_evaluator_x_sr_state_t* pstate = pevaluator->pvstate;
@ -1554,14 +1463,10 @@ typedef struct _rval_evaluator_s_xs_state_t {
rval_evaluator_t* parg2;
} rval_evaluator_s_xs_state_t;
mv_t rval_evaluator_s_xs_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_s_xs_func(void* pvstate, variables_t* pvars) {
rval_evaluator_s_xs_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg2->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
NULL_OR_ERROR_OUT_FOR_STRINGS(val2);
if (!mv_is_string_or_empty(&val2))
return mv_error();
@ -1600,26 +1505,21 @@ typedef struct _rval_evaluator_s_sss_state_t {
rval_evaluator_t* parg3;
} rval_evaluator_s_sss_state_t;
mv_t rval_evaluator_s_sss_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_s_sss_func(void* pvstate, variables_t* pvars) {
rval_evaluator_s_sss_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
NULL_OR_ERROR_OUT_FOR_STRINGS(val1);
if (!mv_is_string_or_empty(&val1))
return mv_error();
mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg2->pvstate);
mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
NULL_OR_ERROR_OUT_FOR_STRINGS(val2);
if (!mv_is_string_or_empty(&val2)) {
mv_free(&val1);
return mv_error();
}
mv_t val3 = pstate->parg3->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg3->pvstate);
mv_t val3 = pstate->parg3->pprocess_func(pstate->parg3->pvstate, pvars);
NULL_OR_ERROR_OUT_FOR_STRINGS(val3);
if (!mv_is_string_or_empty(&val3)) {
mv_free(&val1);
@ -1664,19 +1564,15 @@ typedef struct _rval_evaluator_x_srs_state_t {
string_builder_t* psb;
} rval_evaluator_x_srs_state_t;
mv_t rval_evaluator_x_srs_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars,
string_array_t** ppregex_captures, context_t* pctx, void* pvstate)
{
mv_t rval_evaluator_x_srs_func(void* pvstate, variables_t* pvars) {
rval_evaluator_x_srs_state_t* pstate = pvstate;
mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg1->pvstate);
mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
NULL_OR_ERROR_OUT_FOR_STRINGS(val1);
if (!mv_is_string_or_empty(&val1))
return mv_error();
mv_t val3 = pstate->parg3->pprocess_func(prec, ptyped_overlay, poosvars, ppregex_captures,
pctx, pstate->parg3->pvstate);
mv_t val3 = pstate->parg3->pprocess_func(pstate->parg3->pvstate, pvars);
NULL_OR_ERROR_OUT_FOR_STRINGS(val3);
if (!mv_is_string_or_empty(&val3)) {
mv_free(&val1);

13
c/mapping/rval_list_evaluators.c
View file

@ -13,21 +13,12 @@
// See comments in rval_evaluators.h
// ================================================================
sllmv_t* evaluate_list(
sllv_t* pevaluators,
lrec_t* pinrec,
lhmsv_t* ptyped_overlay,
mlhmmv_t* poosvars,
string_array_t** ppregex_captures,
context_t* pctx,
int* pall_non_null_or_error)
{
sllmv_t* evaluate_list(sllv_t* pevaluators, variables_t* pvars, int* pall_non_null_or_error) {
sllmv_t* pmvs = sllmv_alloc();
int all_non_null_or_error = TRUE;
for (sllve_t* pe = pevaluators->phead; pe != NULL; pe = pe->pnext) {
rval_evaluator_t* pevaluator = pe->pvvalue;
mv_t mv = pevaluator->pprocess_func(pinrec, ptyped_overlay,
poosvars, ppregex_captures, pctx, pevaluator->pvstate);
mv_t mv = pevaluator->pprocess_func(pevaluator->pvstate, pvars);
if (mv_is_null_or_error(&mv)) {
all_non_null_or_error = FALSE;
break;

160
c/unit_test/test_rval_evaluators.c
View file

@ -24,24 +24,34 @@ static char * test_caps() {
lhmsv_t* ptyped_overlay = lhmsv_alloc();
mlhmmv_t* poosvars = mlhmmv_alloc();
string_array_t* pregex_captures = NULL;
bind_stack_t* pbind_stack = bind_stack_alloc();
mv_t val = pnr->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, pnr->pvstate);
variables_t variables = (variables_t) {
.pinrec = prec,
.ptyped_overlay = ptyped_overlay,
.poosvars = poosvars,
.ppregex_captures = &pregex_captures,
.pctx = pctx,
.pbind_stack = pbind_stack,
};
mv_t val = pnr->pprocess_func(pnr->pvstate, &variables);
printf("[%s] %s\n", mt_describe_type(val.type), mv_alloc_format_val(&val));
mu_assert_lf(val.type == MT_INT);
mu_assert_lf(val.u.intv == 888);
val = pfnr->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, pfnr->pvstate);
val = pfnr->pprocess_func(pfnr->pvstate, &variables);
printf("[%s] %s\n", mt_describe_type(val.type), mv_alloc_format_val(&val));
mu_assert_lf(val.type == MT_INT);
mu_assert_lf(val.u.intv == 999);
val = pfilename->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, pfilename->pvstate);
val = pfilename->pprocess_func(pfilename->pvstate, &variables);
printf("[%s] %s\n", mt_describe_type(val.type), mv_alloc_format_val(&val));
mu_assert_lf(val.type == MT_STRING);
mu_assert_lf(val.u.strv != NULL);
mu_assert_lf(streq(val.u.strv, "filename-goes-here"));
val = pfilenum->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, pfilenum->pvstate);
val = pfilenum->pprocess_func(pfilenum->pvstate, &variables);
printf("[%s] %s\n", mt_describe_type(val.type), mv_alloc_format_val(&val));
mu_assert_lf(val.type == MT_INT);
mu_assert_lf(val.u.intv == 123);
@ -66,34 +76,45 @@ static char * test_strings() {
lhmsv_t* ptyped_overlay = lhmsv_alloc();
mlhmmv_t* poosvars = mlhmmv_alloc();
string_array_t* pregex_captures = NULL;
bind_stack_t* pbind_stack = bind_stack_alloc();
lrec_put(prec, "s", "abc", NO_FREE);
printf("lrec s = %s\n", lrec_get(prec, "s"));
mv_t val = ps->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, ps->pvstate);
variables_t variables = (variables_t) {
.pinrec = prec,
.ptyped_overlay = ptyped_overlay,
.poosvars = poosvars,
.ppregex_captures = &pregex_captures,
.pctx = pctx,
.pbind_stack = pbind_stack,
};
mv_t val = ps->pprocess_func(ps->pvstate, &variables);
printf("[%s] %s\n", mt_describe_type(val.type), mv_alloc_format_val(&val));
mu_assert_lf(val.type == MT_STRING);
mu_assert_lf(val.u.strv != NULL);
mu_assert_lf(streq(val.u.strv, "abc"));
val = pdef->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, pdef->pvstate);
val = pdef->pprocess_func(pdef->pvstate, &variables);
printf("[%s] %s\n", mt_describe_type(val.type), mv_alloc_format_val(&val));
mu_assert_lf(val.type == MT_STRING);
mu_assert_lf(val.u.strv != NULL);
mu_assert_lf(streq(val.u.strv, "def"));
val = pdot->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, pdot->pvstate);
val = pdot->pprocess_func(pdot->pvstate, &variables);
printf("[%s] %s\n", mt_describe_type(val.type), mv_alloc_format_val(&val));
mu_assert_lf(val.type == MT_STRING);
mu_assert_lf(val.u.strv != NULL);
mu_assert_lf(streq(val.u.strv, "abcdef"));
val = ptolower->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, ptolower->pvstate);
val = ptolower->pprocess_func(ptolower->pvstate, &variables);
printf("[%s] %s\n", mt_describe_type(val.type), mv_alloc_format_val(&val));
mu_assert_lf(val.type == MT_STRING);
mu_assert_lf(val.u.strv != NULL);
mu_assert_lf(streq(val.u.strv, "abcdef"));
val = ptoupper->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, ptoupper->pvstate);
val = ptoupper->pprocess_func(ptoupper->pvstate, &variables);
printf("[%s] %s\n", mt_describe_type(val.type), mv_alloc_format_val(&val));
mu_assert_lf(val.type == MT_STRING);
mu_assert_lf(val.u.strv != NULL);
@ -129,14 +150,25 @@ static char * test_numbers() {
lhmsv_t* ptyped_overlay = lhmsv_alloc();
mlhmmv_t* poosvars = mlhmmv_alloc();
string_array_t* pregex_captures = NULL;
bind_stack_t* pbind_stack = bind_stack_alloc();
lrec_put(prec, "x", "4.5", NO_FREE);
mv_t valp2 = p2->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, p2->pvstate);
mv_t valp4 = p4->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, p4->pvstate);
mv_t valpx = px->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, px->pvstate);
mv_t valpx2 = px2->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, px2->pvstate);
mv_t valplogx = plogx->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, plogx->pvstate);
mv_t valp2logx = p2logx->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, p2logx->pvstate);
variables_t variables = (variables_t) {
.pinrec = prec,
.ptyped_overlay = ptyped_overlay,
.poosvars = poosvars,
.ppregex_captures = &pregex_captures,
.pctx = pctx,
.pbind_stack = pbind_stack,
};
mv_t valp2 = p2->pprocess_func(p2->pvstate, &variables);
mv_t valp4 = p4->pprocess_func(p4->pvstate, &variables);
mv_t valpx = px->pprocess_func(px->pvstate, &variables);
mv_t valpx2 = px2->pprocess_func(px2->pvstate, &variables);
mv_t valplogx = plogx->pprocess_func(plogx->pvstate, &variables);
mv_t valp2logx = p2logx->pprocess_func(p2logx->pvstate, &variables);
printf("lrec x = %s\n", lrec_get(prec, "x"));
printf("newval 2 = %s\n", mv_describe_val(valp2));
@ -163,17 +195,17 @@ static char * test_numbers() {
mlr_dsl_ast_node_print(p2logxnode);
printf("newval AST = %s\n",
mv_describe_val(pastr->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, pastr->pvstate)));
mv_describe_val(pastr->pprocess_func(pastr->pvstate, &variables)));
printf("\n");
lrec_rename(prec, "x", "y", FALSE);
valp2 = p2->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, p2->pvstate);
valp4 = p4->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, p4->pvstate);
valpx = px->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, px->pvstate);
valpx2 = px2->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, px2->pvstate);
valplogx = plogx->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, plogx->pvstate);
valp2logx = p2logx->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, p2logx->pvstate);
valp2 = p2->pprocess_func(p2->pvstate, &variables);
valp4 = p4->pprocess_func(p4->pvstate, &variables);
valpx = px->pprocess_func(px->pvstate, &variables);
valpx2 = px2->pprocess_func(px2->pvstate, &variables);
valplogx = plogx->pprocess_func(plogx->pvstate, &variables);
valp2logx = p2logx->pprocess_func(p2logx->pvstate, &variables);
printf("lrec x = %s\n", lrec_get(prec, "x"));
printf("newval 2 = %s\n", mv_describe_val(valp2));
@ -207,6 +239,16 @@ static char * test_logical_and() {
lhmsv_t* ptyped_overlay = NULL;
mlhmmv_t* poosvars = NULL;
string_array_t* pregex_captures = NULL;
bind_stack_t* pbind_stack = bind_stack_alloc();
variables_t variables = (variables_t) {
.pinrec = prec,
.ptyped_overlay = ptyped_overlay,
.poosvars = poosvars,
.ppregex_captures = &pregex_captures,
.pctx = pctx,
.pbind_stack = pbind_stack,
};
mv_t t = mv_from_bool(TRUE);
mv_t f = mv_from_bool(FALSE);
@ -226,15 +268,15 @@ static char * test_logical_and() {
rval_evaluator_t* paf = rval_evaluator_alloc_from_b_bb_and_func(pa, pf);
rval_evaluator_t* paa = rval_evaluator_alloc_from_b_bb_and_func(pa, pa);
mv_t ott = ptt->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, ptt->pvstate);
mv_t otf = ptf->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, ptf->pvstate);
mv_t oft = pft->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, pft->pvstate);
mv_t off = pff->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, pff->pvstate);
mv_t oat = pat->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, pat->pvstate);
mv_t oaf = paf->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, paf->pvstate);
mv_t ota = pta->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, pta->pvstate);
mv_t ofa = pfa->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, pfa->pvstate);
mv_t oaa = paa->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, paa->pvstate);
mv_t ott = ptt->pprocess_func(ptt->pvstate, &variables);
mv_t otf = ptf->pprocess_func(ptf->pvstate, &variables);
mv_t oft = pft->pprocess_func(pft->pvstate, &variables);
mv_t off = pff->pprocess_func(pff->pvstate, &variables);
mv_t oat = pat->pprocess_func(pat->pvstate, &variables);
mv_t oaf = paf->pprocess_func(paf->pvstate, &variables);
mv_t ota = pta->pprocess_func(pta->pvstate, &variables);
mv_t ofa = pfa->pprocess_func(pfa->pvstate, &variables);
mv_t oaa = paa->pprocess_func(paa->pvstate, &variables);
mu_assert_lf(ott.type == MT_BOOL); mu_assert_lf(ott.u.boolv == TRUE);
mu_assert_lf(otf.type == MT_BOOL); mu_assert_lf(otf.u.boolv == FALSE);
@ -260,6 +302,16 @@ static char * test_logical_or() {
lhmsv_t* ptyped_overlay = NULL;
mlhmmv_t* poosvars = NULL;
string_array_t* pregex_captures = NULL;
bind_stack_t* pbind_stack = bind_stack_alloc();
variables_t variables = (variables_t) {
.pinrec = prec,
.ptyped_overlay = ptyped_overlay,
.poosvars = poosvars,
.ppregex_captures = &pregex_captures,
.pctx = pctx,
.pbind_stack = pbind_stack,
};
mv_t t = mv_from_bool(TRUE);
mv_t f = mv_from_bool(FALSE);
@ -279,15 +331,15 @@ static char * test_logical_or() {
rval_evaluator_t* paf = rval_evaluator_alloc_from_b_bb_or_func(pa, pf);
rval_evaluator_t* paa = rval_evaluator_alloc_from_b_bb_or_func(pa, pa);
mv_t ott = ptt->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, ptt->pvstate);
mv_t otf = ptf->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, ptf->pvstate);
mv_t ota = pta->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, pta->pvstate);
mv_t oft = pft->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, pft->pvstate);
mv_t off = pff->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, pff->pvstate);
mv_t ofa = pfa->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, pfa->pvstate);
mv_t oat = pat->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, pat->pvstate);
mv_t oaf = paf->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, paf->pvstate);
mv_t oaa = paa->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, paa->pvstate);
mv_t ott = ptt->pprocess_func(ptt->pvstate, &variables);
mv_t otf = ptf->pprocess_func(ptf->pvstate, &variables);
mv_t ota = pta->pprocess_func(pta->pvstate, &variables);
mv_t oft = pft->pprocess_func(pft->pvstate, &variables);
mv_t off = pff->pprocess_func(pff->pvstate, &variables);
mv_t ofa = pfa->pprocess_func(pfa->pvstate, &variables);
mv_t oat = pat->pprocess_func(pat->pvstate, &variables);
mv_t oaf = paf->pprocess_func(paf->pvstate, &variables);
mv_t oaa = paa->pprocess_func(paa->pvstate, &variables);
mu_assert_lf(ott.type == MT_BOOL); mu_assert_lf(ott.u.boolv == TRUE);
mu_assert_lf(otf.type == MT_BOOL); mu_assert_lf(otf.u.boolv == TRUE);
@ -313,6 +365,16 @@ static char * test_logical_xor() {
lhmsv_t* ptyped_overlay = NULL;
mlhmmv_t* poosvars = NULL;
string_array_t* pregex_captures = NULL;
bind_stack_t* pbind_stack = bind_stack_alloc();
variables_t variables = (variables_t) {
.pinrec = prec,
.ptyped_overlay = ptyped_overlay,
.poosvars = poosvars,
.ppregex_captures = &pregex_captures,
.pctx = pctx,
.pbind_stack = pbind_stack,
};
mv_t t = mv_from_bool(TRUE);
mv_t f = mv_from_bool(FALSE);
@ -332,15 +394,15 @@ static char * test_logical_xor() {
rval_evaluator_t* pfa = rval_evaluator_alloc_from_b_bb_xor_func(pf, pa);
rval_evaluator_t* paa = rval_evaluator_alloc_from_b_bb_xor_func(pa, pa);
mv_t ott = ptt->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, ptt->pvstate);
mv_t otf = ptf->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, ptf->pvstate);
mv_t oft = pft->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, pft->pvstate);
mv_t off = pff->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, pff->pvstate);
mv_t oat = pat->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, pat->pvstate);
mv_t oaf = paf->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, paf->pvstate);
mv_t ota = pta->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, pta->pvstate);
mv_t ofa = pfa->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, pfa->pvstate);
mv_t oaa = paa->pprocess_func(prec, ptyped_overlay, poosvars, &pregex_captures, pctx, paa->pvstate);
mv_t ott = ptt->pprocess_func(ptt->pvstate, &variables);
mv_t otf = ptf->pprocess_func(ptf->pvstate, &variables);
mv_t oft = pft->pprocess_func(pft->pvstate, &variables);
mv_t off = pff->pprocess_func(pff->pvstate, &variables);
mv_t oat = pat->pprocess_func(pat->pvstate, &variables);
mv_t oaf = paf->pprocess_func(paf->pvstate, &variables);
mv_t ota = pta->pprocess_func(pta->pvstate, &variables);
mv_t ofa = pfa->pprocess_func(pfa->pvstate, &variables);
mv_t oaa = paa->pprocess_func(paa->pvstate, &variables);
mu_assert_lf(ott.type == MT_BOOL); mu_assert_lf(ott.u.boolv == FALSE);
mu_assert_lf(otf.type == MT_BOOL); mu_assert_lf(otf.u.boolv == TRUE);