From 257c137fdd2ffb2f2acf0c83fb29fcdada465254 Mon Sep 17 00:00:00 2001 From: John Kerl Date: Fri, 22 May 2015 07:36:42 -0400 Subject: [PATCH] renames --- c/cli/mlrcli.c | 24 ++++++++--------- c/containers/lrec_parsers.c | 16 ++++++------ c/containers/lrec_parsers.h | 16 ++++++------ c/containers/test_lrec.c | 10 +++---- ...ader_csv_mmap.c => lrec_reader_mmap_csv.c} | 24 ++++++++--------- ...er_dkvp_mmap.c => lrec_reader_mmap_dkvp.c} | 20 +++++++------- ...er_nidx_mmap.c => lrec_reader_mmap_nidx.c} | 16 ++++++------ ...er_xtab_mmap.c => lrec_reader_mmap_xtab.c} | 18 ++++++------- ...er_csv_stdio.c => lrec_reader_stdio_csv.c} | 26 +++++++++---------- ..._dkvp_stdio.c => lrec_reader_stdio_dkvp.c} | 20 +++++++------- ..._nidx_stdio.c => lrec_reader_stdio_nidx.c} | 20 +++++++------- ..._xtab_stdio.c => lrec_reader_stdio_xtab.c} | 24 ++++++++--------- c/input/lrec_readers.h | 16 ++++++------ c/ren.txt | 6 +++-- 14 files changed, 129 insertions(+), 127 deletions(-) rename c/input/{lrec_reader_csv_mmap.c => lrec_reader_mmap_csv.c} (85%) rename c/input/{lrec_reader_dkvp_mmap.c => lrec_reader_mmap_dkvp.c} (58%) rename c/input/{lrec_reader_nidx_mmap.c => lrec_reader_mmap_nidx.c} (64%) rename c/input/{lrec_reader_xtab_mmap.c => lrec_reader_mmap_xtab.c} (66%) rename c/input/{lrec_reader_csv_stdio.c => lrec_reader_stdio_csv.c} (84%) rename c/input/{lrec_reader_dkvp_stdio.c => lrec_reader_stdio_dkvp.c} (60%) rename c/input/{lrec_reader_nidx_stdio.c => lrec_reader_stdio_nidx.c} (57%) rename c/input/{lrec_reader_xtab_stdio.c => lrec_reader_stdio_xtab.c} (66%) diff --git a/c/cli/mlrcli.c b/c/cli/mlrcli.c index 65824b6fb..209c49f91 100644 --- a/c/cli/mlrcli.c +++ b/c/cli/mlrcli.c @@ -154,10 +154,10 @@ cli_opts_t* parse_command_line(int argc, char** argv) { popts->ops = DEFAULT_PS; popts->ofmt = DEFAULT_OFMT; - popts->plrec_reader_stdio = NULL; - popts->plrec_reader_mmap = NULL; - popts->plrec_writer = NULL; - popts->filenames = NULL; + popts->plrec_reader_stdio = NULL; + popts->plrec_reader_mmap = NULL; + popts->plrec_writer = NULL; + popts->filenames = NULL; popts->use_file_reader_mmap = FALSE; char* rdesc = "dkvp"; @@ -281,17 +281,17 @@ 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_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); + popts->plrec_reader_stdio = lrec_reader_stdio_dkvp_alloc(popts->irs, popts->ifs, popts->ips, popts->allow_repeat_ifs); + popts->plrec_reader_mmap = lrec_reader_mmap_dkvp_alloc(popts->irs, popts->ifs, popts->ips, popts->allow_repeat_ifs); } else if (streq(rdesc, "csv")) { - 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); + popts->plrec_reader_stdio = lrec_reader_stdio_csv_alloc(popts->irs, popts->ifs, popts->allow_repeat_ifs); + popts->plrec_reader_mmap = lrec_reader_mmap_csv_alloc(popts->irs, popts->ifs, popts->ips); } else if (streq(rdesc, "nidx")) { - 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); + popts->plrec_reader_stdio = lrec_reader_stdio_nidx_alloc(popts->irs, popts->ifs, popts->allow_repeat_ifs); + popts->plrec_reader_mmap = lrec_reader_mmap_nidx_alloc(popts->irs, popts->ifs, popts->allow_repeat_ifs); } else if (streq(rdesc, "xtab")) { - 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*/); + popts->plrec_reader_stdio = lrec_reader_stdio_xtab_alloc(popts->ips, TRUE); // xxx parameterize allow_repeat_ips + popts->plrec_reader_mmap = lrec_reader_mmap_xtab_alloc(popts->irs, popts->ips, TRUE/*popts->allow_repeat_ips*/); } else { main_usage(argv[0], 1); } diff --git a/c/containers/lrec_parsers.c b/c/containers/lrec_parsers.c index da5f29e41..2b0e497e5 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_stdio(char* line, char ifs, int allow_repeat_ifs) { +lrec_t* lrec_parse_stdio_nidx(char* line, char ifs, int allow_repeat_ifs) { lrec_t* prec = lrec_nidx_alloc(line); int idx = 0; @@ -64,7 +64,7 @@ lrec_t* lrec_parse_nidx_stdio(char* line, char ifs, int allow_repeat_ifs) { return prec; } -lrec_t* lrec_parse_nidx_mmap(file_reader_mmap_state_t *phandle, char irs, char ifs, int allow_repeat_ifs) { +lrec_t* lrec_parse_mmap_nidx(file_reader_mmap_state_t *phandle, char irs, char ifs, int allow_repeat_ifs) { lrec_t* prec = lrec_unbacked_alloc(); char* line = phandle->sol; @@ -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_stdio(char* line, char ifs, char ips, int allow_repeat_ifs) { +lrec_t* lrec_parse_stdio_dkvp(char* line, char ifs, char ips, int allow_repeat_ifs) { lrec_t* prec = lrec_dkvp_alloc(line); char* key = line; @@ -181,7 +181,7 @@ lrec_t* lrec_parse_dkvp_stdio(char* line, char ifs, char ips, int allow_repeat_i return prec; } -lrec_t* lrec_parse_dkvp_mmap(file_reader_mmap_state_t *phandle, char irs, char ifs, char ips, int allow_repeat_ifs) { +lrec_t* lrec_parse_mmap_dkvp(file_reader_mmap_state_t *phandle, char irs, char ifs, char ips, int allow_repeat_ifs) { lrec_t* prec = lrec_unbacked_alloc(); char* line = phandle->sol; @@ -273,7 +273,7 @@ slls_t* split_csv_header_line(char* 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* lrec_parse_stdio_csv(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; @@ -318,12 +318,12 @@ lrec_t* lrec_parse_csv_stdio(hdr_keeper_t* phdr_keeper, char* data_line, char if } // ---------------------------------------------------------------- -lrec_t* lrec_parse_csv_mmap(hdr_keeper_t* phdr_keeper, file_reader_mmap_state_t* phandle, char irs, char ifs, int allow_repeat_ifs) { +lrec_t* lrec_parse_mmap_csv(hdr_keeper_t* phdr_keeper, file_reader_mmap_state_t* phandle, char irs, char ifs, int allow_repeat_ifs) { return NULL; // xxx stub } // ---------------------------------------------------------------- -lrec_t* lrec_parse_xtab_stdio(slls_t* pxtab_lines, char ips, int allow_repeat_ips) { +lrec_t* lrec_parse_stdio_xtab(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) { @@ -348,7 +348,7 @@ lrec_t* lrec_parse_xtab_stdio(slls_t* pxtab_lines, char ips, int allow_repeat_ip } // ---------------------------------------------------------------- -lrec_t* lrec_parse_xtab_mmap(file_reader_mmap_state_t* phandle, char irs, char ips, int allow_repeat_ips) { +lrec_t* lrec_parse_mmap_xtab(file_reader_mmap_state_t* phandle, char irs, char ips, int allow_repeat_ips) { if (phandle->sol >= phandle->eof) return NULL; diff --git a/c/containers/lrec_parsers.h b/c/containers/lrec_parsers.h index 7d88a88ae..18b000b20 100644 --- a/c/containers/lrec_parsers.h +++ b/c/containers/lrec_parsers.h @@ -8,15 +8,15 @@ #include "containers/hdr_keeper.h" // xxx cmt/arg re freeing ....... -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); +lrec_t* lrec_parse_stdio_nidx(char* line, char ifs, int allow_repeat_ifs); +lrec_t* lrec_parse_stdio_dkvp(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_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_stdio_csv(hdr_keeper_t* phdr_keeper, char* data_line, char ifs, int allow_repeat_ifs); +lrec_t* lrec_parse_stdio_xtab(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); -lrec_t* lrec_parse_csv_mmap(hdr_keeper_t* phdr_keeper, file_reader_mmap_state_t* phandle, char irs, char ifs, int allow_repeat_ifs); -lrec_t* lrec_parse_xtab_mmap(file_reader_mmap_state_t* phandle, char irs, char ips, int allow_repeat_ips); +lrec_t* lrec_parse_mmap_nidx(file_reader_mmap_state_t* phandle, char irs, char ifs, int allow_repeat_ifs); +lrec_t* lrec_parse_mmap_dkvp(file_reader_mmap_state_t *phandle, char irs, char ifs, char ips, int allow_repeat_ifs); +lrec_t* lrec_parse_mmap_csv(hdr_keeper_t* phdr_keeper, file_reader_mmap_state_t* phandle, char irs, char ifs, int allow_repeat_ifs); +lrec_t* lrec_parse_mmap_xtab(file_reader_mmap_state_t* phandle, char irs, char ips, int allow_repeat_ips); #endif // LREC_PARSERS_H diff --git a/c/containers/test_lrec.c b/c/containers/test_lrec.c index 7693d30b0..e195b9523 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_stdio(line, ',', '=', FALSE); + lrec_t* prec = lrec_parse_stdio_dkvp(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_stdio(line, ',', FALSE); + lrec_t* prec = lrec_parse_stdio_nidx(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_stdio(phdr_keeper, data_line_1, ',', FALSE); + lrec_t* prec_1 = lrec_parse_stdio_csv(phdr_keeper, data_line_1, ',', FALSE); char* data_line_2 = strdup("6,7,8,9"); - lrec_t* prec_2 = lrec_parse_csv_stdio(phdr_keeper, data_line_2, ',', FALSE); + lrec_t* prec_2 = lrec_parse_stdio_csv(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_stdio(pxtab_lines, ' ', TRUE); + lrec_t* prec = lrec_parse_stdio_xtab(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_csv_mmap.c b/c/input/lrec_reader_mmap_csv.c similarity index 85% rename from c/input/lrec_reader_csv_mmap.c rename to c/input/lrec_reader_mmap_csv.c index cdfc54b11..a946ca324 100644 --- a/c/input/lrec_reader_csv_mmap.c +++ b/c/input/lrec_reader_mmap_csv.c @@ -17,7 +17,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_mmap_state_t { +typedef struct _lrec_reader_mmap_csv_state_t { long long ifnr; // xxx cmt w/r/t pctx long long ilno; // xxx cmt w/r/t pctx char irs; @@ -27,7 +27,7 @@ typedef struct _lrec_reader_csv_mmap_state_t { int expect_header_line_next; hdr_keeper_t* phdr_keeper; // xxx rename to header_keeper lhmslv_t* phdr_keepers; -} lrec_reader_csv_mmap_state_t; +} lrec_reader_mmap_csv_state_t; // Cases: // @@ -52,9 +52,9 @@ typedef struct _lrec_reader_csv_mmap_state_t { // // etc. -static lrec_t* lrec_reader_csv_mmap_func(file_reader_mmap_state_t* phandle, void* pvstate, context_t* pctx) { +static lrec_t* lrec_reader_mmap_csv_func(file_reader_mmap_state_t* phandle, void* pvstate, context_t* pctx) { return NULL; // xxx stub -// lrec_reader_csv_mmap_state_t* pstate = pvstate; +// lrec_reader_mmap_csv_state_t* pstate = pvstate; // // while (TRUE) { // if (pstate->expect_header_line_next) { @@ -99,14 +99,14 @@ static lrec_t* lrec_reader_csv_mmap_func(file_reader_mmap_state_t* phandle, void // } // } else { // pstate->ifnr++; -// return lrec_parse_csv_mmap(pstate->phdr_keeper, phandle, pstate->irs, pstate->ifs, pstate->allow_repeat_ifs); +// return lrec_parse_mmap_csv(pstate->phdr_keeper, phandle, pstate->irs, pstate->ifs, pstate->allow_repeat_ifs); // } // } } // ---------------------------------------------------------------- -static void reset_csv_mmap_func(void* pvstate) { - lrec_reader_csv_mmap_state_t* pstate = pvstate; +static void reset_mmap_csv_func(void* pvstate) { + lrec_reader_mmap_csv_state_t* pstate = pvstate; pstate->ifnr = 0LL; pstate->ilno = 0LL; pstate->expect_header_line_next = TRUE; @@ -115,10 +115,10 @@ static void reset_csv_mmap_func(void* pvstate) { // xxx restore free func for hdr_keepers ... ? // ---------------------------------------------------------------- -lrec_reader_mmap_t* lrec_reader_csv_mmap_alloc(char irs, char ifs, int allow_repeat_ifs) { +lrec_reader_mmap_t* lrec_reader_mmap_csv_alloc(char irs, char ifs, int allow_repeat_ifs) { 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)); + lrec_reader_mmap_csv_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_mmap_csv_state_t)); pstate->ifnr = 0LL; pstate->irs = irs; pstate->ifs = ifs; @@ -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_stdio->pvstate = (void*)pstate; + plrec_reader_stdio->pvstate = (void*)pstate; // xxx homogenize these names, for all readers & writers - plrec_reader_stdio->plrec_reader_stdio_func = &lrec_reader_csv_mmap_func; - plrec_reader_stdio->preset_func = &reset_csv_mmap_func; + plrec_reader_stdio->plrec_reader_stdio_func = &lrec_reader_mmap_csv_func; + plrec_reader_stdio->preset_func = &reset_mmap_csv_func; return plrec_reader_stdio; } diff --git a/c/input/lrec_reader_dkvp_mmap.c b/c/input/lrec_reader_mmap_dkvp.c similarity index 58% rename from c/input/lrec_reader_dkvp_mmap.c rename to c/input/lrec_reader_mmap_dkvp.c index 6c213cdac..68f54c551 100644 --- a/c/input/lrec_reader_dkvp_mmap.c +++ b/c/input/lrec_reader_mmap_dkvp.c @@ -5,38 +5,38 @@ #include "input/file_reader_mmap.h" #include "input/lrec_readers.h" -typedef struct _lrec_reader_dkvp_mmap_state_t { +typedef struct _lrec_reader_mmap_dkvp_state_t { char irs; char ifs; char ips; int allow_repeat_ifs; -} lrec_reader_dkvp_mmap_state_t; +} lrec_reader_mmap_dkvp_state_t; // ---------------------------------------------------------------- -static lrec_t* lrec_reader_dkvp_mmap_func(file_reader_mmap_state_t* phandle, void* pvstate, context_t* pctx) { - lrec_reader_dkvp_mmap_state_t* pstate = pvstate; +static lrec_t* lrec_reader_mmap_dkvp_func(file_reader_mmap_state_t* phandle, void* pvstate, context_t* pctx) { + lrec_reader_mmap_dkvp_state_t* pstate = pvstate; if (phandle->sol >= phandle->eof) // xxx encapsulate a method for this ... return NULL; else - return lrec_parse_dkvp_mmap(phandle, pstate->irs, pstate->ifs, pstate->ips, pstate->allow_repeat_ifs); + return lrec_parse_mmap_dkvp(phandle, pstate->irs, pstate->ifs, pstate->ips, pstate->allow_repeat_ifs); } // No-op for stateless readers such as this one. -static void reset_dkvp_mmap_func(void* pvstate) { +static void reset_mmap_dkvp_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* lrec_reader_mmap_dkvp_alloc(char irs, char ifs, char ips, int allow_repeat_ifs) { 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)); + lrec_reader_mmap_dkvp_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_mmap_dkvp_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_mmap_func; - plrec_reader_stdio->preset_func = &reset_dkvp_mmap_func; + plrec_reader_stdio->plrec_reader_stdio_func = &lrec_reader_mmap_dkvp_func; + plrec_reader_stdio->preset_func = &reset_mmap_dkvp_func; return plrec_reader_stdio; } diff --git a/c/input/lrec_reader_nidx_mmap.c b/c/input/lrec_reader_mmap_nidx.c similarity index 64% rename from c/input/lrec_reader_nidx_mmap.c rename to c/input/lrec_reader_mmap_nidx.c index 82c3e39c5..08d54ad76 100644 --- a/c/input/lrec_reader_nidx_mmap.c +++ b/c/input/lrec_reader_mmap_nidx.c @@ -4,35 +4,35 @@ #include "input/file_reader_mmap.h" #include "input/lrec_readers.h" -typedef struct _lrec_reader_nidx_mmap_state_t { +typedef struct _lrec_reader_mmap_nidx_state_t { char irs; char ifs; int allow_repeat_ifs; -} lrec_reader_nidx_mmap_state_t; +} lrec_reader_mmap_nidx_state_t; // ---------------------------------------------------------------- -static lrec_t* lrec_reader_nidx_mmap_func(file_reader_mmap_state_t* phandle, void* pvstate, context_t* pctx) { - lrec_reader_nidx_mmap_state_t* pstate = pvstate; +static lrec_t* lrec_reader_mmap_nidx_func(file_reader_mmap_state_t* phandle, void* pvstate, context_t* pctx) { + lrec_reader_mmap_nidx_state_t* pstate = pvstate; if (phandle->sol >= phandle->eof) // xxx encapsulate a method for this ... return NULL; else - return lrec_parse_nidx_mmap(phandle, pstate->irs, pstate->ifs, pstate->allow_repeat_ifs); + return lrec_parse_mmap_nidx(phandle, pstate->irs, pstate->ifs, pstate->allow_repeat_ifs); } // No-op for stateless readers such as this one. 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* lrec_reader_mmap_nidx_alloc(char irs, char ifs, int allow_repeat_ifs) { 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)); + lrec_reader_mmap_nidx_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_mmap_nidx_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_mmap_func; + plrec_reader_stdio->plrec_reader_stdio_func = &lrec_reader_mmap_nidx_func; plrec_reader_stdio->preset_func = &reset_nidx_func; return plrec_reader_stdio; diff --git a/c/input/lrec_reader_xtab_mmap.c b/c/input/lrec_reader_mmap_xtab.c similarity index 66% rename from c/input/lrec_reader_xtab_mmap.c rename to c/input/lrec_reader_mmap_xtab.c index bcde5dcf4..d4764d202 100644 --- a/c/input/lrec_reader_xtab_mmap.c +++ b/c/input/lrec_reader_mmap_xtab.c @@ -5,34 +5,34 @@ #include "input/file_reader_mmap.h" #include "input/lrec_readers.h" -typedef struct _lrec_reader_xtab_mmap_state_t { +typedef struct _lrec_reader_mmap_xtab_state_t { char irs; char ips; // xxx make me real int allow_repeat_ips; int at_eof; // xxx need to remember EOF for subsequent read -} lrec_reader_xtab_mmap_state_t; +} lrec_reader_mmap_xtab_state_t; // ---------------------------------------------------------------- -static lrec_t* lrec_reader_xtab_mmap_func(file_reader_mmap_state_t* phandle, void* pvstate, context_t* pctx) { - lrec_reader_xtab_mmap_state_t* pstate = pvstate; +static lrec_t* lrec_reader_mmap_xtab_func(file_reader_mmap_state_t* phandle, void* pvstate, context_t* pctx) { + lrec_reader_mmap_xtab_state_t* pstate = pvstate; if (pstate->at_eof) return NULL; else - return lrec_parse_xtab_mmap(phandle, pstate->irs, pstate->ips, pstate->allow_repeat_ips); + return lrec_parse_mmap_xtab(phandle, pstate->irs, pstate->ips, pstate->allow_repeat_ips); } // xxx rename resets to sof_reset or some such static void reset_xtab_func(void* pvstate) { - lrec_reader_xtab_mmap_state_t* pstate = pvstate; + lrec_reader_mmap_xtab_state_t* pstate = pvstate; pstate->at_eof = FALSE; } -lrec_reader_mmap_t* lrec_reader_xtab_mmap_alloc(char irs, char ips, int allow_repeat_ips) { +lrec_reader_mmap_t* lrec_reader_mmap_xtab_alloc(char irs, char ips, int allow_repeat_ips) { 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)); + lrec_reader_mmap_xtab_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_mmap_xtab_state_t)); //pstate->ips = ips; //pstate->allow_repeat_ips = allow_repeat_ips; pstate->irs = irs; @@ -41,7 +41,7 @@ lrec_reader_mmap_t* lrec_reader_xtab_mmap_alloc(char irs, char ips, int allow_re pstate->at_eof = FALSE; plrec_reader_stdio->pvstate = (void*)pstate; - plrec_reader_stdio->plrec_reader_stdio_func = &lrec_reader_xtab_mmap_func; + plrec_reader_stdio->plrec_reader_stdio_func = &lrec_reader_mmap_xtab_func; plrec_reader_stdio->preset_func = &reset_xtab_func; return plrec_reader_stdio; diff --git a/c/input/lrec_reader_csv_stdio.c b/c/input/lrec_reader_stdio_csv.c similarity index 84% rename from c/input/lrec_reader_csv_stdio.c rename to c/input/lrec_reader_stdio_csv.c index 66aa9e156..ebfd97b5e 100644 --- a/c/input/lrec_reader_csv_stdio.c +++ b/c/input/lrec_reader_stdio_csv.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_stdio_state_t { +typedef struct _lrec_reader_stdio_csv_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_stdio_state_t { int expect_header_line_next; hdr_keeper_t* phdr_keeper; // xxx rename to header_keeper lhmslv_t* phdr_keepers; -} lrec_reader_csv_stdio_state_t; +} lrec_reader_stdio_csv_state_t; // Cases: // @@ -51,8 +51,8 @@ typedef struct _lrec_reader_csv_stdio_state_t { // // etc. -static lrec_t* lrec_reader_csv_stdio_func(FILE* input_stream, void* pvstate, context_t* pctx) { - lrec_reader_csv_stdio_state_t* pstate = pvstate; +static lrec_t* lrec_reader_stdio_csv_func(FILE* input_stream, void* pvstate, context_t* pctx) { + lrec_reader_stdio_csv_state_t* pstate = pvstate; while (TRUE) { if (pstate->expect_header_line_next) { @@ -99,22 +99,22 @@ static lrec_t* lrec_reader_csv_stdio_func(FILE* input_stream, void* pvstate, con } } else { pstate->ifnr++; - return lrec_parse_csv_stdio(pstate->phdr_keeper, line, pstate->ifs, pstate->allow_repeat_ifs); + return lrec_parse_stdio_csv(pstate->phdr_keeper, line, pstate->ifs, pstate->allow_repeat_ifs); } } } // ---------------------------------------------------------------- static void reset_csv_func(void* pvstate) { - lrec_reader_csv_stdio_state_t* pstate = pvstate; + lrec_reader_stdio_csv_state_t* pstate = pvstate; pstate->ifnr = 0LL; pstate->ilno = 0LL; pstate->expect_header_line_next = TRUE; } // ---------------------------------------------------------------- -static void lrec_reader_csv_stdio_free(void* pvstate) { - lrec_reader_csv_stdio_state_t* pstate = pvstate; +static void lrec_reader_stdio_csv_free(void* pvstate) { + lrec_reader_stdio_csv_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_stdio_free(void* pvstate) { } // ---------------------------------------------------------------- -lrec_reader_stdio_t* lrec_reader_csv_stdio_alloc(char irs, char ifs, int allow_repeat_ifs) { +lrec_reader_stdio_t* lrec_reader_stdio_csv_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_stdio_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_csv_stdio_state_t)); + lrec_reader_stdio_csv_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_stdio_csv_state_t)); pstate->ifnr = 0LL; pstate->irs = irs; pstate->ifs = ifs; @@ -133,12 +133,12 @@ lrec_reader_stdio_t* lrec_reader_csv_stdio_alloc(char irs, char ifs, int allow_r pstate->expect_header_line_next = TRUE; pstate->phdr_keeper = NULL; pstate->phdr_keepers = lhmslv_alloc(); - plrec_reader_stdio->pvstate = (void*)pstate; + plrec_reader_stdio->pvstate = (void*)pstate; // xxx homogenize these names, for all readers & writers - plrec_reader_stdio->plrec_reader_stdio_func = &lrec_reader_csv_stdio_func; + plrec_reader_stdio->plrec_reader_stdio_func = &lrec_reader_stdio_csv_func; plrec_reader_stdio->preset_func = &reset_csv_func; - plrec_reader_stdio->pfree_func = &lrec_reader_csv_stdio_free; + plrec_reader_stdio->pfree_func = &lrec_reader_stdio_csv_free; return plrec_reader_stdio; } diff --git a/c/input/lrec_reader_dkvp_stdio.c b/c/input/lrec_reader_stdio_dkvp.c similarity index 60% rename from c/input/lrec_reader_dkvp_stdio.c rename to c/input/lrec_reader_stdio_dkvp.c index 508417d8a..03b54669a 100644 --- a/c/input/lrec_reader_dkvp_stdio.c +++ b/c/input/lrec_reader_stdio_dkvp.c @@ -4,23 +4,23 @@ #include "containers/lrec_parsers.h" #include "input/lrec_readers.h" -typedef struct _lrec_reader_dkvp_stdio_state_t { +typedef struct _lrec_reader_stdio_dkvp_state_t { char irs; char ifs; char ips; int allow_repeat_ifs; -} lrec_reader_dkvp_stdio_state_t; +} lrec_reader_stdio_dkvp_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; +static lrec_t* lrec_reader_stdio_dkvp_func(FILE* input_stream, void* pvstate, context_t* pctx) { + lrec_reader_stdio_dkvp_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); + return lrec_parse_stdio_dkvp(line, pstate->ifs, pstate->ips, pstate->allow_repeat_ifs); } // No-op for stateless readers such as this one. @@ -28,22 +28,22 @@ 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) { +static void lrec_reader_stdio_dkvp_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* lrec_reader_stdio_dkvp_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)); + lrec_reader_stdio_dkvp_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_stdio_dkvp_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->plrec_reader_stdio_func = &lrec_reader_stdio_dkvp_func; plrec_reader_stdio->preset_func = &reset_dkvp_func; - plrec_reader_stdio->pfree_func = &lrec_reader_dkvp_stdio_free;; + plrec_reader_stdio->pfree_func = &lrec_reader_stdio_dkvp_free;; return plrec_reader_stdio; } diff --git a/c/input/lrec_reader_nidx_stdio.c b/c/input/lrec_reader_stdio_nidx.c similarity index 57% rename from c/input/lrec_reader_nidx_stdio.c rename to c/input/lrec_reader_stdio_nidx.c index cd767899e..dd1bac392 100644 --- a/c/input/lrec_reader_nidx_stdio.c +++ b/c/input/lrec_reader_stdio_nidx.c @@ -3,41 +3,41 @@ #include "containers/lrec_parsers.h" #include "input/lrec_readers.h" -typedef struct _lrec_reader_nidx_stdio_state_t { +typedef struct _lrec_reader_stdio_nidx_state_t { char irs; char ifs; int allow_repeat_ifs; -} lrec_reader_nidx_stdio_state_t; +} lrec_reader_stdio_nidx_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; +static lrec_t* lrec_reader_stdio_nidx_func(FILE* input_stream, void* pvstate, context_t* pctx) { + lrec_reader_stdio_nidx_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); + return lrec_parse_stdio_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_stdio_free_func(void* pvstate) { +static void lrec_reader_stdio_nidx_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* lrec_reader_stdio_nidx_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)); + lrec_reader_stdio_nidx_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_stdio_nidx_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->plrec_reader_stdio_func = &lrec_reader_stdio_nidx_func; plrec_reader_stdio->preset_func = &reset_nidx_func; - plrec_reader_stdio->pfree_func = &lrec_reader_nidx_stdio_free_func; + plrec_reader_stdio->pfree_func = &lrec_reader_stdio_nidx_free_func; return plrec_reader_stdio; } diff --git a/c/input/lrec_reader_xtab_stdio.c b/c/input/lrec_reader_stdio_xtab.c similarity index 66% rename from c/input/lrec_reader_xtab_stdio.c rename to c/input/lrec_reader_stdio_xtab.c index ea983ba98..a57c8ee60 100644 --- a/c/input/lrec_reader_xtab_stdio.c +++ b/c/input/lrec_reader_stdio_xtab.c @@ -4,16 +4,16 @@ #include "containers/lrec_parsers.h" #include "input/lrec_readers.h" -typedef struct _lrec_reader_xtab_stdio_state_t { +typedef struct _lrec_reader_stdio_xtab_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_stdio_state_t; +} lrec_reader_stdio_xtab_state_t; // ---------------------------------------------------------------- -static lrec_t* lrec_reader_xtab_stdio_func(FILE* input_stream, void* pvstate, context_t* pctx) { - lrec_reader_xtab_stdio_state_t* pstate = pvstate; +static lrec_t* lrec_reader_stdio_xtab_func(FILE* input_stream, void* pvstate, context_t* pctx) { + lrec_reader_stdio_xtab_state_t* pstate = pvstate; if (pstate->at_eof) return NULL; @@ -28,12 +28,12 @@ static lrec_t* lrec_reader_xtab_stdio_func(FILE* input_stream, void* pvstate, co if (pxtab_lines->length == 0) { return NULL; } else { - return lrec_parse_xtab_stdio(pxtab_lines, pstate->ips, pstate->allow_repeat_ips); + return lrec_parse_stdio_xtab(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_stdio(pxtab_lines, pstate->ips, pstate->allow_repeat_ips); + return lrec_parse_stdio_xtab(pxtab_lines, pstate->ips, pstate->allow_repeat_ips); } } else { slls_add_with_free(pxtab_lines, line); @@ -43,17 +43,17 @@ static lrec_t* lrec_reader_xtab_stdio_func(FILE* input_stream, void* pvstate, co // xxx rename resets to sof_reset or some such static void reset_xtab_func(void* pvstate) { - lrec_reader_xtab_stdio_state_t* pstate = pvstate; + lrec_reader_stdio_xtab_state_t* pstate = pvstate; pstate->at_eof = FALSE; } -static void lrec_reader_xtab_stdio_free(void* pvstate) { +static void lrec_reader_stdio_xtab_free(void* pvstate) { } -lrec_reader_stdio_t* lrec_reader_xtab_stdio_alloc(char ips, int allow_repeat_ips) { +lrec_reader_stdio_t* lrec_reader_stdio_xtab_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_stdio_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_xtab_stdio_state_t)); + lrec_reader_stdio_xtab_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_stdio_xtab_state_t)); //pstate->ips = ips; //pstate->allow_repeat_ips = allow_repeat_ips; pstate->ips = ' '; @@ -61,9 +61,9 @@ lrec_reader_stdio_t* lrec_reader_xtab_stdio_alloc(char ips, int allow_repeat_ips pstate->at_eof = FALSE; plrec_reader_stdio->pvstate = (void*)pstate; - plrec_reader_stdio->plrec_reader_stdio_func = &lrec_reader_xtab_stdio_func; + plrec_reader_stdio->plrec_reader_stdio_func = &lrec_reader_stdio_xtab_func; plrec_reader_stdio->preset_func = &reset_xtab_func; - plrec_reader_stdio->pfree_func = &lrec_reader_xtab_stdio_free;; + plrec_reader_stdio->pfree_func = &lrec_reader_stdio_xtab_free;; return plrec_reader_stdio; } diff --git a/c/input/lrec_readers.h b/c/input/lrec_readers.h index 2eee08cf4..ab7d063a9 100644 --- a/c/input/lrec_readers.h +++ b/c/input/lrec_readers.h @@ -3,14 +3,14 @@ #include "input/lrec_reader_stdio.h" #include "input/lrec_reader_mmap.h" -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_stdio_t* lrec_reader_stdio_csv_alloc(char irs, char ifs, int allow_repeat_ifs); +lrec_reader_stdio_t* lrec_reader_stdio_dkvp_alloc(char irs, char ifs, char ips, int allow_repeat_ifs); +lrec_reader_stdio_t* lrec_reader_stdio_nidx_alloc(char irs, char ifs, int allow_repeat_ifs); +lrec_reader_stdio_t* lrec_reader_stdio_xtab_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); -lrec_reader_mmap_t* lrec_reader_nidx_mmap_alloc(char irs, char ifs, int allow_repeat_ifs); -lrec_reader_mmap_t* lrec_reader_xtab_mmap_alloc(char irs, char ips, int allow_repeat_ips); +lrec_reader_mmap_t* lrec_reader_mmap_csv_alloc(char irs, char ifs, int allow_repeat_ifs); +lrec_reader_mmap_t* lrec_reader_mmap_dkvp_alloc(char irs, char ifs, char ips, int allow_repeat_ifs); +lrec_reader_mmap_t* lrec_reader_mmap_nidx_alloc(char irs, char ifs, int allow_repeat_ifs); +lrec_reader_mmap_t* lrec_reader_mmap_xtab_alloc(char irs, char ips, int allow_repeat_ips); #endif // LREC_READERS_H diff --git a/c/ren.txt b/c/ren.txt index a988e609a..b8fff61d9 100644 --- a/c/ren.txt +++ b/c/ren.txt @@ -1,3 +1,7 @@ +blah!!!! csv_stdio -> stdio_csv?? filecontents & filenames ... + +\s+= alignment ... :/ +process funcs ... also look for mapper funcs ... lrec_reader_stdio_func_t lrec_reader_csv_stdio_func @@ -30,8 +34,6 @@ reset_dkvp_mmap_func reset_nidx_func reset_xtab_func -xxx mapper funcs -- ?!? - ---------------------------------------------------------------- xxx file renames too!!! xxx HDR_TOP_H renames too!!!