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

renames

Browse source
This commit is contained in:
John Kerl 2015-05-21 19:56:01 -04:00
parent afc364c42b
commit c96c0ca928
24 changed files with 225 additions and 225 deletions
Download patch file Download diff file Expand all files Collapse all files

14
c/cli/mlrcli.c
View file

@ -5,7 +5,7 @@
#include "lib/mlrutil.h"
#include "lib/mtrand.h"
#include "containers/slls.h"
#include "input/readers.h"
#include "input/lrec_readers.h"
#include "mapping/mappers.h"
#include "output/lrec_writers.h"
#include "cli/mlrcli.h"
@ -154,7 +154,7 @@ cli_opts_t* parse_command_line(int argc, char** argv) {
popts->ops = DEFAULT_PS;
popts->ofmt = DEFAULT_OFMT;
popts->preader = NULL;
popts->plrec_reader = NULL;
popts->preader_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->preader = reader_dkvp_alloc(popts->irs, popts->ifs, popts->ips, popts->allow_repeat_ifs);
popts->plrec_reader = lrec_reader_dkvp_alloc(popts->irs, popts->ifs, popts->ips, popts->allow_repeat_ifs);
popts->preader_mmap = reader_dkvp_mmap_alloc(popts->irs, popts->ifs, popts->ips, popts->allow_repeat_ifs);
} else if (streq(rdesc, "csv")) {
popts->preader = reader_csv_alloc(popts->irs, popts->ifs, popts->allow_repeat_ifs);
popts->plrec_reader = lrec_reader_csv_alloc(popts->irs, popts->ifs, popts->allow_repeat_ifs);
popts->preader_mmap = reader_csv_mmap_alloc(popts->irs, popts->ifs, popts->ips);
} else if (streq(rdesc, "nidx")) {
popts->preader = reader_nidx_alloc(popts->irs, popts->ifs, popts->allow_repeat_ifs);
popts->plrec_reader = lrec_reader_nidx_alloc(popts->irs, popts->ifs, popts->allow_repeat_ifs);
popts->preader_mmap = reader_nidx_mmap_alloc(popts->irs, popts->ifs, popts->allow_repeat_ifs);
} else if (streq(rdesc, "xtab")) {
popts->preader = reader_xtab_alloc(popts->ips, TRUE); // xxx parameterize allow_repeat_ips
popts->plrec_reader = lrec_reader_xtab_alloc(popts->ips, TRUE); // xxx parameterize allow_repeat_ips
popts->preader_mmap = 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->preader->pfree_func(popts->preader->pvstate);
popts->plrec_reader->pfree_func(popts->plrec_reader->pvstate);
for (sllve_t* pe = popts->pmapper_list->phead; pe != NULL; pe = pe->pnext) {
mapper_t* pmapper = pe->pvdata;

6
c/cli/mlrcli.h
View file

@ -2,8 +2,8 @@
#define MLRCLI_H
#include "containers/sllv.h"
#include "input/reader.h"
#include "input/reader_mmap.h"
#include "input/lrec_reader.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_mmap_reader;
reader_t* preader;
lrec_reader_t* plrec_reader;
reader_mmap_t* preader_mmap;
sllv_t* pmapper_list;
lrec_writer_t* plrec_writer;

2
c/containers/lrec_parsers.c
View file

@ -2,7 +2,7 @@
#include <stdlib.h>
#include <string.h>
#include "lib/mlrutil.h"
#include "input/mmap.h"
#include "input/file_reader_mmap.h"
#include "containers/lrec.h"
#include "containers/lrec_parsers.h"

2
c/containers/lrec_parsers.h
View file

@ -1,7 +1,7 @@
#ifndef LREC_PARSERS_H
#define LREC_PARSERS_H
#include "input/mmap.h"
#include "input/file_reader_mmap.h"
#include "containers/slls.h"
#include "containers/sllv.h"
#include "containers/lrec.h"

2
c/input/mmap.c → c/input/file_reader_mmap.c
View file

@ -5,7 +5,7 @@
#include <unistd.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include "mmap.h"
#include "file_reader_mmap.h"
mmap_reader_state_t mmap_reader_open(char* file_name) {
mmap_reader_state_t state;

6
c/input/mmap.h → c/input/file_reader_mmap.h
View file

@ -1,5 +1,5 @@
#ifndef MMAP_H
#define MMAP_H
#ifndef FILE_READER_MMAP_H
#define FILE_READER_MMAP_H
// xxx rename to mmap_file_reader
typedef struct _mmap_reader_state_t {
@ -11,4 +11,4 @@ typedef struct _mmap_reader_state_t {
mmap_reader_state_t mmap_reader_open(char* file_name);
void mmap_reader_close(mmap_reader_state_t* pstate);
#endif // MMAP_H
#endif // FILE_READER_MMAP_H

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

@ -0,0 +1,21 @@
#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

32
c/input/reader_csv.c → c/input/lrec_reader_csv.c
View file

@ -4,7 +4,7 @@
#include "containers/slls.h"
#include "containers/lhmslv.h"
#include "containers/lrec_parsers.h"
#include "input/readers.h"
#include "input/lrec_readers.h"
// Idea of phdr_keepers: each hdr_keeper object retains the input-line backing
// and the slls_t for a CSV header line which is used by one or more CSV data
@ -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 _reader_csv_state_t {
typedef struct _lrec_reader_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 _reader_csv_state_t {
int expect_header_line_next;
hdr_keeper_t* phdr_keeper; // xxx rename to header_keeper
lhmslv_t* phdr_keepers;
} reader_csv_state_t;
} lrec_reader_csv_state_t;
// Cases:
//
@ -51,8 +51,8 @@ typedef struct _reader_csv_state_t {
//
// etc.
static lrec_t* reader_csv_func(FILE* input_stream, void* pvstate, context_t* pctx) {
reader_csv_state_t* pstate = pvstate;
static lrec_t* lrec_reader_csv_func(FILE* input_stream, void* pvstate, context_t* pctx) {
lrec_reader_csv_state_t* pstate = pvstate;
while (TRUE) {
if (pstate->expect_header_line_next) {
@ -106,15 +106,15 @@ static lrec_t* reader_csv_func(FILE* input_stream, void* pvstate, context_t* pct
// ----------------------------------------------------------------
static void reset_csv_func(void* pvstate) {
reader_csv_state_t* pstate = pvstate;
lrec_reader_csv_state_t* pstate = pvstate;
pstate->ifnr = 0LL;
pstate->ilno = 0LL;
pstate->expect_header_line_next = TRUE;
}
// ----------------------------------------------------------------
static void reader_csv_free(void* pvstate) {
reader_csv_state_t* pstate = pvstate;
static void lrec_reader_csv_free(void* pvstate) {
lrec_reader_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 reader_csv_free(void* pvstate) {
}
// ----------------------------------------------------------------
reader_t* reader_csv_alloc(char irs, char ifs, int allow_repeat_ifs) {
reader_t* preader = mlr_malloc_or_die(sizeof(reader_t));
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));
reader_csv_state_t* pstate = mlr_malloc_or_die(sizeof(reader_csv_state_t));
lrec_reader_csv_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_csv_state_t));
pstate->ifnr = 0LL;
pstate->irs = irs;
pstate->ifs = ifs;
@ -133,12 +133,12 @@ reader_t* 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();
preader->pvstate = (void*)pstate;
plrec_reader->pvstate = (void*)pstate;
// xxx homogenize these names, for all readers & writers
preader->preader_func = &reader_csv_func;
preader->preset_func = &reset_csv_func;
preader->pfree_func = &reader_csv_free;
plrec_reader->plrec_reader_func = &lrec_reader_csv_func;
plrec_reader->preset_func = &reset_csv_func;
plrec_reader->pfree_func = &lrec_reader_csv_free;
return preader;
return plrec_reader;
}

14
c/input/reader_csv_mmap.c → c/input/lrec_reader_csv_mmap.c
View file

@ -4,8 +4,8 @@
#include "containers/slls.h"
#include "containers/lhmslv.h"
#include "containers/lrec_parsers.h"
#include "input/mmap.h"
#include "input/readers.h"
#include "input/file_reader_mmap.h"
#include "input/lrec_readers.h"
// Idea of phdr_keepers: each hdr_keeper object retains the input-line backing
// and the slls_t for a CSV header line which is used by one or more CSV data
@ -116,7 +116,7 @@ static void reset_csv_mmap_func(void* pvstate) {
// ----------------------------------------------------------------
reader_mmap_t* reader_csv_mmap_alloc(char irs, char ifs, int allow_repeat_ifs) {
reader_mmap_t* preader = mlr_malloc_or_die(sizeof(reader_mmap_t));
reader_mmap_t* plrec_reader = mlr_malloc_or_die(sizeof(reader_mmap_t));
reader_csv_mmap_state_t* pstate = mlr_malloc_or_die(sizeof(reader_csv_mmap_state_t));
pstate->ifnr = 0LL;
@ -126,11 +126,11 @@ reader_mmap_t* reader_csv_mmap_alloc(char irs, char ifs, int allow_repeat_ifs) {
pstate->expect_header_line_next = TRUE;
pstate->phdr_keeper = NULL;
pstate->phdr_keepers = lhmslv_alloc();
preader->pvstate = (void*)pstate;
plrec_reader->pvstate = (void*)pstate;
// xxx homogenize these names, for all readers & writers
preader->preader_func = &reader_csv_mmap_func;
preader->preset_func = &reset_csv_mmap_func;
plrec_reader->plrec_reader_func = &reader_csv_mmap_func;
plrec_reader->preset_func = &reset_csv_mmap_func;
return preader;
return plrec_reader;
}

49
c/input/lrec_reader_dkvp.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_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;
}

14
c/input/reader_dkvp_mmap.c → c/input/lrec_reader_dkvp_mmap.c
View file

@ -2,8 +2,8 @@
#include <stdlib.h>
#include "lib/mlrutil.h"
#include "containers/lrec_parsers.h"
#include "input/mmap.h"
#include "input/readers.h"
#include "input/file_reader_mmap.h"
#include "input/lrec_readers.h"
typedef struct _reader_dkvp_mmap_state_t {
char irs;
@ -26,17 +26,17 @@ static void reset_dkvp_mmap_func(void* pvstate) {
}
reader_mmap_t* reader_dkvp_mmap_alloc(char irs, char ifs, char ips, int allow_repeat_ifs) {
reader_mmap_t* preader = mlr_malloc_or_die(sizeof(reader_mmap_t));
reader_mmap_t* plrec_reader = mlr_malloc_or_die(sizeof(reader_mmap_t));
reader_dkvp_mmap_state_t* pstate = mlr_malloc_or_die(sizeof(reader_dkvp_mmap_state_t));
pstate->irs = irs;
pstate->ifs = ifs;
pstate->ips = ips;
pstate->allow_repeat_ifs = allow_repeat_ifs;
preader->pvstate = (void*)pstate;
plrec_reader->pvstate = (void*)pstate;
preader->preader_func = &reader_dkvp_mmap_func;
preader->preset_func = &reset_dkvp_mmap_func;
plrec_reader->plrec_reader_func = &reader_dkvp_mmap_func;
plrec_reader->preset_func = &reset_dkvp_mmap_func;
return preader;
return plrec_reader;
}

10
c/input/reader_mmap.h → c/input/lrec_reader_mmap.h
View file

@ -1,12 +1,12 @@
#ifndef READER_MMAP_H
#define READER_MMAP_H
#ifndef LREC_READER_MMAP_H
#define LREC_READER_MMAP_H
// xxx rename x all to indicate line/file reader vs. lrec reader
#include <stdio.h>
#include "containers/lrec.h"
#include "mapping/context.h"
#include "input/mmap.h"
#include "input/file_reader_mmap.h"
// xxx rename mmap_state to mmap_handle?
typedef lrec_t* reader_mmap_func_t(mmap_reader_state_t* pfh, void* pvstate, context_t* pctx);
@ -15,8 +15,8 @@ typedef void reset_mmap_func_t(void* pvstate);
typedef struct _reader_mmap_t {
void* pvstate;
reader_mmap_func_t* preader_func;
reader_mmap_func_t* plrec_reader_func;
reset_mmap_func_t* preset_func;
} reader_mmap_t;
#endif // READER_MMAP_H
#endif // LREC_READER_MMAP_H

43
c/input/lrec_reader_nidx.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_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;
}

14
c/input/reader_nidx_mmap.c → c/input/lrec_reader_nidx_mmap.c
View file

@ -1,8 +1,8 @@
#include <stdlib.h>
#include "lib/mlrutil.h"
#include "containers/lrec_parsers.h"
#include "input/mmap.h"
#include "input/readers.h"
#include "input/file_reader_mmap.h"
#include "input/lrec_readers.h"
typedef struct _reader_nidx_mmap_state_t {
char irs;
@ -24,16 +24,16 @@ static void reset_nidx_func(void* pvstate) {
}
reader_mmap_t* reader_nidx_mmap_alloc(char irs, char ifs, int allow_repeat_ifs) {
reader_mmap_t* preader = mlr_malloc_or_die(sizeof(reader_mmap_t));
reader_mmap_t* plrec_reader = mlr_malloc_or_die(sizeof(reader_mmap_t));
reader_nidx_mmap_state_t* pstate = mlr_malloc_or_die(sizeof(reader_nidx_mmap_state_t));
pstate->irs = irs;
pstate->ifs = ifs;
pstate->allow_repeat_ifs = allow_repeat_ifs;
preader->pvstate = (void*)pstate;
plrec_reader->pvstate = (void*)pstate;
preader->preader_func = &reader_nidx_mmap_func;
preader->preset_func = &reset_nidx_func;
plrec_reader->plrec_reader_func = &reader_nidx_mmap_func;
plrec_reader->preset_func = &reset_nidx_func;
return preader;
return plrec_reader;
}

30
c/input/reader_xtab.c → c/input/lrec_reader_xtab.c
View file

@ -2,18 +2,18 @@
#include <stdlib.h>
#include "lib/mlrutil.h"
#include "containers/lrec_parsers.h"
#include "input/readers.h"
#include "input/lrec_readers.h"
typedef struct _reader_xtab_state_t {
typedef struct _lrec_reader_xtab_state_t {
char ips; // xxx make me real
int allow_repeat_ips;
int at_eof;
// xxx need to remember EOF for subsequent read
} reader_xtab_state_t;
} lrec_reader_xtab_state_t;
// ----------------------------------------------------------------
static lrec_t* reader_xtab_func(FILE* input_stream, void* pvstate, context_t* pctx) {
reader_xtab_state_t* pstate = pvstate;
static lrec_t* lrec_reader_xtab_func(FILE* input_stream, void* pvstate, context_t* pctx) {
lrec_reader_xtab_state_t* pstate = pvstate;
if (pstate->at_eof)
return NULL;
@ -43,27 +43,27 @@ static lrec_t* reader_xtab_func(FILE* input_stream, void* pvstate, context_t* pc
// xxx rename resets to sof_reset or some such
static void reset_xtab_func(void* pvstate) {
reader_xtab_state_t* pstate = pvstate;
lrec_reader_xtab_state_t* pstate = pvstate;
pstate->at_eof = FALSE;
}
static void reader_xtab_free(void* pvstate) {
static void lrec_reader_xtab_free(void* pvstate) {
}
reader_t* reader_xtab_alloc(char ips, int allow_repeat_ips) {
reader_t* preader = mlr_malloc_or_die(sizeof(reader_t));
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));
reader_xtab_state_t* pstate = mlr_malloc_or_die(sizeof(reader_xtab_state_t));
lrec_reader_xtab_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_reader_xtab_state_t));
//pstate->ips = ips;
//pstate->allow_repeat_ips = allow_repeat_ips;
pstate->ips = ' ';
pstate->allow_repeat_ips = TRUE;
pstate->at_eof = FALSE;
preader->pvstate = (void*)pstate;
plrec_reader->pvstate = (void*)pstate;
preader->preader_func = &reader_xtab_func;
preader->preset_func = &reset_xtab_func;
preader->pfree_func = &reader_xtab_free;;
plrec_reader->plrec_reader_func = &lrec_reader_xtab_func;
plrec_reader->preset_func = &reset_xtab_func;
plrec_reader->pfree_func = &lrec_reader_xtab_free;;
return preader;
return plrec_reader;
}

14
c/input/reader_xtab_mmap.c → c/input/lrec_reader_xtab_mmap.c
View file

@ -2,8 +2,8 @@
#include <stdlib.h>
#include "lib/mlrutil.h"
#include "containers/lrec_parsers.h"
#include "input/mmap.h"
#include "input/readers.h"
#include "input/file_reader_mmap.h"
#include "input/lrec_readers.h"
typedef struct _reader_xtab_mmap_state_t {
char irs;
@ -30,7 +30,7 @@ static void reset_xtab_func(void* pvstate) {
}
reader_mmap_t* reader_xtab_mmap_alloc(char irs, char ips, int allow_repeat_ips) {
reader_mmap_t* preader = mlr_malloc_or_die(sizeof(reader_mmap_t));
reader_mmap_t* plrec_reader = mlr_malloc_or_die(sizeof(reader_mmap_t));
reader_xtab_mmap_state_t* pstate = mlr_malloc_or_die(sizeof(reader_xtab_mmap_state_t));
//pstate->ips = ips;
@ -39,10 +39,10 @@ reader_mmap_t* reader_xtab_mmap_alloc(char irs, char ips, int allow_repeat_ips)
pstate->ips = ' ';
pstate->allow_repeat_ips = TRUE;
pstate->at_eof = FALSE;
preader->pvstate = (void*)pstate;
plrec_reader->pvstate = (void*)pstate;
preader->preader_func = &reader_xtab_mmap_func;
preader->preset_func = &reset_xtab_func;
plrec_reader->plrec_reader_func = &reader_xtab_mmap_func;
plrec_reader->preset_func = &reset_xtab_func;
return preader;
return plrec_reader;
}

16
c/input/lrec_readers.h Normal file
View file

@ -0,0 +1,16 @@
#ifndef LREC_READERS_H
#define LREC_READERS_H
#include "input/lrec_reader.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);
reader_mmap_t* reader_csv_mmap_alloc(char irs, char ifs, int allow_repeat_ifs);
reader_mmap_t* reader_dkvp_mmap_alloc(char irs, char ifs, char ips, int allow_repeat_ifs);
reader_mmap_t* reader_nidx_mmap_alloc(char irs, char ifs, int allow_repeat_ifs);
reader_mmap_t* reader_xtab_mmap_alloc(char irs, char ips, int allow_repeat_ips);
#endif // LREC_READERS_H

21
c/input/reader.h
View file

@ -1,21 +0,0 @@
#ifndef READER_H
#define READER_H
#include <stdio.h>
#include "containers/lrec.h"
#include "mapping/context.h"
// xxx rename to lrec_reader
typedef lrec_t* 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 reader_free_func_t(void* pvstate);
typedef struct _reader_t {
void* pvstate;
reader_func_t* preader_func;
reset_func_t* preset_func;
reader_free_func_t* pfree_func;
} reader_t;
#endif // READER_H

49
c/input/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/readers.h"
typedef struct _reader_dkvp_state_t {
char irs;
char ifs;
char ips;
int allow_repeat_ifs;
} reader_dkvp_state_t;
// ----------------------------------------------------------------
static lrec_t* reader_dkvp_func(FILE* input_stream, void* pvstate, context_t* pctx) {
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 reader_dkvp_free(void* pvstate) {
}
reader_t* reader_dkvp_alloc(char irs, char ifs, char ips, int allow_repeat_ifs) {
reader_t* preader = mlr_malloc_or_die(sizeof(reader_t));
reader_dkvp_state_t* pstate = mlr_malloc_or_die(sizeof(reader_dkvp_state_t));
pstate->irs = irs;
pstate->ifs = ifs;
pstate->ips = ips;
pstate->allow_repeat_ifs = allow_repeat_ifs;
preader->pvstate = (void*)pstate;
preader->preader_func = &reader_dkvp_func;
preader->preset_func = &reset_dkvp_func;
preader->pfree_func = &reader_dkvp_free;;
return preader;
}

43
c/input/reader_nidx.c
View file

@ -1,43 +0,0 @@
#include <stdlib.h>
#include "lib/mlrutil.h"
#include "containers/lrec_parsers.h"
#include "input/readers.h"
typedef struct _reader_nidx_state_t {
char irs;
char ifs;
int allow_repeat_ifs;
} reader_nidx_state_t;
// ----------------------------------------------------------------
static lrec_t* reader_nidx_func(FILE* input_stream, void* pvstate, context_t* pctx) {
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 reader_nidx_free_func(void* pvstate) {
}
reader_t* reader_nidx_alloc(char irs, char ifs, int allow_repeat_ifs) {
reader_t* preader = mlr_malloc_or_die(sizeof(reader_t));
reader_nidx_state_t* pstate = mlr_malloc_or_die(sizeof(reader_nidx_state_t));
pstate->irs = irs;
pstate->ifs = ifs;
pstate->allow_repeat_ifs = allow_repeat_ifs;
preader->pvstate = (void*)pstate;
preader->preader_func = &reader_nidx_func;
preader->preset_func = &reset_nidx_func;
preader->pfree_func = &reader_nidx_free_func;
return preader;
}

16
c/input/readers.h
View file

@ -1,16 +0,0 @@
#ifndef READERS_H
#define READERS_H
#include "input/reader.h"
#include "input/reader_mmap.h"
reader_t* reader_csv_alloc(char irs, char ifs, int allow_repeat_ifs);
reader_t* reader_dkvp_alloc(char irs, char ifs, char ips, int allow_repeat_ifs);
reader_t* reader_nidx_alloc(char irs, char ifs, int allow_repeat_ifs);
reader_t* reader_xtab_alloc(char ips, int allow_repeat_ips);
reader_mmap_t* reader_csv_mmap_alloc(char irs, char ifs, int allow_repeat_ifs);
reader_mmap_t* reader_dkvp_mmap_alloc(char irs, char ifs, char ips, int allow_repeat_ifs);
reader_mmap_t* reader_nidx_mmap_alloc(char irs, char ifs, int allow_repeat_ifs);
reader_mmap_t* reader_xtab_mmap_alloc(char irs, char ips, int allow_repeat_ips);
#endif // READERS_H

6
c/mlrmain.c
View file

@ -10,7 +10,7 @@
#include "lib/mlr_globals.h"
#include "containers/lrec.h"
#include "containers/sllv.h"
#include "input/readers.h"
#include "input/lrec_readers.h"
#include "mapping/mappers.h"
#include "output/lrec_writers.h"
#include "stream/stream.h"
@ -27,13 +27,13 @@ int main(int argc, char** argv) {
mlr_global_init(argv[0], popts->ofmt);
reader_t* preader = popts->preader;
lrec_reader_t* plrec_reader = popts->plrec_reader;
reader_mmap_t* preader_mmap = popts->preader_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_mmap_reader, preader, preader_mmap,
int ok = do_stream_chained(filenames, popts->use_mmap_reader, plrec_reader, preader_mmap,
pmapper_list, plrec_writer, popts->ofmt);
cli_opts_free(popts);

22
c/stream/stream.c
View file

@ -6,14 +6,14 @@
#include "lib/mlr_globals.h"
#include "containers/lrec.h"
#include "containers/sllv.h"
#include "input/readers.h"
#include "input/lrec_readers.h"
#include "mapping/mappers.h"
#include "output/lrec_writers.h"
static int do_file_chained(char* filename, context_t* pctx,
reader_t* preader, sllv_t* pmapper_list, lrec_writer_t* plrec_writer, FILE* output_stream);
lrec_reader_t* plrec_reader, sllv_t* pmapper_list, lrec_writer_t* plrec_writer, FILE* output_stream);
static int do_file_chained_mmap(char* filename, context_t* pctx,
reader_mmap_t* preader, sllv_t* pmapper_list, lrec_writer_t* plrec_writer, FILE* output_stream);
reader_mmap_t* plrec_reader, 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_mmap_reader, reader_t* preader, reader_mmap_t* preader_mmap,
int do_stream_chained(char** filenames, int use_mmap_reader, lrec_reader_t* plrec_reader, reader_mmap_t* preader_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_mmap_reader, reader_t* preader,
ctx.filenum++;
ctx.filename = "(stdin)";
ctx.fnr = 0;
ok = do_file_chained("-", &ctx, preader, pmapper_list, plrec_writer, output_stream) && ok;
ok = do_file_chained("-", &ctx, plrec_reader, 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_mmap_reader, reader_t* preader,
preader_mmap->preset_func(preader_mmap->pvstate);
ok = do_file_chained_mmap(*pfilename, &ctx, preader_mmap, pmapper_list, plrec_writer, output_stream) && ok;
} else {
preader->preset_func(preader->pvstate);
ok = do_file_chained(*pfilename, &ctx, preader, pmapper_list, plrec_writer, output_stream) && ok;
plrec_reader->preset_func(plrec_reader->pvstate);
ok = do_file_chained(*pfilename, &ctx, plrec_reader, pmapper_list, plrec_writer, output_stream) && ok;
}
}
}
@ -61,7 +61,7 @@ int do_stream_chained(char** filenames, int use_mmap_reader, reader_t* preader,
// ----------------------------------------------------------------
static int do_file_chained(char* filename, context_t* pctx,
reader_t* preader, sllv_t* pmapper_list, lrec_writer_t* plrec_writer, FILE* output_stream)
lrec_reader_t* plrec_reader, 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 = preader->preader_func(input_stream, preader->pvstate, pctx);
lrec_t* pinrec = plrec_reader->plrec_reader_func(input_stream, plrec_reader->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,
reader_mmap_t* preader, sllv_t* pmapper_list, lrec_writer_t* plrec_writer, FILE* output_stream)
reader_mmap_t* plrec_reader, 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
mmap_reader_state_t handle = mmap_reader_open(filename);
while (1) {
lrec_t* pinrec = preader->preader_func(&handle, preader->pvstate, pctx);
lrec_t* pinrec = plrec_reader->plrec_reader_func(&handle, plrec_reader->pvstate, pctx);
if (pinrec == NULL)
break;
pctx->nr++;

4
c/stream/stream.h
View file

@ -2,12 +2,12 @@
#define STREAM_H
#include "containers/sllv.h"
#include "input/readers.h"
#include "input/lrec_readers.h"
#include "mapping/mappers.h"
#include "output/lrec_writers.h"
// filenames must be null-terminated
int do_stream_chained(char** filenames, int use_mmap_reader, reader_t* preader, reader_mmap_t* preader_mmap,
int do_stream_chained(char** filenames, int use_mmap_reader, lrec_reader_t* plrec_reader, reader_mmap_t* preader_mmap,
sllv_t* pmapper_list, lrec_writer_t* plrec_writer, char* ofmt);
#endif // STREAM_H