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

renames

Browse source
This commit is contained in:
John Kerl 2015-05-21 20:12:43 -04:00
parent 785de97ef7
commit ac0584bea4
24 changed files with 211 additions and 210 deletions
Download patch file Download diff file Expand all files Collapse all files

12
c/cli/mlrcli.c
View file

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

4
c/cli/mlrcli.h
View file

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

8
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(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) {

8
c/containers/lrec_parsers.h
View file

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

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

21
c/input/lrec_reader.h
View file

@ -1,21 +0,0 @@
#ifndef LREC_READER_H
#define LREC_READER_H
#include <stdio.h>
#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

10
c/input/lrec_reader_csv_mmap.c
View file

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

32
c/input/lrec_reader_csv.c → c/input/lrec_reader_csv_stdio.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_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;
}

49
c/input/lrec_reader_dkvp.c
View file

@ -1,49 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#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;
}

10
c/input/lrec_reader_dkvp_mmap.c
View file

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

49
c/input/lrec_reader_dkvp_stdio.c Normal file
View file

@ -0,0 +1,49 @@
#include <stdio.h>
#include <stdlib.h>
#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;
}

2
c/input/lrec_reader_mmap.h
View file

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

43
c/input/lrec_reader_nidx.c
View file

@ -1,43 +0,0 @@
#include <stdlib.h>
#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;
}

10
c/input/lrec_reader_nidx_mmap.c
View file

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

43
c/input/lrec_reader_nidx_stdio.c Normal file
View file

@ -0,0 +1,43 @@
#include <stdlib.h>
#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;
}

21
c/input/lrec_reader_stdio.h Normal file
View file

@ -0,0 +1,21 @@
#ifndef LREC_READER_STDIO_H
#define LREC_READER_STDIO_H
#include <stdio.h>
#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

10
c/input/lrec_reader_xtab_mmap.c
View file

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

32
c/input/lrec_reader_xtab.c → c/input/lrec_reader_xtab_stdio.c
View file

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

10
c/input/lrec_readers.h
View file

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

10
c/lib/mlrmath.h
View file

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

1
c/mapping/context.h
View file

@ -1,6 +1,7 @@
#ifndef CONTEXT_H
#define CONTEXT_H
// xxx cmt
typedef struct _context_t {
long long nr;
long long fnr;

4
c/mlrmain.c
View file

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

20
c/stream/stream.c
View file

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

2
c/stream/stream.h
View file

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