From ac0584bea4f200ba0d508eaa33fc9b795f4eac6d Mon Sep 17 00:00:00 2001 From: John Kerl Date: Thu, 21 May 2015 20:12:43 -0400 Subject: [PATCH] renames --- c/cli/mlrcli.c | 12 ++--- c/cli/mlrcli.h | 4 +- c/containers/lrec_parsers.c | 8 +-- c/containers/lrec_parsers.h | 8 +-- c/containers/test_lrec.c | 10 ++-- c/input/lrec_reader.h | 21 -------- c/input/lrec_reader_csv_mmap.c | 10 ++-- ...c_reader_csv.c => lrec_reader_csv_stdio.c} | 32 ++++++------ c/input/lrec_reader_dkvp.c | 49 ------------------- c/input/lrec_reader_dkvp_mmap.c | 10 ++-- c/input/lrec_reader_dkvp_stdio.c | 49 +++++++++++++++++++ c/input/lrec_reader_mmap.h | 2 +- c/input/lrec_reader_nidx.c | 43 ---------------- c/input/lrec_reader_nidx_mmap.c | 10 ++-- c/input/lrec_reader_nidx_stdio.c | 43 ++++++++++++++++ c/input/lrec_reader_stdio.h | 21 ++++++++ c/input/lrec_reader_xtab_mmap.c | 10 ++-- ...reader_xtab.c => lrec_reader_xtab_stdio.c} | 32 ++++++------ c/input/lrec_readers.h | 10 ++-- c/lib/mlrmath.h | 10 ++-- c/mapping/context.h | 1 + c/mlrmain.c | 4 +- c/stream/stream.c | 20 ++++---- c/stream/stream.h | 2 +- 24 files changed, 211 insertions(+), 210 deletions(-) delete mode 100644 c/input/lrec_reader.h rename c/input/{lrec_reader_csv.c => lrec_reader_csv_stdio.c} (79%) delete mode 100644 c/input/lrec_reader_dkvp.c create mode 100644 c/input/lrec_reader_dkvp_stdio.c delete mode 100644 c/input/lrec_reader_nidx.c create mode 100644 c/input/lrec_reader_nidx_stdio.c create mode 100644 c/input/lrec_reader_stdio.h rename c/input/{lrec_reader_xtab.c => lrec_reader_xtab_stdio.c} (51%) diff --git a/c/cli/mlrcli.c b/c/cli/mlrcli.c index 2d09ef41c..65824b6fb 100644 --- a/c/cli/mlrcli.c +++ b/c/cli/mlrcli.c @@ -154,7 +154,7 @@ cli_opts_t* parse_command_line(int argc, char** argv) { popts->ops = DEFAULT_PS; popts->ofmt = DEFAULT_OFMT; - popts->plrec_reader = NULL; + popts->plrec_reader_stdio = NULL; popts->plrec_reader_mmap = NULL; popts->plrec_writer = NULL; popts->filenames = NULL; @@ -281,16 +281,16 @@ cli_opts_t* parse_command_line(int argc, char** argv) { // xxx alloc mmap readers here too // xxx have use-mmap-readers flag ... if (streq(rdesc, "dkvp")) { - popts->plrec_reader = lrec_reader_dkvp_alloc(popts->irs, popts->ifs, popts->ips, popts->allow_repeat_ifs); + popts->plrec_reader_stdio = lrec_reader_dkvp_stdio_alloc(popts->irs, popts->ifs, popts->ips, popts->allow_repeat_ifs); popts->plrec_reader_mmap = lrec_reader_dkvp_mmap_alloc(popts->irs, popts->ifs, popts->ips, popts->allow_repeat_ifs); } else if (streq(rdesc, "csv")) { - popts->plrec_reader = lrec_reader_csv_alloc(popts->irs, popts->ifs, popts->allow_repeat_ifs); + popts->plrec_reader_stdio = lrec_reader_csv_stdio_alloc(popts->irs, popts->ifs, popts->allow_repeat_ifs); popts->plrec_reader_mmap = lrec_reader_csv_mmap_alloc(popts->irs, popts->ifs, popts->ips); } else if (streq(rdesc, "nidx")) { - popts->plrec_reader = lrec_reader_nidx_alloc(popts->irs, popts->ifs, popts->allow_repeat_ifs); + popts->plrec_reader_stdio = lrec_reader_nidx_stdio_alloc(popts->irs, popts->ifs, popts->allow_repeat_ifs); popts->plrec_reader_mmap = lrec_reader_nidx_mmap_alloc(popts->irs, popts->ifs, popts->allow_repeat_ifs); } else if (streq(rdesc, "xtab")) { - popts->plrec_reader = lrec_reader_xtab_alloc(popts->ips, TRUE); // xxx parameterize allow_repeat_ips + popts->plrec_reader_stdio = lrec_reader_xtab_stdio_alloc(popts->ips, TRUE); // xxx parameterize allow_repeat_ips popts->plrec_reader_mmap = lrec_reader_xtab_mmap_alloc(popts->irs, popts->ips, TRUE/*popts->allow_repeat_ips*/); } else { main_usage(argv[0], 1); @@ -355,7 +355,7 @@ cli_opts_t* parse_command_line(int argc, char** argv) { // ---------------------------------------------------------------- void cli_opts_free(cli_opts_t* popts) { - popts->plrec_reader->pfree_func(popts->plrec_reader->pvstate); + popts->plrec_reader_stdio->pfree_func(popts->plrec_reader_stdio->pvstate); for (sllve_t* pe = popts->pmapper_list->phead; pe != NULL; pe = pe->pnext) { mapper_t* pmapper = pe->pvdata; diff --git a/c/cli/mlrcli.h b/c/cli/mlrcli.h index 0d62ae0ce..35fea8a33 100644 --- a/c/cli/mlrcli.h +++ b/c/cli/mlrcli.h @@ -2,7 +2,7 @@ #define MLRCLI_H #include "containers/sllv.h" -#include "input/lrec_reader.h" +#include "input/lrec_reader_stdio.h" #include "input/lrec_reader_mmap.h" #include "mapping/mapper.h" #include "output/lrec_writer.h" @@ -20,7 +20,7 @@ typedef struct _cli_opts_t { char* ofmt; int use_file_reader_mmap; - lrec_reader_t* plrec_reader; + lrec_reader_stdio_t* plrec_reader_stdio; lrec_reader_mmap_t* plrec_reader_mmap; sllv_t* pmapper_list; lrec_writer_t* plrec_writer; diff --git a/c/containers/lrec_parsers.c b/c/containers/lrec_parsers.c index fdb746c17..da5f29e41 100644 --- a/c/containers/lrec_parsers.c +++ b/c/containers/lrec_parsers.c @@ -32,7 +32,7 @@ static char* make_nidx_key(int idx, char* pfree_flags) { } } -lrec_t* lrec_parse_nidx(char* line, char ifs, int allow_repeat_ifs) { +lrec_t* lrec_parse_nidx_stdio(char* line, char ifs, int allow_repeat_ifs) { lrec_t* prec = lrec_nidx_alloc(line); int idx = 0; @@ -119,7 +119,7 @@ lrec_t* lrec_parse_nidx_mmap(file_reader_mmap_state_t *phandle, char irs, char i // I couldn't find a performance gain using stdlib index(3) ... *maybe* even a // fraction of a percent *slower*. -lrec_t* lrec_parse_dkvp(char* line, char ifs, char ips, int allow_repeat_ifs) { +lrec_t* lrec_parse_dkvp_stdio(char* line, char ifs, char ips, int allow_repeat_ifs) { lrec_t* prec = lrec_dkvp_alloc(line); char* key = line; @@ -273,7 +273,7 @@ slls_t* split_csv_header_line(char* line, char ifs, int allow_repeat_ifs) { } // ---------------------------------------------------------------- -lrec_t* lrec_parse_csv(hdr_keeper_t* phdr_keeper, char* data_line, char ifs, int allow_repeat_ifs) { +lrec_t* lrec_parse_csv_stdio(hdr_keeper_t* phdr_keeper, char* data_line, char ifs, int allow_repeat_ifs) { lrec_t* prec = lrec_csv_alloc(data_line); char* key = NULL; char* value = data_line; @@ -323,7 +323,7 @@ lrec_t* lrec_parse_csv_mmap(hdr_keeper_t* phdr_keeper, file_reader_mmap_state_t* } // ---------------------------------------------------------------- -lrec_t* lrec_parse_xtab(slls_t* pxtab_lines, char ips, int allow_repeat_ips) { +lrec_t* lrec_parse_xtab_stdio(slls_t* pxtab_lines, char ips, int allow_repeat_ips) { lrec_t* prec = lrec_xtab_alloc(pxtab_lines); for (sllse_t* pe = pxtab_lines->phead; pe != NULL; pe = pe->pnext) { diff --git a/c/containers/lrec_parsers.h b/c/containers/lrec_parsers.h index 4a0e59d8f..7d88a88ae 100644 --- a/c/containers/lrec_parsers.h +++ b/c/containers/lrec_parsers.h @@ -8,11 +8,11 @@ #include "containers/hdr_keeper.h" // xxx cmt/arg re freeing ....... -lrec_t* lrec_parse_nidx(char* line, char ifs, int allow_repeat_ifs); -lrec_t* lrec_parse_dkvp(char* line, char ifs, char ips, int allow_repeat_ifs); +lrec_t* lrec_parse_nidx_stdio(char* line, char ifs, int allow_repeat_ifs); +lrec_t* lrec_parse_dkvp_stdio(char* line, char ifs, char ips, int allow_repeat_ifs); slls_t* split_csv_header_line(char* line, char ifs, int allow_repeat_ifs); -lrec_t* lrec_parse_csv(hdr_keeper_t* phdr_keeper, char* data_line, char ifs, int allow_repeat_ifs); -lrec_t* lrec_parse_xtab(slls_t* pxtab_lines, char ips, int allow_repeat_ips); +lrec_t* lrec_parse_csv_stdio(hdr_keeper_t* phdr_keeper, char* data_line, char ifs, int allow_repeat_ifs); +lrec_t* lrec_parse_xtab_stdio(slls_t* pxtab_lines, char ips, int allow_repeat_ips); lrec_t* lrec_parse_nidx_mmap(file_reader_mmap_state_t* phandle, char irs, char ifs, int allow_repeat_ifs); lrec_t* lrec_parse_dkvp_mmap(file_reader_mmap_state_t *phandle, char irs, char ifs, char ips, int allow_repeat_ifs); diff --git a/c/containers/test_lrec.c b/c/containers/test_lrec.c index efbcc6a64..7693d30b0 100644 --- a/c/containers/test_lrec.c +++ b/c/containers/test_lrec.c @@ -74,7 +74,7 @@ static char* test_lrec_unbacked_api() { // ---------------------------------------------------------------- static char* test_lrec_dkvp_api() { char* line = strdup("w=2,x=3,y=4,z=5"); - lrec_t* prec = lrec_parse_dkvp(line, ',', '=', FALSE); + lrec_t* prec = lrec_parse_dkvp_stdio(line, ',', '=', FALSE); mu_assert_lf(prec->field_count == 4); mu_assert_lf(streq(lrec_get(prec, "w"), "2")); @@ -112,7 +112,7 @@ static char* test_lrec_dkvp_api() { // ---------------------------------------------------------------- static char* test_lrec_nidx_api() { char* line = strdup("a,b,c,d"); - lrec_t* prec = lrec_parse_nidx(line, ',', FALSE); + lrec_t* prec = lrec_parse_nidx_stdio(line, ',', FALSE); mu_assert_lf(prec->field_count == 4); mu_assert_lf(streq(lrec_get(prec, "1"), "a")); @@ -154,10 +154,10 @@ static char* test_lrec_csv_api() { hdr_keeper_t* phdr_keeper = hdr_keeper_alloc(hdr_line, hdr_fields); char* data_line_1 = strdup("2,3,4,5"); - lrec_t* prec_1 = lrec_parse_csv(phdr_keeper, data_line_1, ',', FALSE); + lrec_t* prec_1 = lrec_parse_csv_stdio(phdr_keeper, data_line_1, ',', FALSE); char* data_line_2 = strdup("6,7,8,9"); - lrec_t* prec_2 = lrec_parse_csv(phdr_keeper, data_line_2, ',', FALSE); + lrec_t* prec_2 = lrec_parse_csv_stdio(phdr_keeper, data_line_2, ',', FALSE); mu_assert_lf(prec_1->field_count == 4); mu_assert_lf(prec_2->field_count == 4); @@ -216,7 +216,7 @@ static char* test_lrec_xtab_api() { slls_add_with_free(pxtab_lines, line_3); slls_add_with_free(pxtab_lines, line_4); - lrec_t* prec = lrec_parse_xtab(pxtab_lines, ' ', TRUE); + lrec_t* prec = lrec_parse_xtab_stdio(pxtab_lines, ' ', TRUE); mu_assert_lf(prec->field_count == 4); mu_assert_lf(streq(lrec_get(prec, "w"), "2")); diff --git a/c/input/lrec_reader.h b/c/input/lrec_reader.h deleted file mode 100644 index d094b1858..000000000 --- a/c/input/lrec_reader.h +++ /dev/null @@ -1,21 +0,0 @@ -#ifndef LREC_READER_H -#define LREC_READER_H - -#include -#include "containers/lrec.h" -#include "mapping/context.h" - -// xxx rename to lrec_reader -typedef lrec_t* lrec_reader_func_t(FILE* fp, void* pvstate, context_t* pctx); -// xxx rename to sof_resetter or some such -typedef void reset_func_t(void* pvstate); -typedef void lrec_reader_free_func_t(void* pvstate); - -typedef struct _lrec_reader_t { - void* pvstate; - lrec_reader_func_t* plrec_reader_func; - reset_func_t* preset_func; - lrec_reader_free_func_t* pfree_func; -} lrec_reader_t; - -#endif // LREC_READER_H diff --git a/c/input/lrec_reader_csv_mmap.c b/c/input/lrec_reader_csv_mmap.c index a64e51e05..cdfc54b11 100644 --- a/c/input/lrec_reader_csv_mmap.c +++ b/c/input/lrec_reader_csv_mmap.c @@ -116,7 +116,7 @@ static void reset_csv_mmap_func(void* pvstate) { // ---------------------------------------------------------------- lrec_reader_mmap_t* lrec_reader_csv_mmap_alloc(char irs, char ifs, int allow_repeat_ifs) { - lrec_reader_mmap_t* plrec_reader = mlr_malloc_or_die(sizeof(lrec_reader_mmap_t)); + lrec_reader_mmap_t* plrec_reader_stdio = mlr_malloc_or_die(sizeof(lrec_reader_mmap_t)); lrec_reader_csv_mmap_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_csv_mmap_state_t)); pstate->ifnr = 0LL; @@ -126,11 +126,11 @@ lrec_reader_mmap_t* lrec_reader_csv_mmap_alloc(char irs, char ifs, int allow_rep pstate->expect_header_line_next = TRUE; pstate->phdr_keeper = NULL; pstate->phdr_keepers = lhmslv_alloc(); - plrec_reader->pvstate = (void*)pstate; + plrec_reader_stdio->pvstate = (void*)pstate; // xxx homogenize these names, for all readers & writers - plrec_reader->plrec_reader_func = &lrec_reader_csv_mmap_func; - plrec_reader->preset_func = &reset_csv_mmap_func; + plrec_reader_stdio->plrec_reader_stdio_func = &lrec_reader_csv_mmap_func; + plrec_reader_stdio->preset_func = &reset_csv_mmap_func; - return plrec_reader; + return plrec_reader_stdio; } diff --git a/c/input/lrec_reader_csv.c b/c/input/lrec_reader_csv_stdio.c similarity index 79% rename from c/input/lrec_reader_csv.c rename to c/input/lrec_reader_csv_stdio.c index f18731d41..66aa9e156 100644 --- a/c/input/lrec_reader_csv.c +++ b/c/input/lrec_reader_csv_stdio.c @@ -16,7 +16,7 @@ // to hdr_keeper object. The current phdr_keeper is a pointer into one of // those. Then when the reader is freed, all the header-keepers are freed. -typedef struct _lrec_reader_csv_state_t { +typedef struct _lrec_reader_csv_stdio_state_t { long long ifnr; // xxx cmt w/r/t pctx long long ilno; // xxx cmt w/r/t pctx char irs; @@ -26,7 +26,7 @@ typedef struct _lrec_reader_csv_state_t { int expect_header_line_next; hdr_keeper_t* phdr_keeper; // xxx rename to header_keeper lhmslv_t* phdr_keepers; -} lrec_reader_csv_state_t; +} lrec_reader_csv_stdio_state_t; // Cases: // @@ -51,8 +51,8 @@ typedef struct _lrec_reader_csv_state_t { // // etc. -static lrec_t* lrec_reader_csv_func(FILE* input_stream, void* pvstate, context_t* pctx) { - lrec_reader_csv_state_t* pstate = pvstate; +static lrec_t* lrec_reader_csv_stdio_func(FILE* input_stream, void* pvstate, context_t* pctx) { + lrec_reader_csv_stdio_state_t* pstate = pvstate; while (TRUE) { if (pstate->expect_header_line_next) { @@ -99,22 +99,22 @@ static lrec_t* lrec_reader_csv_func(FILE* input_stream, void* pvstate, context_t } } else { pstate->ifnr++; - return lrec_parse_csv(pstate->phdr_keeper, line, pstate->ifs, pstate->allow_repeat_ifs); + return lrec_parse_csv_stdio(pstate->phdr_keeper, line, pstate->ifs, pstate->allow_repeat_ifs); } } } // ---------------------------------------------------------------- static void reset_csv_func(void* pvstate) { - lrec_reader_csv_state_t* pstate = pvstate; + lrec_reader_csv_stdio_state_t* pstate = pvstate; pstate->ifnr = 0LL; pstate->ilno = 0LL; pstate->expect_header_line_next = TRUE; } // ---------------------------------------------------------------- -static void lrec_reader_csv_free(void* pvstate) { - lrec_reader_csv_state_t* pstate = pvstate; +static void lrec_reader_csv_stdio_free(void* pvstate) { + lrec_reader_csv_stdio_state_t* pstate = pvstate; for (lhmslve_t* pe = pstate->phdr_keepers->phead; pe != NULL; pe = pe->pnext) { hdr_keeper_t* phdr_keeper = pe->pvvalue; hdr_keeper_free(phdr_keeper); @@ -122,10 +122,10 @@ static void lrec_reader_csv_free(void* pvstate) { } // ---------------------------------------------------------------- -lrec_reader_t* lrec_reader_csv_alloc(char irs, char ifs, int allow_repeat_ifs) { - lrec_reader_t* plrec_reader = mlr_malloc_or_die(sizeof(lrec_reader_t)); +lrec_reader_stdio_t* lrec_reader_csv_stdio_alloc(char irs, char ifs, int allow_repeat_ifs) { + lrec_reader_stdio_t* plrec_reader_stdio = mlr_malloc_or_die(sizeof(lrec_reader_stdio_t)); - lrec_reader_csv_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_csv_state_t)); + lrec_reader_csv_stdio_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_csv_stdio_state_t)); pstate->ifnr = 0LL; pstate->irs = irs; pstate->ifs = ifs; @@ -133,12 +133,12 @@ lrec_reader_t* lrec_reader_csv_alloc(char irs, char ifs, int allow_repeat_ifs) { pstate->expect_header_line_next = TRUE; pstate->phdr_keeper = NULL; pstate->phdr_keepers = lhmslv_alloc(); - plrec_reader->pvstate = (void*)pstate; + plrec_reader_stdio->pvstate = (void*)pstate; // xxx homogenize these names, for all readers & writers - plrec_reader->plrec_reader_func = &lrec_reader_csv_func; - plrec_reader->preset_func = &reset_csv_func; - plrec_reader->pfree_func = &lrec_reader_csv_free; + plrec_reader_stdio->plrec_reader_stdio_func = &lrec_reader_csv_stdio_func; + plrec_reader_stdio->preset_func = &reset_csv_func; + plrec_reader_stdio->pfree_func = &lrec_reader_csv_stdio_free; - return plrec_reader; + return plrec_reader_stdio; } diff --git a/c/input/lrec_reader_dkvp.c b/c/input/lrec_reader_dkvp.c deleted file mode 100644 index 6348c5839..000000000 --- a/c/input/lrec_reader_dkvp.c +++ /dev/null @@ -1,49 +0,0 @@ -#include -#include -#include "lib/mlrutil.h" -#include "containers/lrec_parsers.h" -#include "input/lrec_readers.h" - -typedef struct _lrec_reader_dkvp_state_t { - char irs; - char ifs; - char ips; - int allow_repeat_ifs; -} lrec_reader_dkvp_state_t; - -// ---------------------------------------------------------------- -static lrec_t* lrec_reader_dkvp_func(FILE* input_stream, void* pvstate, context_t* pctx) { - lrec_reader_dkvp_state_t* pstate = pvstate; - - char* line = mlr_get_line(input_stream, pstate->irs); - - if (line == NULL) - return NULL; - else - return lrec_parse_dkvp(line, pstate->ifs, pstate->ips, pstate->allow_repeat_ifs); -} - -// No-op for stateless readers such as this one. -static void reset_dkvp_func(void* pvstate) { -} - -// No-op for stateless readers such as this one. -static void lrec_reader_dkvp_free(void* pvstate) { -} - -lrec_reader_t* lrec_reader_dkvp_alloc(char irs, char ifs, char ips, int allow_repeat_ifs) { - lrec_reader_t* plrec_reader = mlr_malloc_or_die(sizeof(lrec_reader_t)); - - lrec_reader_dkvp_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_dkvp_state_t)); - pstate->irs = irs; - pstate->ifs = ifs; - pstate->ips = ips; - pstate->allow_repeat_ifs = allow_repeat_ifs; - plrec_reader->pvstate = (void*)pstate; - - plrec_reader->plrec_reader_func = &lrec_reader_dkvp_func; - plrec_reader->preset_func = &reset_dkvp_func; - plrec_reader->pfree_func = &lrec_reader_dkvp_free;; - - return plrec_reader; -} diff --git a/c/input/lrec_reader_dkvp_mmap.c b/c/input/lrec_reader_dkvp_mmap.c index 5a4ad0c42..6c213cdac 100644 --- a/c/input/lrec_reader_dkvp_mmap.c +++ b/c/input/lrec_reader_dkvp_mmap.c @@ -26,17 +26,17 @@ static void reset_dkvp_mmap_func(void* pvstate) { } lrec_reader_mmap_t* lrec_reader_dkvp_mmap_alloc(char irs, char ifs, char ips, int allow_repeat_ifs) { - lrec_reader_mmap_t* plrec_reader = mlr_malloc_or_die(sizeof(lrec_reader_mmap_t)); + lrec_reader_mmap_t* plrec_reader_stdio = mlr_malloc_or_die(sizeof(lrec_reader_mmap_t)); lrec_reader_dkvp_mmap_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_dkvp_mmap_state_t)); pstate->irs = irs; pstate->ifs = ifs; pstate->ips = ips; pstate->allow_repeat_ifs = allow_repeat_ifs; - plrec_reader->pvstate = (void*)pstate; + plrec_reader_stdio->pvstate = (void*)pstate; - plrec_reader->plrec_reader_func = &lrec_reader_dkvp_mmap_func; - plrec_reader->preset_func = &reset_dkvp_mmap_func; + plrec_reader_stdio->plrec_reader_stdio_func = &lrec_reader_dkvp_mmap_func; + plrec_reader_stdio->preset_func = &reset_dkvp_mmap_func; - return plrec_reader; + return plrec_reader_stdio; } diff --git a/c/input/lrec_reader_dkvp_stdio.c b/c/input/lrec_reader_dkvp_stdio.c new file mode 100644 index 000000000..508417d8a --- /dev/null +++ b/c/input/lrec_reader_dkvp_stdio.c @@ -0,0 +1,49 @@ +#include +#include +#include "lib/mlrutil.h" +#include "containers/lrec_parsers.h" +#include "input/lrec_readers.h" + +typedef struct _lrec_reader_dkvp_stdio_state_t { + char irs; + char ifs; + char ips; + int allow_repeat_ifs; +} lrec_reader_dkvp_stdio_state_t; + +// ---------------------------------------------------------------- +static lrec_t* lrec_reader_dkvp_stdio_func(FILE* input_stream, void* pvstate, context_t* pctx) { + lrec_reader_dkvp_stdio_state_t* pstate = pvstate; + + char* line = mlr_get_line(input_stream, pstate->irs); + + if (line == NULL) + return NULL; + else + return lrec_parse_dkvp_stdio(line, pstate->ifs, pstate->ips, pstate->allow_repeat_ifs); +} + +// No-op for stateless readers such as this one. +static void reset_dkvp_func(void* pvstate) { +} + +// No-op for stateless readers such as this one. +static void lrec_reader_dkvp_stdio_free(void* pvstate) { +} + +lrec_reader_stdio_t* lrec_reader_dkvp_stdio_alloc(char irs, char ifs, char ips, int allow_repeat_ifs) { + lrec_reader_stdio_t* plrec_reader_stdio = mlr_malloc_or_die(sizeof(lrec_reader_stdio_t)); + + lrec_reader_dkvp_stdio_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_dkvp_stdio_state_t)); + pstate->irs = irs; + pstate->ifs = ifs; + pstate->ips = ips; + pstate->allow_repeat_ifs = allow_repeat_ifs; + plrec_reader_stdio->pvstate = (void*)pstate; + + plrec_reader_stdio->plrec_reader_stdio_func = &lrec_reader_dkvp_stdio_func; + plrec_reader_stdio->preset_func = &reset_dkvp_func; + plrec_reader_stdio->pfree_func = &lrec_reader_dkvp_stdio_free;; + + return plrec_reader_stdio; +} diff --git a/c/input/lrec_reader_mmap.h b/c/input/lrec_reader_mmap.h index e987ee78e..d2c591497 100644 --- a/c/input/lrec_reader_mmap.h +++ b/c/input/lrec_reader_mmap.h @@ -15,7 +15,7 @@ typedef void lrec_reader_reset_mmap_func_t(void* pvstate); typedef struct _lrec_reader_mmap_t { void* pvstate; - lrec_reader_mmap_func_t* plrec_reader_func; + lrec_reader_mmap_func_t* plrec_reader_stdio_func; lrec_reader_reset_mmap_func_t* preset_func; } lrec_reader_mmap_t; diff --git a/c/input/lrec_reader_nidx.c b/c/input/lrec_reader_nidx.c deleted file mode 100644 index 4dc364aaf..000000000 --- a/c/input/lrec_reader_nidx.c +++ /dev/null @@ -1,43 +0,0 @@ -#include -#include "lib/mlrutil.h" -#include "containers/lrec_parsers.h" -#include "input/lrec_readers.h" - -typedef struct _lrec_reader_nidx_state_t { - char irs; - char ifs; - int allow_repeat_ifs; -} lrec_reader_nidx_state_t; - -// ---------------------------------------------------------------- -static lrec_t* lrec_reader_nidx_func(FILE* input_stream, void* pvstate, context_t* pctx) { - lrec_reader_nidx_state_t* pstate = pvstate; - char* line = mlr_get_line(input_stream, pstate->irs); - if (line == NULL) - return NULL; - else - return lrec_parse_nidx(line, pstate->ifs, pstate->allow_repeat_ifs); -} - -// No-op for stateless readers such as this one. -static void reset_nidx_func(void* pvstate) { -} - -static void lrec_reader_nidx_free_func(void* pvstate) { -} - -lrec_reader_t* lrec_reader_nidx_alloc(char irs, char ifs, int allow_repeat_ifs) { - lrec_reader_t* plrec_reader = mlr_malloc_or_die(sizeof(lrec_reader_t)); - - lrec_reader_nidx_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_nidx_state_t)); - pstate->irs = irs; - pstate->ifs = ifs; - pstate->allow_repeat_ifs = allow_repeat_ifs; - plrec_reader->pvstate = (void*)pstate; - - plrec_reader->plrec_reader_func = &lrec_reader_nidx_func; - plrec_reader->preset_func = &reset_nidx_func; - plrec_reader->pfree_func = &lrec_reader_nidx_free_func; - - return plrec_reader; -} diff --git a/c/input/lrec_reader_nidx_mmap.c b/c/input/lrec_reader_nidx_mmap.c index 87998f1c8..82c3e39c5 100644 --- a/c/input/lrec_reader_nidx_mmap.c +++ b/c/input/lrec_reader_nidx_mmap.c @@ -24,16 +24,16 @@ static void reset_nidx_func(void* pvstate) { } lrec_reader_mmap_t* lrec_reader_nidx_mmap_alloc(char irs, char ifs, int allow_repeat_ifs) { - lrec_reader_mmap_t* plrec_reader = mlr_malloc_or_die(sizeof(lrec_reader_mmap_t)); + lrec_reader_mmap_t* plrec_reader_stdio = mlr_malloc_or_die(sizeof(lrec_reader_mmap_t)); lrec_reader_nidx_mmap_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_nidx_mmap_state_t)); pstate->irs = irs; pstate->ifs = ifs; pstate->allow_repeat_ifs = allow_repeat_ifs; - plrec_reader->pvstate = (void*)pstate; + plrec_reader_stdio->pvstate = (void*)pstate; - plrec_reader->plrec_reader_func = &lrec_reader_nidx_mmap_func; - plrec_reader->preset_func = &reset_nidx_func; + plrec_reader_stdio->plrec_reader_stdio_func = &lrec_reader_nidx_mmap_func; + plrec_reader_stdio->preset_func = &reset_nidx_func; - return plrec_reader; + return plrec_reader_stdio; } diff --git a/c/input/lrec_reader_nidx_stdio.c b/c/input/lrec_reader_nidx_stdio.c new file mode 100644 index 000000000..cd767899e --- /dev/null +++ b/c/input/lrec_reader_nidx_stdio.c @@ -0,0 +1,43 @@ +#include +#include "lib/mlrutil.h" +#include "containers/lrec_parsers.h" +#include "input/lrec_readers.h" + +typedef struct _lrec_reader_nidx_stdio_state_t { + char irs; + char ifs; + int allow_repeat_ifs; +} lrec_reader_nidx_stdio_state_t; + +// ---------------------------------------------------------------- +static lrec_t* lrec_reader_nidx_stdio_func(FILE* input_stream, void* pvstate, context_t* pctx) { + lrec_reader_nidx_stdio_state_t* pstate = pvstate; + char* line = mlr_get_line(input_stream, pstate->irs); + if (line == NULL) + return NULL; + else + return lrec_parse_nidx_stdio(line, pstate->ifs, pstate->allow_repeat_ifs); +} + +// No-op for stateless readers such as this one. +static void reset_nidx_func(void* pvstate) { +} + +static void lrec_reader_nidx_stdio_free_func(void* pvstate) { +} + +lrec_reader_stdio_t* lrec_reader_nidx_stdio_alloc(char irs, char ifs, int allow_repeat_ifs) { + lrec_reader_stdio_t* plrec_reader_stdio = mlr_malloc_or_die(sizeof(lrec_reader_stdio_t)); + + lrec_reader_nidx_stdio_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_nidx_stdio_state_t)); + pstate->irs = irs; + pstate->ifs = ifs; + pstate->allow_repeat_ifs = allow_repeat_ifs; + plrec_reader_stdio->pvstate = (void*)pstate; + + plrec_reader_stdio->plrec_reader_stdio_func = &lrec_reader_nidx_stdio_func; + plrec_reader_stdio->preset_func = &reset_nidx_func; + plrec_reader_stdio->pfree_func = &lrec_reader_nidx_stdio_free_func; + + return plrec_reader_stdio; +} diff --git a/c/input/lrec_reader_stdio.h b/c/input/lrec_reader_stdio.h new file mode 100644 index 000000000..041959c75 --- /dev/null +++ b/c/input/lrec_reader_stdio.h @@ -0,0 +1,21 @@ +#ifndef LREC_READER_STDIO_H +#define LREC_READER_STDIO_H + +#include +#include "containers/lrec.h" +#include "mapping/context.h" + +// xxx rename to lrec_reader +typedef lrec_t* lrec_reader_stdio_func_t(FILE* fp, void* pvstate, context_t* pctx); +// xxx rename to sof_resetter or some such +typedef void reset_func_t(void* pvstate); +typedef void lrec_reader_stdio_free_func_t(void* pvstate); + +typedef struct _lrec_reader_stdio_t { + void* pvstate; + lrec_reader_stdio_func_t* plrec_reader_stdio_func; + reset_func_t* preset_func; + lrec_reader_stdio_free_func_t* pfree_func; +} lrec_reader_stdio_t; + +#endif // LREC_READER_STDIO_H diff --git a/c/input/lrec_reader_xtab_mmap.c b/c/input/lrec_reader_xtab_mmap.c index 390d36f10..bcde5dcf4 100644 --- a/c/input/lrec_reader_xtab_mmap.c +++ b/c/input/lrec_reader_xtab_mmap.c @@ -30,7 +30,7 @@ static void reset_xtab_func(void* pvstate) { } lrec_reader_mmap_t* lrec_reader_xtab_mmap_alloc(char irs, char ips, int allow_repeat_ips) { - lrec_reader_mmap_t* plrec_reader = mlr_malloc_or_die(sizeof(lrec_reader_mmap_t)); + lrec_reader_mmap_t* plrec_reader_stdio = mlr_malloc_or_die(sizeof(lrec_reader_mmap_t)); lrec_reader_xtab_mmap_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_xtab_mmap_state_t)); //pstate->ips = ips; @@ -39,10 +39,10 @@ lrec_reader_mmap_t* lrec_reader_xtab_mmap_alloc(char irs, char ips, int allow_re pstate->ips = ' '; pstate->allow_repeat_ips = TRUE; pstate->at_eof = FALSE; - plrec_reader->pvstate = (void*)pstate; + plrec_reader_stdio->pvstate = (void*)pstate; - plrec_reader->plrec_reader_func = &lrec_reader_xtab_mmap_func; - plrec_reader->preset_func = &reset_xtab_func; + plrec_reader_stdio->plrec_reader_stdio_func = &lrec_reader_xtab_mmap_func; + plrec_reader_stdio->preset_func = &reset_xtab_func; - return plrec_reader; + return plrec_reader_stdio; } diff --git a/c/input/lrec_reader_xtab.c b/c/input/lrec_reader_xtab_stdio.c similarity index 51% rename from c/input/lrec_reader_xtab.c rename to c/input/lrec_reader_xtab_stdio.c index 1c76eac25..ea983ba98 100644 --- a/c/input/lrec_reader_xtab.c +++ b/c/input/lrec_reader_xtab_stdio.c @@ -4,16 +4,16 @@ #include "containers/lrec_parsers.h" #include "input/lrec_readers.h" -typedef struct _lrec_reader_xtab_state_t { +typedef struct _lrec_reader_xtab_stdio_state_t { char ips; // xxx make me real int allow_repeat_ips; int at_eof; // xxx need to remember EOF for subsequent read -} lrec_reader_xtab_state_t; +} lrec_reader_xtab_stdio_state_t; // ---------------------------------------------------------------- -static lrec_t* lrec_reader_xtab_func(FILE* input_stream, void* pvstate, context_t* pctx) { - lrec_reader_xtab_state_t* pstate = pvstate; +static lrec_t* lrec_reader_xtab_stdio_func(FILE* input_stream, void* pvstate, context_t* pctx) { + lrec_reader_xtab_stdio_state_t* pstate = pvstate; if (pstate->at_eof) return NULL; @@ -28,12 +28,12 @@ static lrec_t* lrec_reader_xtab_func(FILE* input_stream, void* pvstate, context_ if (pxtab_lines->length == 0) { return NULL; } else { - return lrec_parse_xtab(pxtab_lines, pstate->ips, pstate->allow_repeat_ips); + return lrec_parse_xtab_stdio(pxtab_lines, pstate->ips, pstate->allow_repeat_ips); } } else if (*line == '\0') { free(line); if (pxtab_lines->length > 0) { // xxx make an is_empty_modulo_whitespace() - return lrec_parse_xtab(pxtab_lines, pstate->ips, pstate->allow_repeat_ips); + return lrec_parse_xtab_stdio(pxtab_lines, pstate->ips, pstate->allow_repeat_ips); } } else { slls_add_with_free(pxtab_lines, line); @@ -43,27 +43,27 @@ static lrec_t* lrec_reader_xtab_func(FILE* input_stream, void* pvstate, context_ // xxx rename resets to sof_reset or some such static void reset_xtab_func(void* pvstate) { - lrec_reader_xtab_state_t* pstate = pvstate; + lrec_reader_xtab_stdio_state_t* pstate = pvstate; pstate->at_eof = FALSE; } -static void lrec_reader_xtab_free(void* pvstate) { +static void lrec_reader_xtab_stdio_free(void* pvstate) { } -lrec_reader_t* lrec_reader_xtab_alloc(char ips, int allow_repeat_ips) { - lrec_reader_t* plrec_reader = mlr_malloc_or_die(sizeof(lrec_reader_t)); +lrec_reader_stdio_t* lrec_reader_xtab_stdio_alloc(char ips, int allow_repeat_ips) { + lrec_reader_stdio_t* plrec_reader_stdio = mlr_malloc_or_die(sizeof(lrec_reader_stdio_t)); - lrec_reader_xtab_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_xtab_state_t)); + lrec_reader_xtab_stdio_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_xtab_stdio_state_t)); //pstate->ips = ips; //pstate->allow_repeat_ips = allow_repeat_ips; pstate->ips = ' '; pstate->allow_repeat_ips = TRUE; pstate->at_eof = FALSE; - plrec_reader->pvstate = (void*)pstate; + plrec_reader_stdio->pvstate = (void*)pstate; - plrec_reader->plrec_reader_func = &lrec_reader_xtab_func; - plrec_reader->preset_func = &reset_xtab_func; - plrec_reader->pfree_func = &lrec_reader_xtab_free;; + plrec_reader_stdio->plrec_reader_stdio_func = &lrec_reader_xtab_stdio_func; + plrec_reader_stdio->preset_func = &reset_xtab_func; + plrec_reader_stdio->pfree_func = &lrec_reader_xtab_stdio_free;; - return plrec_reader; + return plrec_reader_stdio; } diff --git a/c/input/lrec_readers.h b/c/input/lrec_readers.h index c7f617339..2eee08cf4 100644 --- a/c/input/lrec_readers.h +++ b/c/input/lrec_readers.h @@ -1,12 +1,12 @@ #ifndef LREC_READERS_H #define LREC_READERS_H -#include "input/lrec_reader.h" +#include "input/lrec_reader_stdio.h" #include "input/lrec_reader_mmap.h" -lrec_reader_t* lrec_reader_csv_alloc(char irs, char ifs, int allow_repeat_ifs); -lrec_reader_t* lrec_reader_dkvp_alloc(char irs, char ifs, char ips, int allow_repeat_ifs); -lrec_reader_t* lrec_reader_nidx_alloc(char irs, char ifs, int allow_repeat_ifs); -lrec_reader_t* lrec_reader_xtab_alloc(char ips, int allow_repeat_ips); +lrec_reader_stdio_t* lrec_reader_csv_stdio_alloc(char irs, char ifs, int allow_repeat_ifs); +lrec_reader_stdio_t* lrec_reader_dkvp_stdio_alloc(char irs, char ifs, char ips, int allow_repeat_ifs); +lrec_reader_stdio_t* lrec_reader_nidx_stdio_alloc(char irs, char ifs, int allow_repeat_ifs); +lrec_reader_stdio_t* lrec_reader_xtab_stdio_alloc(char ips, int allow_repeat_ips); lrec_reader_mmap_t* lrec_reader_csv_mmap_alloc(char irs, char ifs, int allow_repeat_ifs); lrec_reader_mmap_t* lrec_reader_dkvp_mmap_alloc(char irs, char ifs, char ips, int allow_repeat_ifs); diff --git a/c/lib/mlrmath.h b/c/lib/mlrmath.h index fa6fb07df..08ef25f6b 100644 --- a/c/lib/mlrmath.h +++ b/c/lib/mlrmath.h @@ -2,10 +2,10 @@ #define MLRMATH_H void mlr_get_real_symmetric_eigensystem( - double matrix[2][2], // Input - double *peigenvalue_1, // Output: dominant eigenvalue - double *peigenvalue_2, // Output: less-dominant eigenvalue - double eigenvector_1[2], // Output: corresponding to dominant eigenvalue - double eigenvector_2[2]); // Output: corresponding to less-dominant eigenvalue + double matrix[2][2], // Input + double* peigenvalue_1, // Output: dominant eigenvalue + double* peigenvalue_2, // Output: less-dominant eigenvalue + double eigenvector_1[2], // Output: corresponding to dominant eigenvalue + double eigenvector_2[2]); // Output: corresponding to less-dominant eigenvalue #endif // MLRMATH_H diff --git a/c/mapping/context.h b/c/mapping/context.h index 21363ce62..8f952a932 100644 --- a/c/mapping/context.h +++ b/c/mapping/context.h @@ -1,6 +1,7 @@ #ifndef CONTEXT_H #define CONTEXT_H +// xxx cmt typedef struct _context_t { long long nr; long long fnr; diff --git a/c/mlrmain.c b/c/mlrmain.c index 3f28138b9..41e4f28aa 100644 --- a/c/mlrmain.c +++ b/c/mlrmain.c @@ -27,13 +27,13 @@ int main(int argc, char** argv) { mlr_global_init(argv[0], popts->ofmt); - lrec_reader_t* plrec_reader = popts->plrec_reader; + lrec_reader_stdio_t* plrec_reader_stdio = popts->plrec_reader_stdio; lrec_reader_mmap_t* plrec_reader_mmap = popts->plrec_reader_mmap; sllv_t* pmapper_list = popts->pmapper_list; lrec_writer_t* plrec_writer = popts->plrec_writer; char** filenames = popts->filenames; - int ok = do_stream_chained(filenames, popts->use_file_reader_mmap, plrec_reader, plrec_reader_mmap, + int ok = do_stream_chained(filenames, popts->use_file_reader_mmap, plrec_reader_stdio, plrec_reader_mmap, pmapper_list, plrec_writer, popts->ofmt); cli_opts_free(popts); diff --git a/c/stream/stream.c b/c/stream/stream.c index 0634cdc52..52e46d258 100644 --- a/c/stream/stream.c +++ b/c/stream/stream.c @@ -11,9 +11,9 @@ #include "output/lrec_writers.h" static int do_file_chained(char* filename, context_t* pctx, - lrec_reader_t* plrec_reader, sllv_t* pmapper_list, lrec_writer_t* plrec_writer, FILE* output_stream); + lrec_reader_stdio_t* plrec_reader_stdio, sllv_t* pmapper_list, lrec_writer_t* plrec_writer, FILE* output_stream); static int do_file_chained_mmap(char* filename, context_t* pctx, - lrec_reader_mmap_t* plrec_reader, sllv_t* pmapper_list, lrec_writer_t* plrec_writer, FILE* output_stream); + lrec_reader_mmap_t* plrec_reader_stdio, sllv_t* pmapper_list, lrec_writer_t* plrec_writer, FILE* output_stream); static sllv_t* chain_map(lrec_t* pinrec, context_t* pctx, sllve_t* pmapper_list_head); @@ -21,7 +21,7 @@ static void drive_lrec(lrec_t* pinrec, context_t* pctx, sllve_t* pmapper_list_he // ---------------------------------------------------------------- // xxx assert pmapper_list non-empty ... -int do_stream_chained(char** filenames, int use_file_reader_mmap, lrec_reader_t* plrec_reader, lrec_reader_mmap_t* plrec_reader_mmap, +int do_stream_chained(char** filenames, int use_file_reader_mmap, lrec_reader_stdio_t* plrec_reader_stdio, lrec_reader_mmap_t* plrec_reader_mmap, sllv_t* pmapper_list, lrec_writer_t* plrec_writer, char* ofmt) { FILE* output_stream = stdout; @@ -32,7 +32,7 @@ int do_stream_chained(char** filenames, int use_file_reader_mmap, lrec_reader_t* ctx.filenum++; ctx.filename = "(stdin)"; ctx.fnr = 0; - ok = do_file_chained("-", &ctx, plrec_reader, pmapper_list, plrec_writer, output_stream) && ok; + ok = do_file_chained("-", &ctx, plrec_reader_stdio, pmapper_list, plrec_writer, output_stream) && ok; } else { for (char** pfilename = filenames; *pfilename != NULL; pfilename++) { ctx.filenum++; @@ -43,8 +43,8 @@ int do_stream_chained(char** filenames, int use_file_reader_mmap, lrec_reader_t* plrec_reader_mmap->preset_func(plrec_reader_mmap->pvstate); ok = do_file_chained_mmap(*pfilename, &ctx, plrec_reader_mmap, pmapper_list, plrec_writer, output_stream) && ok; } else { - plrec_reader->preset_func(plrec_reader->pvstate); - ok = do_file_chained(*pfilename, &ctx, plrec_reader, pmapper_list, plrec_writer, output_stream) && ok; + plrec_reader_stdio->preset_func(plrec_reader_stdio->pvstate); + ok = do_file_chained(*pfilename, &ctx, plrec_reader_stdio, pmapper_list, plrec_writer, output_stream) && ok; } } } @@ -61,7 +61,7 @@ int do_stream_chained(char** filenames, int use_file_reader_mmap, lrec_reader_t* // ---------------------------------------------------------------- static int do_file_chained(char* filename, context_t* pctx, - lrec_reader_t* plrec_reader, sllv_t* pmapper_list, lrec_writer_t* plrec_writer, FILE* output_stream) + lrec_reader_stdio_t* plrec_reader_stdio, sllv_t* pmapper_list, lrec_writer_t* plrec_writer, FILE* output_stream) { FILE* input_stream = stdin; @@ -75,7 +75,7 @@ static int do_file_chained(char* filename, context_t* pctx, } while (1) { - lrec_t* pinrec = plrec_reader->plrec_reader_func(input_stream, plrec_reader->pvstate, pctx); + lrec_t* pinrec = plrec_reader_stdio->plrec_reader_stdio_func(input_stream, plrec_reader_stdio->pvstate, pctx); if (pinrec == NULL) break; pctx->nr++; @@ -91,13 +91,13 @@ static int do_file_chained(char* filename, context_t* pctx, // ---------------------------------------------------------------- static int do_file_chained_mmap(char* filename, context_t* pctx, - lrec_reader_mmap_t* plrec_reader, sllv_t* pmapper_list, lrec_writer_t* plrec_writer, FILE* output_stream) + lrec_reader_mmap_t* plrec_reader_stdio, sllv_t* pmapper_list, lrec_writer_t* plrec_writer, FILE* output_stream) { // xxx communicate error back from open, or rename it to ..._open_or_die file_reader_mmap_state_t handle = file_reader_mmap_open(filename); while (1) { - lrec_t* pinrec = plrec_reader->plrec_reader_func(&handle, plrec_reader->pvstate, pctx); + lrec_t* pinrec = plrec_reader_stdio->plrec_reader_stdio_func(&handle, plrec_reader_stdio->pvstate, pctx); if (pinrec == NULL) break; pctx->nr++; diff --git a/c/stream/stream.h b/c/stream/stream.h index f60ee33ef..8c3083a86 100644 --- a/c/stream/stream.h +++ b/c/stream/stream.h @@ -7,7 +7,7 @@ #include "output/lrec_writers.h" // filenames must be null-terminated -int do_stream_chained(char** filenames, int use_file_reader_mmap, lrec_reader_t* plrec_reader, lrec_reader_mmap_t* plrec_reader_mmap, +int do_stream_chained(char** filenames, int use_file_reader_mmap, lrec_reader_stdio_t* plrec_reader_stdio, lrec_reader_mmap_t* plrec_reader_mmap, sllv_t* pmapper_list, lrec_writer_t* plrec_writer, char* ofmt); #endif // STREAM_H