From a4ea7f08f0bbe2dfe727fffe15f5d8831a5845f6 Mon Sep 17 00:00:00 2001 From: John Kerl Date: Fri, 29 Jan 2016 19:25:10 -0500 Subject: [PATCH] moosvars -> oosvars: fully functional replacement/extension --- c/containers/mlr_dsl_ast.c | 6 +- c/containers/mlr_dsl_ast.h | 32 ++-- c/dsls/mlr_dsl_lexer.l | 9 +- c/dsls/mlr_dsl_parse.y | 50 +++--- c/mapping/lrec_evaluator.h | 2 +- c/mapping/lrec_evaluators.c | 322 ++++++++++++++++++------------------ c/mapping/lrec_evaluators.h | 2 +- c/mapping/mapper_put.c | 28 ++-- c/mapping/mlr_dsl_cst.c | 52 +++--- c/mapping/mlr_dsl_cst.h | 4 +- c/reg_test/expected/out | 40 ++--- 11 files changed, 273 insertions(+), 274 deletions(-) diff --git a/c/containers/mlr_dsl_ast.c b/c/containers/mlr_dsl_ast.c index fab513d77..b7a20095e 100644 --- a/c/containers/mlr_dsl_ast.c +++ b/c/containers/mlr_dsl_ast.c @@ -129,12 +129,12 @@ char* mlr_dsl_ast_node_describe_type(int type) { case MD_AST_NODE_TYPE_BOOLEAN_LITERAL: return "boolean_literal"; break; case MD_AST_NODE_TYPE_REGEXI: return "regexi"; break; case MD_AST_NODE_TYPE_FIELD_NAME: return "field_name"; break; - case MD_AST_NODE_TYPE_MOOSVAR_NAME: return "moosvar_name"; break; - case MD_AST_NODE_TYPE_MOOSVAR_LEVEL_KEY: return "moosvar_level_key"; break; + case MD_AST_NODE_TYPE_OOSVAR_NAME: return "oosvar_name"; break; + case MD_AST_NODE_TYPE_OOSVAR_LEVEL_KEY: return "oosvar_level_key"; break; case MD_AST_NODE_TYPE_FUNCTION_NAME: return "function_name"; break; case MD_AST_NODE_TYPE_OPERATOR: return "operator"; break; case MD_AST_NODE_TYPE_SREC_ASSIGNMENT: return "srec_assignment"; break; - case MD_AST_NODE_TYPE_MOOSVAR_ASSIGNMENT: return "moosvar_assignment"; break; + case MD_AST_NODE_TYPE_OOSVAR_ASSIGNMENT: return "oosvar_assignment"; break; case MD_AST_NODE_TYPE_CONTEXT_VARIABLE: return "context_variable"; break; case MD_AST_NODE_TYPE_STRIPPED_AWAY: return "stripped_away"; break; case MD_AST_NODE_TYPE_FILTER: return "filter"; break; diff --git a/c/containers/mlr_dsl_ast.h b/c/containers/mlr_dsl_ast.h index dfd3e8af6..291b195b8 100644 --- a/c/containers/mlr_dsl_ast.h +++ b/c/containers/mlr_dsl_ast.h @@ -6,22 +6,22 @@ #define MLR_DSL_AST_H #include "sllv.h" -#define MD_AST_NODE_TYPE_STRNUM_LITERAL 0xda00 -#define MD_AST_NODE_TYPE_BOOLEAN_LITERAL 0xda11 -#define MD_AST_NODE_TYPE_REGEXI 0xda22 -#define MD_AST_NODE_TYPE_FIELD_NAME 0xda33 -#define MD_AST_NODE_TYPE_MOOSVAR_NAME 0xda55 -#define MD_AST_NODE_TYPE_MOOSVAR_LEVEL_KEY 0xda5c -#define MD_AST_NODE_TYPE_FUNCTION_NAME 0xda66 -#define MD_AST_NODE_TYPE_OPERATOR 0xda77 -#define MD_AST_NODE_TYPE_SREC_ASSIGNMENT 0xda88 -#define MD_AST_NODE_TYPE_MOOSVAR_ASSIGNMENT 0xdaaa -#define MD_AST_NODE_TYPE_CONTEXT_VARIABLE 0xdabb -#define MD_AST_NODE_TYPE_STRIPPED_AWAY 0xdacc -#define MD_AST_NODE_TYPE_FILTER 0xdadd -#define MD_AST_NODE_TYPE_GATE 0xdaee -#define MD_AST_NODE_TYPE_EMIT 0xdaff -#define MD_AST_NODE_TYPE_DUMP 0xddff +#define MD_AST_NODE_TYPE_STRNUM_LITERAL 0xda00 +#define MD_AST_NODE_TYPE_BOOLEAN_LITERAL 0xda11 +#define MD_AST_NODE_TYPE_REGEXI 0xda22 +#define MD_AST_NODE_TYPE_FIELD_NAME 0xda33 +#define MD_AST_NODE_TYPE_OOSVAR_NAME 0xda44 +#define MD_AST_NODE_TYPE_OOSVAR_LEVEL_KEY 0xda55 +#define MD_AST_NODE_TYPE_FUNCTION_NAME 0xda66 +#define MD_AST_NODE_TYPE_OPERATOR 0xda77 +#define MD_AST_NODE_TYPE_SREC_ASSIGNMENT 0xda88 +#define MD_AST_NODE_TYPE_OOSVAR_ASSIGNMENT 0xda99 +#define MD_AST_NODE_TYPE_CONTEXT_VARIABLE 0xdaaa +#define MD_AST_NODE_TYPE_STRIPPED_AWAY 0xdabb +#define MD_AST_NODE_TYPE_FILTER 0xdacc +#define MD_AST_NODE_TYPE_GATE 0xdadd +#define MD_AST_NODE_TYPE_EMIT 0xdaee +#define MD_AST_NODE_TYPE_DUMP 0xdaff typedef struct _mlr_dsl_ast_t { sllv_t* pbegin_statements; diff --git a/c/dsls/mlr_dsl_lexer.l b/c/dsls/mlr_dsl_lexer.l index c797974c2..d2a7701cc 100644 --- a/c/dsls/mlr_dsl_lexer.l +++ b/c/dsls/mlr_dsl_lexer.l @@ -196,15 +196,14 @@ @[a-zA-Z_0-9]+ { // Note: the parser depends on the at-sign being here. If this is changed, // that needs to be changed as well. - *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_MOOSVAR_NAME); - return MD_TOKEN_MOOSVAR_NAME; + *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OOSVAR_NAME); + return MD_TOKEN_OOSVAR_NAME; } @\{([^\}]|\\.)*\} { - // xxx moosvars are just temporary // Note: the parser depends on the percent-sign being here. If this is changed, // that needs to be changed as well. - *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_MOOSVAR_NAME); - return MD_TOKEN_BRACED_MOOSVAR_NAME; + *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_OOSVAR_NAME); + return MD_TOKEN_BRACED_OOSVAR_NAME; } "\[" { *yyextra = mlr_dsl_ast_node_alloc(yytext, MD_AST_NODE_TYPE_STRIPPED_AWAY); diff --git a/c/dsls/mlr_dsl_parse.y b/c/dsls/mlr_dsl_parse.y index 5ce71f3d5..b4e90526c 100644 --- a/c/dsls/mlr_dsl_parse.y +++ b/c/dsls/mlr_dsl_parse.y @@ -46,7 +46,7 @@ md_statements ::= md_statement MD_TOKEN_SEMICOLON md_statements. md_statement ::= . md_statement ::= md_main_srec_assignment. -md_statement ::= md_main_moosvar_assignment. +md_statement ::= md_main_oosvar_assignment. md_statement ::= md_main_bare_boolean. md_statement ::= md_main_filter. md_statement ::= md_main_gate. @@ -56,7 +56,7 @@ md_statement ::= md_main_dump. // E.g. 'begin { emit @count }' md_statement ::= md_begin_block. // E.g. 'begin emit @count' -md_statement ::= md_begin_solo_moosvar_assignment. +md_statement ::= md_begin_solo_oosvar_assignment. md_statement ::= md_begin_solo_bare_boolean. md_statement ::= md_begin_solo_filter. md_statement ::= md_begin_solo_gate. @@ -66,7 +66,7 @@ md_statement ::= md_begin_solo_dump. // E.g. 'end { emit @count }' md_statement ::= md_end_block. // E.g. 'end emit @count' -md_statement ::= md_end_solo_moosvar_assignment. +md_statement ::= md_end_solo_oosvar_assignment. md_statement ::= md_end_solo_bare_boolean. md_statement ::= md_end_solo_filter. md_statement ::= md_end_solo_gate. @@ -83,7 +83,7 @@ md_begin_block_statements ::= md_begin_block_statement MD_TOKEN_SEMICOLON md_beg // This allows for trailing semicolon, as well as empty string (or whitespace) between semicolons: md_begin_block_statement ::= . -md_begin_block_statement ::= md_begin_block_moosvar_assignment. +md_begin_block_statement ::= md_begin_block_oosvar_assignment. md_begin_block_statement ::= md_begin_block_bare_boolean. md_begin_block_statement ::= md_begin_block_filter. md_begin_block_statement ::= md_begin_block_gate. @@ -97,7 +97,7 @@ md_end_block_statements ::= md_end_block_statement MD_TOKEN_SEMICOLON md_end_blo // This allows for trailing semicolon, as well as empty string (or whitespace) between semicolons: md_end_block_statement ::= . -md_end_block_statement ::= md_end_block_moosvar_assignment. +md_end_block_statement ::= md_end_block_oosvar_assignment. md_end_block_statement ::= md_end_block_bare_boolean. md_end_block_statement ::= md_end_block_filter. md_end_block_statement ::= md_end_block_gate. @@ -112,7 +112,7 @@ md_main_srec_assignment(A) ::= md_field_name(B) MD_TOKEN_ASSIGN(O) md_ternary(C A = mlr_dsl_ast_node_alloc_binary(O->text, MD_AST_NODE_TYPE_SREC_ASSIGNMENT, B, C); sllv_add(past->pmain_statements, A); } -md_main_moosvar_assignment(A) ::= md_moosvar_assignment(B). { +md_main_oosvar_assignment(A) ::= md_oosvar_assignment(B). { A = B; sllv_add(past->pmain_statements, A); } @@ -140,7 +140,7 @@ md_main_dump(A) ::= md_dump(B). { // ---------------------------------------------------------------- // These are top-level; they update the AST top-level statement-lists. -md_begin_solo_moosvar_assignment(A) ::= MD_TOKEN_BEGIN md_moosvar_assignment(B). { +md_begin_solo_oosvar_assignment(A) ::= MD_TOKEN_BEGIN md_oosvar_assignment(B). { A = B; sllv_add(past->pbegin_statements, A); } @@ -165,7 +165,7 @@ md_begin_solo_dump(A) ::= MD_TOKEN_BEGIN md_dump(B). { sllv_add(past->pbegin_statements, A); } -md_begin_block_moosvar_assignment(A) ::= md_moosvar_assignment(B). { +md_begin_block_oosvar_assignment(A) ::= md_oosvar_assignment(B). { A = B; sllv_add(past->pbegin_statements, A); } @@ -194,7 +194,7 @@ md_begin_block_dump(A) ::= md_dump(B). { // ---------------------------------------------------------------- // These are top-level; they update the AST top-level statement-lists. -md_end_solo_moosvar_assignment(A) ::= MD_TOKEN_END md_moosvar_assignment(B). { +md_end_solo_oosvar_assignment(A) ::= MD_TOKEN_END md_oosvar_assignment(B). { A = B; sllv_add(past->pend_statements, A); } @@ -219,7 +219,7 @@ md_end_solo_dump(A) ::= MD_TOKEN_END md_dump(B). { sllv_add(past->pend_statements, A); } -md_end_block_moosvar_assignment(A) ::= md_moosvar_assignment(B). { +md_end_block_oosvar_assignment(A) ::= md_oosvar_assignment(B). { A = B; sllv_add(past->pend_statements, A); } @@ -245,11 +245,11 @@ md_end_block_dump(A) ::= md_dump(B). { } // ---------------------------------------------------------------- -md_moosvar_assignment(A) ::= md_moosvar_name(B) MD_TOKEN_ASSIGN(O) md_ternary(C). { - A = mlr_dsl_ast_node_alloc_binary(O->text, MD_AST_NODE_TYPE_MOOSVAR_ASSIGNMENT, B, C); +md_oosvar_assignment(A) ::= md_oosvar_name(B) MD_TOKEN_ASSIGN(O) md_ternary(C). { + A = mlr_dsl_ast_node_alloc_binary(O->text, MD_AST_NODE_TYPE_OOSVAR_ASSIGNMENT, B, C); } -md_moosvar_assignment(A) ::= md_keyed_moosvar_name(B) MD_TOKEN_ASSIGN(O) md_ternary(C). { - A = mlr_dsl_ast_node_alloc_binary(O->text, MD_AST_NODE_TYPE_MOOSVAR_ASSIGNMENT, B, C); +md_oosvar_assignment(A) ::= md_keyed_oosvar_name(B) MD_TOKEN_ASSIGN(O) md_ternary(C). { + A = mlr_dsl_ast_node_alloc_binary(O->text, MD_AST_NODE_TYPE_OOSVAR_ASSIGNMENT, B, C); } // ---------------------------------------------------------------- @@ -268,15 +268,15 @@ md_emit_args(A) ::= . { A = mlr_dsl_ast_node_alloc_zary("temp", MD_AST_NODE_TYPE_EMIT); } -md_emit_args(A) ::= md_moosvar_name(B). { +md_emit_args(A) ::= md_oosvar_name(B). { A = mlr_dsl_ast_node_alloc_unary("temp", MD_AST_NODE_TYPE_EMIT, B); } -md_emit_args(A) ::= md_emit_args(B) MD_TOKEN_COMMA md_moosvar_name(C). { +md_emit_args(A) ::= md_emit_args(B) MD_TOKEN_COMMA md_oosvar_name(C). { A = mlr_dsl_ast_node_append_arg(B, C); } // ---------------------------------------------------------------- -// Dev/debug hook for moosvars +// Dev/debug hook for oosvars md_dump(A) ::= MD_TOKEN_DUMP(O). { A = mlr_dsl_ast_node_alloc_zary(O->text, MD_AST_NODE_TYPE_DUMP); } @@ -464,26 +464,26 @@ md_field_name(A) ::= MD_TOKEN_BRACED_FIELD_NAME(B). { A = mlr_dsl_ast_node_alloc(no_dollar_name, B->type); } -md_atom_or_fcn(A) ::= md_keyed_moosvar_name(B). { +md_atom_or_fcn(A) ::= md_keyed_oosvar_name(B). { A = B; } -md_atom_or_fcn(A) ::= md_moosvar_name(B). { +md_atom_or_fcn(A) ::= md_oosvar_name(B). { A = B; } -md_keyed_moosvar_name(A) ::= md_moosvar_name(B) MD_TOKEN_LEFT_BRACKET md_ternary(C) MD_TOKEN_RIGHT_BRACKET. { - A = mlr_dsl_ast_node_alloc_binary("[]", MD_AST_NODE_TYPE_MOOSVAR_LEVEL_KEY, B, C); +md_keyed_oosvar_name(A) ::= md_oosvar_name(B) MD_TOKEN_LEFT_BRACKET md_ternary(C) MD_TOKEN_RIGHT_BRACKET. { + A = mlr_dsl_ast_node_alloc_binary("[]", MD_AST_NODE_TYPE_OOSVAR_LEVEL_KEY, B, C); } -md_keyed_moosvar_name(A) ::= md_keyed_moosvar_name(B) MD_TOKEN_LEFT_BRACKET md_ternary(C) MD_TOKEN_RIGHT_BRACKET. { - A = mlr_dsl_ast_node_alloc_binary("[]", MD_AST_NODE_TYPE_MOOSVAR_LEVEL_KEY, B, C); +md_keyed_oosvar_name(A) ::= md_keyed_oosvar_name(B) MD_TOKEN_LEFT_BRACKET md_ternary(C) MD_TOKEN_RIGHT_BRACKET. { + A = mlr_dsl_ast_node_alloc_binary("[]", MD_AST_NODE_TYPE_OOSVAR_LEVEL_KEY, B, C); } -md_moosvar_name(A) ::= MD_TOKEN_MOOSVAR_NAME(B). { +md_oosvar_name(A) ::= MD_TOKEN_OOSVAR_NAME(B). { char* at_name = B->text; char* no_at_name = &at_name[1]; A = mlr_dsl_ast_node_alloc(no_at_name, B->type); } -md_moosvar_name(A) ::= MD_TOKEN_BRACED_MOOSVAR_NAME(B). { +md_oosvar_name(A) ::= MD_TOKEN_BRACED_OOSVAR_NAME(B). { // Replace "@%{field.name}" with just "field.name" char* at_name = B->text; char* no_at_name = &at_name[2]; diff --git a/c/mapping/lrec_evaluator.h b/c/mapping/lrec_evaluator.h index 18296d1de..32d449b30 100644 --- a/c/mapping/lrec_evaluator.h +++ b/c/mapping/lrec_evaluator.h @@ -34,7 +34,7 @@ struct _lrec_evaluator_t; // forward reference for method declarations // See also the comments above mapper_put.c for more information. typedef mv_t lrec_evaluator_process_func_t( - lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, + lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate); typedef void lrec_evaluator_free_func_t(struct _lrec_evaluator_t*); diff --git a/c/mapping/lrec_evaluators.c b/c/mapping/lrec_evaluators.c index 23ebeee2b..ea2f45a6f 100644 --- a/c/mapping/lrec_evaluators.c +++ b/c/mapping/lrec_evaluators.c @@ -38,11 +38,11 @@ typedef struct _lrec_evaluator_b_b_state_t { lrec_evaluator_t* parg1; } lrec_evaluator_b_b_state_t; -mv_t lrec_evaluator_b_b_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_b_b_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_b_b_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); NULL_OR_ERROR_OUT(val1); if (val1.type != MT_BOOL) @@ -78,19 +78,19 @@ typedef struct _lrec_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 lrec_evaluator_b_bb_and_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_b_bb_and_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_b_bb_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); NULL_OR_ERROR_OUT(val1); if (val1.type != MT_BOOL) return MV_ERROR; if (val1.u.boolv == FALSE) return val1; - mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg2->pvstate); + mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg2->pvstate); NULL_OR_ERROR_OUT(val2); if (val2.type != MT_BOOL) return MV_ERROR; @@ -100,19 +100,19 @@ mv_t lrec_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 lrec_evaluator_b_bb_or_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_b_bb_or_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_b_bb_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); NULL_OR_ERROR_OUT(val1); if (val1.type != MT_BOOL) return MV_ERROR; if (val1.u.boolv == TRUE) return val1; - mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg2->pvstate); + mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg2->pvstate); NULL_OR_ERROR_OUT(val2); if (val2.type != MT_BOOL) return MV_ERROR; @@ -120,17 +120,17 @@ mv_t lrec_evaluator_b_bb_or_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t return val2; } -mv_t lrec_evaluator_b_bb_xor_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_b_bb_xor_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_b_bb_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); NULL_OR_ERROR_OUT(val1); if (val1.type != MT_BOOL) return MV_ERROR; - mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg2->pvstate); + mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg2->pvstate); NULL_OR_ERROR_OUT(val2); if (val2.type != MT_BOOL) return MV_ERROR; @@ -190,7 +190,7 @@ typedef struct _lrec_evaluator_x_z_state_t { mv_zary_func_t* pfunc; } lrec_evaluator_x_z_state_t; -mv_t lrec_evaluator_x_z_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_x_z_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_x_z_state_t* pstate = pvstate; @@ -219,11 +219,11 @@ typedef struct _lrec_evaluator_f_f_state_t { lrec_evaluator_t* parg1; } lrec_evaluator_f_f_state_t; -mv_t lrec_evaluator_f_f_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_f_f_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_f_f_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); mv_set_float_nullable(&val1); NULL_OR_ERROR_OUT(val1); @@ -258,12 +258,12 @@ typedef struct _lrec_evaluator_x_n_state_t { lrec_evaluator_t* parg1; } lrec_evaluator_x_n_state_t; -mv_t lrec_evaluator_x_n_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_x_n_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_x_n_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); mv_set_number_nullable(&val1); NULL_OR_ERROR_OUT(val1); @@ -295,11 +295,11 @@ typedef struct _lrec_evaluator_i_i_state_t { lrec_evaluator_t* parg1; } lrec_evaluator_i_i_state_t; -mv_t lrec_evaluator_i_i_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_i_i_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_i_i_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); mv_set_int_nullable(&val1); NULL_OR_ERROR_OUT(val1); @@ -333,15 +333,15 @@ typedef struct _lrec_evaluator_f_ff_state_t { lrec_evaluator_t* parg2; } lrec_evaluator_f_ff_state_t; -mv_t lrec_evaluator_f_ff_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_f_ff_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_f_ff_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); mv_set_float_nullable(&val1); NULL_OR_ERROR_OUT(val1); - mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg2->pvstate); + mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg2->pvstate); mv_set_float_nullable(&val2); NULL_OR_ERROR_OUT(val2); @@ -378,12 +378,12 @@ typedef struct _lrec_evaluator_n_nn_state_t { lrec_evaluator_t* parg2; } lrec_evaluator_n_nn_state_t; -mv_t lrec_evaluator_n_nn_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_n_nn_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_n_nn_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); - mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg2->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg2->pvstate); mv_set_number_nullable(&val1); NULL_OR_ERROR_OUT(val1); @@ -428,15 +428,15 @@ typedef struct _lrec_evaluator_n_nn_nullable_state_t { lrec_evaluator_t* parg2; } lrec_evaluator_n_nn_nullable_state_t; -mv_t lrec_evaluator_n_nn_nullable_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_n_nn_nullable_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_n_nn_nullable_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); mv_set_number_nullable(&val1); ERROR_OUT(val1); - mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg2->pvstate); + mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg2->pvstate); mv_set_number_nullable(&val2); ERROR_OUT(val2); @@ -474,19 +474,19 @@ typedef struct _lrec_evaluator_f_fff_state_t { lrec_evaluator_t* parg3; } lrec_evaluator_f_fff_state_t; -mv_t lrec_evaluator_f_fff_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_f_fff_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_f_fff_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); mv_set_float_nullable(&val1); NULL_OR_ERROR_OUT(val1); - mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg2->pvstate); + mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg2->pvstate); mv_set_float_nullable(&val2); NULL_OR_ERROR_OUT(val2); - mv_t val3 = pstate->parg3->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg3->pvstate); + mv_t val3 = pstate->parg3->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg3->pvstate); mv_set_float_nullable(&val3); NULL_OR_ERROR_OUT(val3); @@ -525,18 +525,18 @@ typedef struct _lrec_evaluator_i_ii_state_t { lrec_evaluator_t* parg2; } lrec_evaluator_i_ii_state_t; -mv_t lrec_evaluator_i_ii_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_i_ii_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_i_ii_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); NULL_OR_ERROR_OUT(val1); mv_set_int_nullable(&val1); NULL_OUT(val1); if (val1.type != MT_INT) return MV_ERROR; - mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg2->pvstate); + mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg2->pvstate); NULL_OR_ERROR_OUT(val2); mv_set_int_nullable(&val2); NULL_OUT(val2); @@ -577,25 +577,25 @@ typedef struct _lrec_evaluator_i_iii_state_t { lrec_evaluator_t* parg3; } lrec_evaluator_i_iii_state_t; -mv_t lrec_evaluator_i_iii_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_i_iii_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_i_iii_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); NULL_OR_ERROR_OUT(val1); mv_set_int_nullable(&val1); NULL_OUT(val1); if (val1.type != MT_INT) return MV_ERROR; - mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg2->pvstate); + mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg2->pvstate); NULL_OR_ERROR_OUT(val2); mv_set_int_nullable(&val2); NULL_OUT(val2); if (val2.type != MT_INT) return MV_ERROR; - mv_t val3 = pstate->parg3->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg3->pvstate); + mv_t val3 = pstate->parg3->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg3->pvstate); NULL_OR_ERROR_OUT(val3); mv_set_int_nullable(&val3); NULL_OUT(val3); @@ -637,17 +637,17 @@ typedef struct _lrec_evaluator_ternop_state_t { lrec_evaluator_t* parg3; } lrec_evaluator_ternop_state_t; -mv_t lrec_evaluator_ternop_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_ternop_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_ternop_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); NULL_OR_ERROR_OUT(val1); mv_set_boolean_strict(&val1); return val1.u.boolv - ? pstate->parg2->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg2->pvstate) - : pstate->parg3->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg3->pvstate); + ? pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg2->pvstate) + : pstate->parg3->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg3->pvstate); } static void lrec_evaluator_ternop_free(lrec_evaluator_t* pevaluator) { lrec_evaluator_ternop_state_t* pstate = pevaluator->pvstate; @@ -679,11 +679,11 @@ typedef struct _lrec_evaluator_s_s_state_t { lrec_evaluator_t* parg1; } lrec_evaluator_s_s_state_t; -mv_t lrec_evaluator_s_s_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_s_s_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_s_s_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); NULL_OR_ERROR_OUT(val1); if (val1.type != MT_STRING) return MV_ERROR; @@ -716,11 +716,11 @@ typedef struct _lrec_evaluator_s_f_state_t { lrec_evaluator_t* parg1; } lrec_evaluator_s_f_state_t; -mv_t lrec_evaluator_s_f_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_s_f_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_s_f_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); mv_set_float_nullable(&val1); NULL_OR_ERROR_OUT(val1); @@ -753,11 +753,11 @@ typedef struct _lrec_evaluator_s_i_state_t { lrec_evaluator_t* parg1; } lrec_evaluator_s_i_state_t; -mv_t lrec_evaluator_s_i_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_s_i_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_s_i_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); mv_set_int_nullable(&val1); NULL_OR_ERROR_OUT(val1); @@ -790,11 +790,11 @@ typedef struct _lrec_evaluator_f_s_state_t { lrec_evaluator_t* parg1; } lrec_evaluator_f_s_state_t; -mv_t lrec_evaluator_f_s_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_f_s_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_f_s_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); NULL_OR_ERROR_OUT(val1); if (val1.type != MT_STRING) return MV_ERROR; @@ -827,11 +827,11 @@ typedef struct _lrec_evaluator_i_s_state_t { lrec_evaluator_t* parg1; } lrec_evaluator_i_s_state_t; -mv_t lrec_evaluator_i_s_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_i_s_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_i_s_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); NULL_OR_ERROR_OUT(val1); if (val1.type != MT_STRING) return MV_ERROR; @@ -864,11 +864,11 @@ typedef struct _lrec_evaluator_x_x_state_t { lrec_evaluator_t* parg1; } lrec_evaluator_x_x_state_t; -mv_t lrec_evaluator_x_x_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_x_x_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_x_x_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); NULL_OR_ERROR_OUT(val1); return pstate->pfunc(&val1); @@ -900,12 +900,12 @@ typedef struct _lrec_evaluator_b_xx_state_t { lrec_evaluator_t* parg2; } lrec_evaluator_b_xx_state_t; -mv_t lrec_evaluator_b_xx_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_b_xx_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_b_xx_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); - mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg2->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg2->pvstate); return pstate->pfunc(&val1, &val2); } static void lrec_evaluator_b_xx_free(lrec_evaluator_t* pevaluator) { @@ -939,15 +939,15 @@ typedef struct _lrec_evaluator_x_ns_state_t { lrec_evaluator_t* parg2; } lrec_evaluator_x_ns_state_t; -mv_t lrec_evaluator_x_ns_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_x_ns_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_x_ns_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); mv_set_number_nullable(&val1); NULL_OR_ERROR_OUT(val1); - mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg2->pvstate); + mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg2->pvstate); NULL_OR_ERROR_OUT(val2); if (val2.type != MT_STRING) { mv_free(&val1); @@ -987,16 +987,16 @@ typedef struct _lrec_evaluator_x_ss_state_t { lrec_evaluator_t* parg2; } lrec_evaluator_x_ss_state_t; -mv_t lrec_evaluator_x_ss_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_x_ss_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_x_ss_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); NULL_OR_ERROR_OUT(val1); if (val1.type != MT_STRING) return MV_ERROR; - mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg2->pvstate); + mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg2->pvstate); NULL_OR_ERROR_OUT(val2); if (val2.type != MT_STRING) return MV_ERROR; @@ -1034,16 +1034,16 @@ typedef struct _lrec_evaluator_x_ssc_state_t { lrec_evaluator_t* parg2; } lrec_evaluator_x_ssc_state_t; -mv_t lrec_evaluator_x_ssc_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_x_ssc_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_x_ssc_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); NULL_OR_ERROR_OUT(val1); if (val1.type != MT_STRING) return MV_ERROR; - mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg2->pvstate); + mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg2->pvstate); NULL_OR_ERROR_OUT(val2); if (val2.type != MT_STRING) return MV_ERROR; @@ -1082,11 +1082,11 @@ typedef struct _lrec_evaluator_x_sr_state_t { string_builder_t* psb; } lrec_evaluator_x_sr_state_t; -mv_t lrec_evaluator_x_sr_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_x_sr_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_x_sr_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); NULL_OR_ERROR_OUT(val1); if (val1.type != MT_STRING) return MV_ERROR; @@ -1128,13 +1128,13 @@ typedef struct _lrec_evaluator_s_xs_state_t { lrec_evaluator_t* parg2; } lrec_evaluator_s_xs_state_t; -mv_t lrec_evaluator_s_xs_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_s_xs_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_s_xs_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); NULL_OR_ERROR_OUT(val1); - mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg2->pvstate); + mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg2->pvstate); NULL_OR_ERROR_OUT(val2); if (val2.type != MT_STRING) return MV_ERROR; @@ -1173,23 +1173,23 @@ typedef struct _lrec_evaluator_s_sss_state_t { lrec_evaluator_t* parg3; } lrec_evaluator_s_sss_state_t; -mv_t lrec_evaluator_s_sss_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_s_sss_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_s_sss_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); NULL_OR_ERROR_OUT(val1); if (val1.type != MT_STRING) return MV_ERROR; - mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg2->pvstate); + mv_t val2 = pstate->parg2->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg2->pvstate); NULL_OR_ERROR_OUT(val2); if (val2.type != MT_STRING) { mv_free(&val1); return MV_ERROR; } - mv_t val3 = pstate->parg3->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg3->pvstate); + mv_t val3 = pstate->parg3->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg3->pvstate); NULL_OR_ERROR_OUT(val3); if (val3.type != MT_STRING) { mv_free(&val1); @@ -1234,17 +1234,17 @@ typedef struct _lrec_evaluator_x_srs_state_t { string_builder_t* psb; } lrec_evaluator_x_srs_state_t; -mv_t lrec_evaluator_x_srs_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_x_srs_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_x_srs_state_t* pstate = pvstate; - mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg1->pvstate); + mv_t val1 = pstate->parg1->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg1->pvstate); NULL_OR_ERROR_OUT(val1); if (val1.type != MT_STRING) return MV_ERROR; - mv_t val3 = pstate->parg3->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pstate->parg3->pvstate); + mv_t val3 = pstate->parg3->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pstate->parg3->pvstate); NULL_OR_ERROR_OUT(val3); if (val3.type != MT_STRING) { mv_free(&val1); @@ -1290,7 +1290,7 @@ typedef struct _lrec_evaluator_field_name_state_t { char* field_name; } lrec_evaluator_field_name_state_t; -mv_t lrec_evaluator_field_name_func_string_only(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_field_name_func_string_only(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_field_name_state_t* pstate = pvstate; @@ -1312,7 +1312,7 @@ mv_t lrec_evaluator_field_name_func_string_only(lrec_t* prec, lhmsv_t* ptyped_ov } } -mv_t lrec_evaluator_field_name_func_string_float(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_field_name_func_string_float(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_field_name_state_t* pstate = pvstate; @@ -1339,7 +1339,7 @@ mv_t lrec_evaluator_field_name_func_string_float(lrec_t* prec, lhmsv_t* ptyped_o } } -mv_t lrec_evaluator_field_name_func_string_float_int(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_field_name_func_string_float_int(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_field_name_state_t* pstate = pvstate; // See comments in lrec_evaluator.h and mapper_put.c regarding the typed-overlay map. @@ -1403,16 +1403,16 @@ lrec_evaluator_t* lrec_evaluator_alloc_from_field_name(char* field_name, int typ } // ================================================================ -typedef struct _lrec_evaluator_moosvar_name_state_t { +typedef struct _lrec_evaluator_oosvar_name_state_t { sllmv_t* pmvkeys; -} lrec_evaluator_moosvar_name_state_t; +} lrec_evaluator_oosvar_name_state_t; -mv_t lrec_evaluator_moosvar_name_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_oosvar_name_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { - lrec_evaluator_moosvar_name_state_t* pstate = pvstate; + lrec_evaluator_oosvar_name_state_t* pstate = pvstate; int error = 0; - mv_t* pval = mlhmmv_get(pmoosvars, pstate->pmvkeys, &error); + mv_t* pval = mlhmmv_get(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 @@ -1423,24 +1423,24 @@ mv_t lrec_evaluator_moosvar_name_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlh } } -static void lrec_evaluator_moosvar_name_free(lrec_evaluator_t* pevaluator) { - lrec_evaluator_moosvar_name_state_t* pstate = pevaluator->pvstate; +static void lrec_evaluator_oosvar_name_free(lrec_evaluator_t* pevaluator) { + lrec_evaluator_oosvar_name_state_t* pstate = pevaluator->pvstate; free(pstate); free(pevaluator); } // xxx comment!! -lrec_evaluator_t* lrec_evaluator_alloc_from_moosvar_name(char* moosvar_name) { - lrec_evaluator_moosvar_name_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_evaluator_moosvar_name_state_t)); - mv_t mv_name = mv_from_string(moosvar_name, NO_FREE); +lrec_evaluator_t* lrec_evaluator_alloc_from_oosvar_name(char* oosvar_name) { + lrec_evaluator_oosvar_name_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_evaluator_oosvar_name_state_t)); + mv_t mv_name = mv_from_string(oosvar_name, NO_FREE); pstate->pmvkeys = sllmv_single(&mv_name); mv_free(&mv_name); lrec_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(lrec_evaluator_t)); pevaluator->pvstate = pstate; pevaluator->pprocess_func = NULL; - pevaluator->pprocess_func = lrec_evaluator_moosvar_name_func; - pevaluator->pfree_func = lrec_evaluator_moosvar_name_free; + pevaluator->pprocess_func = lrec_evaluator_oosvar_name_func; + pevaluator->pfree_func = lrec_evaluator_oosvar_name_free; return pevaluator; } @@ -1451,12 +1451,12 @@ lrec_evaluator_t* lrec_evaluator_alloc_from_moosvar_name(char* moosvar_name) { // Example AST: // % mlr put -v 'begin{@@x[1]["2"][$3][@4]=5}' /dev/null // AST BEGIN STATEMENTS (1): -// = (moosvar_assignment): -// [] (moosvar_level_key): -// [] (moosvar_level_key): -// [] (moosvar_level_key): -// [] (moosvar_level_key): -// x (moosvar_name). +// = (oosvar_assignment): +// [] (oosvar_level_key): +// [] (oosvar_level_key): +// [] (oosvar_level_key): +// [] (oosvar_level_key): +// x (oosvar_name). // 1 (strnum_literal). // 2 (strnum_literal). // 3 (field_name). @@ -1464,23 +1464,23 @@ lrec_evaluator_t* lrec_evaluator_alloc_from_moosvar_name(char* moosvar_name) { // 5 (strnum_literal). // // Here past is the =; pright is the 5; pleft is the string of bracket references -// ending at the moosvar name. +// ending at the oosvar name. -typedef struct _lrec_evaluator_moosvar_level_keys_state_t { - sllv_t* pmoosvar_rhs_keylist_evaluators; -} lrec_evaluator_moosvar_level_keys_state_t; +typedef struct _lrec_evaluator_oosvar_level_keys_state_t { + sllv_t* poosvar_rhs_keylist_evaluators; +} lrec_evaluator_oosvar_level_keys_state_t; -mv_t lrec_evaluator_moosvar_level_keys_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_oosvar_level_keys_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { - lrec_evaluator_moosvar_level_keys_state_t* pstate = pvstate; + lrec_evaluator_oosvar_level_keys_state_t* pstate = pvstate; sllmv_t* pmvkeys = sllmv_alloc(); int ok = TRUE; - for (sllve_t* pe = pstate->pmoosvar_rhs_keylist_evaluators->phead; pe != NULL; pe = pe->pnext) { + for (sllve_t* pe = pstate->poosvar_rhs_keylist_evaluators->phead; pe != NULL; pe = pe->pnext) { lrec_evaluator_t* pmvkey_evaluator = pe->pvvalue; mv_t mvkey = pmvkey_evaluator->pprocess_func(prec, ptyped_overlay, - pmoosvars, pregex_captures, pctx, pmvkey_evaluator->pvstate); + poosvars, pregex_captures, pctx, pmvkey_evaluator->pvstate); if (mv_is_null(&mvkey)) { ok = FALSE; break; @@ -1494,7 +1494,7 @@ mv_t lrec_evaluator_moosvar_level_keys_func(lrec_t* prec, lhmsv_t* ptyped_overla mv_t rv = MV_NULL; if (ok) { int error = 0; - mv_t* pval = mlhmmv_get(pmoosvars, pmvkeys, &error); + mv_t* pval = mlhmmv_get(poosvars, pmvkeys, &error); if (pval != NULL) rv = *pval; } @@ -1503,9 +1503,9 @@ mv_t lrec_evaluator_moosvar_level_keys_func(lrec_t* prec, lhmsv_t* ptyped_overla return rv; } -static void lrec_evaluator_moosvar_level_keys_free(lrec_evaluator_t* pevaluator) { - lrec_evaluator_moosvar_level_keys_state_t* pstate = pevaluator->pvstate; - for (sllve_t* pe = pstate->pmoosvar_rhs_keylist_evaluators->phead; pe != NULL; pe = pe->pnext) { +static void lrec_evaluator_oosvar_level_keys_free(lrec_evaluator_t* pevaluator) { + lrec_evaluator_oosvar_level_keys_state_t* pstate = pevaluator->pvstate; + for (sllve_t* pe = pstate->poosvar_rhs_keylist_evaluators->phead; pe != NULL; pe = pe->pnext) { lrec_evaluator_t* pevaluator = pe->pvvalue; pevaluator->pfree_func(pevaluator); } @@ -1514,19 +1514,19 @@ static void lrec_evaluator_moosvar_level_keys_free(lrec_evaluator_t* pevaluator) } // xxx temp! -lrec_evaluator_t* lrec_evaluator_alloc_from_moosvar_level_keys(mlr_dsl_ast_node_t* past) { - lrec_evaluator_moosvar_level_keys_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_evaluator_moosvar_level_keys_state_t)); +lrec_evaluator_t* lrec_evaluator_alloc_from_oosvar_level_keys(mlr_dsl_ast_node_t* past) { + lrec_evaluator_oosvar_level_keys_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_evaluator_oosvar_level_keys_state_t)); - sllv_t* pmoosvar_rhs_keylist_evaluators = sllv_alloc(); + sllv_t* poosvar_rhs_keylist_evaluators = sllv_alloc(); mlr_dsl_ast_node_t* pnode = past; while (TRUE) { // xxx rename pfoo - if (pnode->type == MD_AST_NODE_TYPE_MOOSVAR_LEVEL_KEY) { + if (pnode->type == MD_AST_NODE_TYPE_OOSVAR_LEVEL_KEY) { mlr_dsl_ast_node_t* pfoo = pnode->pchildren->phead->pnext->pvvalue; - sllv_add(pmoosvar_rhs_keylist_evaluators, + sllv_add(poosvar_rhs_keylist_evaluators, lrec_evaluator_alloc_from_ast(pfoo, TYPE_INFER_STRING_FLOAT_INT)); } else { - sllv_add(pmoosvar_rhs_keylist_evaluators, + sllv_add(poosvar_rhs_keylist_evaluators, // xxx big comment here. this is confusing. lrec_evaluator_alloc_from_strnum_literal(mlr_strdup_or_die(pnode->text), TYPE_INFER_STRING_ONLY)); } @@ -1535,16 +1535,16 @@ lrec_evaluator_t* lrec_evaluator_alloc_from_moosvar_level_keys(mlr_dsl_ast_node_ pnode = pnode->pchildren->phead->pvvalue; } // Bracket operators come in from the right. So the highest AST node is the rightmost - // map, and the lowest is the moosvar name. - sllv_reverse(pmoosvar_rhs_keylist_evaluators); + // map, and the lowest is the oosvar name. + sllv_reverse(poosvar_rhs_keylist_evaluators); // xxx just make an sllv_add_at_head function - pstate->pmoosvar_rhs_keylist_evaluators = pmoosvar_rhs_keylist_evaluators; + pstate->poosvar_rhs_keylist_evaluators = poosvar_rhs_keylist_evaluators; lrec_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(lrec_evaluator_t)); pevaluator->pvstate = pstate; pevaluator->pprocess_func = NULL; - pevaluator->pprocess_func = lrec_evaluator_moosvar_level_keys_func; - pevaluator->pfree_func = lrec_evaluator_moosvar_level_keys_free; + pevaluator->pprocess_func = lrec_evaluator_oosvar_level_keys_func; + pevaluator->pfree_func = lrec_evaluator_oosvar_level_keys_free; return pevaluator; } @@ -1554,14 +1554,14 @@ typedef struct _lrec_evaluator_strnum_literal_state_t { mv_t literal; } lrec_evaluator_strnum_literal_state_t; -mv_t lrec_evaluator_non_string_literal_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_non_string_literal_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_strnum_literal_state_t* pstate = pvstate; return pstate->literal; } -mv_t lrec_evaluator_string_literal_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_string_literal_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_strnum_literal_state_t* pstate = pvstate; @@ -1640,7 +1640,7 @@ typedef struct _lrec_evaluator_boolean_literal_state_t { mv_t literal; } lrec_evaluator_boolean_literal_state_t; -mv_t lrec_evaluator_boolean_literal_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_boolean_literal_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { lrec_evaluator_boolean_literal_state_t* pstate = pvstate; @@ -1675,7 +1675,7 @@ lrec_evaluator_t* lrec_evaluator_alloc_from_boolean_literal(char* string) { } // ================================================================ -mv_t lrec_evaluator_NF_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_NF_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { return mv_from_int(prec->field_count); @@ -1692,7 +1692,7 @@ lrec_evaluator_t* lrec_evaluator_alloc_from_NF() { } // ---------------------------------------------------------------- -mv_t lrec_evaluator_NR_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_NR_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { return mv_from_int(pctx->nr); @@ -1709,7 +1709,7 @@ lrec_evaluator_t* lrec_evaluator_alloc_from_NR() { } // ---------------------------------------------------------------- -mv_t lrec_evaluator_FNR_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_FNR_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { return mv_from_int(pctx->fnr); @@ -1726,7 +1726,7 @@ lrec_evaluator_t* lrec_evaluator_alloc_from_FNR() { } // ---------------------------------------------------------------- -mv_t lrec_evaluator_FILENAME_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_FILENAME_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { return mv_from_string_no_free(pctx->filename); @@ -1744,7 +1744,7 @@ lrec_evaluator_t* lrec_evaluator_alloc_from_FILENAME() { } // ---------------------------------------------------------------- -mv_t lrec_evaluator_FILENUM_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_FILENUM_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { return mv_from_int(pctx->filenum); @@ -1761,7 +1761,7 @@ lrec_evaluator_t* lrec_evaluator_alloc_from_FILENUM() { } // ---------------------------------------------------------------- -mv_t lrec_evaluator_PI_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_PI_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { return mv_from_float(M_PI); @@ -1778,7 +1778,7 @@ lrec_evaluator_t* lrec_evaluator_alloc_from_PI() { } // ---------------------------------------------------------------- -mv_t lrec_evaluator_E_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* pmoosvars, +mv_t lrec_evaluator_E_func(lrec_t* prec, lhmsv_t* ptyped_overlay, mlhmmv_t* poosvars, string_array_t* pregex_captures, context_t* pctx, void* pvstate) { return mv_from_float(M_E); @@ -2220,8 +2220,8 @@ static lrec_evaluator_t* lrec_evaluator_alloc_from_ast_aux(mlr_dsl_ast_node_t* p if (pnode->pchildren == NULL) { // leaf node if (pnode->type == MD_AST_NODE_TYPE_FIELD_NAME) { return lrec_evaluator_alloc_from_field_name(pnode->text, type_inferencing); - } else if (pnode->type == MD_AST_NODE_TYPE_MOOSVAR_NAME) { - return lrec_evaluator_alloc_from_moosvar_name(pnode->text); + } else if (pnode->type == MD_AST_NODE_TYPE_OOSVAR_NAME) { + return lrec_evaluator_alloc_from_oosvar_name(pnode->text); } else if (pnode->type == MD_AST_NODE_TYPE_STRNUM_LITERAL) { return lrec_evaluator_alloc_from_strnum_literal(pnode->text, type_inferencing); } else if (pnode->type == MD_AST_NODE_TYPE_BOOLEAN_LITERAL) { @@ -2236,8 +2236,8 @@ static lrec_evaluator_t* lrec_evaluator_alloc_from_ast_aux(mlr_dsl_ast_node_t* p exit(1); } - } else if (pnode->type == MD_AST_NODE_TYPE_MOOSVAR_LEVEL_KEY) { - return lrec_evaluator_alloc_from_moosvar_level_keys(pnode); + } else if (pnode->type == MD_AST_NODE_TYPE_OOSVAR_LEVEL_KEY) { + return lrec_evaluator_alloc_from_oosvar_level_keys(pnode); } else { // operator/function if ((pnode->type != MD_AST_NODE_TYPE_FUNCTION_NAME) @@ -2348,26 +2348,26 @@ static char * test1() { lrec_t* prec = lrec_unbacked_alloc(); lhmsv_t* ptyped_overlay = lhmsv_alloc(); - mlhmmv_t* pmoosvars = mlhmmv_alloc(); + mlhmmv_t* poosvars = mlhmmv_alloc(); string_array_t* pregex_captures = NULL; - mv_t val = pnr->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pnr->pvstate); + mv_t val = pnr->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pnr->pvstate); 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, pmoosvars, pregex_captures, pctx, pfnr->pvstate); + val = pfnr->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pfnr->pvstate); 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, pmoosvars, pregex_captures, pctx, pfilename->pvstate); + val = pfilename->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pfilename->pvstate); 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, pmoosvars, pregex_captures, pctx, pfilenum->pvstate); + val = pfilenum->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pfilenum->pvstate); 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); @@ -2390,36 +2390,36 @@ static char * test2() { lrec_t* prec = lrec_unbacked_alloc(); lhmsv_t* ptyped_overlay = lhmsv_alloc(); - mlhmmv_t* pmoosvars = mlhmmv_alloc(); + mlhmmv_t* poosvars = mlhmmv_alloc(); string_array_t* pregex_captures = NULL; 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, pmoosvars, pregex_captures, pctx, ps->pvstate); + mv_t val = ps->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, ps->pvstate); 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, pmoosvars, pregex_captures, pctx, pdef->pvstate); + val = pdef->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pdef->pvstate); 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, pmoosvars, pregex_captures, pctx, pdot->pvstate); + val = pdot->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pdot->pvstate); 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, pmoosvars, pregex_captures, pctx, ptolower->pvstate); + val = ptolower->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, ptolower->pvstate); 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, pmoosvars, pregex_captures, pctx, ptoupper->pvstate); + val = ptoupper->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, ptoupper->pvstate); 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); @@ -2453,16 +2453,16 @@ static char * test3() { lrec_t* prec = lrec_unbacked_alloc(); lhmsv_t* ptyped_overlay = lhmsv_alloc(); - mlhmmv_t* pmoosvars = mlhmmv_alloc(); + mlhmmv_t* poosvars = mlhmmv_alloc(); string_array_t* pregex_captures = NULL; lrec_put(prec, "x", "4.5", NO_FREE); - mv_t valp2 = p2->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, p2->pvstate); - mv_t valp4 = p4->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, p4->pvstate); - mv_t valpx = px->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, px->pvstate); - mv_t valpx2 = px2->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, px2->pvstate); - mv_t valplogx = plogx->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, plogx->pvstate); - mv_t valp2logx = p2logx->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, p2logx->pvstate); + 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); printf("lrec x = %s\n", lrec_get(prec, "x")); printf("newval 2 = %s\n", mv_describe_val(valp2)); @@ -2489,17 +2489,17 @@ static char * test3() { mlr_dsl_ast_node_print(p2logxnode); printf("newval AST = %s\n", - mv_describe_val(pastr->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, pastr->pvstate))); + mv_describe_val(pastr->pprocess_func(prec, ptyped_overlay, poosvars, pregex_captures, pctx, pastr->pvstate))); printf("\n"); lrec_rename(prec, "x", "y", FALSE); - valp2 = p2->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, p2->pvstate); - valp4 = p4->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, p4->pvstate); - valpx = px->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, px->pvstate); - valpx2 = px2->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, px2->pvstate); - valplogx = plogx->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, plogx->pvstate); - valp2logx = p2logx->pprocess_func(prec, ptyped_overlay, pmoosvars, pregex_captures, pctx, p2logx->pvstate); + 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); printf("lrec x = %s\n", lrec_get(prec, "x")); printf("newval 2 = %s\n", mv_describe_val(valp2)); diff --git a/c/mapping/lrec_evaluators.h b/c/mapping/lrec_evaluators.h index 22c22e3c4..6ae694bb6 100644 --- a/c/mapping/lrec_evaluators.h +++ b/c/mapping/lrec_evaluators.h @@ -9,7 +9,7 @@ #define TYPE_INFER_STRING_ONLY 0xce0a lrec_evaluator_t* lrec_evaluator_alloc_from_ast(mlr_dsl_ast_node_t* past, int type_inferencing); -lrec_evaluator_t* lrec_evaluator_alloc_from_moosvar_name(char* moosvar_name); // xxx still need this external? +lrec_evaluator_t* lrec_evaluator_alloc_from_oosvar_name(char* oosvar_name); // xxx still need this external? lrec_evaluator_t* lrec_evaluator_alloc_from_strnum_literal(char* string, int type_inferencing); void lrec_evaluator_list_functions(FILE* output_stream, char* leader); diff --git a/c/mapping/mapper_put.c b/c/mapping/mapper_put.c index 30a87ae4b..3d4259793 100644 --- a/c/mapping/mapper_put.c +++ b/c/mapping/mapper_put.c @@ -15,7 +15,7 @@ typedef struct _mapper_put_state_t { mlr_dsl_ast_t* past; mlr_dsl_cst_t* pcst; int at_begin; - mlhmmv_t* pmoosvars; + mlhmmv_t* poosvars; } mapper_put_state_t; static mapper_t* mapper_put_alloc(ap_state_t* pargp, mlr_dsl_ast_t* past, int type_inferencing); @@ -127,7 +127,7 @@ static mapper_t* mapper_put_alloc(ap_state_t* pargp, mlr_dsl_ast_t* past, int ty pstate->past = past; pstate->pcst = mlr_dsl_cst_alloc(past, type_inferencing); pstate->at_begin = TRUE; - pstate->pmoosvars = mlhmmv_alloc(); + pstate->poosvars = mlhmmv_alloc(); mapper_t* pmapper = mlr_malloc_or_die(sizeof(mapper_t)); pmapper->pvstate = (void*)pstate; @@ -140,7 +140,7 @@ static mapper_t* mapper_put_alloc(ap_state_t* pargp, mlr_dsl_ast_t* past, int ty static void mapper_put_free(mapper_t* pmapper) { mapper_put_state_t* pstate = pmapper->pvstate; - mlhmmv_free(pstate->pmoosvars); + mlhmmv_free(pstate->poosvars); mlr_dsl_cst_free(pstate->pcst); mlr_dsl_ast_free(pstate->past); @@ -271,7 +271,7 @@ static void evaluate_statements( char* output_field_name = pitem->output_field_name; lrec_evaluator_t* prhs_evaluator = pitem->prhs_evaluator; - mv_t val = prhs_evaluator->pprocess_func(pinrec, ptyped_overlay, pstate->pmoosvars, + mv_t val = prhs_evaluator->pprocess_func(pinrec, ptyped_overlay, pstate->poosvars, pregex_captures, pctx, prhs_evaluator->pvstate); mv_t* pval = mlr_malloc_or_die(sizeof(mv_t)); *pval = val; @@ -287,19 +287,19 @@ static void evaluate_statements( lhmsv_put(ptyped_overlay, output_field_name, pval, NO_FREE); lrec_put(pinrec, output_field_name, "bug", NO_FREE); - } else if (node_type == MD_AST_NODE_TYPE_MOOSVAR_ASSIGNMENT) { + } else if (node_type == MD_AST_NODE_TYPE_OOSVAR_ASSIGNMENT) { mlr_dsl_cst_statement_item_t* pitem = pstatement->pitems->phead->pvvalue; lrec_evaluator_t* prhs_evaluator = pitem->prhs_evaluator; mv_t rhs_value = prhs_evaluator->pprocess_func(pinrec, ptyped_overlay, - pstate->pmoosvars, pregex_captures, pctx, prhs_evaluator->pvstate); + pstate->poosvars, pregex_captures, pctx, prhs_evaluator->pvstate); sllmv_t* pmvkeys = sllmv_alloc(); int ok = TRUE; - for (sllve_t* pe = pitem->pmoosvar_lhs_keylist_evaluators->phead; pe != NULL; pe = pe->pnext) { + for (sllve_t* pe = pitem->poosvar_lhs_keylist_evaluators->phead; pe != NULL; pe = pe->pnext) { lrec_evaluator_t* pmvkey_evaluator = pe->pvvalue; mv_t mvkey = pmvkey_evaluator->pprocess_func(pinrec, ptyped_overlay, - pstate->pmoosvars, pregex_captures, pctx, pmvkey_evaluator->pvstate); + pstate->poosvars, pregex_captures, pctx, pmvkey_evaluator->pvstate); if (mv_is_null(&mvkey)) { ok = FALSE; break; @@ -311,7 +311,7 @@ static void evaluate_statements( // xxx move this null-check into mlhmmv.c? if (ok) - mlhmmv_put(pstate->pmoosvars, pmvkeys, &rhs_value); + mlhmmv_put(pstate->poosvars, pmvkeys, &rhs_value); sllmv_free(pmvkeys); @@ -324,7 +324,7 @@ static void evaluate_statements( // xxx 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 output_field_name here. - mv_t val = prhs_evaluator->pprocess_func(pinrec, ptyped_overlay, pstate->pmoosvars, + mv_t val = prhs_evaluator->pprocess_func(pinrec, ptyped_overlay, pstate->poosvars, pregex_captures, pctx, prhs_evaluator->pvstate); if (val.type == MT_STRING) { @@ -339,13 +339,13 @@ static void evaluate_statements( sllv_add(poutrecs, prec_to_emit); } else if (node_type == MD_AST_NODE_TYPE_DUMP) { - mlhmmv_print(pstate->pmoosvars); + mlhmmv_print(pstate->poosvars); } else if (node_type == MD_AST_NODE_TYPE_FILTER) { mlr_dsl_cst_statement_item_t* pitem = pstatement->pitems->phead->pvvalue; lrec_evaluator_t* prhs_evaluator = pitem->prhs_evaluator; - mv_t val = prhs_evaluator->pprocess_func(pinrec, ptyped_overlay, pstate->pmoosvars, + mv_t val = prhs_evaluator->pprocess_func(pinrec, ptyped_overlay, pstate->poosvars, pregex_captures, pctx, prhs_evaluator->pvstate); if (val.type != MT_NULL) { mv_set_boolean_strict(&val); @@ -359,7 +359,7 @@ static void evaluate_statements( mlr_dsl_cst_statement_item_t* pitem = pstatement->pitems->phead->pvvalue; lrec_evaluator_t* prhs_evaluator = pitem->prhs_evaluator; - mv_t val = prhs_evaluator->pprocess_func(pinrec, ptyped_overlay, pstate->pmoosvars, + mv_t val = prhs_evaluator->pprocess_func(pinrec, ptyped_overlay, pstate->poosvars, pregex_captures, pctx, prhs_evaluator->pvstate); if (val.type == MT_NULL) break; @@ -372,7 +372,7 @@ static void evaluate_statements( mlr_dsl_cst_statement_item_t* pitem = pstatement->pitems->phead->pvvalue; lrec_evaluator_t* prhs_evaluator = pitem->prhs_evaluator; - mv_t val = prhs_evaluator->pprocess_func(pinrec, ptyped_overlay, pstate->pmoosvars, + mv_t val = prhs_evaluator->pprocess_func(pinrec, ptyped_overlay, pstate->poosvars, pregex_captures, pctx, prhs_evaluator->pvstate); if (val.type != MT_NULL) mv_set_boolean_strict(&val); diff --git a/c/mapping/mlr_dsl_cst.c b/c/mapping/mlr_dsl_cst.c index 80e3423da..ba69438bf 100644 --- a/c/mapping/mlr_dsl_cst.c +++ b/c/mapping/mlr_dsl_cst.c @@ -9,7 +9,7 @@ static void cst_statement_free(mlr_dsl_cst_statement_t* pstatement); static mlr_dsl_cst_statement_item_t* mlr_dsl_cst_statement_item_alloc( int lhs_type, char* output_field_name, - sllv_t* pmoosvar_lhs_keylist_evaluators, + sllv_t* poosvar_lhs_keylist_evaluators, lrec_evaluator_t* prhs_evaluator); static void cst_statement_item_free(mlr_dsl_cst_statement_item_t* pitem); @@ -116,20 +116,20 @@ static mlr_dsl_cst_statement_t* cst_statement_alloc(mlr_dsl_ast_node_t* past, in NULL, lrec_evaluator_alloc_from_ast(pright, type_inferencing))); - } else if (past->type == MD_AST_NODE_TYPE_MOOSVAR_ASSIGNMENT) { - sllv_t* pmoosvar_lhs_keylist_evaluators = sllv_alloc(); + } else if (past->type == MD_AST_NODE_TYPE_OOSVAR_ASSIGNMENT) { + sllv_t* poosvar_lhs_keylist_evaluators = sllv_alloc(); mlr_dsl_ast_node_t* pleft = past->pchildren->phead->pvvalue; mlr_dsl_ast_node_t* pright = past->pchildren->phead->pnext->pvvalue; - if (pleft->type != MD_AST_NODE_TYPE_MOOSVAR_NAME && pleft->type != MD_AST_NODE_TYPE_MOOSVAR_LEVEL_KEY) { + if (pleft->type != MD_AST_NODE_TYPE_OOSVAR_NAME && pleft->type != MD_AST_NODE_TYPE_OOSVAR_LEVEL_KEY) { fprintf(stderr, "%s: internal coding error detected in file %s at line %d.\n", MLR_GLOBALS.argv0, __FILE__, __LINE__); exit(1); } - if (pleft->type == MD_AST_NODE_TYPE_MOOSVAR_NAME) { - sllv_add(pmoosvar_lhs_keylist_evaluators, + if (pleft->type == MD_AST_NODE_TYPE_OOSVAR_NAME) { + sllv_add(poosvar_lhs_keylist_evaluators, // xxx need a version with no regex-captures. lrec_evaluator_alloc_from_strnum_literal(mlr_strdup_or_die(pleft->text), TYPE_INFER_STRING_ONLY)); } else { @@ -139,12 +139,12 @@ static mlr_dsl_cst_statement_t* cst_statement_alloc(mlr_dsl_ast_node_t* past, in // Example AST: // % mlr put -v 'begin{@@x[1]["2"][$3][@4]=5}' /dev/null // AST BEGIN STATEMENTS (1): - // = (moosvar_assignment): - // [] (moosvar_level_key): - // [] (moosvar_level_key): - // [] (moosvar_level_key): - // [] (moosvar_level_key): - // x (moosvar_name). + // = (oosvar_assignment): + // [] (oosvar_level_key): + // [] (oosvar_level_key): + // [] (oosvar_level_key): + // [] (oosvar_level_key): + // x (oosvar_name). // 1 (strnum_literal). // 2 (strnum_literal). // 3 (field_name). @@ -152,15 +152,15 @@ static mlr_dsl_cst_statement_t* cst_statement_alloc(mlr_dsl_ast_node_t* past, in // 5 (strnum_literal). // // Here past is the =; pright is the 5; pleft is the string of bracket references - // ending at the moosvar name. + // ending at the oosvar name. // xxx rename pfoo - if (pnode->type == MD_AST_NODE_TYPE_MOOSVAR_LEVEL_KEY) { + if (pnode->type == MD_AST_NODE_TYPE_OOSVAR_LEVEL_KEY) { mlr_dsl_ast_node_t* pfoo = pnode->pchildren->phead->pnext->pvvalue; - sllv_add(pmoosvar_lhs_keylist_evaluators, + sllv_add(poosvar_lhs_keylist_evaluators, lrec_evaluator_alloc_from_ast(pfoo, type_inferencing)); } else { - sllv_add(pmoosvar_lhs_keylist_evaluators, + sllv_add(poosvar_lhs_keylist_evaluators, // xxx big comment here. this is confusing. lrec_evaluator_alloc_from_strnum_literal(mlr_strdup_or_die(pnode->text), TYPE_INFER_STRING_ONLY)); } @@ -169,15 +169,15 @@ static mlr_dsl_cst_statement_t* cst_statement_alloc(mlr_dsl_ast_node_t* past, in pnode = pnode->pchildren->phead->pvvalue; } // Bracket operators come in from the right. So the highest AST node is the rightmost - // map, and the lowest is the moosvar name. - sllv_reverse(pmoosvar_lhs_keylist_evaluators); + // map, and the lowest is the oosvar name. + sllv_reverse(poosvar_lhs_keylist_evaluators); // xxx just make an sllv_add_at_head function } sllv_add(pstatement->pitems, mlr_dsl_cst_statement_item_alloc( - MLR_DSL_CST_LHS_TYPE_MOOSVAR, + MLR_DSL_CST_LHS_TYPE_OOSVAR, NULL, - pmoosvar_lhs_keylist_evaluators, + poosvar_lhs_keylist_evaluators, lrec_evaluator_alloc_from_ast(pright, type_inferencing))); } else if (past->type == MD_AST_NODE_TYPE_FILTER) { @@ -201,7 +201,7 @@ static mlr_dsl_cst_statement_t* cst_statement_alloc(mlr_dsl_ast_node_t* past, in for (sllve_t* pe = past->pchildren->phead; pe != NULL; pe = pe->pnext) { mlr_dsl_ast_node_t* pnode = pe->pvvalue; sllv_add(pstatement->pitems, mlr_dsl_cst_statement_item_alloc( - MLR_DSL_CST_LHS_TYPE_MOOSVAR, + MLR_DSL_CST_LHS_TYPE_OOSVAR, pnode->text, NULL, lrec_evaluator_alloc_from_ast(pnode, type_inferencing))); @@ -232,13 +232,13 @@ static void cst_statement_free(mlr_dsl_cst_statement_t* pstatement) { static mlr_dsl_cst_statement_item_t* mlr_dsl_cst_statement_item_alloc( int lhs_type, char* output_field_name, - sllv_t* pmoosvar_lhs_keylist_evaluators, + sllv_t* poosvar_lhs_keylist_evaluators, lrec_evaluator_t* prhs_evaluator) { mlr_dsl_cst_statement_item_t* pitem = mlr_malloc_or_die(sizeof(mlr_dsl_cst_statement_item_t)); pitem->lhs_type = lhs_type; pitem->output_field_name = output_field_name == NULL ? NULL : mlr_strdup_or_die(output_field_name); - pitem->pmoosvar_lhs_keylist_evaluators = pmoosvar_lhs_keylist_evaluators; + pitem->poosvar_lhs_keylist_evaluators = poosvar_lhs_keylist_evaluators; pitem->prhs_evaluator = prhs_evaluator; return pitem; } @@ -248,12 +248,12 @@ static void cst_statement_item_free(mlr_dsl_cst_statement_item_t* pitem) { return; free(pitem->output_field_name); pitem->prhs_evaluator->pfree_func(pitem->prhs_evaluator); - if (pitem->pmoosvar_lhs_keylist_evaluators != NULL) { - for (sllve_t* pe = pitem->pmoosvar_lhs_keylist_evaluators->phead; pe != NULL; pe = pe->pnext) { + if (pitem->poosvar_lhs_keylist_evaluators != NULL) { + for (sllve_t* pe = pitem->poosvar_lhs_keylist_evaluators->phead; pe != NULL; pe = pe->pnext) { lrec_evaluator_t* pevaluator = pe->pvvalue; pevaluator->pfree_func(pevaluator); } - sllv_free(pitem->pmoosvar_lhs_keylist_evaluators); + sllv_free(pitem->poosvar_lhs_keylist_evaluators); } free(pitem); } diff --git a/c/mapping/mlr_dsl_cst.h b/c/mapping/mlr_dsl_cst.h index 22648df8c..8ad5a1964 100644 --- a/c/mapping/mlr_dsl_cst.h +++ b/c/mapping/mlr_dsl_cst.h @@ -40,13 +40,13 @@ #define MLR_DSL_CST_LHS_TYPE_NONE 0xdc33 #define MLR_DSL_CST_LHS_TYPE_SREC 0xdc55 -#define MLR_DSL_CST_LHS_TYPE_MOOSVAR 0xdcaa +#define MLR_DSL_CST_LHS_TYPE_OOSVAR 0xdcaa typedef struct _mlr_dsl_cst_statement_item_t { // LHS: int lhs_type; char* output_field_name; - sllv_t* pmoosvar_lhs_keylist_evaluators; + sllv_t* poosvar_lhs_keylist_evaluators; // RHS: lrec_evaluator_t* prhs_evaluator; diff --git a/c/reg_test/expected/out b/c/reg_test/expected/out index 66fd538dc..b8616bd09 100644 --- a/c/reg_test/expected/out +++ b/c/reg_test/expected/out @@ -11909,22 +11909,22 @@ mean ================================================================ DSL EXPERIMENTAL MOOSVARS -mlr put -v begin{ @@a = @@b[1] }; $c = @@d; @@e[$i][2+$j][3] = $4; end @@f[@@g[5][@@h]] = 6 /dev/null +mlr put -v begin{ @a = @b[1] }; $c = @d; @e[$i][2+$j][3] = $4; end @f[@g[5][@h]] = 6 /dev/null AST BEGIN STATEMENTS (1): -= (moosvar_assignment): - a (moosvar_name). - [] (moosvar_level_key): - b (moosvar_name). += (oosvar_assignment): + a (oosvar_name). + [] (oosvar_level_key): + b (oosvar_name). 1 (strnum_literal). AST MAIN STATEMENTS (2): = (srec_assignment): c (field_name). - d (moosvar_name). -= (moosvar_assignment): - [] (moosvar_level_key): - [] (moosvar_level_key): - [] (moosvar_level_key): - e (moosvar_name). + d (oosvar_name). += (oosvar_assignment): + [] (oosvar_level_key): + [] (oosvar_level_key): + [] (oosvar_level_key): + e (oosvar_name). i (field_name). + (operator): 2 (strnum_literal). @@ -11932,17 +11932,17 @@ AST MAIN STATEMENTS (2): 3 (strnum_literal). 4 (field_name). AST END STATEMENTS (1): -= (moosvar_assignment): - [] (moosvar_level_key): - f (moosvar_name). - [] (moosvar_level_key): - [] (moosvar_level_key): - g (moosvar_name). += (oosvar_assignment): + [] (oosvar_level_key): + f (oosvar_name). + [] (oosvar_level_key): + [] (oosvar_level_key): + g (oosvar_name). 5 (strnum_literal). - h (moosvar_name). + h (oosvar_name). 6 (strnum_literal). -mlr put @@y[$a]=$y; end dump ./reg_test/input/abixy +mlr put @y[$a]=$y; end dump ./reg_test/input/abixy a=pan,b=pan,i=1,x=0.3467901443380824,y=0.7268028627434533 a=eks,b=pan,i=2,x=0.7586799647899636,y=0.5221511083334797 a=wye,b=wye,i=3,x=0.20460330576630303,y=0.33831852551664776 @@ -11970,7 +11970,7 @@ a=wye,y_sum=1.201943 a=zee,y_sum=1.469403 a=hat,y_sum=0.749551 -mlr put @@y_sum[$a] = $y; end dump ./reg_test/input/abixy +mlr put @y_sum[$a] = $y; end dump ./reg_test/input/abixy a=pan,b=pan,i=1,x=0.3467901443380824,y=0.7268028627434533 a=eks,b=pan,i=2,x=0.7586799647899636,y=0.5221511083334797 a=wye,b=wye,i=3,x=0.20460330576630303,y=0.33831852551664776