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

oosvar-to-oosvar-assignment iterate

Browse source
This commit is contained in:
John Kerl 2016-03-07 14:59:50 -05:00
parent 83171d653e
commit e75be44baa
3 changed files with 77 additions and 27 deletions
Download patch file Download diff file Expand all files Collapse all files

38
c/containers/mlhmmv.c
View file

@ -39,6 +39,8 @@ static void mlhmmv_level_put_value(mlhmmv_level_t* plevel, sllmve_t* prest_keys,
static void mlhmmv_level_put_value_no_enlarge(mlhmmv_level_t* plevel, sllmve_t* prest_keys,
mlhmmv_level_value_t* pvalue);
static mlhmmv_level_value_t mlhmmv_copy_aux(mlhmmv_level_value_t* pvalue);
static void mlhmmv_to_lrecs_aux_vert(mlhmmv_level_t* plevel, char* prefix, sllmve_t* prestnames,
lrec_t* ptemplate, sllv_t* poutrecs);
static void mlhmmv_to_lrecs_aux_horiz(mlhmmv_level_t* plevel, char* prefix,
@ -606,36 +608,40 @@ void mlhmmv_remove(mlhmmv_t* pmap, sllmv_t* prestkeys) {
// ----------------------------------------------------------------
void mlhmmv_copy(mlhmmv_t* pmap, sllmv_t* ptokeys, sllmv_t* pfromkeys) {
int error = 0; // xxx remove from API?
mlhmmv_level_value_t submap = mlhmmv_copy_from_level(pmap->proot_level, pfromkeys->phead, &error);
mlhmmv_put_at_level(pmap, ptokeys, &submap);
mlhmmv_level_entry_t* pfromentry = mlhmmv_get_entry_at_level(pmap->proot_level, pfromkeys->phead, &error);
if (pfromentry != NULL) {
mlhmmv_level_value_t submap = mlhmmv_copy_aux(&pfromentry->level_value);
mlhmmv_put_at_level(pmap, ptokeys, &submap);
}
}
// xxx need perror here? probably not.
mlhmmv_level_value_t mlhmmv_copy_from_level(mlhmmv_level_t* plevel, sllmve_t* prestkeys, int* perror) {
mlhmmv_level_entry_t* pentry = mlhmmv_get_entry_at_level(plevel, prestkeys, perror);
if (pentry == NULL) {
fprintf(stderr,
"%s: Coding error: table full even after enlargement.\n", MLR_GLOBALS.argv0);
exit(1);
} else if (pentry->level_value.is_terminal) {
static mlhmmv_level_value_t mlhmmv_copy_aux(mlhmmv_level_value_t* pvalue) {
if (pvalue->is_terminal) {
return (mlhmmv_level_value_t) {
.is_terminal = TRUE,
.u.mlrval = mv_copy(&pentry->level_value.u.mlrval)
.u.mlrval = mv_copy(&pvalue->u.mlrval)
};
} else {
mlhmmv_level_t* psrc_level = pentry->level_value.u.pnext_level;
mlhmmv_level_t* psrc_level = pvalue->u.pnext_level;
mlhmmv_level_t* pdst_level = mlr_malloc_or_die(sizeof(mlhmmv_level_t));
// xxx stub
mlhmmv_level_init(pdst_level, MLHMMV_INITIAL_ARRAY_LENGTH);
for (
mlhmmv_level_entry_t* psubentry = psrc_level->phead;
psubentry != NULL;
psubentry = psubentry->pnext)
{
mlhmmv_level_value_t next_value = mlhmmv_copy_from_level(psrc_level, prestkeys->pnext, perror);
mlhmmv_level_put_value(pdst_level, prestkeys->pnext, &next_value);
sllmve_t e = { .value = psubentry->level_key, .free_flags = 0, .pnext = NULL };
if (psubentry->level_value.is_terminal) {
mlhmmv_level_put_value(pdst_level, &e, &psubentry->level_value);
} else {
mlhmmv_level_value_t next_value = mlhmmv_copy_aux(&psubentry->level_value);
mlhmmv_level_put_value(pdst_level, &e, &next_value);
}
}
return (mlhmmv_level_value_t) {

2
c/containers/mlhmmv.h
View file

@ -91,7 +91,7 @@ mlhmmv_level_t* mlhmmv_get_level(mlhmmv_t* pmap, sllmv_t* pmvkeys, int* perror);
// xxx cmt
void mlhmmv_copy(mlhmmv_t* pmap, sllmv_t* ptokeys, sllmv_t* pfromkeys);
// xxx make private?
mlhmmv_level_value_t mlhmmv_copy_from_level(mlhmmv_level_t* plevel, sllmve_t* prestkeys, int* perror);
mlhmmv_level_value_t mlhmmv_copy_from_level(mlhmmv_level_t* plevel, int* perror);
void mlhmmv_put_at_level(mlhmmv_t* pmap, sllmv_t* pmvkeys, mlhmmv_level_value_t* pvalue);
// Unset value/submap from a specified level onward. Example:

64
c/mapping/mlr_dsl_cst.c
View file

@ -204,6 +204,8 @@ void mlr_dsl_cst_free(mlr_dsl_cst_t* pcst) {
}
// ----------------------------------------------------------------
// xxx split up this function -- too long.
static mlr_dsl_cst_statement_t* cst_statement_alloc(mlr_dsl_ast_node_t* past, int type_inferencing) {
mlr_dsl_cst_statement_t* pstatement = mlr_malloc_or_die(sizeof(mlr_dsl_cst_statement_t));
@ -295,18 +297,60 @@ static mlr_dsl_cst_statement_t* cst_statement_alloc(mlr_dsl_ast_node_t* past, in
}
}
sllv_append(pstatement->pitems, mlr_dsl_cst_statement_item_alloc(
NULL,
poosvar_lhs_keylist_evaluators,
NULL,
FALSE,
rval_evaluator_alloc_from_ast(pright, type_inferencing),
NULL,
NULL));
int is_oosvar_to_oosvar = FALSE;
pstatement->pevaluator = mlr_dsl_cst_node_evaluate_oosvar_to_oosvar_assignment; // xxx temp
if (pleft->type == MD_AST_NODE_TYPE_OOSVAR_NAME || pleft->type == MD_AST_NODE_TYPE_OOSVAR_LEVEL_KEY) {
if (pright->type == MD_AST_NODE_TYPE_OOSVAR_NAME || pright->type == MD_AST_NODE_TYPE_OOSVAR_LEVEL_KEY) {
is_oosvar_to_oosvar = TRUE;
}
}
pstatement->pevaluator = mlr_dsl_cst_node_evaluate_oosvar_assignment;
if (is_oosvar_to_oosvar) {
sllv_t* poosvar_rhs_keylist_evaluators = sllv_alloc();
if (pright->type == MD_AST_NODE_TYPE_OOSVAR_NAME) {
sllv_append(poosvar_rhs_keylist_evaluators,
rval_evaluator_alloc_from_string(mlr_strdup_or_die(pright->text)));
} else {
// xxx make a private helper method out of this
mlr_dsl_ast_node_t* pnode = pright;
while (TRUE) {
if (pnode->type == MD_AST_NODE_TYPE_OOSVAR_LEVEL_KEY) {
mlr_dsl_ast_node_t* pkeynode = pnode->pchildren->phead->pnext->pvvalue;
sllv_prepend(poosvar_rhs_keylist_evaluators,
rval_evaluator_alloc_from_ast(pkeynode, type_inferencing));
} else {
sllv_prepend(poosvar_rhs_keylist_evaluators,
rval_evaluator_alloc_from_string(mlr_strdup_or_die(pnode->text)));
}
if (pnode->pchildren == NULL)
break;
pnode = pnode->pchildren->phead->pvvalue;
}
}
sllv_append(pstatement->pitems, mlr_dsl_cst_statement_item_alloc(
NULL,
poosvar_lhs_keylist_evaluators,
NULL,
FALSE,
rval_evaluator_alloc_from_ast(pright, type_inferencing),
NULL,
poosvar_rhs_keylist_evaluators));
pstatement->pevaluator = mlr_dsl_cst_node_evaluate_oosvar_to_oosvar_assignment; // xxx temp
} else {
sllv_append(pstatement->pitems, mlr_dsl_cst_statement_item_alloc(
NULL,
poosvar_lhs_keylist_evaluators,
NULL,
FALSE,
rval_evaluator_alloc_from_ast(pright, type_inferencing),
NULL,
NULL));
pstatement->pevaluator = mlr_dsl_cst_node_evaluate_oosvar_assignment;
}
} else if (past->type == MD_AST_NODE_TYPE_OOSVAR_FROM_FULL_SREC_ASSIGNMENT) {
sllv_t* poosvar_lhs_keylist_evaluators = sllv_alloc();