Lines Matching +full:ats +full:- +full:supported
5 ** 2006-07-17 by Arthur David Olson.
30 ZIC32_MIN = -1 - (zic_t) 0x7fffffff,
38 /* Minimum and maximum years, assuming signed 32-bit time_t. */
73 /* The minimum alignment of a type, for pre-C23 platforms.
160 return -1;
166 return -1;
171 (errno = ENOTSUP, -1)
208 enum { PERCENT_Z_LEN_BOUND = sizeof "+995959" - 1 };
324 (The "+"s pacify gcc -Wenum-compare.) */
407 { "last-Sunday", TM_SUNDAY },
408 { "last-Monday", TM_MONDAY },
409 { "last-Tuesday", TM_TUESDAY },
410 { "last-Wednesday", TM_WEDNESDAY },
411 { "last-Thursday", TM_THURSDAY },
412 { "last-Friday", TM_FRIDAY },
413 { "last-Saturday", TM_SATURDAY },
483 if (a <= INDEX_MAX && b <= INDEX_MAX - a)
507 size_t lo_bits = alignment - 1, sum = size_sum(size, lo_bits);
556 if (*nitems_alloc <= ((INDEX_MAX - 1) / 3 * 2) / itemsize) {
580 enum { LEAPSEC_FILENUM = -2, COMMAND_LINE_FILENUM = -1 };
590 return strcmp(fname, "-") == 0 ? _("standard input") : fname;
606 eats(fnum, num, 0, -1);
614 ** zic ... 2>&1 | error -t "*" -v
671 _("%s: usage is %s [ --version ] [ --help ] [ -v ] \\\n"
672 "\t[ -b {slim|fat} ] [ -d directory ] [ -l localtime ]"
673 " [ -L leapseconds ] \\\n"
674 "\t[ -p posixrules ] [ -r '[@lo][/@hi]' ] [ -R '@hi' ] \\\n"
675 "\t[ -t localtime-link ] [ -D ] [ -g gid ] [ -u uid ] \\\n"
710 int cmp = strcmp(l->l_linkname, m->l_linkname);
717 cmp = l->l_filenum - m->l_filenum;
720 return (l->l_linenum > m->l_linenum) - (l->l_linenum < m->l_linenum);
728 return strcmp(key, m->l_linkname);
752 up with a small sorted subsequence of not-yet-made links.
755 a link to a not-yet-made link, so the process repeats.
760 0 .. (i - 1):
764 i .. (j - 1):
765 not-yet-made links for this pass
766 j .. (nalinks - 1):
767 not-yet-made links that this pass has skipped because
768 they were links to not-yet-made links
772 not alter entries 0 .. (nlinks - 1), which remain sorted.
776 short (e.g., 3) though its worst-case value is L. */
787 if (nalinks - i == pass_size) {
793 pass_size = nalinks - i;
804 l = bsearch(links[i].l_target, &links[i + 1], j - (i + 1),
807 l = bsearch(links[i].l_target, &links[j], nalinks - j,
819 warning(_("link %s targeting link %s mishandled by pre-2023 zic"),
898 the -r option. These default to MIN_TIME and MAX_TIME. */
902 /* The time specified by the -R option, defaulting to MIN_TIME;
907 static zic_t leapexpires = -1;
928 hi -= ! (hi == INTMAX_MAX && errno == ERANGE);
958 static uid_t uflag = (uid_t)-1;
959 static gid_t gflag = (gid_t)-1;
964 /* -1 if the TZif output file should be slim, 0 if default, 1 if the
1000 _("wild compilation-time specification of zic_t"));
1004 if (strcmp(argv[k], "--version") == 0) {
1008 } else if (strcmp(argv[k], "--help") == 0) {
1012 && c != -1)
1022 error(_("incompatible -b options"));
1023 bloat = -1;
1026 error(_("incompatible -b options"));
1029 error(_("invalid option: -b '%s'"), optarg);
1036 _("%s: More than one -d option"
1050 _("%s: More than one -l option"
1073 _("%s: More than one -p option"
1082 _("%s: More than one -t option"
1093 warning(_("-y ignored"));
1100 _("%s: More than one -L option"
1112 _("%s: More than one -r option"
1133 warning(_("-s ignored"));
1136 if (optind == argc - 1 && strcmp(argv[optind], "=") == 0)
1139 fprintf(stderr, _("%s: -R time exceeds -r cutoff\n"), progname);
1147 bloat = -1;
1172 ** Find the next non-continuation zone entry.
1176 outzone(&zones[i], j - i);
1197 ptrdiff_t component_len = component_end - component;
1211 && component[0] == '.' && component_end[-1] == '.') {
1218 if (0 < component_len && component[0] == '-')
1219 warning(_("file name '%s' component contains leading '-'"),
1236 "-/_"
1240 /* Non-control chars in the POSIX portable character set,
1277 nwords = -1;
1282 return entropy_buffer[--nwords];
1298 In other cases this code yields a sort-of-random number. */
1337 enum { prefixlen = sizeof prefix - 1, alphabetlen = sizeof alphabet - 1 };
1340 ptrdiff_t dirlen = lastslash ? lastslash + 1 - src : 0;
1351 mathematical value of ((UINTMAX_MAX + 1) - (UINTMAX_MAX + 1) % BASE**6)
1353 uint_fast64_t unfair_min = - ((UINTMAX_MAX % base__6 + 1) % base__6);
1450 size_t lenslash = len + (len && directory[len - 1] != '/');
1462 dotdots += linkname[i] == '/' && linkname[i - 1] != '/';
1494 int targetissym = -2, linknameissym = -2;
1498 if (strcmp(target, "-") == 0) {
1520 /* If linkat is not supported, fall back on link(A, B).
1604 /* Return 1 if NAME is an absolute symbolic link, -1 if it is relative,
1605 0 if it is not a symbolic link. If *CACHE is not -2, it is the
1610 if (*cache == -2) {
1612 *cache = readlink(name, &c, 1) < 0 ? 0 : c == '/' ? 1 : -1;
1629 return strcmp(r1->r_name, r2->r_name);
1641 for (i = 0; i < nrules - 1; ++i) {
1662 i = j - 1;
1667 zp->z_rules = NULL;
1668 zp->z_nrules = 0;
1673 if (strcmp(rp->r_name, rules[out].r_name) != 0)
1677 if (strcmp(zp->z_rule, rp->r_name) != 0)
1679 zp->z_rules = rp;
1680 zp->z_nrules = out - base;
1685 if (zp->z_nrules == 0) {
1689 eat(zp->z_filenum, zp->z_linenum);
1690 zp->z_save = getsave(zp->z_rule, &zp->z_isdst);
1695 if (zp->z_format_specifier == 's')
1744 if (strcmp(name, "-") == 0) {
1775 else switch (lp->l_value) {
1806 ** h -h hh:mm -hh:mm hh:mm:ss -hh:mm:ss
1823 if (*string == '-') {
1824 sign = -1;
1838 " pre-2018 versions of zic"));
1861 warning(_("values over 24 hours not handled by pre-2007 versions of zic"));
1869 int dst = -1;
1873 char *ep = field + fieldlen - 1;
1896 case '+': case '-':
1927 error(_("\"Zone %s\" line and -l option are mutually exclusive"),
1932 error(_("\"Zone %s\" line and -p option are mutually exclusive"),
2023 zones[nzones - 1].z_untiltime > min_time &&
2024 zones[nzones - 1].z_untiltime < max_time &&
2025 zones[nzones - 1].z_untiltime >= z.z_untiltime) {
2035 cp1[cp - fields[i_format]] = 's';
2037 warning(_("format '%s' not handled by pre-2015 versions of zic"),
2068 return -1;
2083 --j;
2084 i = -len_years[isleap(j)];
2090 return -1;
2092 month = lp->l_value;
2103 return -1;
2105 dayoff = oadd(dayoff, day - 1);
2108 return -1;
2112 return -1;
2135 if (!fields[LP_CORR][0]) /* infile() turns "-" into "". */
2136 correction = -1;
2142 leapadd(t, correction, lp->l_value);
2197 rp->r_month = lp->l_value;
2198 rp->r_todisstd = false;
2199 rp->r_todisut = false;
2202 ep = dp + strlen(dp) - 1;
2205 rp->r_todisstd = true;
2206 rp->r_todisut = false;
2210 rp->r_todisstd = false;
2211 rp->r_todisut = false;
2217 rp->r_todisstd = true;
2218 rp->r_todisut = true;
2223 rp->r_tod = gethms(dp, _("invalid time of day"));
2230 if (lp) switch (lp->l_value) {
2234 cp, YEAR_32BIT_MIN - 1);
2235 rp->r_loyear = YEAR_32BIT_MIN - 1;
2238 } else if (sscanf(cp, "%"SCNdZIC"%c", &rp->r_loyear, &xs) != 1) {
2244 rp->r_hiwasnum = lp == NULL;
2245 if (!rp->r_hiwasnum) switch (lp->l_value) {
2247 rp->r_hiyear = ZIC_MAX;
2250 rp->r_hiyear = rp->r_loyear;
2253 } else if (sscanf(cp, "%"SCNdZIC"%c", &rp->r_hiyear, &xs) != 1) {
2257 if (rp->r_loyear > rp->r_hiyear) {
2262 error(_("year type \"%s\" is unsupported; use \"-\" instead"),
2271 ** last-Sunday (undocumented; warn about this)
2277 rp->r_dycode = DC_DOWLEQ;
2278 rp->r_wday = lp->l_value;
2279 rp->r_dayofmonth = len_months[1][rp->r_month];
2282 rp->r_dycode = DC_DOWLEQ;
2284 rp->r_dycode = DC_DOWGEQ;
2287 rp->r_dycode = DC_DOM;
2289 if (rp->r_dycode != DC_DOM) {
2301 rp->r_wday = lp->l_value;
2303 if (sscanf(ep, "%d%c", &rp->r_dayofmonth, &xs) != 1 ||
2304 rp->r_dayofmonth <= 0 ||
2305 (rp->r_dayofmonth > len_months[1][rp->r_month])) {
2322 for (i = 0, shift = 24; i < 4; ++i, shift -= 8)
2333 for (i = 0, shift = 56; i < 8; ++i, shift -= 8)
2363 zic_t a = ap->at, b = bp->at;
2364 return a < b ? -1 : a > b;
2376 zic_t const *ats, unsigned char const *types)
2379 while (0 < r.count && ats[r.base] < lo) {
2381 r.count--;
2391 r.leapcount--;
2395 && ((corr[r.leapbase - 1] < corr[r.leapbase])
2398 r.leapbase--;
2404 while (0 < r.count && hi + 1 < ats[r.base + r.count - 1])
2405 r.count--;
2406 while (0 < r.leapcount && hi + 1 < trans[r.leapbase + r.leapcount - 1])
2407 r.leapcount--;
2411 r.leapexpiry = 0 <= leapexpires && leapexpires - 1 <= hi;
2427 /* Allocate the ATS and TYPES arrays via a single malloc,
2430 zic_t *ats = emalloc(align_to(size_product(timecnt + !timecnt,
2431 sizeof *ats + 1),
2433 void *typesptr = ats + timecnt;
2453 + utoffs[attypes[toi - 1].type])
2454 <= (attypes[toi - 1].at
2456 : attypes[toi - 2].type]))) {
2457 attypes[toi - 1].type =
2463 || (utoffs[attypes[toi - 1].type]
2465 || (isdsts[attypes[toi - 1].type]
2467 || (desigidx[attypes[toi - 1].type]
2480 warning(_("pre-2014 clients may mishandle"
2487 ats[i] = attypes[i].at;
2496 while (--j >= 0)
2497 if (ats[i] > trans[j] - corr[j]) {
2498 ats[i] = tadd(ats[i], corr[j]);
2508 redundant_time - (ZIC_MIN < redundant_time)),
2509 ats, types);
2510 range32 = limitrange(range64, ZIC32_MIN, ZIC32_MAX, ats, types);
2512 /* TZif version 4 is needed if a no-op transition is appended to
2514 leap second transition is not to a +1 or -1 correction. */
2519 if (r->leapexpiry) {
2521 warning(_("%s: pre-2021b clients may mishandle"
2526 if (0 < r->leapcount
2527 && corr[r->leapbase] != 1 && corr[r->leapbase] != -1) {
2529 warning(_("%s: pre-2021b clients may mishandle"
2544 int pretranstype = -1, thisdefaulttype;
2588 buggy 32-bit clients that do not use time type 0 for
2591 && ! (thistimecnt && ats[thistimei] == lo_time)) {
2596 /* Arguably the default time type in the 32-bit data
2601 ignore 32-bit data, so this discrepancy matters only
2604 the historical zic value, unless -r specifies a low
2605 cutoff that excludes some 32-bit timestamps. */
2625 ** For some pre-2011 systems: if the last-to-be-written
2635 hidst = histd = mrudst = mrustd = -1;
2658 isdsts[mrudst] = -1;
2669 isdsts[mrustd] = -1;
2688 indmap[u] = -1;
2713 pretranstype = -1;
2743 putc(0, fp); /* empty-string abbreviation */
2755 puttzcodepass(ats[i], fp, pass);
2783 if (timecnt == 0 || trans[i] < ats[0]) {
2793 trans[i] >= ats[j])
2795 j = types[j - 1];
2797 todo = tadd(trans[i], -utoffs[j]);
2803 /* Append a no-op leap correction indicating when the leap
2809 puttzcode(thisleaplim ? corr[thisleaplim - 1] : 0, fp);
2827 if ((uflag != (uid_t)-1 || gflag != (gid_t)-1)
2834 free(ats);
2844 offset = -offset;
2845 sign = '-';
2882 char const *format = zp->z_format;
2887 if (zp->z_format_specifier == 'z')
2888 letters = abbroffset(letterbuf, zp->z_stdoff + save);
2897 memcpy(abbr, format, slashp - format);
2898 abbr[slashp - format] = '\0';
2933 offset = -offset;
2934 result[0] = '-';
2957 register zic_t tod = rp->r_tod;
2960 if (rp->r_dycode == DC_DOM) {
2963 if (rp->r_dayofmonth == 29 && rp->r_month == TM_FEBRUARY)
2964 return -1;
2966 for (month = 0; month < rp->r_month; ++month)
2969 if (rp->r_month <= 1)
2970 result += sprintf(result, "%d", total + rp->r_dayofmonth - 1);
2972 result += sprintf(result, "J%d", total + rp->r_dayofmonth);
2975 register int wday = rp->r_wday;
2978 if (rp->r_dycode == DC_DOWGEQ) {
2979 wdayoff = (rp->r_dayofmonth - 1) % DAYSPERWEEK;
2982 wday -= wdayoff;
2984 week = 1 + (rp->r_dayofmonth - 1) / DAYSPERWEEK;
2985 } else if (rp->r_dycode == DC_DOWLEQ) {
2986 if (rp->r_dayofmonth == len_months[1][rp->r_month])
2989 wdayoff = rp->r_dayofmonth % DAYSPERWEEK;
2992 wday -= wdayoff;
2994 week = rp->r_dayofmonth / DAYSPERWEEK;
2996 } else return -1; /* "cannot happen" */
3000 rp->r_month + 1, week, wday);
3002 if (rp->r_todisut)
3004 if (rp->r_todisstd && !rp->r_isdst)
3009 return -1;
3025 return -!!b;
3028 if (a->r_hiyear != b->r_hiyear)
3029 return a->r_hiyear < b->r_hiyear ? -1 : 1;
3030 if (a->r_hiyear == ZIC_MAX)
3032 if (a->r_month - b->r_month != 0)
3033 return a->r_month - b->r_month;
3034 return a->r_dayofmonth - b->r_dayofmonth;
3065 return -1;
3067 zp = zpfirst + zonecount - 1;
3068 for (i = 0; i < zp->z_nrules; ++i) {
3071 rp = &zp->z_rules[i];
3072 last = &lastrp[rp->r_isdst];
3077 return -1;
3081 dstcmp = zp->z_nrules ? rule_cmp(dstrp, stdrp) : zp->z_isdst ? 1 : -1;
3089 "XXX3EDT4,0/0,J365/23" for EDT (-04) all year. */
3090 zic_t save = dstrp ? dstrp->r_save : zp->z_save;
3093 /* Positive DST, the typical case for all-year DST.
3097 zstr[0].z_stdoff = zp->z_stdoff + 2 * save;
3101 zstr[1].z_format = zp->z_format;
3102 zstr[1].z_format_specifier = zp->z_format_specifier;
3110 dstr.r_save = save < 0 ? save : -save;
3111 dstr.r_abbrvar = dstrp ? dstrp->r_abbrvar : NULL;
3119 stdr.r_abbrvar = save < 0 && stdrp ? stdrp->r_abbrvar : NULL;
3123 len = doabbr(result, stdzp, stdrp ? stdrp->r_abbrvar : NULL,
3125 offsetlen = stringoffset(result + len, - stdzp->z_stdoff);
3128 return -1;
3133 len += doabbr(result + len, dstzp, dstrp->r_abbrvar,
3134 dstrp->r_isdst, dstrp->r_save, true);
3135 if (dstrp->r_save != SECSPERMIN * MINSPERHOUR) {
3137 - (dstzp->z_stdoff + dstrp->r_save));
3140 return -1;
3145 c = stringrule(result + len, dstrp, dstrp->r_save, stdzp->z_stdoff);
3148 return -1;
3154 c = stringrule(result + len, stdrp, dstrp->r_save, stdzp->z_stdoff);
3157 return -1;
3180 int nonTZlimtype = -1;
3182 int defaulttype = -1;
3214 if (i < zonecount - 1)
3215 updateminmax(zp->z_untilrule.r_loyear);
3216 for (j = 0; j < zp->z_nrules; ++j) {
3217 struct rule *rp = &zp->z_rules[j];
3218 updateminmax(rp->r_loyear);
3219 if (rp->r_hiwasnum)
3220 updateminmax(rp->r_hiyear);
3233 zpfirst->z_name);
3235 /* Circa-COMPAT clients, and earlier clients, might
3238 warning(_("%s: pre-%d clients may mishandle"
3240 zpfirst->z_name, compat);
3245 min_year -= years_of_observations;
3247 if (max_year <= ZIC_MAX - years_of_observations)
3257 if (min_year > YEAR_32BIT_MIN - 1)
3258 min_year = YEAR_32BIT_MIN - 1;
3264 unspecifiedtype = addtype(0, "-00", false, false, false);
3272 bool usestart = i > 0 && (zp - 1)->z_untiltime > min_time;
3273 bool useuntil = i < (zonecount - 1);
3274 zic_t stdoff = zp->z_stdoff;
3276 if (useuntil && zp->z_untiltime <= min_time)
3278 eat(zp->z_filenum, zp->z_linenum);
3280 if (zp->z_nrules == 0) {
3282 save = zp->z_save;
3283 doabbr(startbuf, zp, NULL, zp->z_isdst, save, false);
3284 type = addtype(oadd(zp->z_stdoff, save),
3285 startbuf, zp->z_isdst, startttisstd,
3299 if (useuntil && year > zp->z_untilrule.r_hiyear)
3306 for (j = 0; j < zp->z_nrules; ++j) {
3309 struct rule *rp = &zp->z_rules[j];
3310 eats(zp->z_filenum, zp->z_linenum,
3311 rp->r_filenum, rp->r_linenum);
3312 rp->r_todo = year >= rp->r_loyear &&
3313 year <= rp->r_hiyear;
3314 if (rp->r_todo) {
3315 rp->r_temp = rpytime(rp, year);
3316 rp->r_todo
3317 = (rp->r_temp < y2038_boundary
3335 untiltime = zp->z_untiltime;
3336 if (!zp->z_untilrule.r_todisut)
3338 -stdoff);
3339 if (!zp->z_untilrule.r_todisstd)
3341 -save);
3347 k = -1;
3348 for (j = 0; j < zp->z_nrules; ++j) {
3349 struct rule *r = &zp->z_rules[j];
3350 if (!r->r_todo)
3352 eats(zp->z_filenum, zp->z_linenum,
3353 r->r_filenum, r->r_linenum);
3354 offset = r->r_todisut ? 0 : stdoff;
3355 if (!r->r_todisstd)
3357 jtime = r->r_temp;
3361 jtime = tadd(jtime, -offset);
3368 eats(zp->z_filenum, zp->z_linenum,
3369 r->r_filenum, r->r_linenum);
3371 r = &zp->z_rules[k];
3372 eats(zp->z_filenum, zp->z_linenum,
3373 r->r_filenum, r->r_linenum);
3379 rp = &zp->z_rules[k];
3380 rp->r_todo = false;
3383 && (oadd(zp->z_stdoff, rp->r_save)
3385 doabbr(startbuf, zp, rp->r_abbrvar,
3386 rp->r_isdst, rp->r_save,
3390 save = rp->r_save;
3395 startoff = oadd(zp->z_stdoff,
3398 rp->r_abbrvar,
3399 rp->r_isdst,
3400 rp->r_save,
3405 && startoff == oadd(zp->z_stdoff,
3409 rp->r_abbrvar,
3410 rp->r_isdst,
3411 rp->r_save,
3415 eats(zp->z_filenum, zp->z_linenum,
3416 rp->r_filenum, rp->r_linenum);
3417 doabbr(ab, zp, rp->r_abbrvar,
3418 rp->r_isdst, rp->r_save, false);
3419 offset = oadd(zp->z_stdoff, rp->r_save);
3420 type = addtype(offset, ab, rp->r_isdst,
3421 rp->r_todisstd, rp->r_todisut);
3422 if (defaulttype < 0 && !rp->r_isdst)
3426 && (useuntil || rp->r_hiyear != ZIC_MAX)) {
3434 bool isdst = startoff != zp->z_stdoff;
3435 if (*startbuf == '\0' && zp->z_format)
3438 eat(zp->z_filenum, zp->z_linenum);
3454 startttisstd = zp->z_untilrule.r_todisstd;
3455 startttisut = zp->z_untilrule.r_todisut;
3456 starttime = zp->z_untiltime;
3458 starttime = tadd(starttime, -save);
3460 starttime = tadd(starttime, -stdoff);
3480 and not needed for -r or -R. */
3499 ** near the end of the 400-year period, add a redundant
3511 if (attypes[i].at > lastat->at)
3513 if (!lastat || lastat->at < rpytime(&xr, max_year - 1)) {
3515 lastat ? lastat->type : defaulttype);
3516 attypes[timecnt - 1].dontmerge = true;
3519 writezone(zpfirst->z_name, envvar, version, defaulttype);
3540 if (! (-1L - 2147483647L <= utoff && utoff <= 2147483647L)) {
3586 error(_("Rolling leap seconds not supported with -r"));
3592 memmove(&trans[i + 1], &trans[i], (leapcnt - i) * sizeof *trans);
3593 memmove(&corr[i + 1], &corr[i], (leapcnt - i) * sizeof *corr);
3594 memmove(&roll[i + 1], &roll[i], (leapcnt - i) * sizeof *roll);
3612 if (trans[i] - prevtrans < 28 * SECSPERDAY) {
3623 if (! (leapcnt == 0 || (trans[leapcnt - 1] < leapexpires))) {
3680 /* case-insensitive equality */
3727 by a non-'-', skip the "last" and look in WDAY_NAMES instead.
3728 Warn about any usage of the undocumented prefix "last-". */
3730 if (word[4] == '-')
3742 for (lp = table; lp->l_word != NULL; ++lp)
3743 if (ciequal(word, lp->l_word))
3749 for (lp = table; lp->l_word != NULL; ++lp)
3750 if (ciprefix(word, lp->l_word)) {
3757 /* Warn about any backward-compatibility issue with pre-2017c zic. */
3759 for (lp = table; lp->l_word; lp++)
3760 if (itsabbr(word, lp->l_word)) {
3762 warning(_("\"%s\" is ambiguous in pre-2017c zic"), word);
3804 array[nsubs++] = dstart + (*dstart == '-' && dp == dstart + 1);
3824 if (t1 < 0 ? ZIC_MIN - t1 <= t2 : t2 <= ZIC_MAX - t1)
3838 if (t1 < 0 ? min_time - t1 <= t2 : t2 <= max_time - t1)
3866 /* dayoff = floor((wantedy - y) / YEARSPERREPEAT) * DAYSPERREPEAT,
3868 yrem = wantedy % YEARSPERREPEAT - y % YEARSPERREPEAT;
3869 dayoff = ((wantedy / YEARSPERREPEAT - y / YEARSPERREPEAT
3870 + yrem / YEARSPERREPEAT - (yrem % YEARSPERREPEAT < 0))
3872 /* wantedy = y + ((wantedy - y) mod YEARSPERREPEAT), sans overflow. */
3880 while (m != rp->r_month) {
3885 i = rp->r_dayofmonth;
3887 if (rp->r_dycode == DC_DOWLEQ)
3888 --i;
3890 error(_("use of 2/29 in non leap-year"));
3894 --i;
3896 if (rp->r_dycode == DC_DOWGEQ || rp->r_dycode == DC_DOWLEQ) {
3902 while (wday != rp->r_wday)
3903 if (rp->r_dycode == DC_DOWGEQ) {
3909 dayoff = oadd(dayoff, -1);
3910 if (--wday < 0)
3911 wday = DAYSPERWEEK - 1;
3912 --i;
3917 will not work with pre-2004 versions of zic"));
3925 return tadd(t, rp->r_tod);
3940 || *cp == '-' || *cp == '+')
3942 if (noise && cp - string < 3)
3944 if (cp - string > ZIC_MAX_ABBR_LEN_WO_WARN)
3968 * If -D was specified, do not create directories. A subsequent
3978 /* On MS-Windows systems, do not worry about drive letters or
3980 names do not use drive letters and backslashes. If the -d
3981 option of zic does not name an already-existing directory,
3982 it can use slashes to separate the already-existing
3983 ancestor prefix from the to-be-created subdirectories. */
4031 if (*flag != (gid_t)-1) {
4032 fprintf(stderr, _("multiple -g flags specified"));
4049 *flag = gr->gr_gid;
4057 if (*flag != (gid_t)-1) {
4058 fprintf(stderr, _("multiple -u flags specified"));
4075 *flag = pw->pw_uid;