The Tor Browser / file comparison

comparison: intl/icu/source/tools/tzcode/zic.c

intl/icu/source/tools/tzcode/zic.c

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:69d7aac79f18
1 /*
2 ** This file is in the public domain, so clarified as of
3 ** 2006-07-17 by Arthur David Olson.
4 */
5
6 static char elsieid[] = "@(#)zic.c 8.18";
7
8 #include "private.h"
9 #include "locale.h"
10 #include "tzfile.h"
11
12 #define ZIC_VERSION '2'
13
14 typedef int_fast64_t zic_t;
15
16 #ifndef ZIC_MAX_ABBR_LEN_WO_WARN
17 #define ZIC_MAX_ABBR_LEN_WO_WARN 6
18 #endif /* !defined ZIC_MAX_ABBR_LEN_WO_WARN */
19
20 #if HAVE_SYS_STAT_H
21 #include "sys/stat.h"
22 #endif
23 #ifdef S_IRUSR
24 #define MKDIR_UMASK (S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH)
25 #else
26 #define MKDIR_UMASK 0755
27 #endif
28
29 /* Enable extensions and modifications for ICU. */
30 #define ICU
31
32 /* Continue executing after link failure. Even if ICU is undefined
33 * (for vanilla zic behavior), ICU_LINKS should be defined, since zic
34 * appears to fail on the 2003 data the first time through during the
35 * linking phase. Running zic twice, with ICU_LINKS defined, causes
36 * links to be handled correctly. */
37 #define ICU_LINKS
38
39 #ifdef ICU
40 #include "tz2icu.h"
41 #endif
42
43 /*
44 ** On some ancient hosts, predicates like `isspace(C)' are defined
45 ** only if isascii(C) || C == EOF. Modern hosts obey the C Standard,
46 ** which says they are defined only if C == ((unsigned char) C) || C == EOF.
47 ** Neither the C Standard nor Posix require that `isascii' exist.
48 ** For portability, we check both ancient and modern requirements.
49 ** If isascii is not defined, the isascii check succeeds trivially.
50 */
51 #include "ctype.h"
52 #ifndef isascii
53 #define isascii(x) 1
54 #endif
55
56 #define OFFSET_STRLEN_MAXIMUM (7 + INT_STRLEN_MAXIMUM(long))
57 #define RULE_STRLEN_MAXIMUM 8 /* "Mdd.dd.d" */
58
59 #define end(cp) (strchr((cp), '\0'))
60
61 struct rule {
62 const char * r_filename;
63 int r_linenum;
64 const char * r_name;
65
66 int r_loyear; /* for example, 1986 */
67 int r_hiyear; /* for example, 1986 */
68 const char * r_yrtype;
69 int r_lowasnum;
70 int r_hiwasnum;
71
72 int r_month; /* 0..11 */
73
74 int r_dycode; /* see below */
75 int r_dayofmonth;
76 int r_wday;
77
78 long r_tod; /* time from midnight */
79 int r_todisstd; /* above is standard time if TRUE */
80 /* or wall clock time if FALSE */
81 int r_todisgmt; /* above is GMT if TRUE */
82 /* or local time if FALSE */
83 long r_stdoff; /* offset from standard time */
84 const char * r_abbrvar; /* variable part of abbreviation */
85
86 int r_todo; /* a rule to do (used in outzone) */
87 zic_t r_temp; /* used in outzone */
88 };
89
90 /*
91 ** r_dycode r_dayofmonth r_wday
92 */
93
94 #define DC_DOM 0 /* 1..31 */ /* unused */
95 #define DC_DOWGEQ 1 /* 1..31 */ /* 0..6 (Sun..Sat) */
96 #define DC_DOWLEQ 2 /* 1..31 */ /* 0..6 (Sun..Sat) */
97
98 struct zone {
99 const char * z_filename;
100 int z_linenum;
101
102 const char * z_name;
103 long z_gmtoff;
104 const char * z_rule;
105 const char * z_format;
106
107 long z_stdoff;
108
109 struct rule * z_rules;
110 int z_nrules;
111
112 struct rule z_untilrule;
113 zic_t z_untiltime;
114 };
115
116 extern int getopt(int argc, char * const argv[],
117 const char * options);
118 extern int link(const char * fromname, const char * toname);
119 extern char * optarg;
120 extern int optind;
121
122 static void addtt(zic_t starttime, int type);
123 #ifdef ICU
124 static int addtype(long gmtoff, long rawoff, long dstoff,
125 const char * abbr, int isdst,
126 int ttisstd, int ttisgmt);
127 #else
128 static int addtype(long gmtoff, const char * abbr, int isdst,
129 int ttisstd, int ttisgmt);
130 #endif
131 static void leapadd(zic_t t, int positive, int rolling, int count);
132 static void adjleap(void);
133 static void associate(void);
134 static int ciequal(const char * ap, const char * bp);
135 static void convert(long val, char * buf);
136 static void convert64(zic_t val, char * buf);
137 static void dolink(const char * fromfield, const char * tofield);
138 static void doabbr(char * abbr, const char * format,
139 const char * letters, int isdst, int doquotes);
140 static void eat(const char * name, int num);
141 static void eats(const char * name, int num,
142 const char * rname, int rnum);
143 static long eitol(int i);
144 static void error(const char * message);
145 static char ** getfields(char * buf);
146 static long gethms(const char * string, const char * errstrng,
147 int signable);
148 static void infile(const char * filename);
149 static void inleap(char ** fields, int nfields);
150 static void inlink(char ** fields, int nfields);
151 static void inrule(char ** fields, int nfields);
152 static int inzcont(char ** fields, int nfields);
153 static int inzone(char ** fields, int nfields);
154 static int inzsub(char ** fields, int nfields, int iscont);
155 static int is32(zic_t x);
156 static int itsabbr(const char * abbr, const char * word);
157 static int itsdir(const char * name);
158 static int lowerit(int c);
159 static char * memcheck(char * tocheck);
160 static int mkdirs(char * filename);
161 static void newabbr(const char * abbr);
162 static long oadd(long t1, long t2);
163 static void outzone(const struct zone * zp, int ntzones);
164 static void puttzcode(long code, FILE * fp);
165 static void puttzcode64(zic_t code, FILE * fp);
166 static int rcomp(const void * leftp, const void * rightp);
167 static zic_t rpytime(const struct rule * rp, int wantedy);
168 static void rulesub(struct rule * rp,
169 const char * loyearp, const char * hiyearp,
170 const char * typep, const char * monthp,
171 const char * dayp, const char * timep);
172 static int stringoffset(char * result, long offset);
173 static int stringrule(char * result, const struct rule * rp,
174 long dstoff, long gmtoff);
175 static void stringzone(char * result,
176 const struct zone * zp, int ntzones);
177 static void setboundaries(void);
178 static zic_t tadd(zic_t t1, long t2);
179 static void usage(FILE *stream, int status);
180 static void writezone(const char * name, const char * string);
181 static int yearistype(int year, const char * type);
182 #ifdef ICU
183 static void emit_icu_zone(FILE* f, const char* zoneName, int zoneOffset,
184 const struct rule* rule,
185 int ruleIndex, int startYear);
186 static void emit_icu_link(FILE* f, const char* from, const char* to);
187 static void emit_icu_rule(FILE* f, const struct rule* r, int ruleIndex);
188 static int add_icu_final_rules(const struct rule* r1, const struct rule* r2);
189 #endif
190
191 static int charcnt;
192 static int errors;
193 static const char * filename;
194 static int leapcnt;
195 static int leapseen;
196 static int leapminyear;
197 static int leapmaxyear;
198 static int linenum;
199 static int max_abbrvar_len;
200 static int max_format_len;
201 static zic_t max_time;
202 static int max_year;
203 static zic_t min_time;
204 static int min_year;
205 static int noise;
206 static const char * rfilename;
207 static int rlinenum;
208 static const char * progname;
209 static int timecnt;
210 static int typecnt;
211
212 /*
213 ** Line codes.
214 */
215
216 #define LC_RULE 0
217 #define LC_ZONE 1
218 #define LC_LINK 2
219 #define LC_LEAP 3
220
221 /*
222 ** Which fields are which on a Zone line.
223 */
224
225 #define ZF_NAME 1
226 #define ZF_GMTOFF 2
227 #define ZF_RULE 3
228 #define ZF_FORMAT 4
229 #define ZF_TILYEAR 5
230 #define ZF_TILMONTH 6
231 #define ZF_TILDAY 7
232 #define ZF_TILTIME 8
233 #define ZONE_MINFIELDS 5
234 #define ZONE_MAXFIELDS 9
235
236 /*
237 ** Which fields are which on a Zone continuation line.
238 */
239
240 #define ZFC_GMTOFF 0
241 #define ZFC_RULE 1
242 #define ZFC_FORMAT 2
243 #define ZFC_TILYEAR 3
244 #define ZFC_TILMONTH 4
245 #define ZFC_TILDAY 5
246 #define ZFC_TILTIME 6
247 #define ZONEC_MINFIELDS 3
248 #define ZONEC_MAXFIELDS 7
249
250 /*
251 ** Which files are which on a Rule line.
252 */
253
254 #define RF_NAME 1
255 #define RF_LOYEAR 2
256 #define RF_HIYEAR 3
257 #define RF_COMMAND 4
258 #define RF_MONTH 5
259 #define RF_DAY 6
260 #define RF_TOD 7
261 #define RF_STDOFF 8
262 #define RF_ABBRVAR 9
263 #define RULE_FIELDS 10
264
265 /*
266 ** Which fields are which on a Link line.
267 */
268
269 #define LF_FROM 1
270 #define LF_TO 2
271 #define LINK_FIELDS 3
272
273 /*
274 ** Which fields are which on a Leap line.
275 */
276
277 #define LP_YEAR 1
278 #define LP_MONTH 2
279 #define LP_DAY 3
280 #define LP_TIME 4
281 #define LP_CORR 5
282 #define LP_ROLL 6
283 #define LEAP_FIELDS 7
284
285 /*
286 ** Year synonyms.
287 */
288
289 #define YR_MINIMUM 0
290 #define YR_MAXIMUM 1
291 #define YR_ONLY 2
292
293 static struct rule * rules;
294 static int nrules; /* number of rules */
295
296 static struct zone * zones;
297 static int nzones; /* number of zones */
298
299 struct link {
300 const char * l_filename;
301 int l_linenum;
302 const char * l_from;
303 const char * l_to;
304 };
305
306 static struct link * links;
307 static int nlinks;
308
309 struct lookup {
310 const char * l_word;
311 const int l_value;
312 };
313
314 #ifdef ICU
315 /* Indices into rules[] for final rules. They will occur in pairs,
316 * with finalRules[i] occurring before finalRules[i+1] in the year.
317 * Each zone need only store a start year, a standard offset, and an
318 * index into finalRules[]. FinalRules[] are aliases into rules[]. */
319 static const struct rule ** finalRules;
320 static int finalRulesCount;
321 #endif
322
323 static struct lookup const * byword(const char * string,
324 const struct lookup * lp);
325
326 static struct lookup const line_codes[] = {
327 { "Rule", LC_RULE },
328 { "Zone", LC_ZONE },
329 { "Link", LC_LINK },
330 { "Leap", LC_LEAP },
331 { NULL, 0}
332 };
333
334 static struct lookup const mon_names[] = {
335 { "January", TM_JANUARY },
336 { "February", TM_FEBRUARY },
337 { "March", TM_MARCH },
338 { "April", TM_APRIL },
339 { "May", TM_MAY },
340 { "June", TM_JUNE },
341 { "July", TM_JULY },
342 { "August", TM_AUGUST },
343 { "September", TM_SEPTEMBER },
344 { "October", TM_OCTOBER },
345 { "November", TM_NOVEMBER },
346 { "December", TM_DECEMBER },
347 { NULL, 0 }
348 };
349
350 static struct lookup const wday_names[] = {
351 { "Sunday", TM_SUNDAY },
352 { "Monday", TM_MONDAY },
353 { "Tuesday", TM_TUESDAY },
354 { "Wednesday", TM_WEDNESDAY },
355 { "Thursday", TM_THURSDAY },
356 { "Friday", TM_FRIDAY },
357 { "Saturday", TM_SATURDAY },
358 { NULL, 0 }
359 };
360
361 static struct lookup const lasts[] = {
362 { "last-Sunday", TM_SUNDAY },
363 { "last-Monday", TM_MONDAY },
364 { "last-Tuesday", TM_TUESDAY },
365 { "last-Wednesday", TM_WEDNESDAY },
366 { "last-Thursday", TM_THURSDAY },
367 { "last-Friday", TM_FRIDAY },
368 { "last-Saturday", TM_SATURDAY },
369 { NULL, 0 }
370 };
371
372 static struct lookup const begin_years[] = {
373 { "minimum", YR_MINIMUM },
374 { "maximum", YR_MAXIMUM },
375 { NULL, 0 }
376 };
377
378 static struct lookup const end_years[] = {
379 { "minimum", YR_MINIMUM },
380 { "maximum", YR_MAXIMUM },
381 { "only", YR_ONLY },
382 { NULL, 0 }
383 };
384
385 static struct lookup const leap_types[] = {
386 { "Rolling", TRUE },
387 { "Stationary", FALSE },
388 { NULL, 0 }
389 };
390
391 static const int len_months[2][MONSPERYEAR] = {
392 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
393 { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
394 };
395
396 static const int len_years[2] = {
397 DAYSPERNYEAR, DAYSPERLYEAR
398 };
399
400 static struct attype {
401 zic_t at;
402 unsigned char type;
403 } attypes[TZ_MAX_TIMES];
404 static long gmtoffs[TZ_MAX_TYPES];
405 #ifdef ICU
406 /* gmtoffs[i] = rawoffs[i] + dstoffs[i] */
407 static long rawoffs[TZ_MAX_TYPES];
408 static long dstoffs[TZ_MAX_TYPES];
409 #endif
410 static char isdsts[TZ_MAX_TYPES];
411 static unsigned char abbrinds[TZ_MAX_TYPES];
412 static char ttisstds[TZ_MAX_TYPES];
413 static char ttisgmts[TZ_MAX_TYPES];
414 static char chars[TZ_MAX_CHARS];
415 static zic_t trans[TZ_MAX_LEAPS];
416 static long corr[TZ_MAX_LEAPS];
417 static char roll[TZ_MAX_LEAPS];
418
419 /*
420 ** Memory allocation.
421 */
422
423 static char *
424 memcheck(ptr)
425 char * const ptr;
426 {
427 if (ptr == NULL) {
428 const char *e = strerror(errno);
429
430 (void) fprintf(stderr, _("%s: Memory exhausted: %s\n"),
431 progname, e);
432 exit(EXIT_FAILURE);
433 }
434 return ptr;
435 }
436
437 #define emalloc(size) memcheck(imalloc(size))
438 #define erealloc(ptr, size) memcheck(irealloc((ptr), (size)))
439 #define ecpyalloc(ptr) memcheck(icpyalloc(ptr))
440 #define ecatalloc(oldp, newp) memcheck(icatalloc((oldp), (newp)))
441
442 /*
443 ** Error handling.
444 */
445
446 static void
447 eats(name, num, rname, rnum)
448 const char * const name;
449 const int num;
450 const char * const rname;
451 const int rnum;
452 {
453 filename = name;
454 linenum = num;
455 rfilename = rname;
456 rlinenum = rnum;
457 }
458
459 static void
460 eat(name, num)
461 const char * const name;
462 const int num;
463 {
464 eats(name, num, (char *) NULL, -1);
465 }
466
467 static void
468 error(string)
469 const char * const string;
470 {
471 /*
472 ** Match the format of "cc" to allow sh users to
473 ** zic ... 2>&1 | error -t "*" -v
474 ** on BSD systems.
475 */
476 (void) fprintf(stderr, _("\"%s\", line %d: %s"),
477 filename, linenum, string);
478 if (rfilename != NULL)
479 (void) fprintf(stderr, _(" (rule from \"%s\", line %d)"),
480 rfilename, rlinenum);
481 (void) fprintf(stderr, "\n");
482 ++errors;
483 }
484
485 static void
486 warning(string)
487 const char * const string;
488 {
489 char * cp;
490
491 cp = ecpyalloc(_("warning: "));
492 cp = ecatalloc(cp, string);
493 error(cp);
494 ifree(cp);
495 --errors;
496 }
497
498 static void
499 usage(FILE *stream, int status)
500 {
501 (void) fprintf(stream, _("%s: usage is %s \
502 [ --version ] [ --help ] [ -v ] [ -l localtime ] [ -p posixrules ] \\\n\
503 \t[ -d directory ] [ -L leapseconds ] [ -y yearistype ] [ filename ... ]\n\
504 \n\
505 Report bugs to tz@elsie.nci.nih.gov.\n"),
506 progname, progname);
507 exit(status);
508 }
509
510 #ifdef ICU
511 /* File into which we will write supplemental ICU data. */
512 static FILE * icuFile;
513
514 static void
515 emit_icu_zone(FILE* f, const char* zoneName, int zoneOffset,
516 const struct rule* rule,
517 int ruleIndex, int startYear) {
518 /* machine-readable section */
519 fprintf(f, "zone %s %d %d %s", zoneName, zoneOffset, startYear, rule->r_name);
520
521 /* human-readable section */
522 fprintf(f, " # zone %s, offset %d, year >= %d, rule %s (%d)\n",
523 zoneName, zoneOffset, startYear,
524 rule->r_name, ruleIndex);
525 }
526
527 static void
528 emit_icu_link(FILE* f, const char* from, const char* to) {
529 /* machine-readable section */
530 fprintf(f, "link %s %s\n", from, to);
531 }
532
533 static const char* DYCODE[] = {"DOM", "DOWGEQ", "DOWLEQ"};
534
535 static void
536 emit_icu_rule(FILE* f, const struct rule* r, int ruleIndex) {
537 if (r->r_yrtype != NULL) {
538 warning("year types not supported by ICU");
539 fprintf(stderr, "rule %s, file %s, line %d\n",
540 r->r_name, r->r_filename, r->r_linenum);
541 }
542
543 /* machine-readable section */
544 fprintf(f, "rule %s %s %d %d %d %ld %d %d %ld",
545 r->r_name, DYCODE[r->r_dycode],
546 r->r_month, r->r_dayofmonth,
547 (r->r_dycode == DC_DOM ? -1 : r->r_wday),
548 r->r_tod, r->r_todisstd, r->r_todisgmt, r->r_stdoff
549 );
550
551 /* human-readable section */
552 fprintf(f, " # %d: %s, file %s, line %d",
553 ruleIndex, r->r_name, r->r_filename, r->r_linenum);
554 fprintf(f, ", mode %s", DYCODE[r->r_dycode]);
555 fprintf(f, ", %s, dom %d", mon_names[r->r_month].l_word, r->r_dayofmonth);
556 if (r->r_dycode != DC_DOM) {
557 fprintf(f, ", %s", wday_names[r->r_wday].l_word);
558 }
559 fprintf(f, ", time %ld", r->r_tod);
560 fprintf(f, ", isstd %d", r->r_todisstd);
561 fprintf(f, ", isgmt %d", r->r_todisgmt);
562 fprintf(f, ", offset %ld", r->r_stdoff);
563 fprintf(f, "\n");
564 }
565
566 static int
567 add_icu_final_rules(const struct rule* r1, const struct rule* r2) {
568 int i;
569
570 for (i=0; i<finalRulesCount; ++i) { /* i+=2 should work too */
571 if (r1==finalRules[i]) return i; /* [sic] pointer comparison */
572 }
573
574 finalRules = (const struct rule**) (void*) erealloc((char *) finalRules,
575 (finalRulesCount + 2) * sizeof(*finalRules));
576 finalRules[finalRulesCount++] = r1;
577 finalRules[finalRulesCount++] = r2;
578 return finalRulesCount - 2;
579 }
580 #endif
581
582 static const char * psxrules;
583 static const char * lcltime;
584 static const char * directory;
585 static const char * leapsec;
586 static const char * yitcommand;
587
588 int
589 main(argc, argv)
590 int argc;
591 char * argv[];
592 {
593 register int i;
594 register int j;
595 register int c;
596
597 #ifdef unix
598 (void) umask(umask(S_IWGRP | S_IWOTH) | (S_IWGRP | S_IWOTH));
599 #endif /* defined unix */
600 #if HAVE_GETTEXT
601 (void) setlocale(LC_ALL, "");
602 #ifdef TZ_DOMAINDIR
603 (void) bindtextdomain(TZ_DOMAIN, TZ_DOMAINDIR);
604 #endif /* defined TEXTDOMAINDIR */
605 (void) textdomain(TZ_DOMAIN);
606 #endif /* HAVE_GETTEXT */
607 progname = argv[0];
608 if (TYPE_BIT(zic_t) < 64) {
609 (void) fprintf(stderr, "%s: %s\n", progname,
610 _("wild compilation-time specification of zic_t"));
611 exit(EXIT_FAILURE);
612 }
613 for (i = 1; i < argc; ++i)
614 if (strcmp(argv[i], "--version") == 0) {
615 (void) printf("%s\n", elsieid);
616 exit(EXIT_SUCCESS);
617 } else if (strcmp(argv[i], "--help") == 0) {
618 usage(stdout, EXIT_SUCCESS);
619 }
620 while ((c = getopt(argc, argv, "d:l:p:L:vsy:")) != EOF && c != -1)
621 switch (c) {
622 default:
623 usage(stderr, EXIT_FAILURE);
624 case 'd':
625 if (directory == NULL)
626 directory = optarg;
627 else {
628 (void) fprintf(stderr,
629 _("%s: More than one -d option specified\n"),
630 progname);
631 exit(EXIT_FAILURE);
632 }
633 break;
634 case 'l':
635 if (lcltime == NULL)
636 lcltime = optarg;
637 else {
638 (void) fprintf(stderr,
639 _("%s: More than one -l option specified\n"),
640 progname);
641 exit(EXIT_FAILURE);
642 }
643 break;
644 case 'p':
645 if (psxrules == NULL)
646 psxrules = optarg;
647 else {
648 (void) fprintf(stderr,
649 _("%s: More than one -p option specified\n"),
650 progname);
651 exit(EXIT_FAILURE);
652 }
653 break;
654 case 'y':
655 if (yitcommand == NULL)
656 yitcommand = optarg;
657 else {
658 (void) fprintf(stderr,
659 _("%s: More than one -y option specified\n"),
660 progname);
661 exit(EXIT_FAILURE);
662 }
663 break;
664 case 'L':
665 if (leapsec == NULL)
666 leapsec = optarg;
667 else {
668 (void) fprintf(stderr,
669 _("%s: More than one -L option specified\n"),
670 progname);
671 exit(EXIT_FAILURE);
672 }
673 break;
674 case 'v':
675 noise = TRUE;
676 break;
677 case 's':
678 (void) printf("%s: -s ignored\n", progname);
679 break;
680 }
681 if (optind == argc - 1 && strcmp(argv[optind], "=") == 0)
682 usage(stderr, EXIT_FAILURE); /* usage message by request */
683 if (directory == NULL)
684 directory = TZDIR;
685 if (yitcommand == NULL)
686 yitcommand = "yearistype";
687
688 setboundaries();
689
690 if (optind < argc && leapsec != NULL) {
691 infile(leapsec);
692 adjleap();
693 }
694
695 #ifdef ICU
696 if ((icuFile = fopen(ICU_ZONE_FILE, "w")) == NULL) {
697 const char *e = strerror(errno);
698 (void) fprintf(stderr, _("%s: Can't open %s: %s\n"),
699 progname, ICU_ZONE_FILE, e);
700 (void) exit(EXIT_FAILURE);
701 }
702 #endif
703 for (i = optind; i < argc; ++i)
704 infile(argv[i]);
705 if (errors)
706 exit(EXIT_FAILURE);
707 associate();
708 for (i = 0; i < nzones; i = j) {
709 /*
710 ** Find the next non-continuation zone entry.
711 */
712 for (j = i + 1; j < nzones && zones[j].z_name == NULL; ++j)
713 continue;
714 outzone(&zones[i], j - i);
715 }
716 /*
717 ** Make links.
718 */
719 for (i = 0; i < nlinks; ++i) {
720 eat(links[i].l_filename, links[i].l_linenum);
721 dolink(links[i].l_from, links[i].l_to);
722 #ifdef ICU
723 emit_icu_link(icuFile, links[i].l_from, links[i].l_to);
724 #endif
725 if (noise)
726 for (j = 0; j < nlinks; ++j)
727 if (strcmp(links[i].l_to,
728 links[j].l_from) == 0)
729 warning(_("link to link"));
730 }
731 if (lcltime != NULL) {
732 eat("command line", 1);
733 dolink(lcltime, TZDEFAULT);
734 }
735 if (psxrules != NULL) {
736 eat("command line", 1);
737 dolink(psxrules, TZDEFRULES);
738 }
739 #ifdef ICU
740 for (i=0; i<finalRulesCount; ++i) {
741 emit_icu_rule(icuFile, finalRules[i], i);
742 }
743 #endif /*ICU*/
744 return (errors == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
745 }
746
747 static void
748 dolink(fromfield, tofield)
749 const char * const fromfield;
750 const char * const tofield;
751 {
752 register char * fromname;
753 register char * toname;
754
755 if (fromfield[0] == '/')
756 fromname = ecpyalloc(fromfield);
757 else {
758 fromname = ecpyalloc(directory);
759 fromname = ecatalloc(fromname, "/");
760 fromname = ecatalloc(fromname, fromfield);
761 }
762 if (tofield[0] == '/')
763 toname = ecpyalloc(tofield);
764 else {
765 toname = ecpyalloc(directory);
766 toname = ecatalloc(toname, "/");
767 toname = ecatalloc(toname, tofield);
768 }
769 /*
770 ** We get to be careful here since
771 ** there's a fair chance of root running us.
772 */
773 if (!itsdir(toname))
774 (void) remove(toname);
775 if (link(fromname, toname) != 0) {
776 int result;
777
778 if (mkdirs(toname) != 0)
779 exit(EXIT_FAILURE);
780
781 result = link(fromname, toname);
782 #if HAVE_SYMLINK
783 if (result != 0 &&
784 access(fromname, F_OK) == 0 &&
785 !itsdir(fromname)) {
786 const char *s = tofield;
787 register char * symlinkcontents = NULL;
788
789 while ((s = strchr(s+1, '/')) != NULL)
790 symlinkcontents =
791 ecatalloc(symlinkcontents,
792 "../");
793 symlinkcontents =
794 ecatalloc(symlinkcontents,
795 fromname);
796 result = symlink(symlinkcontents,
797 toname);
798 if (result == 0)
799 warning(_("hard link failed, symbolic link used"));
800 ifree(symlinkcontents);
801 }
802 #endif /* HAVE_SYMLINK */
803 if (result != 0) {
804 const char *e = strerror(errno);
805
806 (void) fprintf(stderr,
807 _("%s: Can't link from %s to %s: %s\n"),
808 progname, fromname, toname, e);
809 #ifndef ICU_LINKS
810 exit(EXIT_FAILURE);
811 #endif
812 }
813 }
814 ifree(fromname);
815 ifree(toname);
816 }
817
818 #define TIME_T_BITS_IN_FILE 64
819
820 static void
821 setboundaries(void)
822 {
823 register int i;
824
825 min_time = -1;
826 for (i = 0; i < TIME_T_BITS_IN_FILE - 1; ++i)
827 min_time *= 2;
828 max_time = -(min_time + 1);
829 }
830
831 static int
832 itsdir(name)
833 const char * const name;
834 {
835 register char * myname;
836 register int accres;
837
838 myname = ecpyalloc(name);
839 myname = ecatalloc(myname, "/.");
840 accres = access(myname, F_OK);
841 ifree(myname);
842 return accres == 0;
843 }
844
845 /*
846 ** Associate sets of rules with zones.
847 */
848
849 /*
850 ** Sort by rule name.
851 */
852
853 static int
854 rcomp(cp1, cp2)
855 const void * cp1;
856 const void * cp2;
857 {
858 return strcmp(((const struct rule *) cp1)->r_name,
859 ((const struct rule *) cp2)->r_name);
860 }
861
862 static void
863 associate(void)
864 {
865 register struct zone * zp;
866 register struct rule * rp;
867 register int base, out;
868 register int i, j;
869
870 if (nrules != 0) {
871 (void) qsort((void *) rules, (size_t) nrules,
872 (size_t) sizeof *rules, rcomp);
873 for (i = 0; i < nrules - 1; ++i) {
874 if (strcmp(rules[i].r_name,
875 rules[i + 1].r_name) != 0)
876 continue;
877 if (strcmp(rules[i].r_filename,
878 rules[i + 1].r_filename) == 0)
879 continue;
880 eat(rules[i].r_filename, rules[i].r_linenum);
881 warning(_("same rule name in multiple files"));
882 eat(rules[i + 1].r_filename, rules[i + 1].r_linenum);
883 warning(_("same rule name in multiple files"));
884 for (j = i + 2; j < nrules; ++j) {
885 if (strcmp(rules[i].r_name,
886 rules[j].r_name) != 0)
887 break;
888 if (strcmp(rules[i].r_filename,
889 rules[j].r_filename) == 0)
890 continue;
891 if (strcmp(rules[i + 1].r_filename,
892 rules[j].r_filename) == 0)
893 continue;
894 break;
895 }
896 i = j - 1;
897 }
898 }
899 for (i = 0; i < nzones; ++i) {
900 zp = &zones[i];
901 zp->z_rules = NULL;
902 zp->z_nrules = 0;
903 }
904 for (base = 0; base < nrules; base = out) {
905 rp = &rules[base];
906 for (out = base + 1; out < nrules; ++out)
907 if (strcmp(rp->r_name, rules[out].r_name) != 0)
908 break;
909 for (i = 0; i < nzones; ++i) {
910 zp = &zones[i];
911 if (strcmp(zp->z_rule, rp->r_name) != 0)
912 continue;
913 zp->z_rules = rp;
914 zp->z_nrules = out - base;
915 }
916 }
917 for (i = 0; i < nzones; ++i) {
918 zp = &zones[i];
919 if (zp->z_nrules == 0) {
920 /*
921 ** Maybe we have a local standard time offset.
922 */
923 eat(zp->z_filename, zp->z_linenum);
924 zp->z_stdoff = gethms(zp->z_rule, _("unruly zone"),
925 TRUE);
926 /*
927 ** Note, though, that if there's no rule,
928 ** a '%s' in the format is a bad thing.
929 */
930 if (strchr(zp->z_format, '%') != 0)
931 error(_("%s in ruleless zone"));
932 }
933 }
934 if (errors)
935 exit(EXIT_FAILURE);
936 }
937
938 static void
939 infile(name)
940 const char * name;
941 {
942 register FILE * fp;
943 register char ** fields;
944 register char * cp;
945 register const struct lookup * lp;
946 register int nfields;
947 register int wantcont;
948 register int num;
949 char buf[BUFSIZ];
950
951 if (strcmp(name, "-") == 0) {
952 name = _("standard input");
953 fp = stdin;
954 } else if ((fp = fopen(name, "r")) == NULL) {
955 const char *e = strerror(errno);
956
957 (void) fprintf(stderr, _("%s: Can't open %s: %s\n"),
958 progname, name, e);
959 exit(EXIT_FAILURE);
960 }
961 wantcont = FALSE;
962 for (num = 1; ; ++num) {
963 eat(name, num);
964 if (fgets(buf, (int) sizeof buf, fp) != buf)
965 break;
966 cp = strchr(buf, '\n');
967 if (cp == NULL) {
968 error(_("line too long"));
969 exit(EXIT_FAILURE);
970 }
971 *cp = '\0';
972 fields = getfields(buf);
973 nfields = 0;
974 while (fields[nfields] != NULL) {
975 static char nada;
976
977 if (strcmp(fields[nfields], "-") == 0)
978 fields[nfields] = &nada;
979 ++nfields;
980 }
981 if (nfields == 0) {
982 /* nothing to do */
983 } else if (wantcont) {
984 wantcont = inzcont(fields, nfields);
985 } else {
986 lp = byword(fields[0], line_codes);
987 if (lp == NULL)
988 error(_("input line of unknown type"));
989 else switch ((int) (lp->l_value)) {
990 case LC_RULE:
991 inrule(fields, nfields);
992 wantcont = FALSE;
993 break;
994 case LC_ZONE:
995 wantcont = inzone(fields, nfields);
996 break;
997 case LC_LINK:
998 inlink(fields, nfields);
999 wantcont = FALSE;
1000 break;
1001 case LC_LEAP:
1002 if (name != leapsec)
1003 (void) fprintf(stderr,
1004 _("%s: Leap line in non leap seconds file %s\n"),
1005 progname, name);
1006 else inleap(fields, nfields);
1007 wantcont = FALSE;
1008 break;
1009 default: /* "cannot happen" */
1010 (void) fprintf(stderr,
1011 _("%s: panic: Invalid l_value %d\n"),
1012 progname, lp->l_value);
1013 exit(EXIT_FAILURE);
1014 }
1015 }
1016 ifree((char *) fields);
1017 }
1018 if (ferror(fp)) {
1019 (void) fprintf(stderr, _("%s: Error reading %s\n"),
1020 progname, filename);
1021 exit(EXIT_FAILURE);
1022 }
1023 if (fp != stdin && fclose(fp)) {
1024 const char *e = strerror(errno);
1025
1026 (void) fprintf(stderr, _("%s: Error closing %s: %s\n"),
1027 progname, filename, e);
1028 exit(EXIT_FAILURE);
1029 }
1030 if (wantcont)
1031 error(_("expected continuation line not found"));
1032 }
1033
1034 /*
1035 ** Convert a string of one of the forms
1036 ** h -h hh:mm -hh:mm hh:mm:ss -hh:mm:ss
1037 ** into a number of seconds.
1038 ** A null string maps to zero.
1039 ** Call error with errstring and return zero on errors.
1040 */
1041
1042 static long
1043 gethms(string, errstring, signable)
1044 const char * string;
1045 const char * const errstring;
1046 const int signable;
1047 {
1048 long hh;
1049 int mm, ss, sign;
1050
1051 if (string == NULL || *string == '\0')
1052 return 0;
1053 if (!signable)
1054 sign = 1;
1055 else if (*string == '-') {
1056 sign = -1;
1057 ++string;
1058 } else sign = 1;
1059 if (sscanf(string, scheck(string, "%ld"), &hh) == 1)
1060 mm = ss = 0;
1061 else if (sscanf(string, scheck(string, "%ld:%d"), &hh, &mm) == 2)
1062 ss = 0;
1063 else if (sscanf(string, scheck(string, "%ld:%d:%d"),
1064 &hh, &mm, &ss) != 3) {
1065 error(errstring);
1066 return 0;
1067 }
1068 if (hh < 0 ||
1069 mm < 0 || mm >= MINSPERHOUR ||
1070 ss < 0 || ss > SECSPERMIN) {
1071 error(errstring);
1072 return 0;
1073 }
1074 if (LONG_MAX / SECSPERHOUR < hh) {
1075 error(_("time overflow"));
1076 return 0;
1077 }
1078 if (noise && hh == HOURSPERDAY && mm == 0 && ss == 0)
1079 warning(_("24:00 not handled by pre-1998 versions of zic"));
1080 if (noise && (hh > HOURSPERDAY ||
1081 (hh == HOURSPERDAY && (mm != 0 || ss != 0))))
1082 warning(_("values over 24 hours not handled by pre-2007 versions of zic"));
1083 return oadd(eitol(sign) * hh * eitol(SECSPERHOUR),
1084 eitol(sign) * (eitol(mm) * eitol(SECSPERMIN) + eitol(ss)));
1085 }
1086
1087 static void
1088 inrule(fields, nfields)
1089 register char ** const fields;
1090 const int nfields;
1091 {
1092 static struct rule r;
1093
1094 if (nfields != RULE_FIELDS) {
1095 error(_("wrong number of fields on Rule line"));
1096 return;
1097 }
1098 if (*fields[RF_NAME] == '\0') {
1099 error(_("nameless rule"));
1100 return;
1101 }
1102 r.r_filename = filename;
1103 r.r_linenum = linenum;
1104 r.r_stdoff = gethms(fields[RF_STDOFF], _("invalid saved time"), TRUE);
1105 rulesub(&r, fields[RF_LOYEAR], fields[RF_HIYEAR], fields[RF_COMMAND],
1106 fields[RF_MONTH], fields[RF_DAY], fields[RF_TOD]);
1107 r.r_name = ecpyalloc(fields[RF_NAME]);
1108 r.r_abbrvar = ecpyalloc(fields[RF_ABBRVAR]);
1109 if (max_abbrvar_len < strlen(r.r_abbrvar))
1110 max_abbrvar_len = strlen(r.r_abbrvar);
1111 rules = (struct rule *) (void *) erealloc((char *) rules,
1112 (int) ((nrules + 1) * sizeof *rules));
1113 rules[nrules++] = r;
1114 }
1115
1116 static int
1117 inzone(fields, nfields)
1118 register char ** const fields;
1119 const int nfields;
1120 {
1121 register int i;
1122 static char * buf;
1123
1124 if (nfields < ZONE_MINFIELDS || nfields > ZONE_MAXFIELDS) {
1125 error(_("wrong number of fields on Zone line"));
1126 return FALSE;
1127 }
1128 if (strcmp(fields[ZF_NAME], TZDEFAULT) == 0 && lcltime != NULL) {
1129 buf = erealloc(buf, (int) (132 + strlen(TZDEFAULT)));
1130 (void) sprintf(buf,
1131 _("\"Zone %s\" line and -l option are mutually exclusive"),
1132 TZDEFAULT);
1133 error(buf);
1134 return FALSE;
1135 }
1136 if (strcmp(fields[ZF_NAME], TZDEFRULES) == 0 && psxrules != NULL) {
1137 buf = erealloc(buf, (int) (132 + strlen(TZDEFRULES)));
1138 (void) sprintf(buf,
1139 _("\"Zone %s\" line and -p option are mutually exclusive"),
1140 TZDEFRULES);
1141 error(buf);
1142 return FALSE;
1143 }
1144 for (i = 0; i < nzones; ++i)
1145 if (zones[i].z_name != NULL &&
1146 strcmp(zones[i].z_name, fields[ZF_NAME]) == 0) {
1147 buf = erealloc(buf, (int) (132 +
1148 strlen(fields[ZF_NAME]) +
1149 strlen(zones[i].z_filename)));
1150 (void) sprintf(buf,
1151 _("duplicate zone name %s (file \"%s\", line %d)"),
1152 fields[ZF_NAME],
1153 zones[i].z_filename,
1154 zones[i].z_linenum);
1155 error(buf);
1156 return FALSE;
1157 }
1158 return inzsub(fields, nfields, FALSE);
1159 }
1160
1161 static int
1162 inzcont(fields, nfields)
1163 register char ** const fields;
1164 const int nfields;
1165 {
1166 if (nfields < ZONEC_MINFIELDS || nfields > ZONEC_MAXFIELDS) {
1167 error(_("wrong number of fields on Zone continuation line"));
1168 return FALSE;
1169 }
1170 return inzsub(fields, nfields, TRUE);
1171 }
1172
1173 static int
1174 inzsub(fields, nfields, iscont)
1175 register char ** const fields;
1176 const int nfields;
1177 const int iscont;
1178 {
1179 register char * cp;
1180 static struct zone z;
1181 register int i_gmtoff, i_rule, i_format;
1182 register int i_untilyear, i_untilmonth;
1183 register int i_untilday, i_untiltime;
1184 register int hasuntil;
1185
1186 if (iscont) {
1187 i_gmtoff = ZFC_GMTOFF;
1188 i_rule = ZFC_RULE;
1189 i_format = ZFC_FORMAT;
1190 i_untilyear = ZFC_TILYEAR;
1191 i_untilmonth = ZFC_TILMONTH;
1192 i_untilday = ZFC_TILDAY;
1193 i_untiltime = ZFC_TILTIME;
1194 z.z_name = NULL;
1195 } else {
1196 i_gmtoff = ZF_GMTOFF;
1197 i_rule = ZF_RULE;
1198 i_format = ZF_FORMAT;
1199 i_untilyear = ZF_TILYEAR;
1200 i_untilmonth = ZF_TILMONTH;
1201 i_untilday = ZF_TILDAY;
1202 i_untiltime = ZF_TILTIME;
1203 z.z_name = ecpyalloc(fields[ZF_NAME]);
1204 }
1205 z.z_filename = filename;
1206 z.z_linenum = linenum;
1207 z.z_gmtoff = gethms(fields[i_gmtoff], _("invalid UTC offset"), TRUE);
1208 if ((cp = strchr(fields[i_format], '%')) != 0) {
1209 if (*++cp != 's' || strchr(cp, '%') != 0) {
1210 error(_("invalid abbreviation format"));
1211 return FALSE;
1212 }
1213 }
1214 z.z_rule = ecpyalloc(fields[i_rule]);
1215 z.z_format = ecpyalloc(fields[i_format]);
1216 if (max_format_len < strlen(z.z_format))
1217 max_format_len = strlen(z.z_format);
1218 hasuntil = nfields > i_untilyear;
1219 if (hasuntil) {
1220 z.z_untilrule.r_filename = filename;
1221 z.z_untilrule.r_linenum = linenum;
1222 rulesub(&z.z_untilrule,
1223 fields[i_untilyear],
1224 "only",
1225 "",
1226 (nfields > i_untilmonth) ?
1227 fields[i_untilmonth] : "Jan",
1228 (nfields > i_untilday) ? fields[i_untilday] : "1",
1229 (nfields > i_untiltime) ? fields[i_untiltime] : "0");
1230 z.z_untiltime = rpytime(&z.z_untilrule,
1231 z.z_untilrule.r_loyear);
1232 if (iscont && nzones > 0 &&
1233 z.z_untiltime > min_time &&
1234 z.z_untiltime < max_time &&
1235 zones[nzones - 1].z_untiltime > min_time &&
1236 zones[nzones - 1].z_untiltime < max_time &&
1237 zones[nzones - 1].z_untiltime >= z.z_untiltime) {
1238 error(_(
1239 "Zone continuation line end time is not after end time of previous line"
1240 ));
1241 return FALSE;
1242 }
1243 }
1244 zones = (struct zone *) (void *) erealloc((char *) zones,
1245 (int) ((nzones + 1) * sizeof *zones));
1246 zones[nzones++] = z;
1247 /*
1248 ** If there was an UNTIL field on this line,
1249 ** there's more information about the zone on the next line.
1250 */
1251 return hasuntil;
1252 }
1253
1254 static void
1255 inleap(fields, nfields)
1256 register char ** const fields;
1257 const int nfields;
1258 {
1259 register const char * cp;
1260 register const struct lookup * lp;
1261 register int i, j;
1262 int year, month, day;
1263 long dayoff, tod;
1264 zic_t t;
1265
1266 if (nfields != LEAP_FIELDS) {
1267 error(_("wrong number of fields on Leap line"));
1268 return;
1269 }
1270 dayoff = 0;
1271 cp = fields[LP_YEAR];
1272 if (sscanf(cp, scheck(cp, "%d"), &year) != 1) {
1273 /*
1274 ** Leapin' Lizards!
1275 */
1276 error(_("invalid leaping year"));
1277 return;
1278 }
1279 if (!leapseen || leapmaxyear < year)
1280 leapmaxyear = year;
1281 if (!leapseen || leapminyear > year)
1282 leapminyear = year;
1283 leapseen = TRUE;
1284 j = EPOCH_YEAR;
1285 while (j != year) {
1286 if (year > j) {
1287 i = len_years[isleap(j)];
1288 ++j;
1289 } else {
1290 --j;
1291 i = -len_years[isleap(j)];
1292 }
1293 dayoff = oadd(dayoff, eitol(i));
1294 }
1295 if ((lp = byword(fields[LP_MONTH], mon_names)) == NULL) {
1296 error(_("invalid month name"));
1297 return;
1298 }
1299 month = lp->l_value;
1300 j = TM_JANUARY;
1301 while (j != month) {
1302 i = len_months[isleap(year)][j];
1303 dayoff = oadd(dayoff, eitol(i));
1304 ++j;
1305 }
1306 cp = fields[LP_DAY];
1307 if (sscanf(cp, scheck(cp, "%d"), &day) != 1 ||
1308 day <= 0 || day > len_months[isleap(year)][month]) {
1309 error(_("invalid day of month"));
1310 return;
1311 }
1312 dayoff = oadd(dayoff, eitol(day - 1));
1313 if (dayoff < 0 && !TYPE_SIGNED(zic_t)) {
1314 error(_("time before zero"));
1315 return;
1316 }
1317 if (dayoff < min_time / SECSPERDAY) {
1318 error(_("time too small"));
1319 return;
1320 }
1321 if (dayoff > max_time / SECSPERDAY) {
1322 error(_("time too large"));
1323 return;
1324 }
1325 t = (zic_t) dayoff * SECSPERDAY;
1326 tod = gethms(fields[LP_TIME], _("invalid time of day"), FALSE);
1327 cp = fields[LP_CORR];
1328 {
1329 register int positive;
1330 int count;
1331
1332 if (strcmp(cp, "") == 0) { /* infile() turns "-" into "" */
1333 positive = FALSE;
1334 count = 1;
1335 } else if (strcmp(cp, "--") == 0) {
1336 positive = FALSE;
1337 count = 2;
1338 } else if (strcmp(cp, "+") == 0) {
1339 positive = TRUE;
1340 count = 1;
1341 } else if (strcmp(cp, "++") == 0) {
1342 positive = TRUE;
1343 count = 2;
1344 } else {
1345 error(_("illegal CORRECTION field on Leap line"));
1346 return;
1347 }
1348 if ((lp = byword(fields[LP_ROLL], leap_types)) == NULL) {
1349 error(_(
1350 "illegal Rolling/Stationary field on Leap line"
1351 ));
1352 return;
1353 }
1354 leapadd(tadd(t, tod), positive, lp->l_value, count);
1355 }
1356 }
1357
1358 static void
1359 inlink(fields, nfields)
1360 register char ** const fields;
1361 const int nfields;
1362 {
1363 struct link l;
1364
1365 if (nfields != LINK_FIELDS) {
1366 error(_("wrong number of fields on Link line"));
1367 return;
1368 }
1369 if (*fields[LF_FROM] == '\0') {
1370 error(_("blank FROM field on Link line"));
1371 return;
1372 }
1373 if (*fields[LF_TO] == '\0') {
1374 error(_("blank TO field on Link line"));
1375 return;
1376 }
1377 l.l_filename = filename;
1378 l.l_linenum = linenum;
1379 l.l_from = ecpyalloc(fields[LF_FROM]);
1380 l.l_to = ecpyalloc(fields[LF_TO]);
1381 links = (struct link *) (void *) erealloc((char *) links,
1382 (int) ((nlinks + 1) * sizeof *links));
1383 links[nlinks++] = l;
1384 }
1385
1386 static void
1387 rulesub(rp, loyearp, hiyearp, typep, monthp, dayp, timep)
1388 register struct rule * const rp;
1389 const char * const loyearp;
1390 const char * const hiyearp;
1391 const char * const typep;
1392 const char * const monthp;
1393 const char * const dayp;
1394 const char * const timep;
1395 {
1396 register const struct lookup * lp;
1397 register const char * cp;
1398 register char * dp;
1399 register char * ep;
1400
1401 if ((lp = byword(monthp, mon_names)) == NULL) {
1402 error(_("invalid month name"));
1403 return;
1404 }
1405 rp->r_month = lp->l_value;
1406 rp->r_todisstd = FALSE;
1407 rp->r_todisgmt = FALSE;
1408 dp = ecpyalloc(timep);
1409 if (*dp != '\0') {
1410 ep = dp + strlen(dp) - 1;
1411 switch (lowerit(*ep)) {
1412 case 's': /* Standard */
1413 rp->r_todisstd = TRUE;
1414 rp->r_todisgmt = FALSE;
1415 *ep = '\0';
1416 break;
1417 case 'w': /* Wall */
1418 rp->r_todisstd = FALSE;
1419 rp->r_todisgmt = FALSE;
1420 *ep = '\0';
1421 break;
1422 case 'g': /* Greenwich */
1423 case 'u': /* Universal */
1424 case 'z': /* Zulu */
1425 rp->r_todisstd = TRUE;
1426 rp->r_todisgmt = TRUE;
1427 *ep = '\0';
1428 break;
1429 }
1430 }
1431 rp->r_tod = gethms(dp, _("invalid time of day"), FALSE);
1432 ifree(dp);
1433 /*
1434 ** Year work.
1435 */
1436 cp = loyearp;
1437 lp = byword(cp, begin_years);
1438 rp->r_lowasnum = lp == NULL;
1439 if (!rp->r_lowasnum) switch ((int) lp->l_value) {
1440 case YR_MINIMUM:
1441 rp->r_loyear = INT_MIN;
1442 break;
1443 case YR_MAXIMUM:
1444 rp->r_loyear = INT_MAX;
1445 break;
1446 default: /* "cannot happen" */
1447 (void) fprintf(stderr,
1448 _("%s: panic: Invalid l_value %d\n"),
1449 progname, lp->l_value);
1450 exit(EXIT_FAILURE);
1451 } else if (sscanf(cp, scheck(cp, "%d"), &rp->r_loyear) != 1) {
1452 error(_("invalid starting year"));
1453 return;
1454 }
1455 cp = hiyearp;
1456 lp = byword(cp, end_years);
1457 rp->r_hiwasnum = lp == NULL;
1458 if (!rp->r_hiwasnum) switch ((int) lp->l_value) {
1459 case YR_MINIMUM:
1460 rp->r_hiyear = INT_MIN;
1461 break;
1462 case YR_MAXIMUM:
1463 rp->r_hiyear = INT_MAX;
1464 break;
1465 case YR_ONLY:
1466 rp->r_hiyear = rp->r_loyear;
1467 break;
1468 default: /* "cannot happen" */
1469 (void) fprintf(stderr,
1470 _("%s: panic: Invalid l_value %d\n"),
1471 progname, lp->l_value);
1472 exit(EXIT_FAILURE);
1473 } else if (sscanf(cp, scheck(cp, "%d"), &rp->r_hiyear) != 1) {
1474 error(_("invalid ending year"));
1475 return;
1476 }
1477 if (rp->r_loyear > rp->r_hiyear) {
1478 error(_("starting year greater than ending year"));
1479 return;
1480 }
1481 if (*typep == '\0')
1482 rp->r_yrtype = NULL;
1483 else {
1484 if (rp->r_loyear == rp->r_hiyear) {
1485 error(_("typed single year"));
1486 return;
1487 }
1488 rp->r_yrtype = ecpyalloc(typep);
1489 }
1490 /*
1491 ** Day work.
1492 ** Accept things such as:
1493 ** 1
1494 ** last-Sunday
1495 ** Sun<=20
1496 ** Sun>=7
1497 */
1498 dp = ecpyalloc(dayp);
1499 if ((lp = byword(dp, lasts)) != NULL) {
1500 rp->r_dycode = DC_DOWLEQ;
1501 rp->r_wday = lp->l_value;
1502 rp->r_dayofmonth = len_months[1][rp->r_month];
1503 } else {
1504 if ((ep = strchr(dp, '<')) != 0)
1505 rp->r_dycode = DC_DOWLEQ;
1506 else if ((ep = strchr(dp, '>')) != 0)
1507 rp->r_dycode = DC_DOWGEQ;
1508 else {
1509 ep = dp;
1510 rp->r_dycode = DC_DOM;
1511 }
1512 if (rp->r_dycode != DC_DOM) {
1513 *ep++ = 0;
1514 if (*ep++ != '=') {
1515 error(_("invalid day of month"));
1516 ifree(dp);
1517 return;
1518 }
1519 if ((lp = byword(dp, wday_names)) == NULL) {
1520 error(_("invalid weekday name"));
1521 ifree(dp);
1522 return;
1523 }
1524 rp->r_wday = lp->l_value;
1525 }
1526 if (sscanf(ep, scheck(ep, "%d"), &rp->r_dayofmonth) != 1 ||
1527 rp->r_dayofmonth <= 0 ||
1528 (rp->r_dayofmonth > len_months[1][rp->r_month])) {
1529 error(_("invalid day of month"));
1530 ifree(dp);
1531 return;
1532 }
1533 }
1534 ifree(dp);
1535 }
1536
1537 static void
1538 convert(val, buf)
1539 const long val;
1540 char * const buf;
1541 {
1542 register int i;
1543 register int shift;
1544
1545 for (i = 0, shift = 24; i < 4; ++i, shift -= 8)
1546 buf[i] = val >> shift;
1547 }
1548
1549 static void
1550 convert64(val, buf)
1551 const zic_t val;
1552 char * const buf;
1553 {
1554 register int i;
1555 register int shift;
1556
1557 for (i = 0, shift = 56; i < 8; ++i, shift -= 8)
1558 buf[i] = val >> shift;
1559 }
1560
1561 static void
1562 puttzcode(val, fp)
1563 const long val;
1564 FILE * const fp;
1565 {
1566 char buf[4];
1567
1568 convert(val, buf);
1569 (void) fwrite((void *) buf, (size_t) sizeof buf, (size_t) 1, fp);
1570 }
1571
1572 static void
1573 puttzcode64(val, fp)
1574 const zic_t val;
1575 FILE * const fp;
1576 {
1577 char buf[8];
1578
1579 convert64(val, buf);
1580 (void) fwrite((void *) buf, (size_t) sizeof buf, (size_t) 1, fp);
1581 }
1582
1583 static int
1584 atcomp(avp, bvp)
1585 const void * avp;
1586 const void * bvp;
1587 {
1588 const zic_t a = ((const struct attype *) avp)->at;
1589 const zic_t b = ((const struct attype *) bvp)->at;
1590
1591 return (a < b) ? -1 : (a > b);
1592 }
1593
1594 static int
1595 is32(x)
1596 const zic_t x;
1597 {
1598 return INT32_MIN <= x && x <= INT32_MAX;
1599 }
1600
1601 static void
1602 writezone(name, string)
1603 const char * const name;
1604 const char * const string;
1605 {
1606 register FILE * fp;
1607 register int i, j;
1608 register int leapcnt32, leapi32;
1609 register int timecnt32, timei32;
1610 register int pass;
1611 static char * fullname;
1612 static const struct tzhead tzh0;
1613 static struct tzhead tzh;
1614 zic_t ats[TZ_MAX_TIMES];
1615 unsigned char types[TZ_MAX_TIMES];
1616
1617 /*
1618 ** Sort.
1619 */
1620 if (timecnt > 1)
1621 (void) qsort((void *) attypes, (size_t) timecnt,
1622 (size_t) sizeof *attypes, atcomp);
1623 /*
1624 ** Optimize.
1625 */
1626 {
1627 int fromi;
1628 int toi;
1629
1630 toi = 0;
1631 fromi = 0;
1632 while (fromi < timecnt && attypes[fromi].at < min_time)
1633 ++fromi;
1634 if (isdsts[0] == 0)
1635 while (fromi < timecnt && attypes[fromi].type == 0)
1636 ++fromi; /* handled by default rule */
1637 for ( ; fromi < timecnt; ++fromi) {
1638 if (toi != 0 && ((attypes[fromi].at +
1639 gmtoffs[attypes[toi - 1].type]) <=
1640 (attypes[toi - 1].at + gmtoffs[toi == 1 ? 0
1641 : attypes[toi - 2].type]))) {
1642 attypes[toi - 1].type =
1643 attypes[fromi].type;
1644 continue;
1645 }
1646 if (toi == 0 ||
1647 attypes[toi - 1].type != attypes[fromi].type)
1648 attypes[toi++] = attypes[fromi];
1649 }
1650 timecnt = toi;
1651 }
1652 /*
1653 ** Transfer.
1654 */
1655 for (i = 0; i < timecnt; ++i) {
1656 ats[i] = attypes[i].at;
1657 types[i] = attypes[i].type;
1658 }
1659 /*
1660 ** Correct for leap seconds.
1661 */
1662 for (i = 0; i < timecnt; ++i) {
1663 j = leapcnt;
1664 while (--j >= 0)
1665 if (ats[i] > trans[j] - corr[j]) {
1666 ats[i] = tadd(ats[i], corr[j]);
1667 break;
1668 }
1669 }
1670 /*
1671 ** Figure out 32-bit-limited starts and counts.
1672 */
1673 timecnt32 = timecnt;
1674 timei32 = 0;
1675 leapcnt32 = leapcnt;
1676 leapi32 = 0;
1677 while (timecnt32 > 0 && !is32(ats[timecnt32 - 1]))
1678 --timecnt32;
1679 while (timecnt32 > 0 && !is32(ats[timei32])) {
1680 --timecnt32;
1681 ++timei32;
1682 }
1683 while (leapcnt32 > 0 && !is32(trans[leapcnt32 - 1]))
1684 --leapcnt32;
1685 while (leapcnt32 > 0 && !is32(trans[leapi32])) {
1686 --leapcnt32;
1687 ++leapi32;
1688 }
1689 fullname = erealloc(fullname,
1690 (int) (strlen(directory) + 1 + strlen(name) + 1));
1691 (void) sprintf(fullname, "%s/%s", directory, name);
1692 /*
1693 ** Remove old file, if any, to snap links.
1694 */
1695 if (!itsdir(fullname) && remove(fullname) != 0 && errno != ENOENT) {
1696 const char *e = strerror(errno);
1697
1698 (void) fprintf(stderr, _("%s: Can't remove %s: %s\n"),
1699 progname, fullname, e);
1700 exit(EXIT_FAILURE);
1701 }
1702 if ((fp = fopen(fullname, "wb")) == NULL) {
1703 if (mkdirs(fullname) != 0)
1704 exit(EXIT_FAILURE);
1705 if ((fp = fopen(fullname, "wb")) == NULL) {
1706 const char *e = strerror(errno);
1707
1708 (void) fprintf(stderr, _("%s: Can't create %s: %s\n"),
1709 progname, fullname, e);
1710 exit(EXIT_FAILURE);
1711 }
1712 }
1713 for (pass = 1; pass <= 2; ++pass) {
1714 register int thistimei, thistimecnt;
1715 register int thisleapi, thisleapcnt;
1716 register int thistimelim, thisleaplim;
1717 int writetype[TZ_MAX_TIMES];
1718 int typemap[TZ_MAX_TYPES];
1719 register int thistypecnt;
1720 char thischars[TZ_MAX_CHARS];
1721 char thischarcnt;
1722 int indmap[TZ_MAX_CHARS];
1723
1724 if (pass == 1) {
1725 thistimei = timei32;
1726 thistimecnt = timecnt32;
1727 thisleapi = leapi32;
1728 thisleapcnt = leapcnt32;
1729 } else {
1730 thistimei = 0;
1731 thistimecnt = timecnt;
1732 thisleapi = 0;
1733 thisleapcnt = leapcnt;
1734 }
1735 thistimelim = thistimei + thistimecnt;
1736 thisleaplim = thisleapi + thisleapcnt;
1737 for (i = 0; i < typecnt; ++i)
1738 writetype[i] = thistimecnt == timecnt;
1739 if (thistimecnt == 0) {
1740 /*
1741 ** No transition times fall in the current
1742 ** (32- or 64-bit) window.
1743 */
1744 if (typecnt != 0)
1745 writetype[typecnt - 1] = TRUE;
1746 } else {
1747 for (i = thistimei - 1; i < thistimelim; ++i)
1748 if (i >= 0)
1749 writetype[types[i]] = TRUE;
1750 /*
1751 ** For America/Godthab and Antarctica/Palmer
1752 */
1753 if (thistimei == 0)
1754 writetype[0] = TRUE;
1755 }
1756 thistypecnt = 0;
1757 for (i = 0; i < typecnt; ++i)
1758 typemap[i] = writetype[i] ? thistypecnt++ : -1;
1759 for (i = 0; i < sizeof indmap / sizeof indmap[0]; ++i)
1760 indmap[i] = -1;
1761 thischarcnt = 0;
1762 for (i = 0; i < typecnt; ++i) {
1763 register char * thisabbr;
1764
1765 if (!writetype[i])
1766 continue;
1767 if (indmap[abbrinds[i]] >= 0)
1768 continue;
1769 thisabbr = &chars[abbrinds[i]];
1770 for (j = 0; j < thischarcnt; ++j)
1771 if (strcmp(&thischars[j], thisabbr) == 0)
1772 break;
1773 if (j == thischarcnt) {
1774 (void) strcpy(&thischars[(int) thischarcnt],
1775 thisabbr);
1776 thischarcnt += strlen(thisabbr) + 1;
1777 }
1778 indmap[abbrinds[i]] = j;
1779 }
1780 #define DO(field) (void) fwrite((void *) tzh.field, \
1781 (size_t) sizeof tzh.field, (size_t) 1, fp)
1782 tzh = tzh0;
1783 #ifdef ICU
1784 * (ICUZoneinfoVersion*) &tzh.tzh_reserved = TZ_ICU_VERSION;
1785 (void) strncpy(tzh.tzh_magic, TZ_ICU_MAGIC, sizeof tzh.tzh_magic);
1786 #else
1787 (void) strncpy(tzh.tzh_magic, TZ_MAGIC, sizeof tzh.tzh_magic);
1788 #endif
1789 tzh.tzh_version[0] = ZIC_VERSION;
1790 convert(eitol(thistypecnt), tzh.tzh_ttisgmtcnt);
1791 convert(eitol(thistypecnt), tzh.tzh_ttisstdcnt);
1792 convert(eitol(thisleapcnt), tzh.tzh_leapcnt);
1793 convert(eitol(thistimecnt), tzh.tzh_timecnt);
1794 convert(eitol(thistypecnt), tzh.tzh_typecnt);
1795 convert(eitol(thischarcnt), tzh.tzh_charcnt);
1796 DO(tzh_magic);
1797 DO(tzh_version);
1798 DO(tzh_reserved);
1799 DO(tzh_ttisgmtcnt);
1800 DO(tzh_ttisstdcnt);
1801 DO(tzh_leapcnt);
1802 DO(tzh_timecnt);
1803 DO(tzh_typecnt);
1804 DO(tzh_charcnt);
1805 #undef DO
1806 for (i = thistimei; i < thistimelim; ++i)
1807 if (pass == 1)
1808 puttzcode((long) ats[i], fp);
1809 else puttzcode64(ats[i], fp);
1810 for (i = thistimei; i < thistimelim; ++i) {
1811 unsigned char uc;
1812
1813 uc = typemap[types[i]];
1814 (void) fwrite((void *) &uc,
1815 (size_t) sizeof uc,
1816 (size_t) 1,
1817 fp);
1818 }
1819 for (i = 0; i < typecnt; ++i)
1820 if (writetype[i]) {
1821 #ifdef ICU
1822 puttzcode((long) rawoffs[i], fp);
1823 puttzcode((long) dstoffs[i], fp);
1824 #else
1825 puttzcode(gmtoffs[i], fp);
1826 #endif
1827 (void) putc(isdsts[i], fp);
1828 (void) putc((unsigned char) indmap[abbrinds[i]], fp);
1829 }
1830 if (thischarcnt != 0)
1831 (void) fwrite((void *) thischars,
1832 (size_t) sizeof thischars[0],
1833 (size_t) thischarcnt, fp);
1834 for (i = thisleapi; i < thisleaplim; ++i) {
1835 register zic_t todo;
1836
1837 if (roll[i]) {
1838 if (timecnt == 0 || trans[i] < ats[0]) {
1839 j = 0;
1840 while (isdsts[j])
1841 if (++j >= typecnt) {
1842 j = 0;
1843 break;
1844 }
1845 } else {
1846 j = 1;
1847 while (j < timecnt &&
1848 trans[i] >= ats[j])
1849 ++j;
1850 j = types[j - 1];
1851 }
1852 todo = tadd(trans[i], -gmtoffs[j]);
1853 } else todo = trans[i];
1854 if (pass == 1)
1855 puttzcode((long) todo, fp);
1856 else puttzcode64(todo, fp);
1857 puttzcode(corr[i], fp);
1858 }
1859 for (i = 0; i < typecnt; ++i)
1860 if (writetype[i])
1861 (void) putc(ttisstds[i], fp);
1862 for (i = 0; i < typecnt; ++i)
1863 if (writetype[i])
1864 (void) putc(ttisgmts[i], fp);
1865 }
1866 (void) fprintf(fp, "\n%s\n", string);
1867 if (ferror(fp) || fclose(fp)) {
1868 (void) fprintf(stderr, _("%s: Error writing %s\n"),
1869 progname, fullname);
1870 exit(EXIT_FAILURE);
1871 }
1872 }
1873
1874 static void
1875 doabbr(abbr, format, letters, isdst, doquotes)
1876 char * const abbr;
1877 const char * const format;
1878 const char * const letters;
1879 const int isdst;
1880 const int doquotes;
1881 {
1882 register char * cp;
1883 register char * slashp;
1884 register int len;
1885
1886 slashp = strchr(format, '/');
1887 if (slashp == NULL) {
1888 if (letters == NULL)
1889 (void) strcpy(abbr, format);
1890 else (void) sprintf(abbr, format, letters);
1891 } else if (isdst) {
1892 (void) strcpy(abbr, slashp + 1);
1893 } else {
1894 if (slashp > format)
1895 (void) strncpy(abbr, format,
1896 (unsigned) (slashp - format));
1897 abbr[slashp - format] = '\0';
1898 }
1899 if (!doquotes)
1900 return;
1901 for (cp = abbr; *cp != '\0'; ++cp)
1902 if (strchr("ABCDEFGHIJKLMNOPQRSTUVWXYZ", *cp) == NULL &&
1903 strchr("abcdefghijklmnopqrstuvwxyz", *cp) == NULL)
1904 break;
1905 len = strlen(abbr);
1906 if (len > 0 && *cp == '\0')
1907 return;
1908 abbr[len + 2] = '\0';
1909 abbr[len + 1] = '>';
1910 for ( ; len > 0; --len)
1911 abbr[len] = abbr[len - 1];
1912 abbr[0] = '<';
1913 }
1914
1915 static void
1916 updateminmax(x)
1917 const int x;
1918 {
1919 if (min_year > x)
1920 min_year = x;
1921 if (max_year < x)
1922 max_year = x;
1923 }
1924
1925 static int
1926 stringoffset(result, offset)
1927 char * result;
1928 long offset;
1929 {
1930 register int hours;
1931 register int minutes;
1932 register int seconds;
1933
1934 result[0] = '\0';
1935 if (offset < 0) {
1936 (void) strcpy(result, "-");
1937 offset = -offset;
1938 }
1939 seconds = offset % SECSPERMIN;
1940 offset /= SECSPERMIN;
1941 minutes = offset % MINSPERHOUR;
1942 offset /= MINSPERHOUR;
1943 hours = offset;
1944 if (hours >= HOURSPERDAY) {
1945 result[0] = '\0';
1946 return -1;
1947 }
1948 (void) sprintf(end(result), "%d", hours);
1949 if (minutes != 0 || seconds != 0) {
1950 (void) sprintf(end(result), ":%02d", minutes);
1951 if (seconds != 0)
1952 (void) sprintf(end(result), ":%02d", seconds);
1953 }
1954 return 0;
1955 }
1956
1957 static int
1958 stringrule(result, rp, dstoff, gmtoff)
1959 char * result;
1960 const struct rule * const rp;
1961 const long dstoff;
1962 const long gmtoff;
1963 {
1964 register long tod;
1965
1966 result = end(result);
1967 if (rp->r_dycode == DC_DOM) {
1968 register int month, total;
1969
1970 if (rp->r_dayofmonth == 29 && rp->r_month == TM_FEBRUARY)
1971 return -1;
1972 total = 0;
1973 for (month = 0; month < rp->r_month; ++month)
1974 total += len_months[0][month];
1975 (void) sprintf(result, "J%d", total + rp->r_dayofmonth);
1976 } else {
1977 register int week;
1978
1979 if (rp->r_dycode == DC_DOWGEQ) {
1980 week = 1 + rp->r_dayofmonth / DAYSPERWEEK;
1981 if ((week - 1) * DAYSPERWEEK + 1 != rp->r_dayofmonth)
1982 return -1;
1983 } else if (rp->r_dycode == DC_DOWLEQ) {
1984 if (rp->r_dayofmonth == len_months[1][rp->r_month])
1985 week = 5;
1986 else {
1987 week = 1 + rp->r_dayofmonth / DAYSPERWEEK;
1988 if (week * DAYSPERWEEK - 1 != rp->r_dayofmonth)
1989 return -1;
1990 }
1991 } else return -1; /* "cannot happen" */
1992 (void) sprintf(result, "M%d.%d.%d",
1993 rp->r_month + 1, week, rp->r_wday);
1994 }
1995 tod = rp->r_tod;
1996 if (rp->r_todisgmt)
1997 tod += gmtoff;
1998 if (rp->r_todisstd && rp->r_stdoff == 0)
1999 tod += dstoff;
2000 if (tod < 0) {
2001 result[0] = '\0';
2002 return -1;
2003 }
2004 if (tod != 2 * SECSPERMIN * MINSPERHOUR) {
2005 (void) strcat(result, "/");
2006 if (stringoffset(end(result), tod) != 0)
2007 return -1;
2008 }
2009 return 0;
2010 }
2011
2012 static void
2013 stringzone(result, zpfirst, zonecount)
2014 char * result;
2015 const struct zone * const zpfirst;
2016 const int zonecount;
2017 {
2018 register const struct zone * zp;
2019 register struct rule * rp;
2020 register struct rule * stdrp;
2021 register struct rule * dstrp;
2022 register int i;
2023 register const char * abbrvar;
2024
2025 result[0] = '\0';
2026 zp = zpfirst + zonecount - 1;
2027 stdrp = dstrp = NULL;
2028 for (i = 0; i < zp->z_nrules; ++i) {
2029 rp = &zp->z_rules[i];
2030 if (rp->r_hiwasnum || rp->r_hiyear != INT_MAX)
2031 continue;
2032 if (rp->r_yrtype != NULL)
2033 continue;
2034 if (rp->r_stdoff == 0) {
2035 if (stdrp == NULL)
2036 stdrp = rp;
2037 else return;
2038 } else {
2039 if (dstrp == NULL)
2040 dstrp = rp;
2041 else return;
2042 }
2043 }
2044 if (stdrp == NULL && dstrp == NULL) {
2045 /*
2046 ** There are no rules running through "max".
2047 ** Let's find the latest rule.
2048 */
2049 for (i = 0; i < zp->z_nrules; ++i) {
2050 rp = &zp->z_rules[i];
2051 if (stdrp == NULL || rp->r_hiyear > stdrp->r_hiyear ||
2052 (rp->r_hiyear == stdrp->r_hiyear &&
2053 rp->r_month > stdrp->r_month))
2054 stdrp = rp;
2055 }
2056 if (stdrp != NULL && stdrp->r_stdoff != 0)
2057 return; /* We end up in DST (a POSIX no-no). */
2058 /*
2059 ** Horrid special case: if year is 2037,
2060 ** presume this is a zone handled on a year-by-year basis;
2061 ** do not try to apply a rule to the zone.
2062 */
2063 if (stdrp != NULL && stdrp->r_hiyear == 2037)
2064 return;
2065 }
2066 if (stdrp == NULL && zp->z_nrules != 0)
2067 return;
2068 abbrvar = (stdrp == NULL) ? "" : stdrp->r_abbrvar;
2069 doabbr(result, zp->z_format, abbrvar, FALSE, TRUE);
2070 if (stringoffset(end(result), -zp->z_gmtoff) != 0) {
2071 result[0] = '\0';
2072 return;
2073 }
2074 if (dstrp == NULL)
2075 return;
2076 doabbr(end(result), zp->z_format, dstrp->r_abbrvar, TRUE, TRUE);
2077 if (dstrp->r_stdoff != SECSPERMIN * MINSPERHOUR)
2078 if (stringoffset(end(result),
2079 -(zp->z_gmtoff + dstrp->r_stdoff)) != 0) {
2080 result[0] = '\0';
2081 return;
2082 }
2083 (void) strcat(result, ",");
2084 if (stringrule(result, dstrp, dstrp->r_stdoff, zp->z_gmtoff) != 0) {
2085 result[0] = '\0';
2086 return;
2087 }
2088 (void) strcat(result, ",");
2089 if (stringrule(result, stdrp, dstrp->r_stdoff, zp->z_gmtoff) != 0) {
2090 result[0] = '\0';
2091 return;
2092 }
2093 }
2094
2095 static void
2096 outzone(zpfirst, zonecount)
2097 const struct zone * const zpfirst;
2098 const int zonecount;
2099 {
2100 register const struct zone * zp;
2101 register struct rule * rp;
2102 register int i, j;
2103 register int usestart, useuntil;
2104 register zic_t starttime, untiltime;
2105 register long gmtoff;
2106 register long stdoff;
2107 register int year;
2108 register long startoff;
2109 register int startttisstd;
2110 register int startttisgmt;
2111 register int type;
2112 register char * startbuf;
2113 register char * ab;
2114 register char * envvar;
2115 register int max_abbr_len;
2116 register int max_envvar_len;
2117 #ifdef ICU
2118 int finalRuleYear, finalRuleIndex;
2119 const struct rule* finalRule1;
2120 const struct rule* finalRule2;
2121 #endif
2122
2123 max_abbr_len = 2 + max_format_len + max_abbrvar_len;
2124 max_envvar_len = 2 * max_abbr_len + 5 * 9;
2125 startbuf = emalloc(max_abbr_len + 1);
2126 ab = emalloc(max_abbr_len + 1);
2127 envvar = emalloc(max_envvar_len + 1);
2128 INITIALIZE(untiltime);
2129 INITIALIZE(starttime);
2130 /*
2131 ** Now. . .finally. . .generate some useful data!
2132 */
2133 timecnt = 0;
2134 typecnt = 0;
2135 charcnt = 0;
2136 /*
2137 ** Thanks to Earl Chew
2138 ** for noting the need to unconditionally initialize startttisstd.
2139 */
2140 startttisstd = FALSE;
2141 startttisgmt = FALSE;
2142 min_year = max_year = EPOCH_YEAR;
2143 if (leapseen) {
2144 updateminmax(leapminyear);
2145 updateminmax(leapmaxyear);
2146 }
2147 for (i = 0; i < zonecount; ++i) {
2148 zp = &zpfirst[i];
2149 if (i < zonecount - 1)
2150 updateminmax(zp->z_untilrule.r_loyear);
2151 for (j = 0; j < zp->z_nrules; ++j) {
2152 rp = &zp->z_rules[j];
2153 if (rp->r_lowasnum)
2154 updateminmax(rp->r_loyear);
2155 if (rp->r_hiwasnum)
2156 updateminmax(rp->r_hiyear);
2157 }
2158 }
2159 /*
2160 ** Generate lots of data if a rule can't cover all future times.
2161 */
2162 stringzone(envvar, zpfirst, zonecount);
2163 if (noise && envvar[0] == '\0') {
2164 register char * wp;
2165
2166 wp = ecpyalloc(_("no POSIX environment variable for zone"));
2167 wp = ecatalloc(wp, " ");
2168 wp = ecatalloc(wp, zpfirst->z_name);
2169 warning(wp);
2170 ifree(wp);
2171 }
2172 if (envvar[0] == '\0') {
2173 if (min_year >= INT_MIN + YEARSPERREPEAT)
2174 min_year -= YEARSPERREPEAT;
2175 else min_year = INT_MIN;
2176 if (max_year <= INT_MAX - YEARSPERREPEAT)
2177 max_year += YEARSPERREPEAT;
2178 else max_year = INT_MAX;
2179 }
2180 /*
2181 ** For the benefit of older systems,
2182 ** generate data from 1900 through 2037.
2183 */
2184 if (min_year > 1900)
2185 min_year = 1900;
2186 if (max_year < 2037)
2187 max_year = 2037;
2188 for (i = 0; i < zonecount; ++i) {
2189 /*
2190 ** A guess that may well be corrected later.
2191 */
2192 stdoff = 0;
2193 zp = &zpfirst[i];
2194 usestart = i > 0 && (zp - 1)->z_untiltime > min_time;
2195 useuntil = i < (zonecount - 1);
2196 if (useuntil && zp->z_untiltime <= min_time)
2197 continue;
2198 gmtoff = zp->z_gmtoff;
2199 eat(zp->z_filename, zp->z_linenum);
2200 *startbuf = '\0';
2201 startoff = zp->z_gmtoff;
2202 #ifdef ICU
2203 finalRuleYear = finalRuleIndex = -1;
2204 finalRule1 = finalRule2 = NULL;
2205 if (i == (zonecount - 1)) { /* !useuntil */
2206 /* Look for exactly 2 rules that end at 'max' and
2207 * note them. Determine max(r_loyear) for the 2 of
2208 * them. */
2209 for (j=0; j<zp->z_nrules; ++j) {
2210 rp = &zp->z_rules[j];
2211 if (rp->r_hiyear == INT_MAX) {
2212 if (rp->r_loyear > finalRuleYear) {
2213 finalRuleYear = rp->r_loyear;
2214 }
2215 if (finalRule1 == NULL) {
2216 finalRule1 = rp;
2217 } else if (finalRule2 == NULL) {
2218 finalRule2 = rp;
2219 } else {
2220 error("more than two max rules found (ICU)");
2221 exit(EXIT_FAILURE);
2222 }
2223 } else if (rp->r_hiyear >= finalRuleYear) {
2224 /* There might be an overriding non-max rule
2225 * to be applied to a specific year after one of
2226 * max rule's start year. For example,
2227 *
2228 * Rule Foo 2010 max ...
2229 * Rule Foo 2015 only ...
2230 *
2231 * In this case, we need to change the start year of
2232 * the final (max) rules to the next year. */
2233 finalRuleYear = rp->r_hiyear + 1;
2234
2235 /* When above adjustment is done, max_year might need
2236 * to be adjusted, so the final rule will be properly
2237 * evaluated and emitted by the later code block.
2238 *
2239 * Note: This may push the start year of the final
2240 * rules ahead by 1 year unnecessarily. For example,
2241 * If there are two rules, non-max rule and max rule
2242 * starting in the same year, such as
2243 *
2244 * Rule Foo 2010 only ....
2245 * Rule Foo 2010 max ....
2246 *
2247 * In this case, the final (max) rule actually starts
2248 * in 2010, instead of 2010. We could make this tool
2249 * more intelligent to detect such situation. But pushing
2250 * final rule start year to 1 year ahead (in the worst case)
2251 * will just populate a few extra transitions, and it still
2252 * works fine. So for now, we're not trying to put additional
2253 * logic to optimize the case.
2254 */
2255 if (max_year < finalRuleYear) {
2256 max_year = finalRuleYear;
2257 }
2258 }
2259 }
2260 if (finalRule1 != NULL) {
2261 if (finalRule2 == NULL) {
2262 warning("only one max rule found (ICU)");
2263 finalRuleYear = finalRuleIndex = -1;
2264 finalRule1 = NULL;
2265 } else {
2266 if (finalRule1->r_stdoff == finalRule2->r_stdoff) {
2267 /* America/Resolute in 2009a uses a pair of rules
2268 * which does not change the offset. ICU ignores
2269 * such rules without actual time transitions. */
2270 finalRuleYear = finalRuleIndex = -1;
2271 finalRule1 = finalRule2 = NULL;
2272 } else {
2273 /* Swap if necessary so finalRule1 occurs before
2274 * finalRule2 */
2275 if (finalRule1->r_month > finalRule2->r_month) {
2276 const struct rule* t = finalRule1;
2277 finalRule1 = finalRule2;
2278 finalRule2 = t;
2279 }
2280 /* Add final rule to our list */
2281 finalRuleIndex = add_icu_final_rules(finalRule1, finalRule2);
2282 }
2283 }
2284 }
2285 }
2286 #endif
2287
2288 if (zp->z_nrules == 0) {
2289 stdoff = zp->z_stdoff;
2290 doabbr(startbuf, zp->z_format,
2291 (char *) NULL, stdoff != 0, FALSE);
2292 type = addtype(oadd(zp->z_gmtoff, stdoff),
2293 #ifdef ICU
2294 zp->z_gmtoff, stdoff,
2295 #endif
2296 startbuf, stdoff != 0, startttisstd,
2297 startttisgmt);
2298 if (usestart) {
2299 addtt(starttime, type);
2300 usestart = FALSE;
2301 } else if (stdoff != 0)
2302 addtt(min_time, type);
2303 } else for (year = min_year; year <= max_year; ++year) {
2304 if (useuntil && year > zp->z_untilrule.r_hiyear)
2305 break;
2306 /*
2307 ** Mark which rules to do in the current year.
2308 ** For those to do, calculate rpytime(rp, year);
2309 */
2310 for (j = 0; j < zp->z_nrules; ++j) {
2311 rp = &zp->z_rules[j];
2312 eats(zp->z_filename, zp->z_linenum,
2313 rp->r_filename, rp->r_linenum);
2314 rp->r_todo = year >= rp->r_loyear &&
2315 year <= rp->r_hiyear &&
2316 yearistype(year, rp->r_yrtype);
2317 if (rp->r_todo)
2318 rp->r_temp = rpytime(rp, year);
2319 }
2320 for ( ; ; ) {
2321 register int k;
2322 register zic_t jtime, ktime;
2323 register long offset;
2324
2325 INITIALIZE(ktime);
2326 if (useuntil) {
2327 /*
2328 ** Turn untiltime into UTC
2329 ** assuming the current gmtoff and
2330 ** stdoff values.
2331 */
2332 untiltime = zp->z_untiltime;
2333 if (!zp->z_untilrule.r_todisgmt)
2334 untiltime = tadd(untiltime,
2335 -gmtoff);
2336 if (!zp->z_untilrule.r_todisstd)
2337 untiltime = tadd(untiltime,
2338 -stdoff);
2339 }
2340 /*
2341 ** Find the rule (of those to do, if any)
2342 ** that takes effect earliest in the year.
2343 */
2344 k = -1;
2345 for (j = 0; j < zp->z_nrules; ++j) {
2346 rp = &zp->z_rules[j];
2347 if (!rp->r_todo)
2348 continue;
2349 eats(zp->z_filename, zp->z_linenum,
2350 rp->r_filename, rp->r_linenum);
2351 offset = rp->r_todisgmt ? 0 : gmtoff;
2352 if (!rp->r_todisstd)
2353 offset = oadd(offset, stdoff);
2354 jtime = rp->r_temp;
2355 if (jtime == min_time ||
2356 jtime == max_time)
2357 continue;
2358 jtime = tadd(jtime, -offset);
2359 if (k < 0 || jtime < ktime) {
2360 k = j;
2361 ktime = jtime;
2362 }
2363 }
2364 if (k < 0)
2365 break; /* go on to next year */
2366 rp = &zp->z_rules[k];
2367 rp->r_todo = FALSE;
2368 if (useuntil && ktime >= untiltime)
2369 break;
2370 stdoff = rp->r_stdoff;
2371 if (usestart && ktime == starttime)
2372 usestart = FALSE;
2373 if (usestart) {
2374 if (ktime < starttime) {
2375 startoff = oadd(zp->z_gmtoff,
2376 stdoff);
2377 doabbr(startbuf, zp->z_format,
2378 rp->r_abbrvar,
2379 rp->r_stdoff != 0,
2380 FALSE);
2381 continue;
2382 }
2383 if (*startbuf == '\0' &&
2384 startoff == oadd(zp->z_gmtoff,
2385 stdoff)) {
2386 doabbr(startbuf,
2387 zp->z_format,
2388 rp->r_abbrvar,
2389 rp->r_stdoff !=
2390 0,
2391 FALSE);
2392 }
2393 }
2394 #ifdef ICU
2395 if (year >= finalRuleYear && rp == finalRule1) {
2396 /* We want to shift final year 1 year after
2397 * the actual final rule takes effect (year + 1),
2398 * because the previous type is valid until the first
2399 * transition defined by the final rule. Otherwise
2400 * we may see unexpected offset shift at the
2401 * begining of the year when the final rule takes
2402 * effect.
2403 *
2404 * Note: This may results some 64bit second transitions
2405 * at the very end (year 2038). ICU 4.2 or older releases
2406 * cannot handle 64bit second transitions and they are
2407 * dropped from zoneinfo.txt. */
2408 emit_icu_zone(icuFile,
2409 zpfirst->z_name, zp->z_gmtoff,
2410 rp, finalRuleIndex, year + 1);
2411 /* only emit this for the first year */
2412 finalRule1 = NULL;
2413 }
2414 #endif
2415 eats(zp->z_filename, zp->z_linenum,
2416 rp->r_filename, rp->r_linenum);
2417 doabbr(ab, zp->z_format, rp->r_abbrvar,
2418 rp->r_stdoff != 0, FALSE);
2419 offset = oadd(zp->z_gmtoff, rp->r_stdoff);
2420 #ifdef ICU
2421 type = addtype(offset, zp->z_gmtoff, rp->r_stdoff,
2422 ab, rp->r_stdoff != 0,
2423 rp->r_todisstd, rp->r_todisgmt);
2424 #else
2425 type = addtype(offset, ab, rp->r_stdoff != 0,
2426 rp->r_todisstd, rp->r_todisgmt);
2427 #endif
2428 addtt(ktime, type);
2429 }
2430 }
2431 if (usestart) {
2432 if (*startbuf == '\0' &&
2433 zp->z_format != NULL &&
2434 strchr(zp->z_format, '%') == NULL &&
2435 strchr(zp->z_format, '/') == NULL)
2436 (void) strcpy(startbuf, zp->z_format);
2437 eat(zp->z_filename, zp->z_linenum);
2438 if (*startbuf == '\0')
2439 error(_("can't determine time zone abbreviation to use just after until time"));
2440 else addtt(starttime,
2441 #ifdef ICU
2442 addtype(startoff,
2443 zp->z_gmtoff, startoff - zp->z_gmtoff,
2444 startbuf,
2445 startoff != zp->z_gmtoff,
2446 startttisstd,
2447 startttisgmt));
2448 #else
2449 addtype(startoff, startbuf,
2450 startoff != zp->z_gmtoff,
2451 startttisstd,
2452 startttisgmt));
2453 #endif
2454 }
2455 /*
2456 ** Now we may get to set starttime for the next zone line.
2457 */
2458 if (useuntil) {
2459 startttisstd = zp->z_untilrule.r_todisstd;
2460 startttisgmt = zp->z_untilrule.r_todisgmt;
2461 starttime = zp->z_untiltime;
2462 if (!startttisstd)
2463 starttime = tadd(starttime, -stdoff);
2464 if (!startttisgmt)
2465 starttime = tadd(starttime, -gmtoff);
2466 }
2467 }
2468 writezone(zpfirst->z_name, envvar);
2469 ifree(startbuf);
2470 ifree(ab);
2471 ifree(envvar);
2472 }
2473
2474 static void
2475 addtt(starttime, type)
2476 const zic_t starttime;
2477 int type;
2478 {
2479 if (starttime <= min_time ||
2480 (timecnt == 1 && attypes[0].at < min_time)) {
2481 gmtoffs[0] = gmtoffs[type];
2482 #ifdef ICU
2483 rawoffs[0] = rawoffs[type];
2484 dstoffs[0] = dstoffs[type];
2485 #endif
2486 isdsts[0] = isdsts[type];
2487 ttisstds[0] = ttisstds[type];
2488 ttisgmts[0] = ttisgmts[type];
2489 if (abbrinds[type] != 0)
2490 (void) strcpy(chars, &chars[abbrinds[type]]);
2491 abbrinds[0] = 0;
2492 charcnt = strlen(chars) + 1;
2493 typecnt = 1;
2494 timecnt = 0;
2495 type = 0;
2496 }
2497 if (timecnt >= TZ_MAX_TIMES) {
2498 error(_("too many transitions?!"));
2499 exit(EXIT_FAILURE);
2500 }
2501 attypes[timecnt].at = starttime;
2502 attypes[timecnt].type = type;
2503 ++timecnt;
2504 }
2505
2506 static int
2507 #ifdef ICU
2508 addtype(gmtoff, rawoff, dstoff, abbr, isdst, ttisstd, ttisgmt)
2509 const long gmtoff;
2510 const long rawoff;
2511 const long dstoff;
2512 #else
2513 addtype(gmtoff, abbr, isdst, ttisstd, ttisgmt)
2514 const long gmtoff;
2515 #endif
2516 const char * const abbr;
2517 const int isdst;
2518 const int ttisstd;
2519 const int ttisgmt;
2520 {
2521 register int i, j;
2522
2523 if (isdst != TRUE && isdst != FALSE) {
2524 error(_("internal error - addtype called with bad isdst"));
2525 exit(EXIT_FAILURE);
2526 }
2527 if (ttisstd != TRUE && ttisstd != FALSE) {
2528 error(_("internal error - addtype called with bad ttisstd"));
2529 exit(EXIT_FAILURE);
2530 }
2531 if (ttisgmt != TRUE && ttisgmt != FALSE) {
2532 error(_("internal error - addtype called with bad ttisgmt"));
2533 exit(EXIT_FAILURE);
2534 }
2535 #ifdef ICU
2536 if (isdst != (dstoff != 0)) {
2537 error(_("internal error - addtype called with bad isdst/dstoff"));
2538 (void) exit(EXIT_FAILURE);
2539 }
2540 if (gmtoff != (rawoff + dstoff)) {
2541 error(_("internal error - addtype called with bad gmt/raw/dstoff"));
2542 (void) exit(EXIT_FAILURE);
2543 }
2544 #endif
2545 /*
2546 ** See if there's already an entry for this zone type.
2547 ** If so, just return its index.
2548 */
2549 for (i = 0; i < typecnt; ++i) {
2550 if (gmtoff == gmtoffs[i] && isdst == isdsts[i] &&
2551 #ifdef ICU
2552 rawoff == rawoffs[i] && dstoff == dstoffs[i] &&
2553 #endif
2554 strcmp(abbr, &chars[abbrinds[i]]) == 0 &&
2555 ttisstd == ttisstds[i] &&
2556 ttisgmt == ttisgmts[i])
2557 return i;
2558 }
2559 /*
2560 ** There isn't one; add a new one, unless there are already too
2561 ** many.
2562 */
2563 if (typecnt >= TZ_MAX_TYPES) {
2564 error(_("too many local time types"));
2565 exit(EXIT_FAILURE);
2566 }
2567 if (! (-1L - 2147483647L <= gmtoff && gmtoff <= 2147483647L)) {
2568 error(_("UTC offset out of range"));
2569 exit(EXIT_FAILURE);
2570 }
2571 gmtoffs[i] = gmtoff;
2572 #ifdef ICU
2573 rawoffs[i] = rawoff;
2574 dstoffs[i] = dstoff;
2575 #endif
2576 isdsts[i] = isdst;
2577 ttisstds[i] = ttisstd;
2578 ttisgmts[i] = ttisgmt;
2579
2580 for (j = 0; j < charcnt; ++j)
2581 if (strcmp(&chars[j], abbr) == 0)
2582 break;
2583 if (j == charcnt)
2584 newabbr(abbr);
2585 abbrinds[i] = j;
2586 ++typecnt;
2587 return i;
2588 }
2589
2590 static void
2591 leapadd(t, positive, rolling, count)
2592 const zic_t t;
2593 const int positive;
2594 const int rolling;
2595 int count;
2596 {
2597 register int i, j;
2598
2599 if (leapcnt + (positive ? count : 1) > TZ_MAX_LEAPS) {
2600 error(_("too many leap seconds"));
2601 exit(EXIT_FAILURE);
2602 }
2603 for (i = 0; i < leapcnt; ++i)
2604 if (t <= trans[i]) {
2605 if (t == trans[i]) {
2606 error(_("repeated leap second moment"));
2607 exit(EXIT_FAILURE);
2608 }
2609 break;
2610 }
2611 do {
2612 for (j = leapcnt; j > i; --j) {
2613 trans[j] = trans[j - 1];
2614 corr[j] = corr[j - 1];
2615 roll[j] = roll[j - 1];
2616 }
2617 trans[i] = t;
2618 corr[i] = positive ? 1L : eitol(-count);
2619 roll[i] = rolling;
2620 ++leapcnt;
2621 } while (positive && --count != 0);
2622 }
2623
2624 static void
2625 adjleap(void)
2626 {
2627 register int i;
2628 register long last = 0;
2629
2630 /*
2631 ** propagate leap seconds forward
2632 */
2633 for (i = 0; i < leapcnt; ++i) {
2634 trans[i] = tadd(trans[i], last);
2635 last = corr[i] += last;
2636 }
2637 }
2638
2639 static int
2640 yearistype(year, type)
2641 const int year;
2642 const char * const type;
2643 {
2644 static char * buf;
2645 int result;
2646
2647 if (type == NULL || *type == '\0')
2648 return TRUE;
2649 buf = erealloc(buf, (int) (132 + strlen(yitcommand) + strlen(type)));
2650 (void) sprintf(buf, "%s %d %s", yitcommand, year, type);
2651 result = system(buf);
2652 if (WIFEXITED(result)) switch (WEXITSTATUS(result)) {
2653 case 0:
2654 return TRUE;
2655 case 1:
2656 return FALSE;
2657 }
2658 error(_("Wild result from command execution"));
2659 (void) fprintf(stderr, _("%s: command was '%s', result was %d\n"),
2660 progname, buf, result);
2661 for ( ; ; )
2662 exit(EXIT_FAILURE);
2663 }
2664
2665 static int
2666 lowerit(a)
2667 int a;
2668 {
2669 a = (unsigned char) a;
2670 return (isascii(a) && isupper(a)) ? tolower(a) : a;
2671 }
2672
2673 static int
2674 ciequal(ap, bp) /* case-insensitive equality */
2675 register const char * ap;
2676 register const char * bp;
2677 {
2678 while (lowerit(*ap) == lowerit(*bp++))
2679 if (*ap++ == '\0')
2680 return TRUE;
2681 return FALSE;
2682 }
2683
2684 static int
2685 itsabbr(abbr, word)
2686 register const char * abbr;
2687 register const char * word;
2688 {
2689 if (lowerit(*abbr) != lowerit(*word))
2690 return FALSE;
2691 ++word;
2692 while (*++abbr != '\0')
2693 do {
2694 if (*word == '\0')
2695 return FALSE;
2696 } while (lowerit(*word++) != lowerit(*abbr));
2697 return TRUE;
2698 }
2699
2700 static const struct lookup *
2701 byword(word, table)
2702 register const char * const word;
2703 register const struct lookup * const table;
2704 {
2705 register const struct lookup * foundlp;
2706 register const struct lookup * lp;
2707
2708 if (word == NULL || table == NULL)
2709 return NULL;
2710 /*
2711 ** Look for exact match.
2712 */
2713 for (lp = table; lp->l_word != NULL; ++lp)
2714 if (ciequal(word, lp->l_word))
2715 return lp;
2716 /*
2717 ** Look for inexact match.
2718 */
2719 foundlp = NULL;
2720 for (lp = table; lp->l_word != NULL; ++lp)
2721 if (itsabbr(word, lp->l_word)) {
2722 if (foundlp == NULL)
2723 foundlp = lp;
2724 else return NULL; /* multiple inexact matches */
2725 }
2726 return foundlp;
2727 }
2728
2729 static char **
2730 getfields(cp)
2731 register char * cp;
2732 {
2733 register char * dp;
2734 register char ** array;
2735 register int nsubs;
2736
2737 if (cp == NULL)
2738 return NULL;
2739 array = (char **) (void *)
2740 emalloc((int) ((strlen(cp) + 1) * sizeof *array));
2741 nsubs = 0;
2742 for ( ; ; ) {
2743 while (isascii((unsigned char) *cp) &&
2744 isspace((unsigned char) *cp))
2745 ++cp;
2746 if (*cp == '\0' || *cp == '#')
2747 break;
2748 array[nsubs++] = dp = cp;
2749 do {
2750 if ((*dp = *cp++) != '"')
2751 ++dp;
2752 else while ((*dp = *cp++) != '"')
2753 if (*dp != '\0')
2754 ++dp;
2755 else {
2756 error(_(
2757 "Odd number of quotation marks"
2758 ));
2759 exit(1);
2760 }
2761 } while (*cp != '\0' && *cp != '#' &&
2762 (!isascii(*cp) || !isspace((unsigned char) *cp)));
2763 if (isascii(*cp) && isspace((unsigned char) *cp))
2764 ++cp;
2765 *dp = '\0';
2766 }
2767 array[nsubs] = NULL;
2768 return array;
2769 }
2770
2771 static long
2772 oadd(t1, t2)
2773 const long t1;
2774 const long t2;
2775 {
2776 register long t;
2777
2778 t = t1 + t2;
2779 if ((t2 > 0 && t <= t1) || (t2 < 0 && t >= t1)) {
2780 error(_("time overflow"));
2781 exit(EXIT_FAILURE);
2782 }
2783 return t;
2784 }
2785
2786 static zic_t
2787 tadd(t1, t2)
2788 const zic_t t1;
2789 const long t2;
2790 {
2791 register zic_t t;
2792
2793 if (t1 == max_time && t2 > 0)
2794 return max_time;
2795 if (t1 == min_time && t2 < 0)
2796 return min_time;
2797 t = t1 + t2;
2798 if ((t2 > 0 && t <= t1) || (t2 < 0 && t >= t1)) {
2799 error(_("time overflow"));
2800 exit(EXIT_FAILURE);
2801 }
2802 return t;
2803 }
2804
2805 /*
2806 ** Given a rule, and a year, compute the date - in seconds since January 1,
2807 ** 1970, 00:00 LOCAL time - in that year that the rule refers to.
2808 */
2809
2810 static zic_t
2811 rpytime(rp, wantedy)
2812 register const struct rule * const rp;
2813 register const int wantedy;
2814 {
2815 register int y, m, i;
2816 register long dayoff; /* with a nod to Margaret O. */
2817 register zic_t t;
2818
2819 if (wantedy == INT_MIN)
2820 return min_time;
2821 if (wantedy == INT_MAX)
2822 return max_time;
2823 dayoff = 0;
2824 m = TM_JANUARY;
2825 y = EPOCH_YEAR;
2826 while (wantedy != y) {
2827 if (wantedy > y) {
2828 i = len_years[isleap(y)];
2829 ++y;
2830 } else {
2831 --y;
2832 i = -len_years[isleap(y)];
2833 }
2834 dayoff = oadd(dayoff, eitol(i));
2835 }
2836 while (m != rp->r_month) {
2837 i = len_months[isleap(y)][m];
2838 dayoff = oadd(dayoff, eitol(i));
2839 ++m;
2840 }
2841 i = rp->r_dayofmonth;
2842 if (m == TM_FEBRUARY && i == 29 && !isleap(y)) {
2843 if (rp->r_dycode == DC_DOWLEQ)
2844 --i;
2845 else {
2846 error(_("use of 2/29 in non leap-year"));
2847 exit(EXIT_FAILURE);
2848 }
2849 }
2850 --i;
2851 dayoff = oadd(dayoff, eitol(i));
2852 if (rp->r_dycode == DC_DOWGEQ || rp->r_dycode == DC_DOWLEQ) {
2853 register long wday;
2854
2855 #define LDAYSPERWEEK ((long) DAYSPERWEEK)
2856 wday = eitol(EPOCH_WDAY);
2857 /*
2858 ** Don't trust mod of negative numbers.
2859 */
2860 if (dayoff >= 0)
2861 wday = (wday + dayoff) % LDAYSPERWEEK;
2862 else {
2863 wday -= ((-dayoff) % LDAYSPERWEEK);
2864 if (wday < 0)
2865 wday += LDAYSPERWEEK;
2866 }
2867 while (wday != eitol(rp->r_wday))
2868 if (rp->r_dycode == DC_DOWGEQ) {
2869 dayoff = oadd(dayoff, (long) 1);
2870 if (++wday >= LDAYSPERWEEK)
2871 wday = 0;
2872 ++i;
2873 } else {
2874 dayoff = oadd(dayoff, (long) -1);
2875 if (--wday < 0)
2876 wday = LDAYSPERWEEK - 1;
2877 --i;
2878 }
2879 if (i < 0 || i >= len_months[isleap(y)][m]) {
2880 if (noise)
2881 warning(_("rule goes past start/end of month--\
2882 will not work with pre-2004 versions of zic"));
2883 }
2884 }
2885 if (dayoff < min_time / SECSPERDAY)
2886 return min_time;
2887 if (dayoff > max_time / SECSPERDAY)
2888 return max_time;
2889 t = (zic_t) dayoff * SECSPERDAY;
2890 return tadd(t, rp->r_tod);
2891 }
2892
2893 static void
2894 newabbr(string)
2895 const char * const string;
2896 {
2897 register int i;
2898
2899 if (strcmp(string, GRANDPARENTED) != 0) {
2900 register const char * cp;
2901 register char * wp;
2902
2903 /*
2904 ** Want one to ZIC_MAX_ABBR_LEN_WO_WARN alphabetics
2905 ** optionally followed by a + or - and a number from 1 to 14.
2906 */
2907 cp = string;
2908 wp = NULL;
2909 while (isascii((unsigned char) *cp) &&
2910 isalpha((unsigned char) *cp))
2911 ++cp;
2912 if (cp - string == 0)
2913 wp = _("time zone abbreviation lacks alphabetic at start");
2914 if (noise && cp - string > 3)
2915 wp = _("time zone abbreviation has more than 3 alphabetics");
2916 if (cp - string > ZIC_MAX_ABBR_LEN_WO_WARN)
2917 wp = _("time zone abbreviation has too many alphabetics");
2918 if (wp == NULL && (*cp == '+' || *cp == '-')) {
2919 ++cp;
2920 if (isascii((unsigned char) *cp) &&
2921 isdigit((unsigned char) *cp))
2922 if (*cp++ == '1' &&
2923 *cp >= '0' && *cp <= '4')
2924 ++cp;
2925 }
2926 if (*cp != '\0')
2927 wp = _("time zone abbreviation differs from POSIX standard");
2928 if (wp != NULL) {
2929 wp = ecpyalloc(wp);
2930 wp = ecatalloc(wp, " (");
2931 wp = ecatalloc(wp, string);
2932 wp = ecatalloc(wp, ")");
2933 warning(wp);
2934 ifree(wp);
2935 }
2936 }
2937 i = strlen(string) + 1;
2938 if (charcnt + i > TZ_MAX_CHARS) {
2939 error(_("too many, or too long, time zone abbreviations"));
2940 exit(EXIT_FAILURE);
2941 }
2942 (void) strcpy(&chars[charcnt], string);
2943 charcnt += eitol(i);
2944 }
2945
2946 static int
2947 mkdirs(argname)
2948 char * argname;
2949 {
2950 register char * name;
2951 register char * cp;
2952
2953 if (argname == NULL || *argname == '\0')
2954 return 0;
2955 cp = name = ecpyalloc(argname);
2956 while ((cp = strchr(cp + 1, '/')) != 0) {
2957 *cp = '\0';
2958 #ifndef unix
2959 /*
2960 ** DOS drive specifier?
2961 */
2962 if (isalpha((unsigned char) name[0]) &&
2963 name[1] == ':' && name[2] == '\0') {
2964 *cp = '/';
2965 continue;
2966 }
2967 #endif /* !defined unix */
2968 if (!itsdir(name)) {
2969 /*
2970 ** It doesn't seem to exist, so we try to create it.
2971 ** Creation may fail because of the directory being
2972 ** created by some other multiprocessor, so we get
2973 ** to do extra checking.
2974 */
2975 if (mkdir(name, MKDIR_UMASK) != 0) {
2976 const char *e = strerror(errno);
2977
2978 if (errno != EEXIST || !itsdir(name)) {
2979 (void) fprintf(stderr,
2980 _("%s: Can't create directory %s: %s\n"),
2981 progname, name, e);
2982 ifree(name);
2983 return -1;
2984 }
2985 }
2986 }
2987 *cp = '/';
2988 }
2989 ifree(name);
2990 return 0;
2991 }
2992
2993 static long
2994 eitol(i)
2995 const int i;
2996 {
2997 long l;
2998
2999 l = i;
3000 if ((i < 0 && l >= 0) || (i == 0 && l != 0) || (i > 0 && l <= 0)) {
3001 (void) fprintf(stderr,
3002 _("%s: %d did not sign extend correctly\n"),
3003 progname, i);
3004 exit(EXIT_FAILURE);
3005 }
3006 return l;
3007 }
3008
3009 /*
3010 ** UNIX was a registered trademark of The Open Group in 2003.
3011 */

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial