![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to zic.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / share / zoneinfo|
Return to zic.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / share / zoneinfo |
1.1 root 1: #ifndef lint
2: #ifndef NOID
3: static char elsieid[] = "@(#)zic.c 4.12";
4: #endif /* !defined NOID */
5: #endif /* !defined lint */
6:
7: #include "stdio.h"
8: #include "tzfile.h"
9: #include "ctype.h"
10: #include "time.h"
11: #include "string.h"
12: #include "stdlib.h"
13: #include "sys/stat.h"
14: #include "nonstd.h"
15:
16: #ifndef TRUE
17: #define TRUE 1
18: #define FALSE 0
19: #endif /* !defined TRUE */
20:
21: struct rule {
22: const char * r_filename;
23: int r_linenum;
24: const char * r_name;
25:
26: int r_loyear; /* for example, 1986 */
27: int r_hiyear; /* for example, 1986 */
28: const char * r_yrtype;
29:
30: int r_month; /* 0..11 */
31:
32: int r_dycode; /* see below */
33: int r_dayofmonth;
34: int r_wday;
35:
36: long r_tod; /* time from midnight */
37: int r_todisstd; /* above is standard time if TRUE */
38: /* or wall clock time if FALSE */
39: long r_stdoff; /* offset from standard time */
40: const char * r_abbrvar; /* variable part of abbreviation */
41:
42: int r_todo; /* a rule to do (used in outzone) */
43: time_t r_temp; /* used in outzone */
44: };
45:
46: /*
47: ** r_dycode r_dayofmonth r_wday
48: */
49:
50: #define DC_DOM 0 /* 1..31 */ /* unused */
51: #define DC_DOWGEQ 1 /* 1..31 */ /* 0..6 (Sun..Sat) */
52: #define DC_DOWLEQ 2 /* 1..31 */ /* 0..6 (Sun..Sat) */
53:
54: struct zone {
55: const char * z_filename;
56: int z_linenum;
57:
58: const char * z_name;
59: long z_gmtoff;
60: const char * z_rule;
61: const char * z_format;
62:
63: long z_stdoff;
64:
65: struct rule * z_rules;
66: int z_nrules;
67:
68: struct rule z_untilrule;
69: time_t z_untiltime;
70: };
71:
72: extern int emkdir P((const char * name, int mode));
73: extern int getopt P((int argc, char * argv[], const char * options));
74: extern char * icatalloc P((char * old, const char * new));
75: extern char * icpyalloc P((const char * string));
76: extern void ifree P((char * p));
77: extern char * imalloc P((int n));
78: extern char * irealloc P((char * old, int n));
79: extern int link P((const char * fromname, const char * toname));
80: extern char * optarg;
81: extern int optind;
82: extern void perror P((const char * string));
83: extern char * scheck P((const char * string, const char * format));
84:
85: static void addtt P((time_t starttime, int type));
86: static int addtype P((long gmtoff, const char * abbr, int isdst,
87: int ttisstd));
88: static void addleap P((time_t t, int positive, int rolling));
89: static void adjleap P((void));
90: static void associate P((void));
91: static int ciequal P((const char * ap, const char * bp));
92: static void convert P((long val, char * buf));
93: static void dolink P((const char * fromfile, const char * tofile));
94: static void eat P((const char * name, int num));
95: static void eats P((const char * name, int num,
96: const char * rname, int rnum));
97: static long eitol P((int i));
98: static void error P((const char * message));
99: static char ** getfields P((char * buf));
100: static long gethms P((const char * string, const char * errstrng,
101: int signable));
102: static void infile P((const char * filename));
103: static void inleap P((char ** fields, int nfields));
104: static void inlink P((char ** fields, int nfields));
105: static void inrule P((char ** fields, int nfields));
106: static int inzcont P((char ** fields, int nfields));
107: static int inzone P((char ** fields, int nfields));
108: static int inzsub P((char ** fields, int nfields, int iscont));
109: static int itsabbr P((const char * abbr, const char * word));
110: static int itsdir P((const char * name));
111: static int lowerit P((int c));
112: static char * memcheck P((char * tocheck));
113: static int mkdirs P((char * filename));
114: static void newabbr P((const char * abbr));
115: static long oadd P((long t1, long t2));
116: static void outzone P((const struct zone * zp, int ntzones));
117: static void puttzcode P((long code, FILE * fp));
118: static int rcomp P((const genericptr_t leftp, const genericptr_t rightp));
119: static time_t rpytime P((const struct rule * rp, int wantedy));
120: static void rulesub P((struct rule * rp,
121: char * loyearp, char * hiyearp,
122: char * typep, char * monthp,
123: char * dayp, char * timep));
124: static void setboundaries P((void));
125: static time_t tadd P((time_t t1, long t2));
126: static void usage P((void));
127: static void writezone P((const char * name));
128: static int yearistype P((int year, const char * type));
129:
130: static int charcnt;
131: static int errors;
132: static const char * filename;
133: static int leapcnt;
134: static int linenum;
135: static time_t max_time;
136: static int max_year;
137: static time_t min_time;
138: static int min_year;
139: static int noise;
140: static const char * rfilename;
141: static int rlinenum;
142: static const char * progname;
143: static int timecnt;
144: static int typecnt;
145: static int tt_signed;
146:
147: /*
148: ** Line codes.
149: */
150:
151: #define LC_RULE 0
152: #define LC_ZONE 1
153: #define LC_LINK 2
154: #define LC_LEAP 3
155:
156: /*
157: ** Which fields are which on a Zone line.
158: */
159:
160: #define ZF_NAME 1
161: #define ZF_GMTOFF 2
162: #define ZF_RULE 3
163: #define ZF_FORMAT 4
164: #define ZF_TILYEAR 5
165: #define ZF_TILMONTH 6
166: #define ZF_TILDAY 7
167: #define ZF_TILTIME 8
168: #define ZONE_MINFIELDS 5
169: #define ZONE_MAXFIELDS 9
170:
171: /*
172: ** Which fields are which on a Zone continuation line.
173: */
174:
175: #define ZFC_GMTOFF 0
176: #define ZFC_RULE 1
177: #define ZFC_FORMAT 2
178: #define ZFC_TILYEAR 3
179: #define ZFC_TILMONTH 4
180: #define ZFC_TILDAY 5
181: #define ZFC_TILTIME 6
182: #define ZONEC_MINFIELDS 3
183: #define ZONEC_MAXFIELDS 7
184:
185: /*
186: ** Which files are which on a Rule line.
187: */
188:
189: #define RF_NAME 1
190: #define RF_LOYEAR 2
191: #define RF_HIYEAR 3
192: #define RF_COMMAND 4
193: #define RF_MONTH 5
194: #define RF_DAY 6
195: #define RF_TOD 7
196: #define RF_STDOFF 8
197: #define RF_ABBRVAR 9
198: #define RULE_FIELDS 10
199:
200: /*
201: ** Which fields are which on a Link line.
202: */
203:
204: #define LF_FROM 1
205: #define LF_TO 2
206: #define LINK_FIELDS 3
207:
208: /*
209: ** Which fields are which on a Leap line.
210: */
211:
212: #define LP_YEAR 1
213: #define LP_MONTH 2
214: #define LP_DAY 3
215: #define LP_TIME 4
216: #define LP_CORR 5
217: #define LP_ROLL 6
218: #define LEAP_FIELDS 7
219:
220: /*
221: ** Year synonyms.
222: */
223:
224: #define YR_MINIMUM 0
225: #define YR_MAXIMUM 1
226: #define YR_ONLY 2
227:
228: static struct rule * rules;
229: static int nrules; /* number of rules */
230:
231: static struct zone * zones;
232: static int nzones; /* number of zones */
233:
234: struct link {
235: const char * l_filename;
236: int l_linenum;
237: const char * l_from;
238: const char * l_to;
239: };
240:
241: static struct link * links;
242: static int nlinks;
243:
244: struct lookup {
245: const char * l_word;
246: const int l_value;
247: };
248:
249: static struct lookup const * byword P((const char * string,
250: const struct lookup * lp));
251:
252: static struct lookup const line_codes[] = {
253: "Rule", LC_RULE,
254: "Zone", LC_ZONE,
255: "Link", LC_LINK,
256: "Leap", LC_LEAP,
257: NULL, 0
258: };
259:
260: static struct lookup const mon_names[] = {
261: "January", TM_JANUARY,
262: "February", TM_FEBRUARY,
263: "March", TM_MARCH,
264: "April", TM_APRIL,
265: "May", TM_MAY,
266: "June", TM_JUNE,
267: "July", TM_JULY,
268: "August", TM_AUGUST,
269: "September", TM_SEPTEMBER,
270: "October", TM_OCTOBER,
271: "November", TM_NOVEMBER,
272: "December", TM_DECEMBER,
273: NULL, 0
274: };
275:
276: static struct lookup const wday_names[] = {
277: "Sunday", TM_SUNDAY,
278: "Monday", TM_MONDAY,
279: "Tuesday", TM_TUESDAY,
280: "Wednesday", TM_WEDNESDAY,
281: "Thursday", TM_THURSDAY,
282: "Friday", TM_FRIDAY,
283: "Saturday", TM_SATURDAY,
284: NULL, 0
285: };
286:
287: static struct lookup const lasts[] = {
288: "last-Sunday", TM_SUNDAY,
289: "last-Monday", TM_MONDAY,
290: "last-Tuesday", TM_TUESDAY,
291: "last-Wednesday", TM_WEDNESDAY,
292: "last-Thursday", TM_THURSDAY,
293: "last-Friday", TM_FRIDAY,
294: "last-Saturday", TM_SATURDAY,
295: NULL, 0
296: };
297:
298: static struct lookup const begin_years[] = {
299: "minimum", YR_MINIMUM,
300: "maximum", YR_MAXIMUM,
301: NULL, 0
302: };
303:
304: static struct lookup const end_years[] = {
305: "minimum", YR_MINIMUM,
306: "maximum", YR_MAXIMUM,
307: "only", YR_ONLY,
308: NULL, 0
309: };
310:
311: static struct lookup const leap_types[] = {
312: "Rolling", TRUE,
313: "Stationary", FALSE,
314: NULL, 0
315: };
316:
317: static const int len_months[2][MONSPERYEAR] = {
318: 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
319: 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
320: };
321:
322: static const int len_years[2] = {
323: DAYSPERNYEAR, DAYSPERLYEAR
324: };
325:
326: static time_t ats[TZ_MAX_TIMES];
327: static unsigned char types[TZ_MAX_TIMES];
328: static long gmtoffs[TZ_MAX_TYPES];
329: static char isdsts[TZ_MAX_TYPES];
330: static char abbrinds[TZ_MAX_TYPES];
331: static char ttisstds[TZ_MAX_TYPES];
332: static char chars[TZ_MAX_CHARS];
333: static time_t trans[TZ_MAX_LEAPS];
334: static long corr[TZ_MAX_LEAPS];
335: static char roll[TZ_MAX_LEAPS];
336:
337: /*
338: ** Memory allocation.
339: */
340:
341: static char *
342: memcheck(ptr)
343: char * const ptr;
344: {
345: if (ptr == NULL) {
346: (void) perror(progname);
347: (void) exit(EXIT_FAILURE);
348: }
349: return ptr;
350: }
351:
352: #define emalloc(size) memcheck(imalloc(size))
353: #define erealloc(ptr, size) memcheck(irealloc(ptr, size))
354: #define ecpyalloc(ptr) memcheck(icpyalloc(ptr))
355: #define ecatalloc(oldp, newp) memcheck(icatalloc(oldp, newp))
356:
357: /*
358: ** Error handling.
359: */
360:
361: static void
362: eats(name, num, rname, rnum)
363: const char * const name;
364: const int num;
365: const char * const rname;
366: const int rnum;
367: {
368: filename = name;
369: linenum = num;
370: rfilename = rname;
371: rlinenum = rnum;
372: }
373:
374: static void
375: eat(name, num)
376: const char * const name;
377: const int num;
378: {
379: eats(name, num, (char *) NULL, -1);
380: }
381:
382: static void
383: error(string)
384: const char * const string;
385: {
386: /*
387: ** Match the format of "cc" to allow sh users to
388: ** zic ... 2>&1 | error -t "*" -v
389: ** on BSD systems.
390: */
391: (void) fprintf(stderr, "\"%s\", line %d: %s",
392: filename, linenum, string);
393: if (rfilename != NULL)
394: (void) fprintf(stderr, " (rule from \"%s\", line %d)",
395: rfilename, rlinenum);
396: (void) fprintf(stderr, "\n");
397: ++errors;
398: }
399:
400: static void
401: usage()
402: {
403: (void) fprintf(stderr,
404: "%s: usage is %s [ -s ] [ -v ] [ -l localtime ] [ -p posixrules ] [ -d directory ]\n\
405: \t[ -L leapseconds ] [ filename ... ]\n",
406: progname, progname);
407: (void) exit(EXIT_FAILURE);
408: }
409:
410: static const char * psxrules = NULL;
411: static const char * lcltime = NULL;
412: static const char * directory = NULL;
413: static const char * leapsec = NULL;
414: static int sflag = FALSE;
415:
416: int
417: main(argc, argv)
418: int argc;
419: char * argv[];
420: {
421: register int i, j;
422: register int c;
423:
424: #ifdef unix
425: (void) umask(umask(022) | 022);
426: #endif /* defined unix */
427: progname = argv[0];
428: while ((c = getopt(argc, argv, "d:l:p:L:vs")) != EOF)
429: switch (c) {
430: default:
431: usage();
432: case 'd':
433: if (directory == NULL)
434: directory = optarg;
435: else {
436: (void) fprintf(stderr,
437: "%s: More than one -d option specified\n",
438: progname);
439: (void) exit(EXIT_FAILURE);
440: }
441: break;
442: case 'l':
443: if (lcltime == NULL)
444: lcltime = optarg;
445: else {
446: (void) fprintf(stderr,
447: "%s: More than one -l option specified\n",
448: progname);
449: (void) exit(EXIT_FAILURE);
450: }
451: break;
452: case 'p':
453: if (psxrules == NULL)
454: psxrules = optarg;
455: else {
456: (void) fprintf(stderr,
457: "%s: More than one -p option specified\n",
458: progname);
459: (void) exit(EXIT_FAILURE);
460: }
461: break;
462: case 'L':
463: if (leapsec == NULL)
464: leapsec = optarg;
465: else {
466: (void) fprintf(stderr,
467: "%s: More than one -L option specified\n",
468: progname);
469: (void) exit(EXIT_FAILURE);
470: }
471: break;
472: case 'v':
473: noise = TRUE;
474: break;
475: case 's':
476: sflag = TRUE;
477: break;
478: }
479: if (optind == argc - 1 && strcmp(argv[optind], "=") == 0)
480: usage(); /* usage message by request */
481: if (directory == NULL)
482: directory = TZDIR;
483:
484: setboundaries();
485:
486: if (optind < argc && leapsec != NULL) {
487: infile(leapsec);
488: adjleap();
489: }
490:
491: zones = (struct zone *) emalloc(0);
492: rules = (struct rule *) emalloc(0);
493: links = (struct link *) emalloc(0);
494: for (i = optind; i < argc; ++i)
495: infile(argv[i]);
496: if (errors)
497: (void) exit(EXIT_FAILURE);
498: associate();
499: for (i = 0; i < nzones; i = j) {
500: /*
501: ** Find the next non-continuation zone entry.
502: */
503: for (j = i + 1; j < nzones && zones[j].z_name == NULL; ++j)
504: ;
505: outzone(&zones[i], j - i);
506: }
507: /*
508: ** Make links.
509: */
510: for (i = 0; i < nlinks; ++i)
511: dolink(links[i].l_from, links[i].l_to);
512: if (lcltime != NULL)
513: dolink(lcltime, TZDEFAULT);
514: if (psxrules != NULL)
515: dolink(psxrules, TZDEFRULES);
516: return (errors == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
517: }
518:
519: static void
520: dolink(fromfile, tofile)
521: const char * const fromfile;
522: const char * const tofile;
523: {
524: register char * fromname;
525: register char * toname;
526:
527: fromname = ecpyalloc(directory);
528: fromname = ecatalloc(fromname, "/");
529: fromname = ecatalloc(fromname, fromfile);
530: toname = ecpyalloc(directory);
531: toname = ecatalloc(toname, "/");
532: toname = ecatalloc(toname, tofile);
533: /*
534: ** We get to be careful here since
535: ** there's a fair chance of root running us.
536: */
537: if (!itsdir(toname))
538: (void) remove(toname);
539: if (link(fromname, toname) != 0) {
540: (void) fprintf(stderr, "%s: Can't link from %s to ",
541: progname, fromname);
542: (void) perror(toname);
543: (void) exit(EXIT_FAILURE);
544: }
545: ifree(fromname);
546: ifree(toname);
547: }
548:
549: static void
550: setboundaries()
551: {
552: register time_t bit;
553:
554: for (bit = 1; bit > 0; bit <<= 1)
555: ;
556: if (bit == 0) { /* time_t is an unsigned type */
557: tt_signed = FALSE;
558: min_time = 0;
559: max_time = ~(time_t) 0;
560: if (sflag)
561: max_time >>= 1;
562: } else {
563: tt_signed = TRUE;
564: min_time = bit;
565: max_time = bit;
566: ++max_time;
567: max_time = -max_time;
568: if (sflag)
569: min_time = 0;
570: }
571: min_year = TM_YEAR_BASE + gmtime(&min_time)->tm_year;
572: max_year = TM_YEAR_BASE + gmtime(&max_time)->tm_year;
573: }
574:
575: static int
576: itsdir(name)
577: const char * const name;
578: {
579: struct stat s;
580:
581: return stat(name, &s) == 0 && (s.st_mode & S_IFMT) == S_IFDIR;
582: }
583:
584: /*
585: ** Associate sets of rules with zones.
586: */
587:
588: /*
589: ** Sort by rule name.
590: */
591:
592: static int
593: rcomp(cp1, cp2)
594: const genericptr_t cp1;
595: const genericptr_t cp2;
596: {
597: return strcmp(((struct rule *) cp1)->r_name,
598: ((struct rule *) cp2)->r_name);
599: }
600:
601: static void
602: associate()
603: {
604: register struct zone * zp;
605: register struct rule * rp;
606: register int base, out;
607: register int i;
608:
609: if (nrules != 0)
610: (void) qsort((genericptr_t) rules,
611: (qsort_size_t) nrules,
612: (qsort_size_t) sizeof *rules, rcomp);
613: for (i = 0; i < nzones; ++i) {
614: zp = &zones[i];
615: zp->z_rules = NULL;
616: zp->z_nrules = 0;
617: }
618: for (base = 0; base < nrules; base = out) {
619: rp = &rules[base];
620: for (out = base + 1; out < nrules; ++out)
621: if (strcmp(rp->r_name, rules[out].r_name) != 0)
622: break;
623: for (i = 0; i < nzones; ++i) {
624: zp = &zones[i];
625: if (strcmp(zp->z_rule, rp->r_name) != 0)
626: continue;
627: zp->z_rules = rp;
628: zp->z_nrules = out - base;
629: }
630: }
631: for (i = 0; i < nzones; ++i) {
632: zp = &zones[i];
633: if (zp->z_nrules == 0) {
634: /*
635: ** Maybe we have a local standard time offset.
636: */
637: eat(zp->z_filename, zp->z_linenum);
638: zp->z_stdoff = gethms(zp->z_rule, "unruly zone", TRUE);
639: /*
640: ** Note, though, that if there's no rule,
641: ** a '%s' in the format is a bad thing.
642: */
643: if (strchr(zp->z_format, '%') != 0)
644: error("%s in ruleless zone");
645: }
646: }
647: if (errors)
648: (void) exit(EXIT_FAILURE);
649: }
650:
651: static void
652: infile(name)
653: const char * name;
654: {
655: register FILE * fp;
656: register char ** fields;
657: register char * cp;
658: register const struct lookup * lp;
659: register int nfields;
660: register int wantcont;
661: register int num;
662: char buf[BUFSIZ];
663:
664: if (strcmp(name, "-") == 0) {
665: name = "standard input";
666: fp = stdin;
667: } else if ((fp = fopen(name, "r")) == NULL) {
668: (void) fprintf(stderr, "%s: Can't open ", progname);
669: (void) perror(name);
670: (void) exit(EXIT_FAILURE);
671: }
672: wantcont = FALSE;
673: for (num = 1; ; ++num) {
674: eat(name, num);
675: if (fgets(buf, (int) sizeof buf, fp) != buf)
676: break;
677: cp = strchr(buf, '\n');
678: if (cp == NULL) {
679: error("line too long");
680: (void) exit(EXIT_FAILURE);
681: }
682: *cp = '\0';
683: fields = getfields(buf);
684: nfields = 0;
685: while (fields[nfields] != NULL) {
686: if (ciequal(fields[nfields], "-"))
687: fields[nfields] = "";
688: ++nfields;
689: }
690: if (nfields == 0) {
691: /* nothing to do */
692: } else if (wantcont) {
693: wantcont = inzcont(fields, nfields);
694: } else {
695: lp = byword(fields[0], line_codes);
696: if (lp == NULL)
697: error("input line of unknown type");
698: else switch ((int) (lp->l_value)) {
699: case LC_RULE:
700: inrule(fields, nfields);
701: wantcont = FALSE;
702: break;
703: case LC_ZONE:
704: wantcont = inzone(fields, nfields);
705: break;
706: case LC_LINK:
707: inlink(fields, nfields);
708: wantcont = FALSE;
709: break;
710: case LC_LEAP:
711: if (name != leapsec)
712: (void) fprintf(stderr,
713: "%s: Leap line in non leap seconds file %s\n",
714: progname, name);
715: else inleap(fields, nfields);
716: wantcont = FALSE;
717: break;
718: default: /* "cannot happen" */
719: (void) fprintf(stderr,
720: "%s: panic: Invalid l_value %d\n",
721: progname, lp->l_value);
722: (void) exit(EXIT_FAILURE);
723: }
724: }
725: ifree((char *) fields);
726: }
727: if (ferror(fp)) {
728: (void) fprintf(stderr, "%s: Error reading ", progname);
729: (void) perror(filename);
730: (void) exit(EXIT_FAILURE);
731: }
732: if (fp != stdin && fclose(fp)) {
733: (void) fprintf(stderr, "%s: Error closing ", progname);
734: (void) perror(filename);
735: (void) exit(EXIT_FAILURE);
736: }
737: if (wantcont)
738: error("expected continuation line not found");
739: }
740:
741: /*
742: ** Convert a string of one of the forms
743: ** h -h hh:mm -hh:mm hh:mm:ss -hh:mm:ss
744: ** into a number of seconds.
745: ** A null string maps to zero.
746: ** Call error with errstring and return zero on errors.
747: */
748:
749: static long
750: gethms(string, errstring, signable)
751: const char * string;
752: const char * const errstring;
753: const int signable;
754: {
755: int hh, mm, ss, sign;
756:
757: if (string == NULL || *string == '\0')
758: return 0;
759: if (!signable)
760: sign = 1;
761: else if (*string == '-') {
762: sign = -1;
763: ++string;
764: } else sign = 1;
765: if (sscanf(string, scheck(string, "%d"), &hh) == 1)
766: mm = ss = 0;
767: else if (sscanf(string, scheck(string, "%d:%d"), &hh, &mm) == 2)
768: ss = 0;
769: else if (sscanf(string, scheck(string, "%d:%d:%d"),
770: &hh, &mm, &ss) != 3) {
771: error(errstring);
772: return 0;
773: }
774: if (hh < 0 || hh >= HOURSPERDAY ||
775: mm < 0 || mm >= MINSPERHOUR ||
776: ss < 0 || ss > SECSPERMIN) {
777: error(errstring);
778: return 0;
779: }
780: return eitol(sign) *
781: (eitol(hh * MINSPERHOUR + mm) *
782: eitol(SECSPERMIN) + eitol(ss));
783: }
784:
785: static void
786: inrule(fields, nfields)
787: register char ** const fields;
788: const int nfields;
789: {
790: static struct rule r;
791:
792: if (nfields != RULE_FIELDS) {
793: error("wrong number of fields on Rule line");
794: return;
795: }
796: if (*fields[RF_NAME] == '\0') {
797: error("nameless rule");
798: return;
799: }
800: r.r_filename = filename;
801: r.r_linenum = linenum;
802: r.r_stdoff = gethms(fields[RF_STDOFF], "invalid saved time", TRUE);
803: rulesub(&r, fields[RF_LOYEAR], fields[RF_HIYEAR], fields[RF_COMMAND],
804: fields[RF_MONTH], fields[RF_DAY], fields[RF_TOD]);
805: r.r_name = ecpyalloc(fields[RF_NAME]);
806: r.r_abbrvar = ecpyalloc(fields[RF_ABBRVAR]);
807: rules = (struct rule *) erealloc((char *) rules,
808: (int) ((nrules + 1) * sizeof *rules));
809: rules[nrules++] = r;
810: }
811:
812: static int
813: inzone(fields, nfields)
814: register char ** const fields;
815: const int nfields;
816: {
817: register int i;
818: char buf[132];
819:
820: if (nfields < ZONE_MINFIELDS || nfields > ZONE_MAXFIELDS) {
821: error("wrong number of fields on Zone line");
822: return FALSE;
823: }
824: if (strcmp(fields[ZF_NAME], TZDEFAULT) == 0 && lcltime != NULL) {
825: (void) sprintf(buf,
826: "\"Zone %s\" line and -l option are mutually exclusive",
827: TZDEFAULT);
828: error(buf);
829: return FALSE;
830: }
831: if (strcmp(fields[ZF_NAME], TZDEFRULES) == 0 && psxrules != NULL) {
832: (void) sprintf(buf,
833: "\"Zone %s\" line and -p option are mutually exclusive",
834: TZDEFRULES);
835: error(buf);
836: return FALSE;
837: }
838: for (i = 0; i < nzones; ++i)
839: if (zones[i].z_name != NULL &&
840: strcmp(zones[i].z_name, fields[ZF_NAME]) == 0) {
841: (void) sprintf(buf,
842: "duplicate zone name %s (file \"%s\", line %d)",
843: fields[ZF_NAME],
844: zones[i].z_filename,
845: zones[i].z_linenum);
846: error(buf);
847: return FALSE;
848: }
849: return inzsub(fields, nfields, FALSE);
850: }
851:
852: static int
853: inzcont(fields, nfields)
854: register char ** const fields;
855: const int nfields;
856: {
857: if (nfields < ZONEC_MINFIELDS || nfields > ZONEC_MAXFIELDS) {
858: error("wrong number of fields on Zone continuation line");
859: return FALSE;
860: }
861: return inzsub(fields, nfields, TRUE);
862: }
863:
864: static int
865: inzsub(fields, nfields, iscont)
866: register char ** const fields;
867: const int nfields;
868: const int iscont;
869: {
870: register char * cp;
871: static struct zone z;
872: register int i_gmtoff, i_rule, i_format;
873: register int i_untilyear, i_untilmonth;
874: register int i_untilday, i_untiltime;
875: register int hasuntil;
876:
877: if (iscont) {
878: i_gmtoff = ZFC_GMTOFF;
879: i_rule = ZFC_RULE;
880: i_format = ZFC_FORMAT;
881: i_untilyear = ZFC_TILYEAR;
882: i_untilmonth = ZFC_TILMONTH;
883: i_untilday = ZFC_TILDAY;
884: i_untiltime = ZFC_TILTIME;
885: z.z_name = NULL;
886: } else {
887: i_gmtoff = ZF_GMTOFF;
888: i_rule = ZF_RULE;
889: i_format = ZF_FORMAT;
890: i_untilyear = ZF_TILYEAR;
891: i_untilmonth = ZF_TILMONTH;
892: i_untilday = ZF_TILDAY;
893: i_untiltime = ZF_TILTIME;
894: z.z_name = ecpyalloc(fields[ZF_NAME]);
895: }
896: z.z_filename = filename;
897: z.z_linenum = linenum;
898: z.z_gmtoff = gethms(fields[i_gmtoff], "invalid GMT offset", TRUE);
899: if ((cp = strchr(fields[i_format], '%')) != 0) {
900: if (*++cp != 's' || strchr(cp, '%') != 0) {
901: error("invalid abbreviation format");
902: return FALSE;
903: }
904: }
905: z.z_rule = ecpyalloc(fields[i_rule]);
906: z.z_format = ecpyalloc(fields[i_format]);
907: hasuntil = nfields > i_untilyear;
908: if (hasuntil) {
909: z.z_untilrule.r_filename = filename;
910: z.z_untilrule.r_linenum = linenum;
911: rulesub(&z.z_untilrule,
912: fields[i_untilyear],
913: "only",
914: "",
915: (nfields > i_untilmonth) ? fields[i_untilmonth] : "Jan",
916: (nfields > i_untilday) ? fields[i_untilday] : "1",
917: (nfields > i_untiltime) ? fields[i_untiltime] : "0");
918: z.z_untiltime = rpytime(&z.z_untilrule, z.z_untilrule.r_loyear);
919: if (iscont && nzones > 0 && z.z_untiltime < max_time &&
920: z.z_untiltime > min_time &&
921: zones[nzones - 1].z_untiltime >= z.z_untiltime) {
922: error("Zone continuation line end time is not after end time of previous line");
923: return FALSE;
924: }
925: }
926: zones = (struct zone *) erealloc((char *) zones,
927: (int) ((nzones + 1) * sizeof *zones));
928: zones[nzones++] = z;
929: /*
930: ** If there was an UNTIL field on this line,
931: ** there's more information about the zone on the next line.
932: */
933: return hasuntil;
934: }
935:
936: static void
937: inleap(fields, nfields)
938: register char ** const fields;
939: const int nfields;
940: {
941: register const char * cp;
942: register const struct lookup * lp;
943: register int i, j;
944: int year, month, day;
945: long dayoff, tod;
946: time_t t;
947:
948: if (nfields != LEAP_FIELDS) {
949: error("wrong number of fields on Leap line");
950: return;
951: }
952: dayoff = 0;
953: cp = fields[LP_YEAR];
954: if (sscanf(cp, scheck(cp, "%d"), &year) != 1 ||
955: year < min_year || year > max_year) {
956: /*
957: * Leapin' Lizards!
958: */
959: error("invalid leaping year");
960: return;
961: }
962: j = EPOCH_YEAR;
963: while (j != year) {
964: if (year > j) {
965: i = len_years[isleap(j)];
966: ++j;
967: } else {
968: --j;
969: i = -len_years[isleap(j)];
970: }
971: dayoff = oadd(dayoff, eitol(i));
972: }
973: if ((lp = byword(fields[LP_MONTH], mon_names)) == NULL) {
974: error("invalid month name");
975: return;
976: }
977: month = lp->l_value;
978: j = TM_JANUARY;
979: while (j != month) {
980: i = len_months[isleap(year)][j];
981: dayoff = oadd(dayoff, eitol(i));
982: ++j;
983: }
984: cp = fields[LP_DAY];
985: if (sscanf(cp, scheck(cp, "%d"), &day) != 1 ||
986: day <= 0 || day > len_months[isleap(year)][month]) {
987: error("invalid day of month");
988: return;
989: }
990: dayoff = oadd(dayoff, eitol(day - 1));
991: if (dayoff < 0 && !tt_signed) {
992: error("time before zero");
993: return;
994: }
995: t = (time_t) dayoff * SECSPERDAY;
996: /*
997: ** Cheap overflow check.
998: */
999: if (t / SECSPERDAY != dayoff) {
1000: error("time overflow");
1001: return;
1002: }
1003: tod = gethms(fields[LP_TIME], "invalid time of day", FALSE);
1004: cp = fields[LP_CORR];
1005: if (strcmp(cp, "+") != 0 && strcmp(cp, "") != 0) {
1006: /* infile() turned "-" into "" */
1007: error("illegal CORRECTION field on Leap line");
1008: return;
1009: }
1010: if ((lp = byword(fields[LP_ROLL], leap_types)) == NULL) {
1011: error("illegal Rolling/Stationary field on Leap line");
1012: return;
1013: }
1014: addleap(tadd(t, tod), *cp == '+', lp->l_value);
1015: }
1016:
1017: static void
1018: inlink(fields, nfields)
1019: register char ** const fields;
1020: const int nfields;
1021: {
1022: struct link l;
1023:
1024: if (nfields != LINK_FIELDS) {
1025: error("wrong number of fields on Link line");
1026: return;
1027: }
1028: if (*fields[LF_FROM] == '\0') {
1029: error("blank FROM field on Link line");
1030: return;
1031: }
1032: if (*fields[LF_TO] == '\0') {
1033: error("blank TO field on Link line");
1034: return;
1035: }
1036: l.l_filename = filename;
1037: l.l_linenum = linenum;
1038: l.l_from = ecpyalloc(fields[LF_FROM]);
1039: l.l_to = ecpyalloc(fields[LF_TO]);
1040: links = (struct link *) erealloc((char *) links,
1041: (int) ((nlinks + 1) * sizeof *links));
1042: links[nlinks++] = l;
1043: }
1044:
1045: static void
1046: rulesub(rp, loyearp, hiyearp, typep, monthp, dayp, timep)
1047: register struct rule * const rp;
1048: char * const loyearp;
1049: char * const hiyearp;
1050: char * const typep;
1051: char * const monthp;
1052: char * const dayp;
1053: char * const timep;
1054: {
1055: register struct lookup const * lp;
1056: register char * cp;
1057:
1058: if ((lp = byword(monthp, mon_names)) == NULL) {
1059: error("invalid month name");
1060: return;
1061: }
1062: rp->r_month = lp->l_value;
1063: rp->r_todisstd = FALSE;
1064: cp = timep;
1065: if (*cp != '\0') {
1066: cp += strlen(cp) - 1;
1067: switch (lowerit(*cp)) {
1068: case 's':
1069: rp->r_todisstd = TRUE;
1070: *cp = '\0';
1071: break;
1072: case 'w':
1073: rp->r_todisstd = FALSE;
1074: *cp = '\0';
1075: break;
1076: }
1077: }
1078: rp->r_tod = gethms(timep, "invalid time of day", FALSE);
1079: /*
1080: ** Year work.
1081: */
1082: cp = loyearp;
1083: if ((lp = byword(cp, begin_years)) != NULL) switch ((int) lp->l_value) {
1084: case YR_MINIMUM:
1085: rp->r_loyear = min_year;
1086: break;
1087: case YR_MAXIMUM:
1088: rp->r_loyear = max_year;
1089: break;
1090: default: /* "cannot happen" */
1091: (void) fprintf(stderr,
1092: "%s: panic: Invalid l_value %d\n",
1093: progname, lp->l_value);
1094: (void) exit(EXIT_FAILURE);
1095: } else if (sscanf(cp, scheck(cp, "%d"), &rp->r_loyear) != 1 ||
1096: rp->r_loyear < min_year || rp->r_loyear > max_year) {
1097: if (noise)
1098: error("invalid starting year");
1099: if (rp->r_loyear > max_year)
1100: return;
1101: }
1102: cp = hiyearp;
1103: if ((lp = byword(cp, end_years)) != NULL) switch ((int) lp->l_value) {
1104: case YR_MINIMUM:
1105: rp->r_hiyear = min_year;
1106: break;
1107: case YR_MAXIMUM:
1108: rp->r_hiyear = max_year;
1109: break;
1110: case YR_ONLY:
1111: rp->r_hiyear = rp->r_loyear;
1112: break;
1113: default: /* "cannot happen" */
1114: (void) fprintf(stderr,
1115: "%s: panic: Invalid l_value %d\n",
1116: progname, lp->l_value);
1117: (void) exit(EXIT_FAILURE);
1118: } else if (sscanf(cp, scheck(cp, "%d"), &rp->r_hiyear) != 1 ||
1119: rp->r_hiyear < min_year || rp->r_hiyear > max_year) {
1120: if (noise)
1121: error("invalid ending year");
1122: if (rp->r_hiyear < min_year)
1123: return;
1124: }
1125: if (rp->r_hiyear < min_year)
1126: return;
1127: if (rp->r_loyear < min_year)
1128: rp->r_loyear = min_year;
1129: if (rp->r_hiyear > max_year)
1130: rp->r_hiyear = max_year;
1131: if (rp->r_loyear > rp->r_hiyear) {
1132: error("starting year greater than ending year");
1133: return;
1134: }
1135: if (*typep == '\0')
1136: rp->r_yrtype = NULL;
1137: else {
1138: if (rp->r_loyear == rp->r_hiyear) {
1139: error("typed single year");
1140: return;
1141: }
1142: rp->r_yrtype = ecpyalloc(typep);
1143: }
1144: /*
1145: ** Day work.
1146: ** Accept things such as:
1147: ** 1
1148: ** last-Sunday
1149: ** Sun<=20
1150: ** Sun>=7
1151: */
1152: if ((lp = byword(dayp, lasts)) != NULL) {
1153: rp->r_dycode = DC_DOWLEQ;
1154: rp->r_wday = lp->l_value;
1155: rp->r_dayofmonth = len_months[1][rp->r_month];
1156: } else {
1157: if ((cp = strchr(dayp, '<')) != 0)
1158: rp->r_dycode = DC_DOWLEQ;
1159: else if ((cp = strchr(dayp, '>')) != 0)
1160: rp->r_dycode = DC_DOWGEQ;
1161: else {
1162: cp = dayp;
1163: rp->r_dycode = DC_DOM;
1164: }
1165: if (rp->r_dycode != DC_DOM) {
1166: *cp++ = 0;
1167: if (*cp++ != '=') {
1168: error("invalid day of month");
1169: return;
1170: }
1171: if ((lp = byword(dayp, wday_names)) == NULL) {
1172: error("invalid weekday name");
1173: return;
1174: }
1175: rp->r_wday = lp->l_value;
1176: }
1177: if (sscanf(cp, scheck(cp, "%d"), &rp->r_dayofmonth) != 1 ||
1178: rp->r_dayofmonth <= 0 ||
1179: (rp->r_dayofmonth > len_months[1][rp->r_month])) {
1180: error("invalid day of month");
1181: return;
1182: }
1183: }
1184: }
1185:
1186: static void
1187: convert(val, buf)
1188: const long val;
1189: char * const buf;
1190: {
1191: register int i;
1192: register long shift;
1193:
1194: for (i = 0, shift = 24; i < 4; ++i, shift -= 8)
1195: buf[i] = val >> shift;
1196: }
1197:
1198: static void
1199: puttzcode(val, fp)
1200: const long val;
1201: FILE * const fp;
1202: {
1203: char buf[4];
1204:
1205: convert(val, buf);
1206: (void) fwrite((genericptr_t) buf,
1207: (fwrite_size_t) sizeof buf,
1208: (fwrite_size_t) 1, fp);
1209: }
1210:
1211: static void
1212: writezone(name)
1213: const char * const name;
1214: {
1215: register FILE * fp;
1216: register int i, j;
1217: char fullname[BUFSIZ];
1218: static struct tzhead tzh;
1219:
1220: if (strlen(directory) + 1 + strlen(name) >= sizeof fullname) {
1221: (void) fprintf(stderr,
1222: "%s: File name %s/%s too long\n", progname,
1223: directory, name);
1224: (void) exit(EXIT_FAILURE);
1225: }
1226: (void) sprintf(fullname, "%s/%s", directory, name);
1227: if ((fp = fopen(fullname, "wb")) == NULL) {
1228: if (mkdirs(fullname) != 0)
1229: (void) exit(EXIT_FAILURE);
1230: if ((fp = fopen(fullname, "wb")) == NULL) {
1231: (void) fprintf(stderr, "%s: Can't create ", progname);
1232: (void) perror(fullname);
1233: (void) exit(EXIT_FAILURE);
1234: }
1235: }
1236: convert(eitol(typecnt), tzh.tzh_ttisstdcnt);
1237: convert(eitol(leapcnt), tzh.tzh_leapcnt);
1238: convert(eitol(timecnt), tzh.tzh_timecnt);
1239: convert(eitol(typecnt), tzh.tzh_typecnt);
1240: convert(eitol(charcnt), tzh.tzh_charcnt);
1241: (void) fwrite((genericptr_t) &tzh,
1242: (fwrite_size_t) sizeof tzh,
1243: (fwrite_size_t) 1, fp);
1244: for (i = 0; i < timecnt; ++i) {
1245: j = leapcnt;
1246: while (--j >= 0)
1247: if (ats[i] >= trans[j]) {
1248: ats[i] = tadd(ats[i], corr[j]);
1249: break;
1250: }
1251: puttzcode((long) ats[i], fp);
1252: }
1253: if (timecnt > 0)
1254: (void) fwrite((genericptr_t) types,
1255: (fwrite_size_t) sizeof types[0],
1256: (fwrite_size_t) timecnt, fp);
1257: for (i = 0; i < typecnt; ++i) {
1258: puttzcode((long) gmtoffs[i], fp);
1259: (void) putc(isdsts[i], fp);
1260: (void) putc(abbrinds[i], fp);
1261: }
1262: if (charcnt != 0)
1263: (void) fwrite((genericptr_t) chars,
1264: (fwrite_size_t) sizeof chars[0],
1265: (fwrite_size_t) charcnt, fp);
1266: for (i = 0; i < leapcnt; ++i) {
1267: if (roll[i]) {
1268: if (timecnt == 0 || trans[i] < ats[0]) {
1269: j = 0;
1270: while (isdsts[j])
1271: if (++j >= typecnt) {
1272: j = 0;
1273: break;
1274: }
1275: } else {
1276: j = 1;
1277: while (j < timecnt && trans[i] >= ats[j])
1278: ++j;
1279: j = types[j - 1];
1280: }
1281: puttzcode((long) tadd(trans[i], -gmtoffs[j]), fp);
1282: } else puttzcode((long) trans[i], fp);
1283: puttzcode((long) corr[i], fp);
1284: }
1285: for (i = 0; i < typecnt; ++i)
1286: (void) putc(ttisstds[i], fp);
1287: if (ferror(fp) || fclose(fp)) {
1288: (void) fprintf(stderr, "%s: Write error on ", progname);
1289: (void) perror(fullname);
1290: (void) exit(EXIT_FAILURE);
1291: }
1292: }
1293:
1294: static void
1295: outzone(zpfirst, zonecount)
1296: const struct zone * const zpfirst;
1297: const int zonecount;
1298: {
1299: register const struct zone * zp;
1300: register struct rule * rp;
1301: register int i, j;
1302: register int usestart, useuntil;
1303: register time_t starttime, untiltime;
1304: register long gmtoff;
1305: register long stdoff;
1306: register int year;
1307: register long startoff;
1308: register int startisdst;
1309: register int startttisstd;
1310: register int type;
1311: char startbuf[BUFSIZ];
1312:
1313: /*
1314: ** Now. . .finally. . .generate some useful data!
1315: */
1316: timecnt = 0;
1317: typecnt = 0;
1318: charcnt = 0;
1319: /*
1320: ** Two guesses. . .the second may well be corrected later.
1321: */
1322: gmtoff = zpfirst->z_gmtoff;
1323: stdoff = 0;
1324: #ifdef lint
1325: starttime = 0;
1326: startttisstd = FALSE;
1327: #endif /* defined lint */
1328: for (i = 0; i < zonecount; ++i) {
1329: usestart = i > 0;
1330: useuntil = i < (zonecount - 1);
1331: zp = &zpfirst[i];
1332: eat(zp->z_filename, zp->z_linenum);
1333: startisdst = -1;
1334: if (zp->z_nrules == 0) {
1335: type = addtype(oadd(zp->z_gmtoff, zp->z_stdoff),
1336: zp->z_format, zp->z_stdoff != 0,
1337: startttisstd);
1338: if (usestart)
1339: addtt(starttime, type);
1340: gmtoff = zp->z_gmtoff;
1341: stdoff = zp->z_stdoff;
1342: } else for (year = min_year; year <= max_year; ++year) {
1343: if (useuntil && year > zp->z_untilrule.r_hiyear)
1344: break;
1345: /*
1346: ** Mark which rules to do in the current year.
1347: ** For those to do, calculate rpytime(rp, year);
1348: */
1349: for (j = 0; j < zp->z_nrules; ++j) {
1350: rp = &zp->z_rules[j];
1351: eats(zp->z_filename, zp->z_linenum,
1352: rp->r_filename, rp->r_linenum);
1353: rp->r_todo = year >= rp->r_loyear &&
1354: year <= rp->r_hiyear &&
1355: yearistype(year, rp->r_yrtype);
1356: if (rp->r_todo)
1357: rp->r_temp = rpytime(rp, year);
1358: }
1359: for ( ; ; ) {
1360: register int k;
1361: register time_t jtime, ktime;
1362: register long offset;
1363: char buf[BUFSIZ];
1364:
1365: if (useuntil) {
1366: /*
1367: ** Turn untiltime into GMT
1368: ** assuming the current gmtoff and
1369: ** stdoff values.
1370: */
1371: offset = gmtoff;
1372: if (!zp->z_untilrule.r_todisstd)
1373: offset = oadd(offset, stdoff);
1374: untiltime = tadd(zp->z_untiltime,
1375: -offset);
1376: }
1377: /*
1378: ** Find the rule (of those to do, if any)
1379: ** that takes effect earliest in the year.
1380: */
1381: k = -1;
1382: #ifdef lint
1383: ktime = 0;
1384: #endif /* defined lint */
1385: for (j = 0; j < zp->z_nrules; ++j) {
1386: rp = &zp->z_rules[j];
1387: if (!rp->r_todo)
1388: continue;
1389: eats(zp->z_filename, zp->z_linenum,
1390: rp->r_filename, rp->r_linenum);
1391: offset = gmtoff;
1392: if (!rp->r_todisstd)
1393: offset = oadd(offset, stdoff);
1394: jtime = rp->r_temp;
1395: if (jtime == min_time ||
1396: jtime == max_time)
1397: continue;
1398: jtime = tadd(jtime, -offset);
1399: if (k < 0 || jtime < ktime) {
1400: k = j;
1401: ktime = jtime;
1402: }
1403: }
1404: if (k < 0)
1405: break; /* go on to next year */
1406: rp = &zp->z_rules[k];
1407: rp->r_todo = FALSE;
1408: if (useuntil && ktime >= untiltime)
1409: break;
1410: if (usestart) {
1411: if (ktime < starttime) {
1412: stdoff = rp->r_stdoff;
1413: startoff = oadd(zp->z_gmtoff,
1414: rp->r_stdoff);
1415: (void) sprintf(startbuf,
1416: zp->z_format,
1417: rp->r_abbrvar);
1418: startisdst =
1419: rp->r_stdoff != 0;
1420: continue;
1421: }
1422: if (ktime != starttime &&
1423: startisdst >= 0)
1424: addtt(starttime, addtype(startoff, startbuf, startisdst, startttisstd));
1425: usestart = FALSE;
1426: }
1427: eats(zp->z_filename, zp->z_linenum,
1428: rp->r_filename, rp->r_linenum);
1429: (void) sprintf(buf, zp->z_format,
1430: rp->r_abbrvar);
1431: offset = oadd(zp->z_gmtoff, rp->r_stdoff);
1432: type = addtype(offset, buf, rp->r_stdoff != 0,
1433: rp->r_todisstd);
1434: if (timecnt != 0 || rp->r_stdoff != 0)
1435: addtt(ktime, type);
1436: gmtoff = zp->z_gmtoff;
1437: stdoff = rp->r_stdoff;
1438: }
1439: }
1440: /*
1441: ** Now we may get to set starttime for the next zone line.
1442: */
1443: if (useuntil) {
1444: starttime = tadd(zp->z_untiltime,
1445: -gmtoffs[types[timecnt - 1]]);
1446: startttisstd = zp->z_untilrule.r_todisstd;
1447: }
1448: }
1449: writezone(zpfirst->z_name);
1450: }
1451:
1452: static void
1453: addtt(starttime, type)
1454: const time_t starttime;
1455: const int type;
1456: {
1457: if (timecnt != 0 && type == types[timecnt - 1])
1458: return; /* easy enough! */
1459: if (timecnt >= TZ_MAX_TIMES) {
1460: error("too many transitions?!");
1461: (void) exit(EXIT_FAILURE);
1462: }
1463: ats[timecnt] = starttime;
1464: types[timecnt] = type;
1465: ++timecnt;
1466: }
1467:
1468: static int
1469: addtype(gmtoff, abbr, isdst, ttisstd)
1470: const long gmtoff;
1471: const char * const abbr;
1472: const int isdst;
1473: const int ttisstd;
1474: {
1475: register int i, j;
1476:
1477: /*
1478: ** See if there's already an entry for this zone type.
1479: ** If so, just return its index.
1480: */
1481: for (i = 0; i < typecnt; ++i) {
1482: if (gmtoff == gmtoffs[i] && isdst == isdsts[i] &&
1483: strcmp(abbr, &chars[abbrinds[i]]) == 0 &&
1484: ttisstd == ttisstds[i])
1485: return i;
1486: }
1487: /*
1488: ** There isn't one; add a new one, unless there are already too
1489: ** many.
1490: */
1491: if (typecnt >= TZ_MAX_TYPES) {
1492: error("too many local time types");
1493: (void) exit(EXIT_FAILURE);
1494: }
1495: gmtoffs[i] = gmtoff;
1496: isdsts[i] = isdst;
1497: ttisstds[i] = ttisstd;
1498:
1499: for (j = 0; j < charcnt; ++j)
1500: if (strcmp(&chars[j], abbr) == 0)
1501: break;
1502: if (j == charcnt)
1503: newabbr(abbr);
1504: abbrinds[i] = j;
1505: ++typecnt;
1506: return i;
1507: }
1508:
1509: static void
1510: addleap(t, positive, rolling)
1511: const time_t t;
1512: const int positive;
1513: const int rolling;
1514: {
1515: register int i, j;
1516:
1517: if (leapcnt >= TZ_MAX_LEAPS) {
1518: error("too many leap seconds");
1519: (void) exit(EXIT_FAILURE);
1520: }
1521: for (i = 0; i < leapcnt; ++i)
1522: if (t <= trans[i]) {
1523: if (t == trans[i]) {
1524: error("repeated leap second moment");
1525: (void) exit(EXIT_FAILURE);
1526: }
1527: break;
1528: }
1529: for (j = leapcnt; j > i; --j) {
1530: trans[j] = trans[j-1];
1531: corr[j] = corr[j-1];
1532: roll[j] = roll[j-1];
1533: }
1534: trans[i] = t;
1535: corr[i] = (positive ? 1L : -1L);
1536: roll[i] = rolling;
1537: ++leapcnt;
1538: }
1539:
1540: static void
1541: adjleap()
1542: {
1543: register int i;
1544: register long last = 0;
1545:
1546: /*
1547: ** propagate leap seconds forward
1548: */
1549: for (i = 0; i < leapcnt; ++i) {
1550: trans[i] = tadd(trans[i], last);
1551: last = corr[i] += last;
1552: }
1553: }
1554:
1555: static int
1556: yearistype(year, type)
1557: const int year;
1558: const char * const type;
1559: {
1560: char buf[BUFSIZ];
1561: int result;
1562:
1563: if (type == NULL || *type == '\0')
1564: return TRUE;
1565: if (strcmp(type, "uspres") == 0)
1566: return (year % 4) == 0;
1567: if (strcmp(type, "nonpres") == 0)
1568: return (year % 4) != 0;
1569: (void) sprintf(buf, "yearistype %d %s", year, type);
1570: result = system(buf);
1571: if (result == 0)
1572: return TRUE;
1573: if (result == (1 << 8))
1574: return FALSE;
1575: error("Wild result from command execution");
1576: (void) fprintf(stderr, "%s: command was '%s', result was %d\n",
1577: progname, buf, result);
1578: for ( ; ; )
1579: (void) exit(EXIT_FAILURE);
1580: }
1581:
1582: static int
1583: lowerit(a)
1584: const int a;
1585: {
1586: return (isascii(a) && isupper(a)) ? tolower(a) : a;
1587: }
1588:
1589: static int
1590: ciequal(ap, bp) /* case-insensitive equality */
1591: register const char * ap;
1592: register const char * bp;
1593: {
1594: while (lowerit(*ap) == lowerit(*bp++))
1595: if (*ap++ == '\0')
1596: return TRUE;
1597: return FALSE;
1598: }
1599:
1600: static int
1601: itsabbr(abbr, word)
1602: register const char * abbr;
1603: register const char * word;
1604: {
1605: if (lowerit(*abbr) != lowerit(*word))
1606: return FALSE;
1607: ++word;
1608: while (*++abbr != '\0')
1609: do if (*word == '\0')
1610: return FALSE;
1611: while (lowerit(*word++) != lowerit(*abbr));
1612: return TRUE;
1613: }
1614:
1615: static const struct lookup *
1616: byword(word, table)
1617: register const char * const word;
1618: register const struct lookup * const table;
1619: {
1620: register const struct lookup * foundlp;
1621: register const struct lookup * lp;
1622:
1623: if (word == NULL || table == NULL)
1624: return NULL;
1625: /*
1626: ** Look for exact match.
1627: */
1628: for (lp = table; lp->l_word != NULL; ++lp)
1629: if (ciequal(word, lp->l_word))
1630: return lp;
1631: /*
1632: ** Look for inexact match.
1633: */
1634: foundlp = NULL;
1635: for (lp = table; lp->l_word != NULL; ++lp)
1636: if (itsabbr(word, lp->l_word))
1637: if (foundlp == NULL)
1638: foundlp = lp;
1639: else return NULL; /* multiple inexact matches */
1640: return foundlp;
1641: }
1642:
1643: static char **
1644: getfields(cp)
1645: register char * cp;
1646: {
1647: register char * dp;
1648: register char ** array;
1649: register int nsubs;
1650:
1651: if (cp == NULL)
1652: return NULL;
1653: array = (char **) emalloc((int) ((strlen(cp) + 1) * sizeof *array));
1654: nsubs = 0;
1655: for ( ; ; ) {
1656: while (isascii(*cp) && isspace(*cp))
1657: ++cp;
1658: if (*cp == '\0' || *cp == '#')
1659: break;
1660: array[nsubs++] = dp = cp;
1661: do {
1662: if ((*dp = *cp++) != '"')
1663: ++dp;
1664: else while ((*dp = *cp++) != '"')
1665: if (*dp != '\0')
1666: ++dp;
1667: else error("Odd number of quotation marks");
1668: } while (*cp != '\0' && *cp != '#' &&
1669: (!isascii(*cp) || !isspace(*cp)));
1670: if (isascii(*cp) && isspace(*cp))
1671: ++cp;
1672: *dp = '\0';
1673: }
1674: array[nsubs] = NULL;
1675: return array;
1676: }
1677:
1678: static long
1679: oadd(t1, t2)
1680: const long t1;
1681: const long t2;
1682: {
1683: register long t;
1684:
1685: t = t1 + t2;
1686: if (t2 > 0 && t <= t1 || t2 < 0 && t >= t1) {
1687: error("time overflow");
1688: (void) exit(EXIT_FAILURE);
1689: }
1690: return t;
1691: }
1692:
1693: static time_t
1694: tadd(t1, t2)
1695: const time_t t1;
1696: const long t2;
1697: {
1698: register time_t t;
1699:
1700: if (t1 == max_time && t2 > 0)
1701: return max_time;
1702: if (t1 == min_time && t2 < 0)
1703: return min_time;
1704: t = t1 + t2;
1705: if (t2 > 0 && t <= t1 || t2 < 0 && t >= t1) {
1706: error("time overflow");
1707: (void) exit(EXIT_FAILURE);
1708: }
1709: return t;
1710: }
1711:
1712: /*
1713: ** Given a rule, and a year, compute the date - in seconds since January 1,
1714: ** 1970, 00:00 LOCAL time - in that year that the rule refers to.
1715: */
1716:
1717: static time_t
1718: rpytime(rp, wantedy)
1719: register const struct rule * const rp;
1720: register const int wantedy;
1721: {
1722: register int y, m, i;
1723: register long dayoff; /* with a nod to Margaret O. */
1724: register time_t t;
1725:
1726: dayoff = 0;
1727: m = TM_JANUARY;
1728: y = EPOCH_YEAR;
1729: while (wantedy != y) {
1730: if (wantedy > y) {
1731: i = len_years[isleap(y)];
1732: ++y;
1733: } else {
1734: --y;
1735: i = -len_years[isleap(y)];
1736: }
1737: dayoff = oadd(dayoff, eitol(i));
1738: }
1739: while (m != rp->r_month) {
1740: i = len_months[isleap(y)][m];
1741: dayoff = oadd(dayoff, eitol(i));
1742: ++m;
1743: }
1744: i = rp->r_dayofmonth;
1745: if (m == TM_FEBRUARY && i == 29 && !isleap(y)) {
1746: if (rp->r_dycode == DC_DOWLEQ)
1747: --i;
1748: else {
1749: error("use of 2/29 in non leap-year");
1750: (void) exit(EXIT_FAILURE);
1751: }
1752: }
1753: --i;
1754: dayoff = oadd(dayoff, eitol(i));
1755: if (rp->r_dycode == DC_DOWGEQ || rp->r_dycode == DC_DOWLEQ) {
1756: register long wday;
1757:
1758: #define LDAYSPERWEEK ((long) DAYSPERWEEK)
1759: wday = eitol(EPOCH_WDAY);
1760: /*
1761: ** Don't trust mod of negative numbers.
1762: */
1763: if (dayoff >= 0)
1764: wday = (wday + dayoff) % LDAYSPERWEEK;
1765: else {
1766: wday -= ((-dayoff) % LDAYSPERWEEK);
1767: if (wday < 0)
1768: wday += LDAYSPERWEEK;
1769: }
1770: while (wday != eitol(rp->r_wday))
1771: if (rp->r_dycode == DC_DOWGEQ) {
1772: dayoff = oadd(dayoff, (long) 1);
1773: if (++wday >= LDAYSPERWEEK)
1774: wday = 0;
1775: ++i;
1776: } else {
1777: dayoff = oadd(dayoff, (long) -1);
1778: if (--wday < 0)
1779: wday = LDAYSPERWEEK;
1780: --i;
1781: }
1782: if (i < 0 || i >= len_months[isleap(y)][m]) {
1783: error("no day in month matches rule");
1784: (void) exit(EXIT_FAILURE);
1785: }
1786: }
1787: if (dayoff < 0 && !tt_signed) {
1788: if (wantedy == rp->r_loyear)
1789: return min_time;
1790: error("time before zero");
1791: (void) exit(EXIT_FAILURE);
1792: }
1793: t = (time_t) dayoff * SECSPERDAY;
1794: /*
1795: ** Cheap overflow check.
1796: */
1797: if (t / SECSPERDAY != dayoff) {
1798: if (wantedy == rp->r_hiyear)
1799: return max_time;
1800: if (wantedy == rp->r_loyear)
1801: return min_time;
1802: error("time overflow");
1803: (void) exit(EXIT_FAILURE);
1804: }
1805: return tadd(t, rp->r_tod);
1806: }
1807:
1808: static void
1809: newabbr(string)
1810: const char * const string;
1811: {
1812: register int i;
1813:
1814: i = strlen(string) + 1;
1815: if (charcnt + i >= TZ_MAX_CHARS) {
1816: error("too many, or too long, time zone abbreviations");
1817: (void) exit(EXIT_FAILURE);
1818: }
1819: (void) strcpy(&chars[charcnt], string);
1820: charcnt += eitol(i);
1821: }
1822:
1823: static int
1824: mkdirs(name)
1825: char * const name;
1826: {
1827: register char * cp;
1828:
1829: if ((cp = name) == NULL || *cp == '\0')
1830: return 0;
1831: while ((cp = strchr(cp + 1, '/')) != 0) {
1832: *cp = '\0';
1833: #ifndef unix
1834: /*
1835: ** MS-DOS drive specifier?
1836: */
1837: if (strlen(name) == 2 && isascii(name[0]) &&
1838: isalpha(name[0]) && name[1] == ':') {
1839: *cp = '/';
1840: continue;
1841: }
1842: #endif /* !defined unix */
1843: if (!itsdir(name)) {
1844: /*
1845: ** It doesn't seem to exist, so we try to create it.
1846: */
1847: if (emkdir(name, 0755) != 0) {
1848: (void) fprintf(stderr,
1849: "%s: Can't create directory ",
1850: progname);
1851: (void) perror(name);
1852: return -1;
1853: }
1854: }
1855: *cp = '/';
1856: }
1857: return 0;
1858: }
1859:
1860: static long
1861: eitol(i)
1862: const int i;
1863: {
1864: long l;
1865:
1866: l = i;
1867: if (i < 0 && l >= 0 || i == 0 && l != 0 || i > 0 && l <= 0) {
1868: (void) fprintf(stderr, "%s: %d did not sign extend correctly\n",
1869: progname, i);
1870: (void) exit(EXIT_FAILURE);
1871: }
1872: return l;
1873: }
1874:
1875: /*
1876: ** UNIX is a registered trademark of AT&T.
1877: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.