// ----------------------------------------------------------------
mlr_dsl_ast_t* mlr_dsl_ast_alloc() {
mlr_dsl_ast_t* past = mlr_malloc_or_die(sizeof(mlr_dsl_ast_t));
past->pbegin_statements = sllv_alloc();
past->pmain_statements = sllv_alloc();
past->pend_statements = sllv_alloc();
return past;
}
// ----------------------------------------------------------------
lrec_reader_t* lrec_reader_stdio_json_alloc(char* input_json_flatten_separator, json_array_ingest_t json_array_ingest, char* line_term,
comment_handling_t comment_handling, char* comment_string)
{
lrec_reader_t* plrec_reader = mlr_malloc_or_die(sizeof(lrec_reader_t));
lrec_reader_stdio_json_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_stdio_json_state_t));
pstate->ptop_level_json_objects = sllv_alloc();
pstate->precords = sllv_alloc();
pstate->input_json_flatten_separator = input_json_flatten_separator;
pstate->json_array_ingest = json_array_ingest;
pstate->specified_line_term = line_term;
pstate->do_auto_line_term = FALSE;
pstate->detected_line_term = "\n"; // xxx adapt to MLR_GLOBALS/ctx-const for Windows port
pstate->comment_handling = comment_handling;
pstate->comment_string = comment_string;
if (streq(line_term, "auto")) {
pstate->do_auto_line_term = TRUE;
}
plrec_reader->pvstate = (void*)pstate;
plrec_reader->popen_func = file_ingestor_stdio_vopen;
plrec_reader->pclose_func = file_ingestor_stdio_nop_vclose;
plrec_reader->pprocess_func = lrec_reader_stdio_json_process;
plrec_reader->psof_func = lrec_reader_stdio_json_sof;
plrec_reader->pfree_func = lrec_reader_stdio_json_free;
return plrec_reader;
}
// ----------------------------------------------------------------
static sllv_t* mapper_group_like_process(lrec_t* pinrec, context_t* pctx, void* pvstate) {
mapper_group_like_state_t* pstate = pvstate;
if (pinrec != NULL) {
slls_t* pkey_field_names = mlr_reference_keys_from_record(pinrec);
sllv_t* plist = lhmslv_get(pstate->precords_by_key_field_names, pkey_field_names);
if (plist == NULL) {
plist = sllv_alloc();
sllv_add(plist, pinrec);
lhmslv_put(pstate->precords_by_key_field_names, slls_copy(pkey_field_names), plist);
} else {
sllv_add(plist, pinrec);
}
return NULL;
}
else {
sllv_t* poutput = sllv_alloc();
for (lhmslve_t* pe = pstate->precords_by_key_field_names->phead; pe != NULL; pe = pe->pnext) {
sllv_t* plist = pe->pvvalue;
for (sllve_t* pf = plist->phead; pf != NULL; pf = pf->pnext) {
sllv_add(poutput, pf->pvdata);
}
}
sllv_add(poutput, NULL);
return poutput;
}
}
// ----------------------------------------------------------------
static sllv_t* mapper_tail_process(lrec_t* pinrec, context_t* pctx, void* pvstate) {
mapper_tail_state_t* pstate = pvstate;
if (pinrec != NULL) {
slls_t* pgroup_by_field_values = mlr_selected_values_from_record(pinrec, pstate->pgroup_by_field_names);
sllv_t* precord_list_for_group = lhmslv_get(pstate->precord_lists_by_group, pgroup_by_field_values);
if (precord_list_for_group == NULL) {
precord_list_for_group = sllv_alloc();
lhmslv_put(pstate->precord_lists_by_group, slls_copy(pgroup_by_field_values), precord_list_for_group);
}
if (precord_list_for_group->length >= pstate->tail_count) {
lrec_t* porec = sllv_pop(precord_list_for_group);
if (porec != NULL)
lrec_free(porec);
}
sllv_add(precord_list_for_group, pinrec);
return NULL;
}
else {
sllv_t* poutrecs = sllv_alloc();
for (lhmslve_t* pa = pstate->precord_lists_by_group->phead; pa != NULL; pa = pa->pnext) {
sllv_t* precord_list_for_group = pa->pvvalue;
for (sllve_t* pb = precord_list_for_group->phead; pb != NULL; pb = pb->pnext) {
sllv_add(poutrecs, pb->pvdata);
}
}
sllv_add(poutrecs, NULL);
return poutrecs;
}
}
// ----------------------------------------------------------------
static void lrec_writer_pprint_process(FILE* output_stream, lrec_t* prec, void* pvstate) {
lrec_writer_pprint_state_t* pstate = pvstate;
int drain = FALSE;
if (prec == NULL) {
drain = TRUE;
} else {
if (pstate->pprev_keys != NULL && !lrec_keys_equal_list(prec, pstate->pprev_keys)) {
drain = TRUE;
}
}
if (drain) {
if (pstate->num_blocks_written > 0LL) // separate blocks with empty line
fputs(pstate->ors, output_stream);
print_and_free_record_list(pstate->precords, output_stream, pstate->ors, pstate->ofs, pstate->left_align);
if (pstate->pprev_keys != NULL) {
slls_free(pstate->pprev_keys);
pstate->pprev_keys = NULL;
}
pstate->precords = sllv_alloc();
pstate->num_blocks_written++;
}
if (prec != NULL) {
sllv_append(pstate->precords, prec);
if (pstate->pprev_keys == NULL)
pstate->pprev_keys = mlr_copy_keys_from_record(prec);
}
}
// ----------------------------------------------------------------
static char* test_sllv_append() {
mu_assert_lf(0 == 0);
sllv_t* pa = sllv_alloc();
sllv_add(pa, "a");
sllv_add(pa, "b");
sllv_add(pa, "c");
mu_assert_lf(pa->length == 3);
sllve_t* pe = pa->phead;
mu_assert_lf(pe != NULL); mu_assert_lf(streq(pe->pvdata, "a")); pe = pe->pnext;
mu_assert_lf(pe != NULL); mu_assert_lf(streq(pe->pvdata, "b")); pe = pe->pnext;
mu_assert_lf(pe != NULL); mu_assert_lf(streq(pe->pvdata, "c")); pe = pe->pnext;
mu_assert_lf(pe == NULL);
sllv_t* pb = sllv_alloc();
sllv_add(pb, "d");
sllv_add(pb, "e");
mu_assert_lf(pb->length == 2);
pe = pb->phead;
mu_assert_lf(pe != NULL); mu_assert_lf(streq(pe->pvdata, "d")); pe = pe->pnext;
mu_assert_lf(pe != NULL); mu_assert_lf(streq(pe->pvdata, "e")); pe = pe->pnext;
mu_assert_lf(pe == NULL);
pa = sllv_append(pa, pb);
mu_assert_lf(pa->length == 5);
mu_assert_lf(pb->length == 2);
pe = pa->phead;
mu_assert_lf(pe != NULL); mu_assert_lf(streq(pe->pvdata, "a")); pe = pe->pnext;
mu_assert_lf(pe != NULL); mu_assert_lf(streq(pe->pvdata, "b")); pe = pe->pnext;
mu_assert_lf(pe != NULL); mu_assert_lf(streq(pe->pvdata, "c")); pe = pe->pnext;
mu_assert_lf(pe != NULL); mu_assert_lf(streq(pe->pvdata, "d")); pe = pe->pnext;
mu_assert_lf(pe != NULL); mu_assert_lf(streq(pe->pvdata, "e")); pe = pe->pnext;
mu_assert_lf(pe == NULL);
pe = pb->phead;
mu_assert_lf(pe != NULL); mu_assert_lf(streq(pe->pvdata, "d")); pe = pe->pnext;
mu_assert_lf(pe != NULL); mu_assert_lf(streq(pe->pvdata, "e")); pe = pe->pnext;
mu_assert_lf(pe == NULL);
return NULL;
}
ex_ast_node_t* ex_ast_node_append_arg(
ex_ast_node_t* pa, ex_ast_node_t* pb)
{
if (pa->pchildren == NULL)
pa->pchildren = sllv_alloc();
sllv_append(pa->pchildren, pb);
return pa;
}
// ----------------------------------------------------------------
mlr_dsl_ast_node_t* mlr_dsl_ast_node_alloc_unary(char* text, int type,
mlr_dsl_ast_node_t* pa)
{
mlr_dsl_ast_node_t* pnode = mlr_dsl_ast_node_alloc(text, type);
pnode->pchildren = sllv_alloc();
sllv_add(pnode->pchildren, pa);
return pnode;
}
// ----------------------------------------------------------------
mlr_dsl_ast_node_t* mlr_dsl_ast_node_append_arg(
mlr_dsl_ast_node_t* pa, mlr_dsl_ast_node_t* pb)
{
if (pa->pchildren == NULL)
pa->pchildren = sllv_alloc();
sllv_add(pa->pchildren, pb);
return pa;
}
// ----------------------------------------------------------------
ex_ast_node_t* ex_ast_node_alloc_unary(char* text, ex_ast_node_type_t type,
ex_ast_node_t* pa)
{
ex_ast_node_t* pnode = ex_ast_node_alloc(text, type);
pnode->pchildren = sllv_alloc();
sllv_append(pnode->pchildren, pa);
return pnode;
}
static sllv_t* mlr_dsl_cst_alloc_from_statement_list(sllv_t* pasts, int type_inferencing) {
sllv_t* pstatements = sllv_alloc();
for (sllve_t* pe = pasts->phead; pe != NULL; pe = pe->pnext) {
mlr_dsl_ast_node_t* past = pe->pvvalue;
mlr_dsl_cst_statement_t* pstatement = cst_statement_alloc(past, type_inferencing);
sllv_add(pstatements, pstatement);
}
return pstatements;
}
// ----------------------------------------------------------------
static sllv_t* make_records_113335() {
sllv_t* precords = sllv_alloc();
sllv_append(precords, lrec_literal_2("l","1", "b","10"));
sllv_append(precords, lrec_literal_2("l","1", "b","11"));
sllv_append(precords, lrec_literal_2("l","3", "b","12"));
sllv_append(precords, lrec_literal_2("l","3", "b","13"));
sllv_append(precords, lrec_literal_2("l","3", "b","14"));
sllv_append(precords, lrec_literal_2("l","5", "b","15"));
return precords;
}
// ----------------------------------------------------------------
mlr_dsl_ast_node_t* mlr_dsl_ast_node_alloc_ternary(char* text, int type,
mlr_dsl_ast_node_t* pa, mlr_dsl_ast_node_t* pb, mlr_dsl_ast_node_t* pc)
{
mlr_dsl_ast_node_t* pnode = mlr_dsl_ast_node_alloc(text, type);
pnode->pchildren = sllv_alloc();
sllv_append(pnode->pchildren, pa);
sllv_append(pnode->pchildren, pb);
sllv_append(pnode->pchildren, pc);
return pnode;
}
// ----------------------------------------------------------------
ex_ast_node_t* ex_ast_tree_copy(ex_ast_node_t* pold) {
ex_ast_node_t* pnew = ex_ast_node_copy(pold);
if (pold->pchildren != NULL) {
pnew->pchildren = sllv_alloc();
for (sllve_t* pe = pold->pchildren->phead; pe != NULL; pe = pe->pnext) {
ex_ast_node_t* pchild = pe->pvvalue;
sllv_append(pnew->pchildren, ex_ast_tree_copy(pchild));
}
}
return pnew;
}
// ----------------------------------------------------------------
static sllv_t* make_records_het() {
sllv_t* precords = sllv_alloc();
sllv_append(precords, lrec_literal_2("x","100", "b","10"));
sllv_append(precords, lrec_literal_2("l","1", "b","11"));
sllv_append(precords, lrec_literal_2("l","1", "b","12"));
sllv_append(precords, lrec_literal_2("x","200", "b","13"));
sllv_append(precords, lrec_literal_2("l","3", "b","14"));
sllv_append(precords, lrec_literal_2("l","3", "b","15"));
sllv_append(precords, lrec_literal_2("x","300", "b","16"));
sllv_append(precords, lrec_literal_2("l","5", "b","17"));
sllv_append(precords, lrec_literal_2("l","5", "b","18"));
return precords;
}
// ----------------------------------------------------------------
lrec_writer_t* lrec_writer_pprint_alloc(char* ors, char ofs, int left_align) {
lrec_writer_t* plrec_writer = mlr_malloc_or_die(sizeof(lrec_writer_t));
lrec_writer_pprint_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_writer_pprint_state_t));
pstate->precords = sllv_alloc();
pstate->pprev_keys = NULL;
pstate->ors = ors;
pstate->ofs = ofs;
pstate->left_align = left_align;
pstate->num_blocks_written = 0LL;
plrec_writer->pvstate = pstate;
plrec_writer->pprocess_func = lrec_writer_pprint_process;
plrec_writer->pfree_func = lrec_writer_pprint_free;
return plrec_writer;
}
// pnode is input; pkeylist_evaluators is appended to.
sllv_t* allocate_keylist_evaluators_from_ast_node(
mlr_dsl_ast_node_t* pnode, fmgr_t* pfmgr, int type_inferencing, int context_flags)
{
sllv_t* pkeylist_evaluators = sllv_alloc();
if (pnode->pchildren != NULL) { // Non-indexed localvars have no child nodes in the AST.
for (sllve_t* pe = pnode->pchildren->phead; pe != NULL; pe = pe->pnext) {
mlr_dsl_ast_node_t* pkeynode = pe->pvvalue;
if (pkeynode->type == MD_AST_NODE_TYPE_STRING_LITERAL) {
sllv_append(pkeylist_evaluators, rval_evaluator_alloc_from_string(pkeynode->text));
} else {
sllv_append(pkeylist_evaluators, rval_evaluator_alloc_from_ast(pkeynode, pfmgr,
type_inferencing, context_flags));
}
}
}
return pkeylist_evaluators;
}
int main(int argc, char** argv) {
sllv_t* precords = sllv_alloc();
sllv_add(precords, lrec_literal_2("a","1", "b","10"));
sllv_add(precords, lrec_literal_2("a","1", "b","11"));
sllv_add(precords, lrec_literal_2("a","2", "b","12"));
sllv_add(precords, lrec_literal_2("a","2", "b","13"));
sllv_add(precords, lrec_literal_2("a","3", "b","14"));
sllv_add(precords, lrec_literal_2("a","3", "b","15"));
lrec_reader_t* preader = lrec_reader_in_memory_alloc(precords);
printf("#=%d\n", precords->length);
while (TRUE) {
lrec_t* precord = preader->pprocess_func(NULL, preader->pvstate, NULL);
if (precord == NULL)
break;
lrec_print(precord);
}
return 0;
}
static sllv_t* chain_map(lrec_t* pinrec, context_t* pctx, sllve_t* pmapper_list_head) {
mapper_t* pmapper = pmapper_list_head->pvdata;
sllv_t* outrecs = pmapper->pprocess_func(pinrec, pctx, pmapper->pvstate);
if (pmapper_list_head->pnext == NULL) {
return outrecs;
} else if (outrecs == NULL) { // xxx cmt
return NULL;
} else {
sllv_t* nextrecs = sllv_alloc();
for (sllve_t* pe = outrecs->phead; pe != NULL; pe = pe->pnext) {
lrec_t* poutrec = pe->pvdata;
sllv_t* nextrecsi = chain_map(poutrec, pctx, pmapper_list_head->pnext);
nextrecs = sllv_append(nextrecs, nextrecsi);
}
sllv_free(outrecs);
return nextrecs;
}
}
mlr_dsl_cst_statement_t* alloc_if_head(mlr_dsl_cst_t* pcst, mlr_dsl_ast_node_t* pnode,
int type_inferencing, int context_flags)
{
if_head_state_t* pstate = mlr_malloc_or_die(sizeof(if_head_state_t));
pstate->pif_chain_statements = sllv_alloc();
for (sllve_t* pe = pnode->pchildren->phead; pe != NULL; pe = pe->pnext) {
// For if and elif:
// * Left subnode is the AST for the boolean expression.
// * Right subnode is a list of statements to be executed if the left evaluates to true.
// For else:
// * Sole subnode is a list of statements to be executed.
mlr_dsl_ast_node_t* pitemnode = pe->pvvalue;
mlr_dsl_ast_node_t* pexprnode = NULL;
mlr_dsl_ast_node_t* plistnode = NULL;
if (pitemnode->pchildren->length == 2) {
pexprnode = pitemnode->pchildren->phead->pvvalue;
plistnode = pitemnode->pchildren->phead->pnext->pvvalue;
} else {
pexprnode = NULL;
plistnode = pitemnode->pchildren->phead->pvvalue;
}
sllv_append(pstate->pif_chain_statements,
alloc_if_item(pcst, pitemnode, pexprnode, plistnode, type_inferencing, context_flags)
);
}
mlr_dsl_cst_block_handler_t* pblock_handler = (context_flags & IN_BREAKABLE)
? mlr_dsl_cst_handle_statement_block_with_break_continue
: mlr_dsl_cst_handle_statement_block;
return mlr_dsl_cst_statement_valloc_with_block(
pnode,
handle_if_head,
NULL,
pblock_handler,
free_if_head,
pstate);
}
// ----------------------------------------------------------------
static sllv_t* mapper_stats1_emit(mapper_stats1_state_t* pstate) {
sllv_t* poutrecs = sllv_alloc();
for (lhmslve_t* pa = pstate->groups->phead; pa != NULL; pa = pa->pnext) {
slls_t* pgroup_by_field_values = pa->key;
lrec_t* poutrec = lrec_unbacked_alloc();
// Add in a=s,b=t fields:
sllse_t* pb = pstate->pgroup_by_field_names->phead;
sllse_t* pc = pgroup_by_field_values->phead;
for ( ; pb != NULL && pc != NULL; pb = pb->pnext, pc = pc->pnext) {
lrec_put(poutrec, pb->value, pc->value, 0);
}
// Add in fields such as x_sum=#, y_count=#, etc.:
lhmsv_t* group_to_acc_field = pa->pvvalue;
// for "x", "y"
for (lhmsve_t* pd = group_to_acc_field->phead; pd != NULL; pd = pd->pnext) {
char* value_field_name = pd->key;
lhmsv_t* acc_field_to_acc_state = pd->pvvalue;
for (sllse_t* pe = pstate->paccumulator_names->phead; pe != NULL; pe = pe->pnext) {
char* acc_name = pe->value;
if (streq(acc_name, fake_acc_name_for_setups))
continue;
acc_t* pacc = lhmsv_get(acc_field_to_acc_state, acc_name);
if (pacc == NULL) {
fprintf(stderr, "%s stats1: internal coding error: acc_name \"%s\" has gone missing.\n",
MLR_GLOBALS.argv0, acc_name);
exit(1);
}
pacc->pemit_func(pacc->pvstate, value_field_name, acc_name, poutrec);
}
}
sllv_add(poutrecs, poutrec);
}
sllv_add(poutrecs, NULL);
return poutrecs;
}
// The stdio-JSON lrec-reader is non-streaming: we ingest all records here in the start-of-file hook.
// Then in the process method we pop one lrec off the list at a time, until they are all exhausted.
// This is in contrast to other Miller lrec-readers.
//
// It would be possible to extend the streaming framework to also have an end-of-file hook
// which we could use here to free parsed-JSON data. However, we simply leverage the start-of-file
// hook for the *next* file (if any) or the free method (if not): these free parsed-JSON structures
// from the previous file (if any).
static void lrec_reader_stdio_json_sof(void* pvstate, void* pvhandle) {
lrec_reader_stdio_json_state_t* pstate = pvstate;
file_ingestor_stdio_state_t* phandle = pvhandle;
json_char* json_input = (json_char*)phandle->sof;
json_value_t* parsed_top_level_json;
json_char error_buf[JSON_ERROR_MAX];
if (pstate->ptop_level_json_objects != NULL) {
for (sllve_t* pe = pstate->ptop_level_json_objects->phead; pe != NULL; pe = pe->pnext) {
json_value_t* top_level_json_object = pe->pvvalue;
json_value_free(top_level_json_object);
}
sllv_free(pstate->ptop_level_json_objects);
}
if (pstate->precords != NULL) {
for (sllve_t* pf = pstate->precords->phead; pf != NULL; pf = pf->pnext) {
lrec_t* prec = pf->pvvalue;
lrec_free(prec);
}
sllv_free(pstate->precords);
}
pstate->ptop_level_json_objects = sllv_alloc();
pstate->precords = sllv_alloc();
// This enables us to handle input of the form
//
// { "a" : 1 }
// { "b" : 2 }
// { "c" : 3 }
//
// in addition to
//
// [
// { "a" : 1 }
// { "b" : 2 }
// { "c" : 3 }
// ]
//
// This is in line with what jq can handle. In this case, json_parse will return
// once for each top-level item and will give us back a pointer to the start of
// the rest of the input stream, so we can call json_parse on the rest until it is
// all exhausted.
json_char* item_start = json_input;
int length = phandle->eof - phandle->sof;
while (TRUE) {
parsed_top_level_json = json_parse(item_start, length, error_buf, &item_start);
if (parsed_top_level_json == NULL) {
fprintf(stderr, "Unable to parse JSON data: %s\n", error_buf);
exit(1);
}
// The lrecs have their string pointers pointing into the parsed-JSON objects (for
// efficiency) so it's important we not free the latter until our free method.
reference_json_objects_as_lrecs(pstate->precords, parsed_top_level_json, pstate->json_flatten_separator);
if (item_start == NULL)
break;
if (*item_start == 0)
break;
length -= (item_start - json_input);
json_input = item_start;
}
}
// ----------------------------------------------------------------
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));
pstatement->ast_node_type = past->type;
pstatement->pitems = sllv_alloc();
if (past->type == MD_AST_NODE_TYPE_SREC_ASSIGNMENT) {
if ((past->pchildren == NULL) || (past->pchildren->length != 2)) {
fprintf(stderr, "%s: internal coding error detected in file %s at line %d.\n",
MLR_GLOBALS.argv0, __FILE__, __LINE__);
exit(1);
}
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_FIELD_NAME) {
fprintf(stderr, "%s: internal coding error detected in file %s at line %d.\n",
MLR_GLOBALS.argv0, __FILE__, __LINE__);
exit(1);
} else if (pleft->pchildren != NULL) {
fprintf(stderr, "%s: coding error detected in file %s at line %d.\n",
MLR_GLOBALS.argv0, __FILE__, __LINE__);
exit(1);
}
sllv_add(pstatement->pitems, mlr_dsl_cst_statement_item_alloc(
pleft->text,
MLR_DSL_CST_LHS_TYPE_SREC,
lrec_evaluator_alloc_from_ast(pright, type_inferencing)));
} else if (past->type == MD_AST_NODE_TYPE_OOSVAR_ASSIGNMENT) {
if ((past->pchildren == NULL) || (past->pchildren->length != 2)) {
fprintf(stderr, "%s: internal coding error detected in file %s at line %d.\n",
MLR_GLOBALS.argv0, __FILE__, __LINE__);
exit(1);
}
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_OOSVAR_NAME) {
fprintf(stderr, "%s: internal coding error detected in file %s at line %d.\n",
MLR_GLOBALS.argv0, __FILE__, __LINE__);
exit(1);
} else if (pleft->pchildren != NULL) {
fprintf(stderr, "%s: coding error detected in file %s at line %d.\n",
MLR_GLOBALS.argv0, __FILE__, __LINE__);
exit(1);
}
sllv_add(pstatement->pitems, mlr_dsl_cst_statement_item_alloc(
pleft->text,
MLR_DSL_CST_LHS_TYPE_OOSVAR,
lrec_evaluator_alloc_from_ast(pright, type_inferencing)));
} else if (past->type == MD_AST_NODE_TYPE_MOOSVAR_ASSIGNMENT) {
// xxx stub: make an sllv of lrec_evaluators.
} else if (past->type == MD_AST_NODE_TYPE_FILTER) {
mlr_dsl_ast_node_t* pnode = past->pchildren->phead->pvvalue;
sllv_add(pstatement->pitems, mlr_dsl_cst_statement_item_alloc(
NULL,
MLR_DSL_CST_LHS_TYPE_OOSVAR,
lrec_evaluator_alloc_from_ast(pnode, type_inferencing)));
} else if (past->type == MD_AST_NODE_TYPE_GATE) {
mlr_dsl_ast_node_t* pnode = past->pchildren->phead->pvvalue;
sllv_add(pstatement->pitems, mlr_dsl_cst_statement_item_alloc(
NULL,
MLR_DSL_CST_LHS_TYPE_OOSVAR,
lrec_evaluator_alloc_from_ast(pnode, type_inferencing)));
} else if (past->type == MD_AST_NODE_TYPE_EMIT) {
// Loop over oosvar names to emit in e.g. 'emit @a, @b, @c'.
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(
pnode->text,
MLR_DSL_CST_LHS_TYPE_OOSVAR,
lrec_evaluator_alloc_from_ast(pnode, type_inferencing)));
}
} else if (past->type == MD_AST_NODE_TYPE_DUMP) {
// xxx stub
} else { // Bare-boolean statement
sllv_add(pstatement->pitems, mlr_dsl_cst_statement_item_alloc(
NULL,
MLR_DSL_CST_LHS_TYPE_OOSVAR, // xxx wtf
lrec_evaluator_alloc_from_ast(past, type_inferencing)));
}
return pstatement;
}
// ----------------------------------------------------------------
sllv_t* sllv_single(void* pvvalue) {
sllv_t* psllv = sllv_alloc();
sllv_add(psllv, pvvalue);
return psllv;
}
// ----------------------------------------------------------------
ex_ast_node_t* ex_ast_node_alloc_zary(char* text, ex_ast_node_type_t type)
{
ex_ast_node_t* pnode = ex_ast_node_alloc(text, type);
pnode->pchildren = sllv_alloc();
return pnode;
}
// ----------------------------------------------------------------
cli_opts_t* parse_command_line(int argc, char** argv) {
cli_opts_t* popts = mlr_malloc_or_die(sizeof(cli_opts_t));
memset(popts, 0, sizeof(*popts));
popts->irs = DEFAULT_RS;
popts->ifs = DEFAULT_FS;
popts->ips = DEFAULT_PS;
popts->allow_repeat_ifs = FALSE;
popts->allow_repeat_ips = FALSE;
popts->ors = DEFAULT_RS;
popts->ofs = DEFAULT_FS;
popts->ops = DEFAULT_PS;
popts->ofmt = DEFAULT_OFMT;
popts->plrec_reader = NULL;
popts->plrec_writer = NULL;
popts->filenames = NULL;
popts->ifmt = "dkvp";
char* ofmt = "dkvp";
popts->use_mmap_for_read = TRUE;
int left_align_pprint = TRUE;
int have_rand_seed = FALSE;
unsigned rand_seed = 0;
int argi = 1;
for (; argi < argc; argi++) {
if (argv[argi][0] != '-')
break;
else if (streq(argv[argi], "-h"))
main_usage(argv[0], 0);
else if (streq(argv[argi], "--help"))
main_usage(argv[0], 0);
else if (streq(argv[argi], "--help-all-verbs"))
usage_all_verbs(argv[0]);
else if (streq(argv[argi], "--help-all-functions") || streq(argv[argi], "-f")) {
lrec_evaluator_function_usage(stdout, NULL);
exit(0);
}
else if (streq(argv[argi], "--help-function") || streq(argv[argi], "--hf")) {
check_arg_count(argv, argi, argc, 2);
lrec_evaluator_function_usage(stdout, argv[argi+1]);
exit(0);
}
else if (streq(argv[argi], "--rs")) {
check_arg_count(argv, argi, argc, 2);
popts->ors = popts->irs = sep_from_arg(argv[argi+1], argv[0]);
argi++;
}
else if (streq(argv[argi], "--irs")) {
check_arg_count(argv, argi, argc, 2);
popts->irs = sep_from_arg(argv[argi+1], argv[0]);
argi++;
}
else if (streq(argv[argi], "--ors")) {
check_arg_count(argv, argi, argc, 2);
popts->ors = sep_from_arg(argv[argi+1], argv[0]);
argi++;
}
else if (streq(argv[argi], "--fs")) {
check_arg_count(argv, argi, argc, 2);
popts->ofs = popts->ifs = sep_from_arg(argv[argi+1], argv[0]);
argi++;
}
else if (streq(argv[argi], "--ifs")) {
check_arg_count(argv, argi, argc, 2);
popts->ifs = sep_from_arg(argv[argi+1], argv[0]);
argi++;
}
else if (streq(argv[argi], "--ofs")) {
check_arg_count(argv, argi, argc, 2);
popts->ofs = sep_from_arg(argv[argi+1], argv[0]);
argi++;
}
else if (streq(argv[argi], "--repifs")) {
popts->allow_repeat_ifs = TRUE;
}
else if (streq(argv[argi], "-p")) {
popts->ifmt = "nidx";
ofmt = "nidx";
popts->ifs = ' ';
popts->ofs = ' ';
popts->allow_repeat_ifs = TRUE;
}
else if (streq(argv[argi], "--ps")) {
check_arg_count(argv, argi, argc, 2);
popts->ops = popts->ips = sep_from_arg(argv[argi+1], argv[0]);
argi++;
}
else if (streq(argv[argi], "--ips")) {
check_arg_count(argv, argi, argc, 2);
popts->ips = sep_from_arg(argv[argi+1], argv[0]);
argi++;
}
else if (streq(argv[argi], "--ops")) {
check_arg_count(argv, argi, argc, 2);
popts->ops = sep_from_arg(argv[argi+1], argv[0]);
argi++;
}
else if (streq(argv[argi], "--dkvp")) { popts->ifmt = ofmt = "dkvp"; }
else if (streq(argv[argi], "--idkvp")) { popts->ifmt = "dkvp"; }
else if (streq(argv[argi], "--odkvp")) { ofmt = "dkvp"; }
else if (streq(argv[argi], "--csv")) { popts->ifmt = ofmt = "csv"; }
else if (streq(argv[argi], "--icsv")) { popts->ifmt = "csv"; }
else if (streq(argv[argi], "--ocsv")) { ofmt = "csv"; }
else if (streq(argv[argi], "--nidx")) { popts->ifmt = ofmt = "nidx"; }
else if (streq(argv[argi], "--inidx")) { popts->ifmt = "nidx"; }
else if (streq(argv[argi], "--onidx")) { ofmt = "nidx"; }
else if (streq(argv[argi], "--xtab")) { popts->ifmt = ofmt = "xtab"; }
else if (streq(argv[argi], "--ixtab")) { popts->ifmt = "xtab"; }
else if (streq(argv[argi], "--oxtab")) { ofmt = "xtab"; }
else if (streq(argv[argi], "--ipprint")) {
popts->ifmt = "csv";
popts->ifs = ' ';
popts->allow_repeat_ifs = TRUE;
}
else if (streq(argv[argi], "--opprint")) {
ofmt = "pprint";
}
else if (streq(argv[argi], "--pprint")) {
popts->ifmt = "csv";
popts->ifs = ' ';
popts->allow_repeat_ifs = TRUE;
ofmt = "pprint";
}
else if (streq(argv[argi], "--right")) {
left_align_pprint = FALSE;
}
else if (streq(argv[argi], "--ofmt")) {
check_arg_count(argv, argi, argc, 2);
popts->ofmt = argv[argi+1];
argi++;
}
// xxx put into online help.
else if (streq(argv[argi], "--mmap")) {
popts->use_mmap_for_read = TRUE;
}
else if (streq(argv[argi], "--no-mmap")) {
popts->use_mmap_for_read = FALSE;
}
else if (streq(argv[argi], "--seed")) {
check_arg_count(argv, argi, argc, 2);
if (sscanf(argv[argi+1], "0x%x", &rand_seed) == 1) {
have_rand_seed = TRUE;
} else if (sscanf(argv[argi+1], "%u", &rand_seed) == 1) {
have_rand_seed = TRUE;
} else {
main_usage(argv[0], 1);
}
argi++;
}
else
nusage(argv[0], argv[argi]);
}
if (streq(ofmt, "dkvp")) popts->plrec_writer = lrec_writer_dkvp_alloc(popts->ors, popts->ofs, popts->ops);
else if (streq(ofmt, "csv")) popts->plrec_writer = lrec_writer_csv_alloc(popts->ors, popts->ofs);
else if (streq(ofmt, "nidx")) popts->plrec_writer = lrec_writer_nidx_alloc(popts->ors, popts->ofs);
else if (streq(ofmt, "xtab")) popts->plrec_writer = lrec_writer_xtab_alloc();
else if (streq(ofmt, "pprint")) popts->plrec_writer = lrec_writer_pprint_alloc(left_align_pprint);
else {
main_usage(argv[0], 1);
}
if ((argc - argi) < 1) {
main_usage(argv[0], 1);
}
popts->pmapper_list = sllv_alloc();
while (TRUE) {
check_arg_count(argv, argi, argc, 1);
char* verb = argv[argi];
mapper_setup_t* pmapper_setup = look_up_mapper_setup(verb);
if (pmapper_setup == NULL) {
fprintf(stderr, "%s: verb \"%s\" not found. Please use \"%s --help\" for a list.\n",
argv[0], verb, argv[0]);
exit(1);
}
if ((argc - argi) >= 2) {
if (streq(argv[argi+1], "-h") || streq(argv[argi+1], "--help")) {
pmapper_setup->pusage_func(argv[0], verb);
exit(0);
}
}
// It's up to the parse func to print its usage on CLI-parse failure.
mapper_t* pmapper = pmapper_setup->pparse_func(&argi, argc, argv);
if (pmapper == NULL) {
exit(1);
}
sllv_add(popts->pmapper_list, pmapper);
// xxx cmt
if (argi >= argc || !streq(argv[argi], "then"))
break;
argi++;
}
popts->filenames = &argv[argi];
// No filenames means read from standard input, and standard input cannot be mmapped.
if (argi == argc)
popts->use_mmap_for_read = FALSE;
popts->plrec_reader = lrec_reader_alloc(popts->ifmt, popts->use_mmap_for_read,
popts->irs, popts->ifs, popts->allow_repeat_ifs, popts->ips, popts->allow_repeat_ips);
if (popts->plrec_reader == NULL)
main_usage(argv[0], 1);
if (have_rand_seed) {
mtrand_init(rand_seed);
} else {
mtrand_init_default();
}
return popts;
}
// ----------------------------------------------------------------
static sllv_t* make_records_empty() {
sllv_t* precords = sllv_alloc();
return precords;
}
// ----------------------------------------------------------------
cli_opts_t* parse_command_line(int argc, char** argv) {
cli_opts_t* popts = mlr_malloc_or_die(sizeof(cli_opts_t));
memset(popts, 0, sizeof(*popts));
popts->irs = NULL;
popts->ifs = NULL;
popts->ips = NULL;
popts->allow_repeat_ifs = NEITHER_TRUE_NOR_FALSE;
popts->allow_repeat_ips = NEITHER_TRUE_NOR_FALSE;
popts->use_implicit_csv_header = FALSE;
popts->headerless_csv_output = FALSE;
popts->ors = NULL;
popts->ofs = NULL;
popts->ops = NULL;
popts->right_justify_xtab_value = FALSE;
popts->stack_json_output_vertically = FALSE;
popts->wrap_json_output_in_outer_list = FALSE;
popts->quote_json_values_always = FALSE;
popts->json_flatten_separator = DEFAULT_JSON_FLATTEN_SEPARATOR;
popts->ofmt = DEFAULT_OFMT;
popts->oquoting = DEFAULT_OQUOTING;
popts->plrec_reader = NULL;
popts->plrec_writer = NULL;
popts->prepipe = NULL;
popts->filenames = NULL;
popts->ifile_fmt = "dkvp";
popts->ofile_fmt = "dkvp";
popts->use_mmap_for_read = TRUE;
int left_align_pprint = TRUE;
int have_rand_seed = FALSE;
unsigned rand_seed = 0;
int argi = 1;
for (; argi < argc; argi++) {
if (argv[argi][0] != '-') {
break;
} else if (streq(argv[argi], "--version")) {
#ifdef HAVE_CONFIG_H
printf("Miller %s\n", PACKAGE_VERSION);
#else
printf("Miller %s\n", MLR_VERSION);
#endif // HAVE_CONFIG_H
exit(0);
} else if (streq(argv[argi], "-h")) {
main_usage(stdout, argv[0]);
exit(0);
} else if (streq(argv[argi], "--help")) {
main_usage(stdout, argv[0]);
exit(0);
} else if (streq(argv[argi], "--help-all-verbs")) {
usage_all_verbs(argv[0]);
} else if (streq(argv[argi], "--list-all-verbs") || streq(argv[argi], "-l")) {
list_all_verbs(stdout, "");
exit(0);
} else if (streq(argv[argi], "--list-all-verbs-raw")) {
list_all_verbs_raw(stdout);
exit(0);
} else if (streq(argv[argi], "--list-all-functions-raw")) {
lrec_evaluator_list_all_functions_raw(stdout);
exit(0);
} else if (streq(argv[argi], "--help-all-functions") || streq(argv[argi], "-f")) {
lrec_evaluator_function_usage(stdout, NULL);
exit(0);
} else if (streq(argv[argi], "--help-function") || streq(argv[argi], "--hf")) {
check_arg_count(argv, argi, argc, 2);
lrec_evaluator_function_usage(stdout, argv[argi+1]);
exit(0);
// main-usage subsections, individually accessible for the benefit of
// the manpage-autogenerator
} else if (streq(argv[argi], "--usage-synopsis")) {
main_usage_synopsis(stdout, argv[0]);
exit(0);
} else if (streq(argv[argi], "--usage-examples")) {
main_usage_examples(stdout, argv[0], "");
exit(0);
} else if (streq(argv[argi], "--usage-list-all-verbs")) {
list_all_verbs(stdout, "");
exit(0);
} else if (streq(argv[argi], "--usage-help-options")) {
main_usage_help_options(stdout, argv[0]);
exit(0);
} else if (streq(argv[argi], "--usage-functions")) {
main_usage_functions(stdout, argv[0], "");
exit(0);
} else if (streq(argv[argi], "--usage-data-format-examples")) {
main_usage_data_format_examples(stdout, argv[0]);
exit(0);
} else if (streq(argv[argi], "--usage-data-format-options")) {
main_usage_data_format_options(stdout, argv[0]);
exit(0);
} else if (streq(argv[argi], "--usage-compressed-data-options")) {
main_usage_compressed_data_options(stdout, argv[0]);
exit(0);
} else if (streq(argv[argi], "--usage-separator-options")) {
main_usage_separator_options(stdout, argv[0]);
exit(0);
} else if (streq(argv[argi], "--usage-csv-options")) {
main_usage_csv_options(stdout, argv[0]);
exit(0);
} else if (streq(argv[argi], "--usage-double-quoting")) {
main_usage_double_quoting(stdout, argv[0]);
exit(0);
} else if (streq(argv[argi], "--usage-numerical-formatting")) {
main_usage_numerical_formatting(stdout, argv[0]);
exit(0);
} else if (streq(argv[argi], "--usage-other-options")) {
main_usage_other_options(stdout, argv[0]);
exit(0);
} else if (streq(argv[argi], "--usage-then-chaining")) {
main_usage_then_chaining(stdout, argv[0]);
exit(0);
} else if (streq(argv[argi], "--usage-see-also")) {
main_usage_see_also(stdout, argv[0]);
exit(0);
} else if (streq(argv[argi], "--rs")) {
check_arg_count(argv, argi, argc, 2);
popts->ors = sep_from_arg(argv[argi+1], argv[0]);
popts->irs = sep_from_arg(argv[argi+1], argv[0]);
argi++;
} else if (streq(argv[argi], "--irs")) {
check_arg_count(argv, argi, argc, 2);
popts->irs = sep_from_arg(argv[argi+1], argv[0]);
argi++;
} else if (streq(argv[argi], "--ors")) {
check_arg_count(argv, argi, argc, 2);
popts->ors = sep_from_arg(argv[argi+1], argv[0]);
argi++;
} else if (streq(argv[argi], "--fs")) {
check_arg_count(argv, argi, argc, 2);
popts->ofs = sep_from_arg(argv[argi+1], argv[0]);
popts->ifs = sep_from_arg(argv[argi+1], argv[0]);
argi++;
} else if (streq(argv[argi], "--ifs")) {
check_arg_count(argv, argi, argc, 2);
popts->ifs = sep_from_arg(argv[argi+1], argv[0]);
argi++;
} else if (streq(argv[argi], "--ofs")) {
check_arg_count(argv, argi, argc, 2);
popts->ofs = sep_from_arg(argv[argi+1], argv[0]);
argi++;
} else if (streq(argv[argi], "--repifs")) {
popts->allow_repeat_ifs = TRUE;
} else if (streq(argv[argi], "--implicit-csv-header")) {
popts->use_implicit_csv_header = TRUE;
} else if (streq(argv[argi], "--headerless-csv-output")) {
popts->headerless_csv_output = TRUE;
} else if (streq(argv[argi], "-p")) {
popts->ifile_fmt = "nidx";
popts->ofile_fmt = "nidx";
popts->ifs = " ";
popts->ofs = " ";
popts->allow_repeat_ifs = TRUE;
} else if (streq(argv[argi], "--ps")) {
check_arg_count(argv, argi, argc, 2);
popts->ops = sep_from_arg(argv[argi+1], argv[0]);
popts->ips = sep_from_arg(argv[argi+1], argv[0]);
argi++;
} else if (streq(argv[argi], "--ips")) {
check_arg_count(argv, argi, argc, 2);
popts->ips = sep_from_arg(argv[argi+1], argv[0]);
argi++;
} else if (streq(argv[argi], "--ops")) {
check_arg_count(argv, argi, argc, 2);
popts->ops = sep_from_arg(argv[argi+1], argv[0]);
argi++;
} else if (streq(argv[argi], "--xvright")) {
popts->right_justify_xtab_value = TRUE;
} else if (streq(argv[argi], "--jvstack")) {
popts->stack_json_output_vertically = TRUE;
} else if (streq(argv[argi], "--jlistwrap")) {
popts->wrap_json_output_in_outer_list = TRUE;
} else if (streq(argv[argi], "--jquoteall")) {
popts->quote_json_values_always = TRUE;
} else if (streq(argv[argi], "--jflatsep")) {
check_arg_count(argv, argi, argc, 2);
popts->json_flatten_separator = sep_from_arg(argv[argi+1], argv[0]);
argi++;
} else if (streq(argv[argi], "--csv")) { popts->ifile_fmt = popts->ofile_fmt = "csv";
} else if (streq(argv[argi], "--icsv")) { popts->ifile_fmt = "csv";
} else if (streq(argv[argi], "--ocsv")) { popts->ofile_fmt = "csv";
} else if (streq(argv[argi], "--csvlite")) { popts->ifile_fmt = popts->ofile_fmt = "csvlite";
} else if (streq(argv[argi], "--icsvlite")) { popts->ifile_fmt = "csvlite";
} else if (streq(argv[argi], "--ocsvlite")) { popts->ofile_fmt = "csvlite";
} else if (streq(argv[argi], "--dkvp")) { popts->ifile_fmt = popts->ofile_fmt = "dkvp";
} else if (streq(argv[argi], "--idkvp")) { popts->ifile_fmt = "dkvp";
} else if (streq(argv[argi], "--odkvp")) { popts->ofile_fmt = "dkvp";
} else if (streq(argv[argi], "--json")) { popts->ifile_fmt = popts->ofile_fmt = "json";
} else if (streq(argv[argi], "--ijson")) { popts->ifile_fmt = "json";
} else if (streq(argv[argi], "--ojson")) { popts->ofile_fmt = "json";
} else if (streq(argv[argi], "--nidx")) { popts->ifile_fmt = popts->ofile_fmt = "nidx";
} else if (streq(argv[argi], "--inidx")) { popts->ifile_fmt = "nidx";
} else if (streq(argv[argi], "--onidx")) { popts->ofile_fmt = "nidx";
} else if (streq(argv[argi], "--xtab")) { popts->ifile_fmt = popts->ofile_fmt = "xtab";
} else if (streq(argv[argi], "--ixtab")) { popts->ifile_fmt = "xtab";
} else if (streq(argv[argi], "--oxtab")) { popts->ofile_fmt = "xtab";
} else if (streq(argv[argi], "--ipprint")) {
popts->ifile_fmt = "csvlite";
popts->ifs = " ";
popts->allow_repeat_ifs = TRUE;
} else if (streq(argv[argi], "--opprint")) {
popts->ofile_fmt = "pprint";
} else if (streq(argv[argi], "--pprint")) {
popts->ifile_fmt = "csvlite";
popts->ifs = " ";
popts->allow_repeat_ifs = TRUE;
popts->ofile_fmt = "pprint";
} else if (streq(argv[argi], "--right")) {
left_align_pprint = FALSE;
} else if (streq(argv[argi], "--ofmt")) {
check_arg_count(argv, argi, argc, 2);
popts->ofmt = argv[argi+1];
argi++;
} else if (streq(argv[argi], "--quote-all")) { popts->oquoting = QUOTE_ALL;
} else if (streq(argv[argi], "--quote-none")) { popts->oquoting = QUOTE_NONE;
} else if (streq(argv[argi], "--quote-minimal")) { popts->oquoting = QUOTE_MINIMAL;
} else if (streq(argv[argi], "--quote-numeric")) { popts->oquoting = QUOTE_NUMERIC;
} else if (streq(argv[argi], "--mmap")) {
popts->use_mmap_for_read = TRUE;
} else if (streq(argv[argi], "--no-mmap")) {
popts->use_mmap_for_read = FALSE;
} else if (streq(argv[argi], "--seed")) {
check_arg_count(argv, argi, argc, 2);
if (sscanf(argv[argi+1], "0x%x", &rand_seed) == 1) {
have_rand_seed = TRUE;
} else if (sscanf(argv[argi+1], "%u", &rand_seed) == 1) {
have_rand_seed = TRUE;
} else {
main_usage(stderr, argv[0]);
exit(1);
}
argi++;
} else if (streq(argv[argi], "--prepipe")) {
check_arg_count(argv, argi, argc, 2);
popts->prepipe = argv[argi+1];
popts->use_mmap_for_read = FALSE;
argi++;
} else {
usage_unrecognized_verb(argv[0], argv[argi]);
}
}
lhmss_t* default_rses = get_default_rses();
lhmss_t* default_fses = get_default_fses();
lhmss_t* default_pses = get_default_pses();
lhmsi_t* default_repeat_ifses = get_default_repeat_ifses();
lhmsi_t* default_repeat_ipses = get_default_repeat_ipses();
if (popts->irs == NULL)
popts->irs = lhmss_get(default_rses, popts->ifile_fmt);
if (popts->ifs == NULL)
popts->ifs = lhmss_get(default_fses, popts->ifile_fmt);
if (popts->ips == NULL)
popts->ips = lhmss_get(default_pses, popts->ifile_fmt);
if (popts->allow_repeat_ifs == NEITHER_TRUE_NOR_FALSE)
popts->allow_repeat_ifs = lhmsi_get(default_repeat_ifses, popts->ifile_fmt);
if (popts->allow_repeat_ips == NEITHER_TRUE_NOR_FALSE)
popts->allow_repeat_ips = lhmsi_get(default_repeat_ipses, popts->ifile_fmt);
if (popts->ors == NULL)
popts->ors = lhmss_get(default_rses, popts->ofile_fmt);
if (popts->ofs == NULL)
popts->ofs = lhmss_get(default_fses, popts->ofile_fmt);
if (popts->ops == NULL)
popts->ops = lhmss_get(default_pses, popts->ofile_fmt);
if (popts->irs == NULL) {
fprintf(stderr, "%s: internal coding error detected in file %s at line %d.\n", argv[0], __FILE__, __LINE__);
exit(1);
}
if (popts->ifs == NULL) {
fprintf(stderr, "%s: internal coding error detected in file %s at line %d.\n", argv[0], __FILE__, __LINE__);
exit(1);
}
if (popts->ips == NULL) {
fprintf(stderr, "%s: internal coding error detected in file %s at line %d.\n", argv[0], __FILE__, __LINE__);
exit(1);
}
if (popts->allow_repeat_ifs == NEITHER_TRUE_NOR_FALSE) {
fprintf(stderr, "%s: internal coding error detected in file %s at line %d.\n", argv[0], __FILE__, __LINE__);
exit(1);
}
if (popts->allow_repeat_ips == NEITHER_TRUE_NOR_FALSE) {
fprintf(stderr, "%s: internal coding error detected in file %s at line %d.\n", argv[0], __FILE__, __LINE__);
exit(1);
}
if (popts->ors == NULL) {
fprintf(stderr, "%s: internal coding error detected in file %s at line %d.\n", argv[0], __FILE__, __LINE__);
exit(1);
}
if (popts->ofs == NULL) {
fprintf(stderr, "%s: internal coding error detected in file %s at line %d.\n", argv[0], __FILE__, __LINE__);
exit(1);
}
if (popts->ops == NULL) {
fprintf(stderr, "%s: internal coding error detected in file %s at line %d.\n", argv[0], __FILE__, __LINE__);
exit(1);
}
if (streq(popts->ofile_fmt, "pprint") && strlen(popts->ofs) != 1) {
fprintf(stderr, "%s: OFS for PPRINT format must be single-character; got \"%s\".\n",
argv[0], popts->ofs);
return NULL;
}
if (streq(popts->ofile_fmt, "dkvp"))
popts->plrec_writer = lrec_writer_dkvp_alloc(popts->ors, popts->ofs, popts->ops);
else if (streq(popts->ofile_fmt, "json"))
popts->plrec_writer = lrec_writer_json_alloc(popts->stack_json_output_vertically,
popts->wrap_json_output_in_outer_list, popts->quote_json_values_always, popts->json_flatten_separator);
else if (streq(popts->ofile_fmt, "csv"))
popts->plrec_writer = lrec_writer_csv_alloc(popts->ors, popts->ofs, popts->oquoting,
popts->headerless_csv_output);
else if (streq(popts->ofile_fmt, "csvlite"))
popts->plrec_writer = lrec_writer_csvlite_alloc(popts->ors, popts->ofs, popts->headerless_csv_output);
else if (streq(popts->ofile_fmt, "nidx"))
popts->plrec_writer = lrec_writer_nidx_alloc(popts->ors, popts->ofs);
else if (streq(popts->ofile_fmt, "xtab"))
popts->plrec_writer = lrec_writer_xtab_alloc(popts->ofs, popts->ops, popts->right_justify_xtab_value);
else if (streq(popts->ofile_fmt, "pprint"))
popts->plrec_writer = lrec_writer_pprint_alloc(popts->ors, popts->ofs[0], left_align_pprint);
else {
main_usage(stderr, argv[0]);
exit(1);
}
if ((argc - argi) < 1) {
main_usage(stderr, argv[0]);
exit(1);
}
popts->pmapper_list = sllv_alloc();
while (TRUE) {
check_arg_count(argv, argi, argc, 1);
char* verb = argv[argi];
mapper_setup_t* pmapper_setup = look_up_mapper_setup(verb);
if (pmapper_setup == NULL) {
fprintf(stderr, "%s: verb \"%s\" not found. Please use \"%s --help\" for a list.\n",
argv[0], verb, argv[0]);
exit(1);
}
if ((argc - argi) >= 2) {
if (streq(argv[argi+1], "-h") || streq(argv[argi+1], "--help")) {
pmapper_setup->pusage_func(stdout, argv[0], verb);
exit(0);
}
}
// It's up to the parse func to print its usage on CLI-parse failure.
mapper_t* pmapper = pmapper_setup->pparse_func(&argi, argc, argv);
if (pmapper == NULL) {
exit(1);
}
sllv_append(popts->pmapper_list, pmapper);
if (argi >= argc || !streq(argv[argi], "then"))
break;
argi++;
}
popts->filenames = &argv[argi];
// No filenames means read from standard input, and standard input cannot be mmapped.
if (argi == argc)
popts->use_mmap_for_read = FALSE;
popts->plrec_reader = lrec_reader_alloc(popts->ifile_fmt, popts->use_mmap_for_read,
popts->irs, popts->ifs, popts->allow_repeat_ifs, popts->ips, popts->allow_repeat_ips,
popts->use_implicit_csv_header, popts->json_flatten_separator);
if (popts->plrec_reader == NULL) {
main_usage(stderr, argv[0]);
exit(1);
}
if (have_rand_seed) {
mtrand_init(rand_seed);
} else {
mtrand_init_default();
}
return popts;
}
// ================================================================
ap_state_t* ap_alloc() {
ap_state_t* pstate = mlr_malloc_or_die(sizeof(ap_state_t));
pstate->pflag_defs = sllv_alloc();
return pstate;
}
// ----------------------------------------------------------------
mlr_dsl_ast_node_t* mlr_dsl_ast_node_alloc_zary(char* text, int type)
{
mlr_dsl_ast_node_t* pnode = mlr_dsl_ast_node_alloc(text, type);
pnode->pchildren = sllv_alloc();
return pnode;
}
