Mirrors/miller
1
0
Fork 0
mirror of https://github.com/johnkerl/miller.git synced 2026-07-22 15:37:59 +00:00
Code Issues Projects Releases Wiki Activity

xval hygiene (build-break)

Browse source
This commit is contained in:
John Kerl 2016-11-16 13:01:18 -05:00
parent a3509e22e3
commit 2314e73174
8 changed files with 63 additions and 139 deletions
Download patch file Download diff file Expand all files Collapse all files

36
c/containers/local_stack.c
View file

@ -179,6 +179,32 @@ void local_stack_frame_assign_map(local_stack_frame_t* pframe,
LOCAL_STACK_TRACE(mlhmmv_level_print_stacked(pmvalue->pnext_level, 0, TRUE, TRUE, "", stdout));
}
void local_stack_frame_xassign_map(local_stack_frame_t* pframe, // xxx rename
int vardef_frame_relative_index, sllmv_t* pmvkeys,
mlhmmv_value_t new_value) // xxx by ptr
{
LOCAL_STACK_TRACE(printf("LOCAL STACK FRAME %p SET %d\n", pframe, vardef_frame_relative_index));
LOCAL_STACK_BOUNDS_CHECK(pframe, "ASSIGN", TRUE, vardef_frame_relative_index);
local_stack_frame_entry_t* pentry = &pframe->pvars[vardef_frame_relative_index];
if (!(TYPE_MASK_MAP & pentry->type_mask)) {
local_stack_frame_throw_type_xmismatch(pentry, &new_value);
}
mlhmmv_value_t* pmvalue = &pentry->value;
// xxx encapsulate
if (pmvalue->is_terminal) {
mv_free(&pmvalue->mlrval);
pmvalue->is_terminal = FALSE;
pmvalue->pnext_level = mlhmmv_level_alloc();
}
mlhmmv_put_value_at_level_aux(pmvalue->pnext_level, pmvkeys->phead, &new_value);
LOCAL_STACK_TRACE(printf("VALUE IS:\n"));
LOCAL_STACK_TRACE(mlhmmv_level_print_stacked(pmvalue->pnext_level, 0, TRUE, TRUE, "", stdout));
}
// ----------------------------------------------------------------
static int local_stack_bounds_check_announce_first_call = TRUE;
@ -214,3 +240,13 @@ void local_stack_frame_throw_type_mismatch(local_stack_frame_entry_t* pentry, mv
free(sval);
exit(1);
}
void local_stack_frame_throw_type_xmismatch(local_stack_frame_entry_t* pentry, mlhmmv_value_t* pxval) {
MLR_INTERNAL_CODING_ERROR_IF(pentry->name == NULL);
char* sval = mv_alloc_format_val_quoting_strings(&pxval->mlrval); // xxx temp
fprintf(stderr, "%s: %s type assertion for variable %s unmet by value %s with type %s.\n",
MLR_GLOBALS.bargv0, type_mask_to_desc(pentry->type_mask), pentry->name,
sval, mt_describe_type_simple(pxval->mlrval.type)); // xxx temp -- needs xtype
free(sval);
exit(1);
}

3
c/containers/local_stack.h
View file

