Mirrors/miller
1
0
Fork 0
mirror of https://github.com/johnkerl/miller.git synced 2026-07-20 18:10:07 +00:00
Code Issues Projects Releases Wiki Activity

moosvars -> oosvars: fully functional replacement/extension

Browse source
This commit is contained in:
John Kerl 2016-01-29 19:25:10 -05:00
parent 291646f9fa
commit a4ea7f08f0
11 changed files with 273 additions and 274 deletions
Download patch file Download diff file Expand all files Collapse all files

6
c/containers/mlr_dsl_ast.c
View file

@ -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;

32
c/containers/mlr_dsl_ast.h
View file

@ -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;

9
c/dsls/mlr_dsl_lexer.l
View file

@ -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);

50
c/dsls/mlr_dsl_parse.y
View file

@ -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];

2
c/mapping/lrec_evaluator.h
View file

@ -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*);

322
c/mapping/lrec_evaluators.c
View file

@ -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));

2
c/mapping/lrec_evaluators.h
View file

@ -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);

28
c/mapping/mapper_put.c
View file

@ -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);

52
c/mapping/mlr_dsl_cst.c
View file

@ -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);
}

4
c/mapping/mlr_dsl_cst.h
View file

@ -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;

40
c/reg_test/expected/out
View file

@ -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