diff --git a/c/Makefile.no-autoconfig b/c/Makefile.no-autoconfig index 24dcf357b..6a47b1fc3 100644 --- a/c/Makefile.no-autoconfig +++ b/c/Makefile.no-autoconfig @@ -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 \ diff --git a/c/mapping/mapper_filter.c b/c/mapping/mapper_filter.c index 5b617ac14..73a1f8dd5 100644 --- a/c/mapping/mapper_filter.c +++ b/c/mapping/mapper_filter.c @@ -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 { diff --git a/c/mapping/mapper_put.c b/c/mapping/mapper_put.c index 003a962b4..7eff8b236 100644 --- a/c/mapping/mapper_put.c +++ b/c/mapping/mapper_put.c @@ -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. diff --git a/c/mapping/mlr_dsl_cst.c b/c/mapping/mlr_dsl_cst.c index ac0703ddf..d9df81b9b 100644 --- a/c/mapping/mlr_dsl_cst.c +++ b/c/mapping/mlr_dsl_cst.c @@ -36,267 +36,157 @@ static void cst_statement_vararg_free(mlr_dsl_cst_statement_vararg_t* pvararg); static void mlr_dsl_cst_node_handle_srec_assignment( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator); static void mlr_dsl_cst_node_handle_oosvar_assignment( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator); static void mlr_dsl_cst_node_handle_oosvar_to_oosvar_assignment( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator); static void mlr_dsl_cst_node_handle_oosvar_from_full_srec_assignment( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator); static void mlr_dsl_cst_node_handle_full_srec_from_oosvar_assignment( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator); static void mlr_dsl_cst_node_handle_oosvar_assignment( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator); static void mlr_dsl_cst_node_handle_unset( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator); static void mlr_dsl_cst_node_handle_unset_all( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator); static void mlr_dsl_cst_node_handle_emitf( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator); static void mlr_dsl_cst_node_handle_emitp( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator); static void mlr_dsl_cst_node_handle_emitp_all( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator); static void mlr_dsl_cst_node_handle_emit( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator); static void mlr_dsl_cst_node_handle_emit_all( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator); static void mlr_dsl_cst_node_handle_dump( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator); static void mlr_dsl_cst_node_handle_filter( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator); static void mlr_dsl_cst_node_handle_conditional_block( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator); static void mlr_dsl_cst_node_handle_while( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator); static void mlr_dsl_cst_node_handle_do_while( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator); static void mlr_dsl_cst_node_handle_do_while( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator); static void mlr_dsl_cst_node_handle_for_srec( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator); static void mlr_dsl_cst_node_handle_if_head( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator); static void mlr_dsl_cst_node_handle_bare_boolean( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator); static sllv_t* allocate_keylist_evaluators_from_oosvar_node(mlr_dsl_ast_node_t* pnode, int type_inferencing); @@ -1112,42 +1002,30 @@ static void cst_statement_vararg_free(mlr_dsl_cst_statement_vararg_t* pvararg) { // ---------------------------------------------------------------- void mlr_dsl_cst_handle( - sllv_t* pcst_statements, - 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, + variables_t* pvars, // xxx rename -- not just RHS + int* pshould_emit_rec, + sllv_t* poutrecs, + char* oosvar_flatten_separator) { for (sllve_t* pe = pcst_statements->phead; pe != NULL; pe = pe->pnext) { mlr_dsl_cst_statement_t* pstatement = pe->pvvalue; - pstatement->phandler(pstatement, poosvars, pinrec, ptyped_overlay, ppregex_captures, - pctx, pshould_emit_rec, poutrecs, oosvar_flatten_separator, pbind_stack); + pstatement->phandler(pstatement, pvars, pshould_emit_rec, poutrecs, oosvar_flatten_separator); } } // ---------------------------------------------------------------- static void mlr_dsl_cst_node_handle_srec_assignment( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator) { char* srec_lhs_field_name = pnode->srec_lhs_field_name; rval_evaluator_t* prhs_evaluator = pnode->prhs_evaluator; - mv_t val = prhs_evaluator->pprocess_func(pinrec, ptyped_overlay, poosvars, - ppregex_captures, pctx, prhs_evaluator->pvstate); + mv_t val = prhs_evaluator->pprocess_func(prhs_evaluator->pvstate, pvars); mv_t* pval = mlr_malloc_or_die(sizeof(mv_t)); *pval = val; @@ -1164,13 +1042,13 @@ static void mlr_dsl_cst_node_handle_srec_assignment( // here. And putting something statically allocated minimizes copying/freeing. if (mv_is_present(pval)) { // xxx to do: replace the typed overlay with an mlhmmv entirely. - mv_t* pold = lhmsv_get(ptyped_overlay, srec_lhs_field_name); + mv_t* pold = lhmsv_get(pvars->ptyped_overlay, srec_lhs_field_name); if (pold != NULL) { mv_free(pold); free(pold); } - lhmsv_put(ptyped_overlay, srec_lhs_field_name, pval, FREE_ENTRY_VALUE); - lrec_put(pinrec, srec_lhs_field_name, "bug", NO_FREE); + lhmsv_put(pvars->ptyped_overlay, srec_lhs_field_name, pval, FREE_ENTRY_VALUE); + lrec_put(pvars->pinrec, srec_lhs_field_name, "bug", NO_FREE); } else { mv_free(pval); free(pval); @@ -1180,26 +1058,19 @@ static void mlr_dsl_cst_node_handle_srec_assignment( // ---------------------------------------------------------------- static void mlr_dsl_cst_node_handle_oosvar_assignment( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator) { rval_evaluator_t* prhs_evaluator = pnode->prhs_evaluator; - mv_t rhs_value = prhs_evaluator->pprocess_func(pinrec, ptyped_overlay, - poosvars, ppregex_captures, pctx, prhs_evaluator->pvstate); + mv_t rhs_value = prhs_evaluator->pprocess_func(prhs_evaluator->pvstate, pvars); if (mv_is_present(&rhs_value)) { int all_non_null_or_error = TRUE; - sllmv_t* pmvkeys = evaluate_list(pnode->poosvar_lhs_keylist_evaluators, - pinrec, ptyped_overlay, poosvars, ppregex_captures, pctx, &all_non_null_or_error); + sllmv_t* pmvkeys = evaluate_list(pnode->poosvar_lhs_keylist_evaluators, pvars, &all_non_null_or_error); if (all_non_null_or_error) - mlhmmv_put_terminal(poosvars, pmvkeys, &rhs_value); + mlhmmv_put_terminal(pvars->poosvars, pmvkeys, &rhs_value); sllmv_free(pmvkeys); } mv_free(&rhs_value); @@ -1211,26 +1082,19 @@ static void mlr_dsl_cst_node_handle_oosvar_assignment( static void mlr_dsl_cst_node_handle_oosvar_to_oosvar_assignment( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator) { int lhs_all_non_null_or_error = TRUE; - sllmv_t* plhskeys = evaluate_list(pnode->poosvar_lhs_keylist_evaluators, - pinrec, ptyped_overlay, poosvars, ppregex_captures, pctx, &lhs_all_non_null_or_error); + sllmv_t* plhskeys = evaluate_list(pnode->poosvar_lhs_keylist_evaluators, pvars, &lhs_all_non_null_or_error); if (lhs_all_non_null_or_error) { int rhs_all_non_null_or_error = TRUE; - sllmv_t* prhskeys = evaluate_list(pnode->poosvar_rhs_keylist_evaluators, - pinrec, ptyped_overlay, poosvars, ppregex_captures, pctx, &rhs_all_non_null_or_error); + sllmv_t* prhskeys = evaluate_list(pnode->poosvar_rhs_keylist_evaluators, pvars, &rhs_all_non_null_or_error); if (rhs_all_non_null_or_error) { - mlhmmv_copy(poosvars, plhskeys, prhskeys); + mlhmmv_copy(pvars->poosvars, plhskeys, prhskeys); } sllmv_free(prhskeys); } @@ -1240,30 +1104,24 @@ static void mlr_dsl_cst_node_handle_oosvar_to_oosvar_assignment( static void mlr_dsl_cst_node_handle_oosvar_from_full_srec_assignment( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator) { int all_non_null_or_error = TRUE; - sllmv_t* plhskeys = evaluate_list(pnode->poosvar_lhs_keylist_evaluators, - pinrec, ptyped_overlay, poosvars, ppregex_captures, pctx, &all_non_null_or_error); + sllmv_t* plhskeys = evaluate_list(pnode->poosvar_lhs_keylist_evaluators, pvars, &all_non_null_or_error); if (all_non_null_or_error) { - mlhmmv_level_t* plevel = mlhmmv_get_or_create_level(poosvars, plhskeys); + mlhmmv_level_t* plevel = mlhmmv_get_or_create_level(pvars->poosvars, plhskeys); if (plevel != NULL) { mlhmmv_clear_level(plevel); - for (lrece_t* pe = pinrec->phead; pe != NULL; pe = pe->pnext) { + for (lrece_t* pe = pvars->pinrec->phead; pe != NULL; pe = pe->pnext) { mv_t k = mv_from_string(pe->key, NO_FREE); // mlhmmv_put_terminal_from_level will copy sllmve_t e = { .value = k, .free_flags = 0, .pnext = NULL }; - mv_t* pomv = lhmsv_get(ptyped_overlay, pe->key); + mv_t* pomv = lhmsv_get(pvars->ptyped_overlay, pe->key); if (pomv != NULL) { mlhmmv_put_terminal_from_level(plevel, &e, pomv); } else { @@ -1279,29 +1137,23 @@ static void mlr_dsl_cst_node_handle_oosvar_from_full_srec_assignment( static void mlr_dsl_cst_node_handle_full_srec_from_oosvar_assignment( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator) { - lrec_clear(pinrec); - for (lhmsve_t* pe = ptyped_overlay->phead; pe != NULL; pe = pe->pnext) { + lrec_clear(pvars->pinrec); + for (lhmsve_t* pe = pvars->ptyped_overlay->phead; pe != NULL; pe = pe->pnext) { mv_t* pmv = pe->pvvalue; mv_free(pmv); } - lhmsv_clear(ptyped_overlay); + lhmsv_clear(pvars->ptyped_overlay); int all_non_null_or_error = TRUE; - sllmv_t* prhskeys = evaluate_list(pnode->poosvar_rhs_keylist_evaluators, - pinrec, ptyped_overlay, poosvars, ppregex_captures, pctx, &all_non_null_or_error); + sllmv_t* prhskeys = evaluate_list(pnode->poosvar_rhs_keylist_evaluators, pvars, &all_non_null_or_error); if (all_non_null_or_error) { int error = 0; - mlhmmv_level_t* plevel = mlhmmv_get_level(poosvars, prhskeys, &error); + mlhmmv_level_t* plevel = mlhmmv_get_level(pvars->poosvars, prhskeys, &error); if (plevel != NULL) { for (mlhmmv_level_entry_t* pentry = plevel->phead; pentry != NULL; pentry = pentry->pnext) { if (pentry->level_value.is_terminal) { @@ -1321,14 +1173,14 @@ static void mlr_dsl_cst_node_handle_full_srec_from_oosvar_assignment( // lrec would result in double frees, or awkward bookkeeping. However, the NR // variable evaluator reads prec->field_count, so we need to put something here. // And putting something statically allocated minimizes copying/freeing. - mv_t* pold = lhmsv_get(ptyped_overlay, skey); + mv_t* pold = lhmsv_get(pvars->ptyped_overlay, skey); if (pold != NULL) { // xxx to do: replace the typed overlay with an mlhmmv entirely. mv_free(pold); free(pold); } - lhmsv_put(ptyped_overlay, mlr_strdup_or_die(skey), pval, FREE_ENTRY_KEY); - lrec_put(pinrec, skey, "bug", FREE_ENTRY_KEY); + lhmsv_put(pvars->ptyped_overlay, mlr_strdup_or_die(skey), pval, FREE_ENTRY_KEY); + lrec_put(pvars->pinrec, skey, "bug", FREE_ENTRY_KEY); } } } @@ -1339,29 +1191,23 @@ static void mlr_dsl_cst_node_handle_full_srec_from_oosvar_assignment( // ---------------------------------------------------------------- static void mlr_dsl_cst_node_handle_unset( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator) { for (sllve_t* pf = pnode->pvarargs->phead; pf != NULL; pf = pf->pnext) { mlr_dsl_cst_statement_vararg_t* pvararg = pf->pvvalue; if (pvararg->punset_oosvar_keylist_evaluators != NULL) { int all_non_null_or_error = TRUE; - sllmv_t* pmvkeys = evaluate_list(pvararg->punset_oosvar_keylist_evaluators, - pinrec, ptyped_overlay, poosvars, ppregex_captures, pctx, &all_non_null_or_error); + sllmv_t* pmvkeys = evaluate_list(pvararg->punset_oosvar_keylist_evaluators, pvars, &all_non_null_or_error); if (all_non_null_or_error) - mlhmmv_remove(poosvars, pmvkeys); + mlhmmv_remove(pvars->poosvars, pmvkeys); sllmv_free(pmvkeys); } else { - lrec_remove(pinrec, pvararg->emitf_or_unset_srec_field_name); + lrec_remove(pvars->pinrec, pvararg->emitf_or_unset_srec_field_name); } } } @@ -1369,33 +1215,23 @@ static void mlr_dsl_cst_node_handle_unset( // ---------------------------------------------------------------- static void mlr_dsl_cst_node_handle_unset_all( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator) { sllmv_t* pempty = sllmv_alloc(); - mlhmmv_remove(poosvars, pempty); + mlhmmv_remove(pvars->poosvars, pempty); sllmv_free(pempty); } // ---------------------------------------------------------------- static void mlr_dsl_cst_node_handle_emitf( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator) { lrec_t* prec_to_emit = lrec_unbacked_alloc(); for (sllve_t* pf = pnode->pvarargs->phead; pf != NULL; pf = pf->pnext) { @@ -1405,8 +1241,7 @@ static void mlr_dsl_cst_node_handle_emitf( // This is overkill ... the grammar allows only for oosvar names as args to emit. So we could bypass // that and just hashmap-get keyed by emitf_or_unset_srec_field_name here. - mv_t val = pemitf_arg_evaluator->pprocess_func(pinrec, ptyped_overlay, poosvars, - ppregex_captures, pctx, pemitf_arg_evaluator->pvstate); + mv_t val = pemitf_arg_evaluator->pprocess_func(pemitf_arg_evaluator->pvstate, pvars); if (val.type == MT_STRING) { // Ownership transfer from (newly created) mlrval to (newly created) lrec. @@ -1424,25 +1259,18 @@ static void mlr_dsl_cst_node_handle_emitf( // ---------------------------------------------------------------- static void mlr_dsl_cst_node_handle_emitp( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator) { int keys_all_non_null_or_error = TRUE; - sllmv_t* pmvkeys = evaluate_list(pnode->poosvar_lhs_keylist_evaluators, - pinrec, ptyped_overlay, poosvars, ppregex_captures, pctx, &keys_all_non_null_or_error); + sllmv_t* pmvkeys = evaluate_list(pnode->poosvar_lhs_keylist_evaluators, pvars, &keys_all_non_null_or_error); if (keys_all_non_null_or_error) { int names_all_non_null_or_error = TRUE; - sllmv_t* pmvnames = evaluate_list(pnode->pemit_oosvar_namelist_evaluators, - pinrec, ptyped_overlay, poosvars, ppregex_captures, pctx, &names_all_non_null_or_error); + sllmv_t* pmvnames = evaluate_list(pnode->pemit_oosvar_namelist_evaluators, pvars, &names_all_non_null_or_error); if (names_all_non_null_or_error) { - mlhmmv_to_lrecs(poosvars, pmvkeys, pmvnames, poutrecs, FALSE, oosvar_flatten_separator); + mlhmmv_to_lrecs(pvars->poosvars, pmvkeys, pmvnames, poutrecs, FALSE, oosvar_flatten_separator); } sllmv_free(pmvnames); } @@ -1452,21 +1280,15 @@ static void mlr_dsl_cst_node_handle_emitp( // ---------------------------------------------------------------- static void mlr_dsl_cst_node_handle_emitp_all( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator) { int all_non_null_or_error = TRUE; - sllmv_t* pmvnames = evaluate_list(pnode->pemit_oosvar_namelist_evaluators, - pinrec, ptyped_overlay, poosvars, ppregex_captures, pctx, &all_non_null_or_error); + sllmv_t* pmvnames = evaluate_list(pnode->pemit_oosvar_namelist_evaluators, pvars, &all_non_null_or_error); if (all_non_null_or_error) { - mlhmmv_all_to_lrecs(poosvars, pmvnames, poutrecs, FALSE, oosvar_flatten_separator); + mlhmmv_all_to_lrecs(pvars->poosvars, pmvnames, poutrecs, FALSE, oosvar_flatten_separator); } sllmv_free(pmvnames); } @@ -1474,25 +1296,18 @@ static void mlr_dsl_cst_node_handle_emitp_all( // ---------------------------------------------------------------- static void mlr_dsl_cst_node_handle_emit( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator) { int keys_all_non_null_or_error = TRUE; - sllmv_t* pmvkeys = evaluate_list(pnode->poosvar_lhs_keylist_evaluators, - pinrec, ptyped_overlay, poosvars, ppregex_captures, pctx, &keys_all_non_null_or_error); + sllmv_t* pmvkeys = evaluate_list(pnode->poosvar_lhs_keylist_evaluators, pvars, &keys_all_non_null_or_error); if (keys_all_non_null_or_error) { int names_all_non_null_or_error = TRUE; - sllmv_t* pmvnames = evaluate_list(pnode->pemit_oosvar_namelist_evaluators, - pinrec, ptyped_overlay, poosvars, ppregex_captures, pctx, &names_all_non_null_or_error); + sllmv_t* pmvnames = evaluate_list(pnode->pemit_oosvar_namelist_evaluators, pvars, &names_all_non_null_or_error); if (names_all_non_null_or_error) { - mlhmmv_to_lrecs(poosvars, pmvkeys, pmvnames, poutrecs, TRUE, oosvar_flatten_separator); + mlhmmv_to_lrecs(pvars->poosvars, pmvkeys, pmvnames, poutrecs, TRUE, oosvar_flatten_separator); } sllmv_free(pmvnames); } @@ -1502,21 +1317,15 @@ static void mlr_dsl_cst_node_handle_emit( // ---------------------------------------------------------------- static void mlr_dsl_cst_node_handle_emit_all( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator) { int all_non_null_or_error = TRUE; - sllmv_t* pmvnames = evaluate_list(pnode->pemit_oosvar_namelist_evaluators, - pinrec, ptyped_overlay, poosvars, ppregex_captures, pctx, &all_non_null_or_error); + sllmv_t* pmvnames = evaluate_list(pnode->pemit_oosvar_namelist_evaluators, pvars, &all_non_null_or_error); if (all_non_null_or_error) { - mlhmmv_all_to_lrecs(poosvars, pmvnames, poutrecs, TRUE, oosvar_flatten_separator); + mlhmmv_all_to_lrecs(pvars->poosvars, pmvnames, poutrecs, TRUE, oosvar_flatten_separator); } sllmv_free(pmvnames); } @@ -1524,36 +1333,25 @@ static void mlr_dsl_cst_node_handle_emit_all( // ---------------------------------------------------------------- static void mlr_dsl_cst_node_handle_dump( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator) { - mlhmmv_print_json_stacked(poosvars, FALSE); + mlhmmv_print_json_stacked(pvars->poosvars, FALSE); } // ---------------------------------------------------------------- static void mlr_dsl_cst_node_handle_filter( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator) { rval_evaluator_t* prhs_evaluator = pnode->prhs_evaluator; - mv_t val = prhs_evaluator->pprocess_func(pinrec, ptyped_overlay, poosvars, - ppregex_captures, pctx, prhs_evaluator->pvstate); + mv_t val = prhs_evaluator->pprocess_func(prhs_evaluator->pvstate, pvars); if (mv_is_non_null(&val)) { mv_set_boolean_strict(&val); *pshould_emit_rec = val.u.boolv; @@ -1565,26 +1363,18 @@ static void mlr_dsl_cst_node_handle_filter( // ---------------------------------------------------------------- static void mlr_dsl_cst_node_handle_conditional_block( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator) { rval_evaluator_t* prhs_evaluator = pnode->prhs_evaluator; - mv_t val = prhs_evaluator->pprocess_func(pinrec, ptyped_overlay, poosvars, - ppregex_captures, pctx, prhs_evaluator->pvstate); + mv_t val = prhs_evaluator->pprocess_func(prhs_evaluator->pvstate, pvars); if (mv_is_non_null(&val)) { mv_set_boolean_strict(&val); if (val.u.boolv) { - mlr_dsl_cst_handle(pnode->pblock_statements, - poosvars, pinrec, ptyped_overlay, ppregex_captures, pctx, pshould_emit_rec, poutrecs, - oosvar_flatten_separator, pbind_stack); + mlr_dsl_cst_handle(pnode->pblock_statements, pvars, pshould_emit_rec, poutrecs, oosvar_flatten_separator); } } } @@ -1592,27 +1382,20 @@ static void mlr_dsl_cst_node_handle_conditional_block( // ---------------------------------------------------------------- static void mlr_dsl_cst_node_handle_while( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator) { rval_evaluator_t* prhs_evaluator = pnode->prhs_evaluator; while (TRUE) { - mv_t val = prhs_evaluator->pprocess_func(pinrec, ptyped_overlay, poosvars, - ppregex_captures, pctx, prhs_evaluator->pvstate); + mv_t val = prhs_evaluator->pprocess_func(prhs_evaluator->pvstate, pvars); if (mv_is_non_null(&val)) { mv_set_boolean_strict(&val); if (val.u.boolv) { - mlr_dsl_cst_handle(pnode->pblock_statements, - poosvars, pinrec, ptyped_overlay, ppregex_captures, pctx, pshould_emit_rec, poutrecs, - oosvar_flatten_separator, pbind_stack); + mlr_dsl_cst_handle(pnode->pblock_statements, pvars, pshould_emit_rec, poutrecs, + oosvar_flatten_separator); } else { break; } @@ -1625,25 +1408,18 @@ static void mlr_dsl_cst_node_handle_while( // ---------------------------------------------------------------- static void mlr_dsl_cst_node_handle_do_while( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator) { rval_evaluator_t* prhs_evaluator = pnode->prhs_evaluator; while (TRUE) { - mlr_dsl_cst_handle(pnode->pblock_statements, - poosvars, pinrec, ptyped_overlay, ppregex_captures, pctx, pshould_emit_rec, poutrecs, - oosvar_flatten_separator, pbind_stack); + mlr_dsl_cst_handle(pnode->pblock_statements, pvars, pshould_emit_rec, poutrecs, + oosvar_flatten_separator); - mv_t val = prhs_evaluator->pprocess_func(pinrec, ptyped_overlay, poosvars, - ppregex_captures, pctx, prhs_evaluator->pvstate); + mv_t val = prhs_evaluator->pprocess_func(prhs_evaluator->pvstate, pvars); if (mv_is_non_null(&val)) { mv_set_boolean_strict(&val); if (!val.u.boolv) { @@ -1658,23 +1434,18 @@ static void mlr_dsl_cst_node_handle_do_while( // ---------------------------------------------------------------- static void mlr_dsl_cst_node_handle_for_srec( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator) { - bind_stack_push(pbind_stack, pnode->pbound_variables); - for (lrece_t* pe = pinrec->phead; pe != NULL; pe = pe->pnext) { + bind_stack_push(pvars->pbind_stack, pnode->pbound_variables); + for (lrece_t* pe = pvars->pinrec->phead; pe != NULL; pe = pe->pnext) { // xxx beware string/integer for lrec keys ... // Copy, not pointer-reference, in case of srec-unset in loop body. mv_t mvkey = mv_from_string_with_free(mlr_strdup_or_die(pe->key)); - mv_t* poverlay = lhmsv_get(ptyped_overlay, pe->key); + mv_t* poverlay = lhmsv_get(pvars->ptyped_overlay, pe->key); mv_t mvval = (poverlay != NULL) ? mv_copy(poverlay) : mv_from_string_with_free(mlr_strdup_or_die(pe->value)); @@ -1682,39 +1453,30 @@ static void mlr_dsl_cst_node_handle_for_srec( lhmsmv_put(pnode->pbound_variables, pnode->for_srec_k_name, &mvkey, FREE_ENTRY_VALUE); lhmsmv_put(pnode->pbound_variables, pnode->for_srec_v_name, &mvval, FREE_ENTRY_VALUE); - mlr_dsl_cst_handle(pnode->pblock_statements, - poosvars, pinrec, ptyped_overlay, ppregex_captures, pctx, pshould_emit_rec, poutrecs, - oosvar_flatten_separator, pbind_stack); + mlr_dsl_cst_handle(pnode->pblock_statements, pvars, pshould_emit_rec, poutrecs, oosvar_flatten_separator); } // xxx break/continue-handling (needs to be in rval evluators w/ stack of brk/ctu flags @ context - bind_stack_pop(pbind_stack); + bind_stack_pop(pvars->pbind_stack); } // ---------------------------------------------------------------- static void mlr_dsl_cst_node_handle_if_head( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator) { for (sllve_t* pe = pnode->pif_chain_statements->phead; pe != NULL; pe = pe->pnext) { mlr_dsl_cst_statement_t* pitemnode = pe->pvvalue; rval_evaluator_t* prhs_evaluator = pitemnode->prhs_evaluator; - mv_t val = prhs_evaluator->pprocess_func(pinrec, ptyped_overlay, poosvars, - ppregex_captures, pctx, prhs_evaluator->pvstate); + mv_t val = prhs_evaluator->pprocess_func(prhs_evaluator->pvstate, pvars); if (mv_is_non_null(&val)) { mv_set_boolean_strict(&val); if (val.u.boolv) { - mlr_dsl_cst_handle(pitemnode->pblock_statements, - poosvars, pinrec, ptyped_overlay, ppregex_captures, pctx, pshould_emit_rec, poutrecs, - oosvar_flatten_separator, pbind_stack); + mlr_dsl_cst_handle(pitemnode->pblock_statements, pvars, pshould_emit_rec, poutrecs, + oosvar_flatten_separator); break; } @@ -1725,20 +1487,14 @@ static void mlr_dsl_cst_node_handle_if_head( // ---------------------------------------------------------------- static void mlr_dsl_cst_node_handle_bare_boolean( 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, + sllv_t* poutrecs, + char* oosvar_flatten_separator) { rval_evaluator_t* prhs_evaluator = pnode->prhs_evaluator; - mv_t val = prhs_evaluator->pprocess_func(pinrec, ptyped_overlay, poosvars, - ppregex_captures, pctx, prhs_evaluator->pvstate); + mv_t val = prhs_evaluator->pprocess_func(prhs_evaluator->pvstate, pvars); if (mv_is_non_null(&val)) mv_set_boolean_strict(&val); } diff --git a/c/mapping/mlr_dsl_cst.h b/c/mapping/mlr_dsl_cst.h index 217816c77..5dbdd36cf 100644 --- a/c/mapping/mlr_dsl_cst.h +++ b/c/mapping/mlr_dsl_cst.h @@ -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 diff --git a/c/mapping/rval_evaluator.h b/c/mapping/rval_evaluator.h index 1c004b9fb..3def9473a 100644 --- a/c/mapping/rval_evaluator.h +++ b/c/mapping/rval_evaluator.h @@ -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*); diff --git a/c/mapping/rval_evaluators.h b/c/mapping/rval_evaluators.h index 15800c9d5..64445be05 100644 --- a/c/mapping/rval_evaluators.h +++ b/c/mapping/rval_evaluators.h @@ -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 diff --git a/c/mapping/rval_expr_evaluators.c b/c/mapping/rval_expr_evaluators.c index bbbdf5e7e..f4d8bfb7a 100644 --- a/c/mapping/rval_expr_evaluators.c +++ b/c/mapping/rval_expr_evaluators.c @@ -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); diff --git a/c/mapping/rval_func_evaluators.c b/c/mapping/rval_func_evaluators.c index 6dc27e1d0..88608e67d 100644 --- a/c/mapping/rval_func_evaluators.c +++ b/c/mapping/rval_func_evaluators.c @@ -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); diff --git a/c/mapping/rval_list_evaluators.c b/c/mapping/rval_list_evaluators.c index 8d60f9fe2..498f9a3d8 100644 --- a/c/mapping/rval_list_evaluators.c +++ b/c/mapping/rval_list_evaluators.c @@ -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; diff --git a/c/unit_test/test_rval_evaluators.c b/c/unit_test/test_rval_evaluators.c index d88b25a82..a55e1ed3d 100644 --- a/c/unit_test/test_rval_evaluators.c +++ b/c/unit_test/test_rval_evaluators.c @@ -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);