@ -83,6 +83,7 @@ void local_stack_bounds_check(local_stack_frame_t* pframe, char* op, int set, in
local_stack_frame_t* local_stack_frame_enter(local_stack_frame_t* pframe);
void local_stack_frame_exit(local_stack_frame_t* pframe);
void local_stack_frame_throw_type_mismatch(local_stack_frame_entry_t* pentry, mv_t* pval);
void local_stack_frame_throw_type_xmismatch(local_stack_frame_entry_t* pentry, mlhmmv_value_t* pxval); // xxx temp
// ----------------------------------------------------------------
static inline mv_t local_stack_frame_get_non_map(local_stack_frame_t* pframe,
@ -207,7 +208,7 @@ void local_stack_frame_assign_map(local_stack_frame_t* pframe,
void local_stack_frame_xassign_map(local_stack_frame_t* pframe, // xxx rename
int vardef_frame_relative_index, sllmv_t* pmvkeys,
mv_t terminal_value);
mlhmmv_value_t terminal_value);
// ----------------------------------------------------------------
// Frames are entered/exited for each curly-braced statement block, including

129
c/mapping/mlr_dsl_cst_assignment_statements.c
View file

@ -168,11 +168,9 @@ typedef struct _local_variable_definition_state_t {
char* lhs_variable_name;
int lhs_frame_relative_index;
int lhs_type_mask;
rval_evaluator_t* prhs_evaluator;
rxval_evaluator_t* prhs_xevaluator;
} local_variable_definition_state_t;
static mlr_dsl_cst_statement_handler_t handle_local_variable_definition_from_val;
static mlr_dsl_cst_statement_handler_t handle_local_variable_definition_from_xval;
static mlr_dsl_cst_statement_freer_t free_local_variable_definition;
@ -190,7 +188,6 @@ mlr_dsl_cst_statement_t* alloc_local_variable_definition(
pstate->lhs_variable_name = NULL;
pstate->lhs_frame_relative_index = MD_UNUSED_INDEX;
pstate->lhs_type_mask = 0;
pstate->prhs_evaluator = NULL;
pstate->prhs_xevaluator = NULL;
mlr_dsl_ast_node_t* pname_node = pnode->pchildren->phead->pvvalue;
@ -202,14 +199,9 @@ mlr_dsl_cst_statement_t* alloc_local_variable_definition(
mlr_dsl_cst_statement_handler_t* pstatement_handler = NULL;
mlr_dsl_ast_node_t* prhs_node = pnode->pchildren->phead->pnext->pvvalue;
pstate->prhs_xevaluator = rxval_evaluator_pure_alloc_from_ast(
pstate->prhs_xevaluator = rxval_evaluator_alloc_from_astx( // xxx rename
prhs_node, pcst->pfmgr, type_inferencing, context_flags);
if (pstate->prhs_xevaluator != NULL) {
pstatement_handler = handle_local_variable_definition_from_xval;
} else {
pstate->prhs_evaluator = rval_evaluator_alloc_from_ast(prhs_node, pcst->pfmgr, type_inferencing, context_flags);
pstatement_handler = handle_local_variable_definition_from_val;
}
pstatement_handler = handle_local_variable_definition_from_xval;
return mlr_dsl_cst_statement_valloc(
pnode,
@ -222,30 +214,11 @@ mlr_dsl_cst_statement_t* alloc_local_variable_definition(
static void free_local_variable_definition(mlr_dsl_cst_statement_t* pstatement) {
local_variable_definition_state_t* pstate = pstatement->pvstate;
if (pstate->prhs_evaluator != NULL) {
pstate->prhs_evaluator->pfree_func(pstate->prhs_evaluator);
}
pstate->prhs_xevaluator->pfree_func(pstate->prhs_xevaluator);
free(pstate);
}
// ----------------------------------------------------------------
static void handle_local_variable_definition_from_val( // xxx mapvar
mlr_dsl_cst_statement_t* pstatement,
variables_t* pvars,
cst_outputs_t* pcst_outputs)
{
local_variable_definition_state_t* pstate = pstatement->pvstate;
rval_evaluator_t* prhs_evaluator = pstate->prhs_evaluator;
mv_t val = prhs_evaluator->pprocess_func(prhs_evaluator->pvstate, pvars);
local_stack_frame_t* pframe = local_stack_get_top_frame(pvars->plocal_stack);
local_stack_frame_define(pframe,
pstate->lhs_variable_name, pstate->lhs_frame_relative_index,
pstate->lhs_type_mask, val);
}
// ----------------------------------------------------------------
static void handle_local_variable_definition_from_xval( // xxx mapvar
mlr_dsl_cst_statement_t* pstatement,
@ -267,11 +240,9 @@ static void handle_local_variable_definition_from_xval( // xxx mapvar
typedef struct _nonindexed_local_variable_assignment_state_t {
char* lhs_variable_name; // For error messages only: stack-index is computed by stack-allocator:
int lhs_frame_relative_index;
rval_evaluator_t* prhs_evaluator;
rxval_evaluator_t* prhs_xevaluator;
} nonindexed_local_variable_assignment_state_t;
static mlr_dsl_cst_statement_handler_t handle_nonindexed_local_variable_assignment_from_val;
static mlr_dsl_cst_statement_handler_t handle_nonindexed_local_variable_assignment_from_xval;
static mlr_dsl_cst_statement_freer_t free_nonindexed_local_variable_assignment;
@ -284,7 +255,6 @@ mlr_dsl_cst_statement_t* alloc_nonindexed_local_variable_assignment(mlr_dsl_cst_
pstate->lhs_variable_name = NULL;
pstate->lhs_frame_relative_index = MD_UNUSED_INDEX;
pstate->prhs_evaluator = NULL;
pstate->prhs_xevaluator = NULL;
MLR_INTERNAL_CODING_ERROR_IF((pnode->pchildren == NULL) || (pnode->pchildren->length != 2));
@ -301,14 +271,9 @@ mlr_dsl_cst_statement_t* alloc_nonindexed_local_variable_assignment(mlr_dsl_cst_
mlr_dsl_cst_statement_handler_t* pstatement_handler = NULL;
pstate->prhs_xevaluator = rxval_evaluator_pure_alloc_from_ast(
pstate->prhs_xevaluator = rxval_evaluator_alloc_from_astx( // xxx rename
prhs_node, pcst->pfmgr, type_inferencing, context_flags);
if (pstate->prhs_xevaluator != NULL) {
pstatement_handler = handle_nonindexed_local_variable_assignment_from_xval;
} else {
pstate->prhs_evaluator = rval_evaluator_alloc_from_ast(prhs_node, pcst->pfmgr, type_inferencing, context_flags);
pstatement_handler = handle_nonindexed_local_variable_assignment_from_val;
}
pstatement_handler = handle_nonindexed_local_variable_assignment_from_xval;
return mlr_dsl_cst_statement_valloc(
pnode,
@ -321,9 +286,6 @@ mlr_dsl_cst_statement_t* alloc_nonindexed_local_variable_assignment(mlr_dsl_cst_
static void free_nonindexed_local_variable_assignment(mlr_dsl_cst_statement_t* pstatement) {
nonindexed_local_variable_assignment_state_t* pstate = pstatement->pvstate;
if (pstate->prhs_evaluator != NULL) {
pstate->prhs_evaluator->pfree_func(pstate->prhs_evaluator);
}
if (pstate->prhs_xevaluator != NULL) {
pstate->prhs_xevaluator->pfree_func(pstate->prhs_xevaluator);
}
@ -331,26 +293,6 @@ static void free_nonindexed_local_variable_assignment(mlr_dsl_cst_statement_t* p
free(pstate);
}
// ----------------------------------------------------------------
static void handle_nonindexed_local_variable_assignment_from_val(
mlr_dsl_cst_statement_t* pstatement,
variables_t* pvars,
cst_outputs_t* pcst_outputs)
{
nonindexed_local_variable_assignment_state_t* pstate = pstatement->pvstate;
rval_evaluator_t* prhs_evaluator = pstate->prhs_evaluator;
mv_t val = prhs_evaluator->pprocess_func(prhs_evaluator->pvstate, pvars);
if (mv_is_present(&val)) {
local_stack_frame_t* pframe = local_stack_get_top_frame(pvars->plocal_stack);
local_stack_frame_assign_non_map(pframe,
pstate->lhs_frame_relative_index, val);
} else {
mv_free(&val);
}
}
// ----------------------------------------------------------------
static void handle_nonindexed_local_variable_assignment_from_xval(
mlr_dsl_cst_statement_t* pstatement,
@ -375,11 +317,9 @@ typedef struct _indexed_local_variable_assignment_state_t {
char* lhs_variable_name; // For error messages only: stack-index is computed by stack-allocator:
int lhs_frame_relative_index;
sllv_t* plhs_keylist_evaluators;
rval_evaluator_t* prhs_evaluator;
rxval_evaluator_t* prhs_xevaluator;
} indexed_local_variable_assignment_state_t;
static mlr_dsl_cst_statement_handler_t handle_indexed_local_variable_assignment_from_val;
static mlr_dsl_cst_statement_handler_t handle_indexed_local_variable_assignment_from_xval;
static mlr_dsl_cst_statement_freer_t free_indexed_local_variable_assignment;
@ -392,7 +332,6 @@ mlr_dsl_cst_statement_t* alloc_indexed_local_variable_assignment(mlr_dsl_cst_t*
pstate->lhs_variable_name = NULL;
pstate->lhs_frame_relative_index = MD_UNUSED_INDEX;
pstate->prhs_evaluator = NULL;
pstate->prhs_xevaluator = NULL;
mlr_dsl_ast_node_t* plhs_node = pnode->pchildren->phead->pvvalue;
@ -410,14 +349,9 @@ mlr_dsl_cst_statement_t* alloc_indexed_local_variable_assignment(mlr_dsl_cst_t*
mlr_dsl_cst_statement_handler_t* pstatement_handler = NULL;
pstate->prhs_xevaluator = rxval_evaluator_pure_alloc_from_ast(
pstate->prhs_xevaluator = rxval_evaluator_alloc_from_astx(
prhs_node, pcst->pfmgr, type_inferencing, context_flags);
if (pstate->prhs_xevaluator != NULL) {
pstatement_handler = handle_indexed_local_variable_assignment_from_xval;
} else {
pstate->prhs_evaluator = rval_evaluator_alloc_from_ast(prhs_node, pcst->pfmgr, type_inferencing, context_flags);
pstatement_handler = handle_indexed_local_variable_assignment_from_val;
}
pstatement_handler = handle_indexed_local_variable_assignment_from_xval;
return mlr_dsl_cst_statement_valloc(
pnode,
@ -435,42 +369,11 @@ static void free_indexed_local_variable_assignment(mlr_dsl_cst_statement_t* psta
pev->pfree_func(pev);
}
if (pstate->prhs_evaluator != NULL) {
pstate->prhs_evaluator->pfree_func(pstate->prhs_evaluator);
}
if (pstate->prhs_xevaluator != NULL) {
pstate->prhs_xevaluator->pfree_func(pstate->prhs_xevaluator);
}
pstate->prhs_xevaluator->pfree_func(pstate->prhs_xevaluator);
free(pstate);
}
// ----------------------------------------------------------------
static void handle_indexed_local_variable_assignment_from_val(
mlr_dsl_cst_statement_t* pstatement,
variables_t* pvars,
cst_outputs_t* pcst_outputs)
{
indexed_local_variable_assignment_state_t* pstate = pstatement->pvstate;
rval_evaluator_t* prhs_evaluator = pstate->prhs_evaluator;
mv_t rhs_value = prhs_evaluator->pprocess_func(prhs_evaluator->pvstate, pvars);
if (mv_is_present(&rhs_value)) {
int all_non_null_or_error = TRUE;
sllmv_t* pmvkeys = evaluate_list(pstate->plhs_keylist_evaluators, pvars,
&all_non_null_or_error);
if (all_non_null_or_error) {
local_stack_frame_t* pframe = local_stack_get_top_frame(pvars->plocal_stack);
local_stack_frame_assign_map(pframe, pstate->lhs_frame_relative_index, pmvkeys, rhs_value);
}
sllmv_free(pmvkeys);
} else {
mv_free(&rhs_value);
}
}
// ----------------------------------------------------------------
static void handle_indexed_local_variable_assignment_from_xval(
mlr_dsl_cst_statement_t* pstatement,
@ -478,23 +381,21 @@ static void handle_indexed_local_variable_assignment_from_xval(
cst_outputs_t* pcst_outputs)
{
indexed_local_variable_assignment_state_t* pstate = pstatement->pvstate;
// xxx
rval_evaluator_t* prhs_evaluator = pstate->prhs_evaluator;
mv_t rhs_value = prhs_evaluator->pprocess_func(prhs_evaluator->pvstate, pvars);
if (mv_is_present(&rhs_value)) {
rxval_evaluator_t* prhs_xevaluator = pstate->prhs_xevaluator;
mlhmmv_value_t rhs_xvalue = prhs_xevaluator->pprocess_func(prhs_xevaluator->pvstate, pvars);
if (!rhs_xvalue.is_terminal || mv_is_present(&rhs_xvalue.mlrval)) {
int all_non_null_or_error = TRUE;
sllmv_t* pmvkeys = evaluate_list(pstate->plhs_keylist_evaluators, pvars,
&all_non_null_or_error);
if (all_non_null_or_error) {
local_stack_frame_t* pframe = local_stack_get_top_frame(pvars->plocal_stack);
local_stack_frame_assign_map(pframe, pstate->lhs_frame_relative_index, pmvkeys, rhs_value);
local_stack_frame_xassign_map(pframe, pstate->lhs_frame_relative_index, pmvkeys, rhs_xvalue);
}
sllmv_free(pmvkeys);
} else {
mv_free(&rhs_value);
mlhmmv_free_submap(rhs_xvalue);
}
}
@ -535,7 +436,7 @@ mlr_dsl_cst_statement_t* alloc_oosvar_assignment(mlr_dsl_cst_t* pcst, mlr_dsl_as
mlr_dsl_cst_statement_handler_t* pstatement_handler = NULL;
pstate->prhs_xevaluator = rxval_evaluator_pure_alloc_from_ast( // xxx search for others needing 'pure'
pstate->prhs_xevaluator = rxval_evaluator_alloc_from_astx(
prhs_node, pcst->pfmgr, type_inferencing, context_flags);
if (pstate->prhs_xevaluator != NULL) {
pstatement_handler = handle_oosvar_assignment_from_xval;
@ -732,7 +633,7 @@ mlr_dsl_cst_statement_t* alloc_full_srec_assignment(mlr_dsl_cst_t* pcst, mlr_dsl
pstate->prhs_xevaluator = NULL;
phandler = handle_full_srec_assignment_nop;
} else {
pstate->prhs_xevaluator = rxval_evaluator_alloc_from_ast(
pstate->prhs_xevaluator = rxval_evaluator_alloc_from_astx(
prhs_node, pcst->pfmgr, type_inferencing, context_flags);
phandler = handle_full_srec_assignment;
}

4
c/mapping/mlr_dsl_cst_for_map_statements.c
View file

@ -817,7 +817,7 @@ mlr_dsl_cst_statement_t* alloc_for_map_literal(mlr_dsl_cst_t* pcst, mlr_dsl_ast_
pstate->v_type_mask = mlr_dsl_ast_node_type_to_type_mask(psubright->type);
// xxx comment liberally
pstate->ptarget_xevaluator = rxval_evaluator_pure_alloc_from_ast(
pstate->ptarget_xevaluator = rxval_evaluator_alloc_from_astx(
pmiddle, pcst->pfmgr, type_inferencing, context_flags);
MLR_INTERNAL_CODING_ERROR_IF(pnode->subframe_var_count == MD_UNUSED_INDEX);
@ -1000,7 +1000,7 @@ mlr_dsl_cst_statement_t* alloc_for_map_literal_key_only(mlr_dsl_cst_t* pcst, mlr
pstate->k_frame_relative_index = pleft->vardef_frame_relative_index;
pstate->k_type_mask = mlr_dsl_ast_node_type_to_type_mask(pleft->type);
pstate->ptarget_xevaluator = rxval_evaluator_pure_alloc_from_ast(
pstate->ptarget_xevaluator = rxval_evaluator_alloc_from_astx(
pmiddle, pcst->pfmgr, type_inferencing, context_flags);
MLR_INTERNAL_CODING_ERROR_IF(pnode->subframe_var_count == MD_UNUSED_INDEX);

6
c/mapping/mlr_dsl_cst_output_statements.c
View file

@ -572,7 +572,7 @@ mlr_dsl_cst_statement_t* alloc_emit(
} else if (pkeylist_node->type == MD_AST_NODE_TYPE_MAP_LITERAL) {
pstate->precord_emitter = record_emitter_from_map_literal;
pstate->prhs_xevaluator = rxval_evaluator_pure_alloc_from_ast(
pstate->prhs_xevaluator = rxval_evaluator_alloc_from_astx(
pkeylist_node, pcst->pfmgr, type_inferencing, context_flags);
} else {
@ -1089,7 +1089,7 @@ mlr_dsl_cst_statement_t* alloc_emit_lashed(mlr_dsl_cst_t* pcst, mlr_dsl_ast_node
pitem->pemit_lashed_item_freer = map_literal_emit_lashed_item_free;
pitem->pemit_keylist_evaluators = sllv_alloc();
sllv_push(pitem->pemit_keylist_evaluators, rval_evaluator_alloc_from_string("_"));
pitem->prhs_xevaluator = rxval_evaluator_pure_alloc_from_ast(
pitem->prhs_xevaluator = rxval_evaluator_alloc_from_astx(
pkeylist_node, pcst->pfmgr, type_inferencing, context_flags);
break;
@ -1485,7 +1485,7 @@ mlr_dsl_cst_statement_t* alloc_dump(mlr_dsl_cst_t* pcst, mlr_dsl_ast_node_t* pno
} else {
pstate->pdump_target_getter = ephemeral_target_getter;
pstate->pdump_target_freer = dump_target_free;
pstate->pephemeral_target_xevaluator = rxval_evaluator_alloc_from_ast(
pstate->pephemeral_target_xevaluator = rxval_evaluator_alloc_from_astx(
ptarget_node, pcst->pfmgr, type_inferencing, context_flags);
}

6
c/mapping/rval_evaluators.h
View file

@ -159,11 +159,7 @@ mv_t get_srec_value_string_float_int_aux(lrece_t* pentry, lhmsmv_t* ptyped_overl
// Topmost functions:
// Wraps mv_t evaluator in an mlhmmv_value_t evaluator.
rxval_evaluator_t* rxval_evaluator_alloc_from_ast(
mlr_dsl_ast_node_t* past, fmgr_t* pfmgr, int type_inferencing, int context_flags);
// Does not wrap mv_t evaluator in an mlhmmv_value_t evaluator; returns NULL if the
// AST isn't map-evaluable.
rxval_evaluator_t* rxval_evaluator_pure_alloc_from_ast(
rxval_evaluator_t* rxval_evaluator_alloc_from_astx(
mlr_dsl_ast_node_t* past, fmgr_t* pfmgr, int type_inferencing, int context_flags);
// Next level:

17
c/mapping/rxval_expr_evaluators.c
View file

@ -17,18 +17,7 @@
// ================================================================
// ----------------------------------------------------------------
rxval_evaluator_t* rxval_evaluator_alloc_from_ast(mlr_dsl_ast_node_t* pnode, fmgr_t* pfmgr,
int type_inferencing, int context_flags)
{
rxval_evaluator_t* pxev = rxval_evaluator_pure_alloc_from_ast(pnode, pfmgr, type_inferencing, context_flags);
if (pxev != NULL) {
return pxev;
} else {
return rxval_evaluator_alloc_wrapping_rval(pnode, pfmgr, type_inferencing, context_flags);
}
}
rxval_evaluator_t* rxval_evaluator_pure_alloc_from_ast(mlr_dsl_ast_node_t* pnode, fmgr_t* pfmgr,
rxval_evaluator_t* rxval_evaluator_alloc_from_astx(mlr_dsl_ast_node_t* pnode, fmgr_t* pfmgr,
int type_inferencing, int context_flags)
{
switch(pnode->type) {
@ -71,7 +60,7 @@ rxval_evaluator_t* rxval_evaluator_pure_alloc_from_ast(mlr_dsl_ast_node_t* pnode
break;
default:
return NULL;
return rxval_evaluator_alloc_wrapping_rval(pnode, pfmgr, type_inferencing, context_flags);
break;
}
}
@ -154,7 +143,7 @@ static map_literal_list_evaluator_t* allocate_map_literal_evaluator_from_ast(
mlr_dsl_ast_node_t* pright = pchild->pchildren->phead->pnext->pvvalue;
mlr_dsl_ast_node_t* pvalnode = pright->pchildren->phead->pvvalue;
if (pright->type == MD_AST_NODE_TYPE_MAP_LITERAL_VALUE) {
ppair->pxval_evaluator = rxval_evaluator_alloc_from_ast(pvalnode, pfmgr, type_inferencing, context_flags);
ppair->pxval_evaluator = rxval_evaluator_alloc_from_astx(pvalnode, pfmgr, type_inferencing, context_flags);
} else if (pright->type == MD_AST_NODE_TYPE_MAP_LITERAL) {
ppair->is_terminal = FALSE;
ppair->plist_evaluator = allocate_map_literal_evaluator_from_ast(

1
c/todo.txt
View file

@ -23,6 +23,7 @@ OTHER:
* typeof -> include 'map' and 'srec'
* dump @records after @records[NR]=$*: json "1" rather than 1 indices are b04k3d
* rename dsls/ to parsers; mapping -> mappers & dsl ?
! 'Error code 1' -> clearer on regdiff fail
----------------------------------------------------------------
MAPVAR CHECKLIST: