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

renames

Browse source
This commit is contained in:
John Kerl 2015-05-22 07:36:42 -04:00
parent 109bea620d
commit 257c137fdd
14 changed files with 129 additions and 127 deletions
Download patch file Download diff file Expand all files Collapse all files

24
c/cli/mlrcli.c
View file

@ -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);
}

16
c/containers/lrec_parsers.c
View file

@ -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;

16
c/containers/lrec_parsers.h
View file

@ -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

10
c/containers/test_lrec.c
View file

@ -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"));

24
c/input/lrec_reader_csv_mmap.c → c/input/lrec_reader_mmap_csv.c
View file

@ -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;
}

20
c/input/lrec_reader_dkvp_mmap.c → c/input/lrec_reader_mmap_dkvp.c
View file

@ -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;
}

16
c/input/lrec_reader_nidx_mmap.c → c/input/lrec_reader_mmap_nidx.c
View file

@ -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;

18
c/input/lrec_reader_xtab_mmap.c → c/input/lrec_reader_mmap_xtab.c
View file

@ -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;

26
c/input/lrec_reader_csv_stdio.c → c/input/lrec_reader_stdio_csv.c
View file

@ -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;
}

20
c/input/lrec_reader_dkvp_stdio.c → c/input/lrec_reader_stdio_dkvp.c
View file

@ -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;
}

20
c/input/lrec_reader_nidx_stdio.c → c/input/lrec_reader_stdio_nidx.c
View file

@ -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;
}

24
c/input/lrec_reader_xtab_stdio.c → c/input/lrec_reader_stdio_xtab.c
View file

@ -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;
}

16
c/input/lrec_readers.h
View file

@ -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

6
c/ren.txt
View file

@ -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!!!