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