static void
proc_line(struct prln_ctx_s ctx, char *line, size_t llen)
{
struct dt_dt_s d;
char *sp = NULL;
char *ep = NULL;
do {
d = dt_io_find_strpdt2(line, ctx.ndl, &sp, &ep, ctx.fromz);
/* check if line matches */
if (!dt_unk_p(d) && ctx.sed_mode_p) {
__io_write(line, sp - line, stdout);
dt_io_write(d, ctx.ofmt, ctx.outz, '\0');
llen -= (ep - line);
line = ep;
} else if (!dt_unk_p(d)) {
dt_io_write(d, ctx.ofmt, ctx.outz, '\n');
break;
} else if (ctx.sed_mode_p) {
line[llen] = '\n';
__io_write(line, llen + 1, stdout);
break;
} else {
/* obviously unmatched, warn about it in non -q mode */
if (!ctx.quietp) {
dt_io_warn_strpdt(line);
}
break;
}
} while (1);
return;
}
static void
proc_line(struct prln_ctx_s ctx, char *line, size_t llen)
{
char *osp = NULL;
char *oep = NULL;
/* check if line matches,
* there's currently no way to specify NEEDLE */
for (char *lp = line, *sp, *ep; ; lp = ep, osp = sp, oep = ep) {
struct dt_dt_s d =
dt_io_find_strpdt2(lp, ctx.ndl, &sp, &ep, ctx.fromz);
bool unkp = dt_unk_p(d);
if (unkp) {
/* just plain nothing */
break;
} else if (ctx.z != NULL) {
/* promote to zone ctx.z */
d = dtz_enrichz(d, ctx.z);
}
/* otherwise */
if (dexpr_matches_p(ctx.root, d)) {
if (ctx.invert_match_p) {
/* nothing must match */
return;
} else if (!ctx.only_matching_p) {
sp = line;
ep = line + llen;
}
/* make sure we finish the line */
*ep++ = '\n';
__io_write(sp, ep - sp, stdout);
return;
}
}
if (ctx.invert_match_p) {
/* no match but invert_match select, print line */
if (!ctx.only_matching_p) {
osp = line;
oep = line + llen;
} else if (osp == NULL || oep == NULL) {
/* no date in line and only-matching is active
* bugger off */
return;
}
/* finish the line and bugger off */
*oep++ = '\n';
__io_write(osp, oep - osp, stdout);
}
return;
}
static int
proc_line(const struct mass_add_clo_s *clo, char *line, size_t llen)
{
struct dt_dt_s d;
char *sp = NULL;
char *ep = NULL;
int rc = 0;
do {
/* check if line matches, */
d = dt_io_find_strpdt2(
line, llen, clo->gra, &sp, &ep, clo->fromz);
if (!dt_unk_p(d)) {
if (UNLIKELY(d.fix) && !clo->quietp) {
rc = 2;
}
/* perform addition now */
d = dadd_add(d, clo->st.durs, clo->st.ndurs);
if (clo->hackz == NULL && clo->fromz != NULL) {
/* fixup zone */
d = dtz_forgetz(d, clo->fromz);
}
if (clo->sed_mode_p) {
__io_write(line, sp - line, stdout);
dt_io_write(d, clo->ofmt, clo->z, '\0');
llen -= (ep - line);
line = ep;
} else {
dt_io_write(d, clo->ofmt, clo->z, '\n');
break;
}
} else if (clo->sed_mode_p) {
line[llen] = '\n';
__io_write(line, llen + 1, stdout);
break;
} else {
/* obviously unmatched, warn about it in non -q mode */
if (!clo->quietp) {
dt_io_warn_strpdt(line);
rc = 2;
}
break;
}
} while (1);
return rc;
}
static int
proc_line(struct prln_ctx_s ctx, char *line, size_t llen)
{
struct dt_dt_s d;
char *sp = NULL;
char *ep = NULL;
int rc = 0;
do {
/* check if line matches, */
d = dt_io_find_strpdt2(
line, llen, ctx.ndl, &sp, &ep, ctx.fromz);
if (!dt_unk_p(d)) {
if (UNLIKELY(d.fix) && !ctx.quietp) {
rc = 2;
}
/* perform addition now */
d = dround(d, ctx.st->durs, ctx.st->ndurs, ctx.nextp);
if (ctx.hackz == NULL && ctx.fromz != NULL) {
/* fixup zone */
d = dtz_forgetz(d, ctx.fromz);
}
if (ctx.sed_mode_p) {
__io_write(line, sp - line, stdout);
dt_io_write(d, ctx.ofmt, ctx.outz, '\0');
llen -= (ep - line);
line = ep;
} else {
dt_io_write(d, ctx.ofmt, ctx.outz, '\n');
break;
}
} else if (ctx.sed_mode_p) {
line[llen] = '\n';
__io_write(line, llen + 1, stdout);
break;
} else {
/* obviously unmatched, warn about it in non -q mode */
if (!ctx.quietp) {
dt_io_warn_strpdt(line);
rc = 2;
}
break;
}
} while (1);
return rc;
}
static void
proc_line(struct prln_ctx_s ctx, char *line, size_t llen)
{
struct dt_dt_s d;
do {
char buf[64U];
char *sp, *tp;
char *bp = buf;
const char *const ep = buf + sizeof(buf);
/* find first occurrence then */
d = dt_io_find_strpdt2(
line, llen, ctx.ndl, &sp, &tp, ctx.fromz);
/* print line, first thing */
safe_write(ctx.outfd, line, llen);
/* extend by separator */
*bp++ = '\001';
/* check if line matches */
if (!dt_unk_p(d)) {
/* match! */
if (!dt_sandwich_only_t_p(d)) {
bp += dt_strfdt(bp, ep - bp, "%F", d);
}
*bp++ = '\001';
if (!dt_sandwich_only_d_p(d)) {
bp += dt_strfdt(bp, ep - bp, "%T", d);
}
} else {
/* just two empty fields then, innit? */
*bp++ = '\001';
}
/* finalise the line and print */
*bp++ = '\n';
safe_write(ctx.outfd, buf, bp - buf);
} while (0);
return;
}
int
main(int argc, char *argv[])
{
yuck_t argi[1U];
struct dt_dt_s d;
struct __strpdtdur_st_s st = __strpdtdur_st_initialiser();
const char *ofmt;
char **fmt;
size_t nfmt;
int rc = 0;
bool dt_given_p = false;
zif_t fromz = NULL;
zif_t z = NULL;
zif_t hackz = NULL;
if (yuck_parse(argi, argc, argv)) {
rc = 1;
goto out;
} else if (argi->nargs == 0) {
error("Error: DATE or DURATION must be specified\n");
yuck_auto_help(argi);
rc = 1;
goto out;
}
/* init and unescape sequences, maybe */
ofmt = argi->format_arg;
fmt = argi->input_format_args;
nfmt = argi->input_format_nargs;
if (argi->backslash_escapes_flag) {
dt_io_unescape(argi->format_arg);
for (size_t i = 0; i < nfmt; i++) {
dt_io_unescape(fmt[i]);
}
}
/* try and read the from and to time zones */
if (argi->from_zone_arg) {
fromz = dt_io_zone(argi->from_zone_arg);
}
if (argi->zone_arg) {
z = dt_io_zone(argi->zone_arg);
}
if (argi->base_arg) {
struct dt_dt_s base = dt_strpdt(argi->base_arg, NULL, NULL);
dt_set_base(base);
}
/* sanity checks, decide whether we're a mass date adder
* or a mass duration adder, or both, a date and durations are
* present on the command line */
with (const char *inp = argi->args[0U]) {
/* date parsing needed postponing as we need to find out
* about the durations */
if (!dt_unk_p(dt_io_strpdt(inp, fmt, nfmt, NULL))) {
dt_given_p = true;
}
}
/* check first arg, if it's a date the rest of the arguments are
* durations, if not, dates must be read from stdin */
for (size_t i = dt_given_p; i < argi->nargs; i++) {
const char *inp = argi->args[i];
do {
if (dt_io_strpdtdur(&st, inp) < 0) {
serror("Error: \
cannot parse duration string `%s'", st.istr);
rc = 1;
goto dur_out;
}
} while (__strpdtdur_more_p(&st));
}
/* check if there's only d durations */
hackz = durs_only_d_p(st.durs, st.ndurs) ? NULL : fromz;
/* read the first argument again in light of a completely parsed
* duration sequence */
if (dt_given_p) {
const char *inp = argi->args[0U];
if (dt_unk_p(d = dt_io_strpdt(inp, fmt, nfmt, hackz))) {
error("\
Error: cannot interpret date/time string `%s'", inp);
rc = 1;
goto dur_out;
}
}
/* start the actual work */
if (dt_given_p && st.ndurs) {
if (!dt_unk_p(d = dadd_add(d, st.durs, st.ndurs))) {
if (UNLIKELY(d.fix) && !argi->quiet_flag) {
rc = 2;
}
if (hackz == NULL && fromz != NULL) {
/* fixup zone */
d = dtz_forgetz(d, fromz);
}
dt_io_write(d, ofmt, z, '\n');
} else {
rc = 1;
}
} else if (st.ndurs) {
/* read dates from stdin */
struct grep_atom_s __nstk[16], *needle = __nstk;
size_t nneedle = countof(__nstk);
struct grep_atom_soa_s ndlsoa;
struct mass_add_clo_s clo[1];
void *pctx;
/* no threads reading this stream */
__io_setlocking_bycaller(stdout);
/* lest we overflow the stack */
if (nfmt >= nneedle) {
/* round to the nearest 8-multiple */
nneedle = (nfmt | 7) + 1;
needle = calloc(nneedle, sizeof(*needle));
}
/* and now build the needle */
ndlsoa = build_needle(needle, nneedle, fmt, nfmt);
/* using the prchunk reader now */
if ((pctx = init_prchunk(STDIN_FILENO)) == NULL) {
serror("could not open stdin");
goto ndl_free;
}
/* build the clo and then loop */
clo->pctx = pctx;
clo->gra = &ndlsoa;
clo->st = st;
clo->fromz = fromz;
clo->hackz = hackz;
clo->z = z;
clo->ofmt = ofmt;
clo->sed_mode_p = argi->sed_mode_flag;
clo->quietp = argi->quiet_flag;
while (prchunk_fill(pctx) >= 0) {
rc |= mass_add_dur(clo);
}
/* get rid of resources */
free_prchunk(pctx);
ndl_free:
if (needle != __nstk) {
free(needle);
}
} else {
/* mass-adding durations to reference date */
struct mass_add_clo_s clo[1];
void *pctx;
/* no threads reading this stream */
__io_setlocking_bycaller(stdout);
/* using the prchunk reader now */
if ((pctx = init_prchunk(STDIN_FILENO)) == NULL) {
serror("could not open stdin");
goto dur_out;
}
/* build the clo and then loop */
clo->pctx = pctx;
clo->rd = d;
clo->fromz = fromz;
clo->hackz = hackz;
clo->z = z;
clo->ofmt = ofmt;
clo->sed_mode_p = argi->sed_mode_flag;
clo->quietp = argi->quiet_flag;
while (prchunk_fill(pctx) >= 0) {
rc |= mass_add_d(clo);
}
/* get rid of resources */
free_prchunk(pctx);
}
dur_out:
/* free the strpdur status */
__strpdtdur_free(&st);
dt_io_clear_zones();
out:
yuck_free(argi);
return rc;
}
int
main(int argc, char *argv[])
{
static struct dt_dtdur_s ite_p1;
yuck_t argi[1U];
struct dt_dt_s tmp;
char **ifmt;
size_t nifmt;
char *ofmt;
dt_dttyp_t tgttyp;
int rc = 0;
struct dseq_clo_s clo = {
.ite = &ite_p1,
.nite = 1,
.altite = NULL,
.naltite = 0,
.ss = 0,
.dir = 0,
.flags = 0,
};
if (yuck_parse(argi, argc, argv)) {
rc = 1;
goto out;
}
/* assign ofmt/ifmt */
ofmt = argi->format_arg;
if (argi->backslash_escapes_flag) {
dt_io_unescape(ofmt);
}
nifmt = argi->input_format_nargs;
ifmt = argi->input_format_args;
if (argi->from_locale_arg) {
setilocale(argi->from_locale_arg);
}
if (argi->locale_arg) {
setflocale(argi->locale_arg);
}
if (argi->base_arg) {
struct dt_dt_s base = dt_strpdt(argi->base_arg, NULL, NULL);
dt_set_base(base);
}
for (size_t i = 0; i < argi->skip_nargs; i++) {
clo.ss = set_skip(clo.ss, argi->skip_args[i]);
}
if (argi->alt_inc_arg) {
struct __strpdtdur_st_s st = __strpdtdur_st_initialiser();
do {
if (dt_io_strpdtdur(&st, argi->alt_inc_arg) < 0) {
if (!argi->quiet_flag) {
error("Error: \
cannot parse duration string `%s'", argi->alt_inc_arg);
}
rc = 1;
goto out;
}
} while (__strpdtdur_more_p(&st));
/* assign values */
clo.altite = st.durs;
clo.naltite = st.ndurs;
}
switch (argi->nargs) {
struct dt_dt_s fst, lst;
default:
yuck_auto_help(argi);
rc = 1;
goto out;
case 2:
lst = dt_io_strpdt(argi->args[1U], ifmt, nifmt, NULL);
if (dt_unk_p(lst)) {
if (!argi->quiet_flag) {
dt_io_warn_strpdt(argi->args[1U]);
}
rc = 1;
goto out;
} else if (UNLIKELY(lst.fix) && !argi->quiet_flag) {
rc = 2;
}
/* fallthrough */
case 1:
fst = dt_io_strpdt(argi->args[0U], ifmt, nifmt, NULL);
if (dt_unk_p(fst)) {
if (!argi->quiet_flag) {
dt_io_warn_strpdt(argi->args[0U]);
}
rc = 1;
goto out;
} else if (UNLIKELY(fst.fix) && !argi->quiet_flag) {
rc = 2;
}
/* check the input arguments and do the sane thing now
* if it's all dates, use DURD iterator
* if it's all times, use DURS/DURM/DURH iterators
* if one of them is a dt, promote the other */
if (dt_sandwich_only_d_p(fst)) {
/* emulates old dseq(1) */
if (argi->nargs == 1U) {
lst.d = dt_date(fst.d.typ);
dt_make_d_only(&lst, fst.d.typ);
}
clo.ite->d = dt_make_ddur(DT_DURD, 1);
} else if (dt_sandwich_only_t_p(fst)) {
/* emulates old tseq(1) */
if (argi->nargs == 1U) {
lst.t = dt_time();
dt_make_t_only(&lst, DT_HMS);
}
} else if (dt_sandwich_p(fst)) {
if (argi->nargs == 1U) {
lst = dt_datetime(fst.typ);
dt_make_sandwich(&lst, fst.d.typ, DT_HMS);
}
clo.ite->d = dt_make_ddur(DT_DURD, 1);
} else {
error("\
don't know how to handle single argument case");
rc = 1;
goto out;
}
goto make_compat;
case 3: {
struct __strpdtdur_st_s st = __strpdtdur_st_initialiser();
/* get lower bound */
fst = dt_io_strpdt(argi->args[0U], ifmt, nifmt, NULL);
if (dt_unk_p(fst)) {
if (!argi->quiet_flag) {
dt_io_warn_strpdt(argi->args[0U]);
}
rc = 1;
goto out;
} else if (UNLIKELY(fst.fix) && !argi->quiet_flag) {
rc = 2;
}
/* get increment */
do {
if (dt_io_strpdtdur(&st, argi->args[1U]) < 0) {
error("Error: \
cannot parse duration string `%s'", argi->args[1U]);
rc = 1;
goto out;
}
} while (__strpdtdur_more_p(&st));
/* assign values */
clo.ite = st.durs;
clo.nite = st.ndurs;
clo.flags |= CLO_FL_FREE_ITE;
/* get upper bound */
lst = dt_io_strpdt(argi->args[2U], ifmt, nifmt, NULL);
if (dt_unk_p(lst)) {
if (!argi->quiet_flag) {
dt_io_warn_strpdt(argi->args[2U]);
}
rc = 1;
goto out;
} else if (UNLIKELY(lst.fix) && !argi->quiet_flag) {
rc = 2;
}
goto make_compat;
}
make_compat:
if (LIKELY(fst.typ == lst.typ)) {
clo.fst = fst;
clo.lst = lst;
} else {
clo.fst = fst;
clo.lst = dt_dtconv(fst.typ, lst);
}
break;
}
/* promote the args maybe */
if ((dt_sandwich_only_d_p(clo.fst) && dt_sandwich_only_t_p(clo.lst)) ||
(dt_sandwich_only_t_p(clo.fst) && dt_sandwich_only_d_p(clo.lst))) {
error("\
cannot mix dates and times as arguments");
rc = 1;
goto out;
} else if (dt_sandwich_only_d_p(clo.fst) && dt_sandwich_p(clo.lst)) {
int
main(int argc, char *argv[])
{
struct gengetopt_args_info argi[1];
const char *ofmt;
char **fmt;
size_t nfmt;
int res = 0;
zif_t fromz = NULL;
zif_t z = NULL;
if (cmdline_parser(argc, argv, argi)) {
res = 1;
goto out;
}
/* init and unescape sequences, maybe */
ofmt = argi->format_arg;
fmt = argi->input_format_arg;
nfmt = argi->input_format_given;
if (argi->backslash_escapes_given) {
dt_io_unescape(argi->format_arg);
for (size_t i = 0; i < nfmt; i++) {
dt_io_unescape(fmt[i]);
}
}
/* try and read the from and to time zones */
if (argi->from_zone_given) {
fromz = zif_open(argi->from_zone_arg);
}
if (argi->zone_given) {
z = zif_open(argi->zone_arg);
}
if (argi->default_given) {
struct dt_dt_s dflt = dt_strpdt(argi->default_arg, NULL, NULL);
dt_set_default(dflt);
}
if (argi->inputs_num) {
for (size_t i = 0; i < argi->inputs_num; i++) {
const char *inp = argi->inputs[i];
struct dt_dt_s d = dt_io_strpdt(inp, fmt, nfmt, fromz);
if (!dt_unk_p(d)) {
dt_io_write(d, ofmt, z, '\n');
} else if (!argi->quiet_given) {
dt_io_warn_strpdt(inp);
}
}
} else {
/* read from stdin */
size_t lno = 0;
struct grep_atom_s __nstk[16], *needle = __nstk;
size_t nneedle = countof(__nstk);
struct grep_atom_soa_s ndlsoa;
void *pctx;
struct prln_ctx_s prln = {
.ndl = &ndlsoa,
.ofmt = ofmt,
.fromz = fromz,
.outz = z,
.sed_mode_p = argi->sed_mode_given,
.quietp = argi->quiet_given,
};
/* no threads reading this stream */
__io_setlocking_bycaller(stdout);
/* lest we overflow the stack */
if (nfmt >= nneedle) {
/* round to the nearest 8-multiple */
nneedle = (nfmt | 7) + 1;
needle = calloc(nneedle, sizeof(*needle));
}
/* and now build the needles */
ndlsoa = build_needle(needle, nneedle, fmt, nfmt);
/* using the prchunk reader now */
if ((pctx = init_prchunk(STDIN_FILENO)) == NULL) {
error(errno, "Error: could not open stdin");
goto ndl_free;
}
while (prchunk_fill(pctx) >= 0) {
for (char *line; prchunk_haslinep(pctx); lno++) {
size_t llen = prchunk_getline(pctx, &line);
proc_line(prln, line, llen);
}
}
/* get rid of resources */
free_prchunk(pctx);
ndl_free:
if (needle != __nstk) {
free(needle);
}
}
if (argi->from_zone_given) {
zif_close(fromz);
}
if (argi->zone_given) {
zif_close(z);
}
out:
cmdline_parser_free(argi);
return res;
}
