timezone/zic.c

   1 /* Compile .zi time zone data into TZif binary files.  */
   2
   3 /*
   4 ** This file is in the public domain, so clarified as of
   5 ** 2006-07-17 by Arthur David Olson.
   6 */
   7
   8 #include "version.h"
   9 #include "private.h"
  10 #include "tzfile.h"
  11
  12 #include <fcntl.h>
  13 #include <locale.h>
  14 #include <stdarg.h>
  15 #include <stddef.h>
  16 #include <stdio.h>
  17
  18 #define ZIC_VERSION_PRE_2013 '2'
  19 #define ZIC_VERSION     '3'
  20
  21 typedef int_fast64_t    zic_t;
  22 #define ZIC_MIN INT_FAST64_MIN
  23 #define ZIC_MAX INT_FAST64_MAX
  24 #define PRIdZIC PRIdFAST64
  25 #define SCNdZIC SCNdFAST64
  26
  27 #ifndef ZIC_MAX_ABBR_LEN_WO_WARN
  28 #define ZIC_MAX_ABBR_LEN_WO_WARN        6
  29 #endif /* !defined ZIC_MAX_ABBR_LEN_WO_WARN */
  30
  31 #ifdef HAVE_DIRECT_H
  32 # include <direct.h>
  33 # include <io.h>
  34 # undef mkdir
  35 # define mkdir(name, mode) _mkdir(name)
  36 #endif
  37
  38 #if HAVE_SYS_STAT_H
  39 #include <sys/stat.h>
  40 #endif
  41 #ifdef S_IRUSR
  42 #define MKDIR_UMASK (S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH)
  43 #else
  44 #define MKDIR_UMASK 0755
  45 #endif
  46 /* Port to native MS-Windows and to ancient UNIX.  */
  47 #if !defined S_ISDIR && defined S_IFDIR && defined S_IFMT
  48 # define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
  49 #endif
  50
  51 #if HAVE_SYS_WAIT_H
  52 #include <sys/wait.h>   /* for WIFEXITED and WEXITSTATUS */
  53 #endif /* HAVE_SYS_WAIT_H */
  54
  55 #ifndef WIFEXITED
  56 #define WIFEXITED(status)       (((status) & 0xff) == 0)
  57 #endif /* !defined WIFEXITED */
  58 #ifndef WEXITSTATUS
  59 #define WEXITSTATUS(status)     (((status) >> 8) & 0xff)
  60 #endif /* !defined WEXITSTATUS */
  61
  62 /* The maximum ptrdiff_t value, for pre-C99 platforms.  */
  63 #ifndef PTRDIFF_MAX
  64 static ptrdiff_t const PTRDIFF_MAX = MAXVAL(ptrdiff_t, TYPE_BIT(ptrdiff_t));
  65 #endif
  66
  67 /* The minimum alignment of a type, for pre-C11 platforms.  */
  68 #if __STDC_VERSION__ < 201112
  69 # define _Alignof(type) offsetof(struct { char a; type b; }, b)
  70 #endif
  71
  72 /* The type for line numbers.  Use PRIdMAX to format them; formerly
  73    there was also "#define PRIdLINENO PRIdMAX" and formats used
  74    PRIdLINENO, but xgettext cannot grok that.  */
  75 typedef intmax_t lineno;
  76
  77 struct rule {
  78         const char *    r_filename;
  79         lineno          r_linenum;
  80         const char *    r_name;
  81
  82         zic_t           r_loyear;       /* for example, 1986 */
  83         zic_t           r_hiyear;       /* for example, 1986 */
  84         const char *    r_yrtype;
  85         bool            r_lowasnum;
  86         bool            r_hiwasnum;
  87
  88         int             r_month;        /* 0..11 */
  89
  90         int             r_dycode;       /* see below */
  91         int             r_dayofmonth;
  92         int             r_wday;
  93
  94         zic_t           r_tod;          /* time from midnight */
  95         bool            r_todisstd;     /* is r_tod standard time? */
  96         bool            r_todisut;      /* is r_tod UT? */
  97         bool            r_isdst;        /* is this daylight saving time? */
  98         zic_t           r_save;         /* offset from standard time */
  99         const char *    r_abbrvar;      /* variable part of abbreviation */
 100
 101         bool            r_todo;         /* a rule to do (used in outzone) */
 102         zic_t           r_temp;         /* used in outzone */
 103 };
 104
 105 /*
 106 **      r_dycode                r_dayofmonth    r_wday
 107 */
 108
 109 #define DC_DOM          0       /* 1..31 */     /* unused */
 110 #define DC_DOWGEQ       1       /* 1..31 */     /* 0..6 (Sun..Sat) */
 111 #define DC_DOWLEQ       2       /* 1..31 */     /* 0..6 (Sun..Sat) */
 112
 113 struct zone {
 114         const char *    z_filename;
 115         lineno          z_linenum;
 116
 117         const char *    z_name;
 118         zic_t           z_stdoff;
 119         char *          z_rule;
 120         const char *    z_format;
 121         char            z_format_specifier;
 122
 123         bool            z_isdst;
 124         zic_t           z_save;
 125
 126         struct rule *   z_rules;
 127         ptrdiff_t       z_nrules;
 128
 129         struct rule     z_untilrule;
 130         zic_t           z_untiltime;
 131 };
 132
 133 #if !HAVE_POSIX_DECLS
 134 extern int      getopt(int argc, char * const argv[],
 135                         const char * options);
 136 extern int      link(const char * fromname, const char * toname);
 137 extern char *   optarg;
 138 extern int      optind;
 139 #endif
 140
 141 #if ! HAVE_LINK
 142 # define link(from, to) (errno = ENOTSUP, -1)
 143 #endif
 144 #if ! HAVE_SYMLINK
 145 # define readlink(file, buf, size) (errno = ENOTSUP, -1)
 146 # define symlink(from, to) (errno = ENOTSUP, -1)
 147 # define S_ISLNK(m) 0
 148 #endif
 149 #ifndef AT_SYMLINK_FOLLOW
 150 # define linkat(fromdir, from, todir, to, flag) \
 151     (itssymlink(from) ? (errno = ENOTSUP, -1) : link(from, to))
 152 #endif
 153
 154 static void     addtt(zic_t starttime, int type);
 155 static int      addtype(zic_t, char const *, bool, bool, bool);
 156 static void     leapadd(zic_t, int, int);
 157 static void     adjleap(void);
 158 static void     associate(void);
 159 static void     dolink(const char *, const char *, bool);
 160 static char **  getfields(char * buf);
 161 static zic_t    gethms(const char * string, const char * errstring);
 162 static zic_t    getsave(char *, bool *);
 163 static void     inexpires(char **, int);
 164 static void     infile(const char * filename);
 165 static void     inleap(char ** fields, int nfields);
 166 static void     inlink(char ** fields, int nfields);
 167 static void     inrule(char ** fields, int nfields);
 168 static bool     inzcont(char ** fields, int nfields);
 169 static bool     inzone(char ** fields, int nfields);
 170 static bool     inzsub(char **, int, bool);
 171 static bool     itsdir(char const *);
 172 static bool     itssymlink(char const *);
 173 static bool     is_alpha(char a);
 174 static char     lowerit(char);
 175 static void     mkdirs(char const *, bool);
 176 static void     newabbr(const char * abbr);
 177 static zic_t    oadd(zic_t t1, zic_t t2);
 178 static void     outzone(const struct zone * zp, ptrdiff_t ntzones);
 179 static zic_t    rpytime(const struct rule * rp, zic_t wantedy);
 180 static void     rulesub(struct rule * rp,
 181                         const char * loyearp, const char * hiyearp,
 182                         const char * typep, const char * monthp,
 183                         const char * dayp, const char * timep);
 184 static zic_t    tadd(zic_t t1, zic_t t2);
 185 static bool     yearistype(zic_t year, const char * type);
 186
 187 /* Bound on length of what %z can expand to.  */
 188 enum { PERCENT_Z_LEN_BOUND = sizeof "+995959" - 1 };
 189
 190 /* If true, work around a bug in Qt 5.6.1 and earlier, which mishandles
 191    TZif files whose POSIX-TZ-style strings contain '<'; see
 192    QTBUG-53071 <https://bugreports.qt.io/browse/QTBUG-53071>.  This
 193    workaround will no longer be needed when Qt 5.6.1 and earlier are
 194    obsolete, say in the year 2021.  */
 195 #ifndef WORK_AROUND_QTBUG_53071
 196 enum { WORK_AROUND_QTBUG_53071 = true };
 197 #endif
 198
 199 static int              charcnt;
 200 static bool             errors;
 201 static bool             warnings;
 202 static const char *     filename;
 203 static int              leapcnt;
 204 static bool             leapseen;
 205 static zic_t            leapminyear;
 206 static zic_t            leapmaxyear;
 207 static lineno           linenum;
 208 static int              max_abbrvar_len = PERCENT_Z_LEN_BOUND;
 209 static int              max_format_len;
 210 static zic_t            max_year;
 211 static zic_t            min_year;
 212 static bool             noise;
 213 static const char *     rfilename;
 214 static lineno           rlinenum;
 215 static const char *     progname;
 216 static ptrdiff_t        timecnt;
 217 static ptrdiff_t        timecnt_alloc;
 218 static int              typecnt;
 219
 220 /*
 221 ** Line codes.
 222 */
 223
 224 #define LC_RULE         0
 225 #define LC_ZONE         1
 226 #define LC_LINK         2
 227 #define LC_LEAP         3
 228 #define LC_EXPIRES      4
 229
 230 /*
 231 ** Which fields are which on a Zone line.
 232 */
 233
 234 #define ZF_NAME         1
 235 #define ZF_STDOFF       2
 236 #define ZF_RULE         3
 237 #define ZF_FORMAT       4
 238 #define ZF_TILYEAR      5
 239 #define ZF_TILMONTH     6
 240 #define ZF_TILDAY       7
 241 #define ZF_TILTIME      8
 242 #define ZONE_MINFIELDS  5
 243 #define ZONE_MAXFIELDS  9
 244
 245 /*
 246 ** Which fields are which on a Zone continuation line.
 247 */
 248
 249 #define ZFC_STDOFF      0
 250 #define ZFC_RULE        1
 251 #define ZFC_FORMAT      2
 252 #define ZFC_TILYEAR     3
 253 #define ZFC_TILMONTH    4
 254 #define ZFC_TILDAY      5
 255 #define ZFC_TILTIME     6
 256 #define ZONEC_MINFIELDS 3
 257 #define ZONEC_MAXFIELDS 7
 258
 259 /*
 260 ** Which files are which on a Rule line.
 261 */
 262
 263 #define RF_NAME         1
 264 #define RF_LOYEAR       2
 265 #define RF_HIYEAR       3
 266 #define RF_COMMAND      4
 267 #define RF_MONTH        5
 268 #define RF_DAY          6
 269 #define RF_TOD          7
 270 #define RF_SAVE         8
 271 #define RF_ABBRVAR      9
 272 #define RULE_FIELDS     10
 273
 274 /*
 275 ** Which fields are which on a Link line.
 276 */
 277
 278 #define LF_FROM         1
 279 #define LF_TO           2
 280 #define LINK_FIELDS     3
 281
 282 /*
 283 ** Which fields are which on a Leap line.
 284 */
 285
 286 #define LP_YEAR         1
 287 #define LP_MONTH        2
 288 #define LP_DAY          3
 289 #define LP_TIME         4
 290 #define LP_CORR         5
 291 #define LP_ROLL         6
 292 #define LEAP_FIELDS     7
 293
 294 /* Expires lines are like Leap lines, except without CORR and ROLL fields.  */
 295 #define EXPIRES_FIELDS  5
 296
 297 /*
 298 ** Year synonyms.
 299 */
 300
 301 #define YR_MINIMUM      0
 302 #define YR_MAXIMUM      1
 303 #define YR_ONLY         2
 304
 305 static struct rule *    rules;
 306 static ptrdiff_t        nrules; /* number of rules */
 307 static ptrdiff_t        nrules_alloc;
 308
 309 static struct zone *    zones;
 310 static ptrdiff_t        nzones; /* number of zones */
 311 static ptrdiff_t        nzones_alloc;
 312
 313 struct link {
 314         const char *    l_filename;
 315         lineno          l_linenum;
 316         const char *    l_from;
 317         const char *    l_to;
 318 };
 319
 320 static struct link *    links;
 321 static ptrdiff_t        nlinks;
 322 static ptrdiff_t        nlinks_alloc;
 323
 324 struct lookup {
 325         const char *    l_word;
 326         const int       l_value;
 327 };
 328
 329 static struct lookup const *    byword(const char * string,
 330                                         const struct lookup * lp);
 331
 332 static struct lookup const zi_line_codes[] = {
 333         { "Rule",       LC_RULE },
 334         { "Zone",       LC_ZONE },
 335         { "Link",       LC_LINK },
 336         { NULL,         0 }
 337 };
 338 static struct lookup const leap_line_codes[] = {
 339         { "Leap",       LC_LEAP },
 340         { "Expires",    LC_EXPIRES },
 341         { NULL,         0}
 342 };
 343
 344 static struct lookup const      mon_names[] = {
 345         { "January",    TM_JANUARY },
 346         { "February",   TM_FEBRUARY },
 347         { "March",      TM_MARCH },
 348         { "April",      TM_APRIL },
 349         { "May",        TM_MAY },
 350         { "June",       TM_JUNE },
 351         { "July",       TM_JULY },
 352         { "August",     TM_AUGUST },
 353         { "September",  TM_SEPTEMBER },
 354         { "October",    TM_OCTOBER },
 355         { "November",   TM_NOVEMBER },
 356         { "December",   TM_DECEMBER },
 357         { NULL,         0 }
 358 };
 359
 360 static struct lookup const      wday_names[] = {
 361         { "Sunday",     TM_SUNDAY },
 362         { "Monday",     TM_MONDAY },
 363         { "Tuesday",    TM_TUESDAY },
 364         { "Wednesday",  TM_WEDNESDAY },
 365         { "Thursday",   TM_THURSDAY },
 366         { "Friday",     TM_FRIDAY },
 367         { "Saturday",   TM_SATURDAY },
 368         { NULL,         0 }
 369 };
 370
 371 static struct lookup const      lasts[] = {
 372         { "last-Sunday",        TM_SUNDAY },
 373         { "last-Monday",        TM_MONDAY },
 374         { "last-Tuesday",       TM_TUESDAY },
 375         { "last-Wednesday",     TM_WEDNESDAY },
 376         { "last-Thursday",      TM_THURSDAY },
 377         { "last-Friday",        TM_FRIDAY },
 378         { "last-Saturday",      TM_SATURDAY },
 379         { NULL,                 0 }
 380 };
 381
 382 static struct lookup const      begin_years[] = {
 383         { "minimum",    YR_MINIMUM },
 384         { "maximum",    YR_MAXIMUM },
 385         { NULL,         0 }
 386 };
 387
 388 static struct lookup const      end_years[] = {
 389         { "minimum",    YR_MINIMUM },
 390         { "maximum",    YR_MAXIMUM },
 391         { "only",       YR_ONLY },
 392         { NULL,         0 }
 393 };
 394
 395 static struct lookup const      leap_types[] = {
 396         { "Rolling",    true },
 397         { "Stationary", false },
 398         { NULL,         0 }
 399 };
 400
 401 static const int        len_months[2][MONSPERYEAR] = {
 402         { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
 403         { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
 404 };
 405
 406 static const int        len_years[2] = {
 407         DAYSPERNYEAR, DAYSPERLYEAR
 408 };
 409
 410 static struct attype {
 411         zic_t           at;
 412         bool            dontmerge;
 413         unsigned char   type;
 414 } *                     attypes;
 415 static zic_t            utoffs[TZ_MAX_TYPES];
 416 static char             isdsts[TZ_MAX_TYPES];
 417 static unsigned char    desigidx[TZ_MAX_TYPES];
 418 static bool             ttisstds[TZ_MAX_TYPES];
 419 static bool             ttisuts[TZ_MAX_TYPES];
 420 static char             chars[TZ_MAX_CHARS];
 421 static zic_t            trans[TZ_MAX_LEAPS];
 422 static zic_t            corr[TZ_MAX_LEAPS];
 423 static char             roll[TZ_MAX_LEAPS];
 424
 425 /*
 426 ** Memory allocation.
 427 */
 428
 429 static _Noreturn void
 430 memory_exhausted(const char *msg)
 431 {
 432         fprintf(stderr, _("%s: Memory exhausted: %s\n"), progname, msg);
 433         exit(EXIT_FAILURE);
 434 }
 435
 436 static ATTRIBUTE_PURE size_t
 437 size_product(size_t nitems, size_t itemsize)
 438 {
 439         if (SIZE_MAX / itemsize < nitems)
 440                 memory_exhausted(_("size overflow"));
 441         return nitems * itemsize;
 442 }
 443
 444 static ATTRIBUTE_PURE size_t
 445 align_to(size_t size, size_t alignment)
 446 {
 447   size_t aligned_size = size + alignment - 1;
 448   aligned_size -= aligned_size % alignment;
 449   if (aligned_size < size)
 450     memory_exhausted(_("alignment overflow"));
 451   return aligned_size;
 452 }
 453
 454 #if !HAVE_STRDUP
 455 static char *
 456 strdup(char const *str)
 457 {
 458   char *result = malloc(strlen(str) + 1);
 459   return result ? strcpy(result, str) : result;
 460 }
 461 #endif
 462
 463 static void *
 464 memcheck(void *ptr)
 465 {
 466         if (ptr == NULL)
 467                 memory_exhausted(strerror(errno));
 468         return ptr;
 469 }
 470
 471 static void * ATTRIBUTE_MALLOC
 472 emalloc(size_t size)
 473 {
 474   return memcheck(malloc(size));
 475 }
 476
 477 static void *
 478 erealloc(void *ptr, size_t size)
 479 {
 480   return memcheck(realloc(ptr, size));
 481 }
 482
 483 static char * ATTRIBUTE_MALLOC
 484 ecpyalloc (char const *str)
 485 {
 486   return memcheck(strdup(str));
 487 }
 488
 489 static void *
 490 growalloc(void *ptr, size_t itemsize, ptrdiff_t nitems, ptrdiff_t *nitems_alloc)
 491 {
 492         if (nitems < *nitems_alloc)
 493                 return ptr;
 494         else {
 495                 ptrdiff_t nitems_max = PTRDIFF_MAX - WORK_AROUND_QTBUG_53071;
 496                 ptrdiff_t amax = nitems_max < SIZE_MAX ? nitems_max : SIZE_MAX;
 497                 if ((amax - 1) / 3 * 2 < *nitems_alloc)
 498                         memory_exhausted(_("integer overflow"));
 499                 *nitems_alloc += (*nitems_alloc >> 1) + 1;
 500                 return erealloc(ptr, size_product(*nitems_alloc, itemsize));
 501         }
 502 }
 503
 504 /*
 505 ** Error handling.
 506 */
 507
 508 static void
 509 eats(char const *name, lineno num, char const *rname, lineno rnum)
 510 {
 511         filename = name;
 512         linenum = num;
 513         rfilename = rname;
 514         rlinenum = rnum;
 515 }
 516
 517 static void
 518 eat(char const *name, lineno num)
 519 {
 520         eats(name, num, NULL, -1);
 521 }
 522
 523 static void ATTRIBUTE_FORMAT((printf, 1, 0))
 524 verror(const char *const string, va_list args)
 525 {
 526         /*
 527         ** Match the format of "cc" to allow sh users to
 528         **      zic ... 2>&1 | error -t "*" -v
 529         ** on BSD systems.
 530         */
 531         if (filename)
 532           fprintf(stderr, _("\"%s\", line %"PRIdMAX": "), filename, linenum);
 533         vfprintf(stderr, string, args);
 534         if (rfilename != NULL)
 535                 fprintf(stderr, _(" (rule from \"%s\", line %"PRIdMAX")"),
 536                         rfilename, rlinenum);
 537         fprintf(stderr, "\n");
 538 }
 539
 540 static void ATTRIBUTE_FORMAT((printf, 1, 2))
 541 error(const char *const string, ...)
 542 {
 543         va_list args;
 544         va_start(args, string);
 545         verror(string, args);
 546         va_end(args);
 547         errors = true;
 548 }
 549
 550 static void ATTRIBUTE_FORMAT((printf, 1, 2))
 551 warning(const char *const string, ...)
 552 {
 553         va_list args;
 554         fprintf(stderr, _("warning: "));
 555         va_start(args, string);
 556         verror(string, args);
 557         va_end(args);
 558         warnings = true;
 559 }
 560
 561 static void
 562 close_file(FILE *stream, char const *dir, char const *name)
 563 {
 564   char const *e = (ferror(stream) ? _("I/O error")
 565                    : fclose(stream) != 0 ? strerror(errno) : NULL);
 566   if (e) {
 567     fprintf(stderr, "%s: %s%s%s%s%s\n", progname,
 568             dir ? dir : "", dir ? "/" : "",
 569             name ? name : "", name ? ": " : "",
 570             e);
 571     exit(EXIT_FAILURE);
 572   }
 573 }
 574
 575 static _Noreturn void
 576 usage(FILE *stream, int status)
 577 {
 578   fprintf(stream,
 579           _("%s: usage is %s [ --version ] [ --help ] [ -v ] \\\n"
 580             "\t[ -b {slim|fat} ] [ -d directory ] [ -l localtime ]"
 581             " [ -L leapseconds ] \\\n"
 582             "\t[ -p posixrules ] [ -r '[@lo][/@hi]' ] [ -t localtime-link ] \\\n"
 583             "\t[ filename ... ]\n\n"
 584             "Report bugs to %s.\n"),
 585           progname, progname, REPORT_BUGS_TO);
 586   if (status == EXIT_SUCCESS)
 587     close_file(stream, NULL, NULL);
 588   exit(status);
 589 }
 590
 591 /* Change the working directory to DIR, possibly creating DIR and its
 592    ancestors.  After this is done, all files are accessed with names
 593    relative to DIR.  */
 594 static void
 595 change_directory (char const *dir)
 596 {
 597   if (chdir(dir) != 0) {
 598     int chdir_errno = errno;
 599     if (chdir_errno == ENOENT) {
 600       mkdirs(dir, false);
 601       chdir_errno = chdir(dir) == 0 ? 0 : errno;
 602     }
 603     if (chdir_errno != 0) {
 604       fprintf(stderr, _("%s: Can't chdir to %s: %s\n"),
 605               progname, dir, strerror(chdir_errno));
 606       exit(EXIT_FAILURE);
 607     }
 608   }
 609 }
 610
 611 #define TIME_T_BITS_IN_FILE 64
 612
 613 /* The minimum and maximum values representable in a TZif file.  */
 614 static zic_t const min_time = MINVAL(zic_t, TIME_T_BITS_IN_FILE);
 615 static zic_t const max_time = MAXVAL(zic_t, TIME_T_BITS_IN_FILE);
 616
 617 /* The minimum, and one less than the maximum, values specified by
 618    the -r option.  These default to MIN_TIME and MAX_TIME.  */
 619 static zic_t lo_time = MINVAL(zic_t, TIME_T_BITS_IN_FILE);
 620 static zic_t hi_time = MAXVAL(zic_t, TIME_T_BITS_IN_FILE);
 621
 622 /* The time specified by an Expires line, or negative if no such line.  */
 623 static zic_t leapexpires = -1;
 624
 625 /* The time specified by an #expires comment, or negative if no such line.  */
 626 static zic_t comment_leapexpires = -1;
 627
 628 /* Set the time range of the output to TIMERANGE.
 629    Return true if successful.  */
 630 static bool
 631 timerange_option(char *timerange)
 632 {
 633   intmax_t lo = min_time, hi = max_time;
 634   char *lo_end = timerange, *hi_end;
 635   if (*timerange == '@') {
 636     errno = 0;
 637     lo = strtoimax (timerange + 1, &lo_end, 10);
 638     if (lo_end == timerange + 1 || (lo == INTMAX_MAX && errno == ERANGE))
 639       return false;
 640   }
 641   hi_end = lo_end;
 642   if (lo_end[0] == '/' && lo_end[1] == '@') {
 643     errno = 0;
 644     hi = strtoimax (lo_end + 2, &hi_end, 10);
 645     if (hi_end == lo_end + 2 || hi == INTMAX_MIN)
 646       return false;
 647     hi -= ! (hi == INTMAX_MAX && errno == ERANGE);
 648   }
 649   if (*hi_end || hi < lo || max_time < lo || hi < min_time)
 650     return false;
 651   lo_time = lo < min_time ? min_time : lo;
 652   hi_time = max_time < hi ? max_time : hi;
 653   return true;
 654 }
 655
 656 static const char *     psxrules;
 657 static const char *     lcltime;
 658 static const char *     directory;
 659 static const char *     leapsec;
 660 static const char *     tzdefault;
 661 static const char *     yitcommand;
 662
 663 /* -1 if the TZif output file should be slim, 0 if default, 1 if the
 664    output should be fat for backward compatibility.  Currently the
 665    default is fat, although this may change.  */
 666 static int bloat;
 667
 668 static bool
 669 want_bloat(void)
 670 {
 671   return 0 <= bloat;
 672 }
 673
 674 #ifndef ZIC_BLOAT_DEFAULT
 675 # define ZIC_BLOAT_DEFAULT "fat"
 676 #endif
 677
 678 int
 679 main(int argc, char **argv)
 680 {
 681         register int c, k;
 682         register ptrdiff_t i, j;
 683         bool timerange_given = false;
 684
 685 #ifdef S_IWGRP
 686         umask(umask(S_IWGRP | S_IWOTH) | (S_IWGRP | S_IWOTH));
 687 #endif
 688 #if HAVE_GETTEXT
 689         setlocale(LC_ALL, "");
 690 #ifdef TZ_DOMAINDIR
 691         bindtextdomain(TZ_DOMAIN, TZ_DOMAINDIR);
 692 #endif /* defined TEXTDOMAINDIR */
 693         textdomain(TZ_DOMAIN);
 694 #endif /* HAVE_GETTEXT */
 695         progname = argv[0];
 696         if (TYPE_BIT(zic_t) < 64) {
 697                 fprintf(stderr, "%s: %s\n", progname,
 698                         _("wild compilation-time specification of zic_t"));
 699                 return EXIT_FAILURE;
 700         }
 701         for (k = 1; k < argc; k++)
 702                 if (strcmp(argv[k], "--version") == 0) {
 703                         printf("zic %s%s\n", PKGVERSION, TZVERSION);
 704                         close_file(stdout, NULL, NULL);
 705                         return EXIT_SUCCESS;
 706                 } else if (strcmp(argv[k], "--help") == 0) {
 707                         usage(stdout, EXIT_SUCCESS);
 708                 }
 709         while ((c = getopt(argc, argv, "b:d:l:L:p:r:st:vy:")) != EOF && c != -1)
 710                 switch (c) {
 711                         default:
 712                                 usage(stderr, EXIT_FAILURE);
 713                         case 'b':
 714                                 if (strcmp(optarg, "slim") == 0) {
 715                                   if (0 < bloat)
 716                                     error(_("incompatible -b options"));
 717                                   bloat = -1;
 718                                 } else if (strcmp(optarg, "fat") == 0) {
 719                                   if (bloat < 0)
 720                                     error(_("incompatible -b options"));
 721                                   bloat = 1;
 722                                 } else
 723                                   error(_("invalid option: -b '%s'"), optarg);
 724                                 break;
 725                         case 'd':
 726                                 if (directory == NULL)
 727                                         directory = optarg;
 728                                 else {
 729                                         fprintf(stderr,
 730 _("%s: More than one -d option specified\n"),
 731                                                 progname);
 732                                         return EXIT_FAILURE;
 733                                 }
 734                                 break;
 735                         case 'l':
 736                                 if (lcltime == NULL)
 737                                         lcltime = optarg;
 738                                 else {
 739                                         fprintf(stderr,
 740 _("%s: More than one -l option specified\n"),
 741                                                 progname);
 742                                         return EXIT_FAILURE;
 743                                 }
 744                                 break;
 745                         case 'p':
 746                                 if (psxrules == NULL)
 747                                         psxrules = optarg;
 748                                 else {
 749                                         fprintf(stderr,
 750 _("%s: More than one -p option specified\n"),
 751                                                 progname);
 752                                         return EXIT_FAILURE;
 753                                 }
 754                                 break;
 755                         case 't':
 756                                 if (tzdefault != NULL) {
 757                                   fprintf(stderr,
 758                                           _("%s: More than one -t option"
 759                                             " specified\n"),
 760                                           progname);
 761                                   return EXIT_FAILURE;
 762                                 }
 763                                 tzdefault = optarg;
 764                                 break;
 765                         case 'y':
 766                                 if (yitcommand == NULL) {
 767                                         warning(_("-y is obsolescent"));
 768                                         yitcommand = optarg;
 769                                 } else {
 770                                         fprintf(stderr,
 771 _("%s: More than one -y option specified\n"),
 772                                                 progname);
 773                                         return EXIT_FAILURE;
 774                                 }
 775                                 break;
 776                         case 'L':
 777                                 if (leapsec == NULL)
 778                                         leapsec = optarg;
 779                                 else {
 780                                         fprintf(stderr,
 781 _("%s: More than one -L option specified\n"),
 782                                                 progname);
 783                                         return EXIT_FAILURE;
 784                                 }
 785                                 break;
 786                         case 'v':
 787                                 noise = true;
 788                                 break;
 789                         case 'r':
 790                                 if (timerange_given) {
 791                                   fprintf(stderr,
 792 _("%s: More than one -r option specified\n"),
 793                                           progname);
 794                                   return EXIT_FAILURE;
 795                                 }
 796                                 if (! timerange_option(optarg)) {
 797                                   fprintf(stderr,
 798 _("%s: invalid time range: %s\n"),
 799                                           progname, optarg);
 800                                   return EXIT_FAILURE;
 801                                 }
 802                                 timerange_given = true;
 803                                 break;
 804                         case 's':
 805                                 warning(_("-s ignored"));
 806                                 break;
 807                 }
 808         if (optind == argc - 1 && strcmp(argv[optind], "=") == 0)
 809                 usage(stderr, EXIT_FAILURE);    /* usage message by request */
 810         if (bloat == 0)
 811           bloat = strcmp(ZIC_BLOAT_DEFAULT, "slim") == 0 ? -1 : 1;
 812         if (directory == NULL)
 813                 directory = TZDIR;
 814         if (tzdefault == NULL)
 815                 tzdefault = TZDEFAULT;
 816         if (yitcommand == NULL)
 817                 yitcommand = "yearistype";
 818
 819         if (optind < argc && leapsec != NULL) {
 820                 infile(leapsec);
 821                 adjleap();
 822         }
 823
 824         for (k = optind; k < argc; k++)
 825                 infile(argv[k]);
 826         if (errors)
 827                 return EXIT_FAILURE;
 828         associate();
 829         change_directory(directory);
 830         for (i = 0; i < nzones; i = j) {
 831                 /*
 832                 ** Find the next non-continuation zone entry.
 833                 */
 834                 for (j = i + 1; j < nzones && zones[j].z_name == NULL; ++j)
 835                         continue;
 836                 outzone(&zones[i], j - i);
 837         }
 838         /*
 839         ** Make links.
 840         */
 841         for (i = 0; i < nlinks; ++i) {
 842                 eat(links[i].l_filename, links[i].l_linenum);
 843                 dolink(links[i].l_from, links[i].l_to, false);
 844                 if (noise)
 845                         for (j = 0; j < nlinks; ++j)
 846                                 if (strcmp(links[i].l_to,
 847                                         links[j].l_from) == 0)
 848                                                 warning(_("link to link"));
 849         }
 850         if (lcltime != NULL) {
 851                 eat(_("command line"), 1);
 852                 dolink(lcltime, tzdefault, true);
 853         }
 854         if (psxrules != NULL) {
 855                 eat(_("command line"), 1);
 856                 dolink(psxrules, TZDEFRULES, true);
 857         }
 858         if (warnings && (ferror(stderr) || fclose(stderr) != 0))
 859           return EXIT_FAILURE;
 860         return errors ? EXIT_FAILURE : EXIT_SUCCESS;
 861 }
 862
 863 static bool
 864 componentcheck(char const *name, char const *component,
 865                char const *component_end)
 866 {
 867         enum { component_len_max = 14 };
 868         ptrdiff_t component_len = component_end - component;
 869         if (component_len == 0) {
 870           if (!*name)
 871             error (_("empty file name"));
 872           else
 873             error (_(component == name
 874                      ? "file name '%s' begins with '/'"
 875                      : *component_end
 876                      ? "file name '%s' contains '//'"
 877                      : "file name '%s' ends with '/'"),
 878                    name);
 879           return false;
 880         }
 881         if (0 < component_len && component_len <= 2
 882             && component[0] == '.' && component_end[-1] == '.') {
 883           int len = component_len;
 884           error(_("file name '%s' contains '%.*s' component"),
 885                 name, len, component);
 886           return false;
 887         }
 888         if (noise) {
 889           if (0 < component_len && component[0] == '-')
 890             warning(_("file name '%s' component contains leading '-'"),
 891                     name);
 892           if (component_len_max < component_len)
 893             warning(_("file name '%s' contains overlength component"
 894                       " '%.*s...'"),
 895                     name, component_len_max, component);
 896         }
 897         return true;
 898 }
 899
 900 static bool
 901 namecheck(const char *name)
 902 {
 903         register char const *cp;
 904
 905         /* Benign characters in a portable file name.  */
 906         static char const benign[] =
 907           "-/_"
 908           "abcdefghijklmnopqrstuvwxyz"
 909           "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 910
 911         /* Non-control chars in the POSIX portable character set,
 912            excluding the benign characters.  */
 913         static char const printable_and_not_benign[] =
 914           " !\"#$%&'()*+,.0123456789:;<=>?@[\\]^`{|}~";
 915
 916         register char const *component = name;
 917         for (cp = name; *cp; cp++) {
 918                 unsigned char c = *cp;
 919                 if (noise && !strchr(benign, c)) {
 920                         warning((strchr(printable_and_not_benign, c)
 921                                  ? _("file name '%s' contains byte '%c'")
 922                                  : _("file name '%s' contains byte '\\%o'")),
 923                                 name, c);
 924                 }
 925                 if (c == '/') {
 926                         if (!componentcheck(name, component, cp))
 927                           return false;
 928                         component = cp + 1;
 929                 }
 930         }
 931         return componentcheck(name, component, cp);
 932 }
 933
 934 /* Create symlink contents suitable for symlinking FROM to TO, as a
 935    freshly allocated string.  FROM should be a relative file name, and
 936    is relative to the global variable DIRECTORY.  TO can be either
 937    relative or absolute.  */
 938 static char *
 939 relname(char const *from, char const *to)
 940 {
 941   size_t i, taillen, dotdotetcsize;
 942   size_t dir_len = 0, dotdots = 0, linksize = SIZE_MAX;
 943   char const *f = from;
 944   char *result = NULL;
 945   if (*to == '/') {
 946     /* Make F absolute too.  */
 947     size_t len = strlen(directory);
 948     bool needslash = len && directory[len - 1] != '/';
 949     linksize = len + needslash + strlen(from) + 1;
 950     f = result = emalloc(linksize);
 951     strcpy(result, directory);
 952     result[len] = '/';
 953     strcpy(result + len + needslash, from);
 954   }
 955   for (i = 0; f[i] && f[i] == to[i]; i++)
 956     if (f[i] == '/')
 957       dir_len = i + 1;
 958   for (; to[i]; i++)
 959     dotdots += to[i] == '/' && to[i - 1] != '/';
 960   taillen = strlen(f + dir_len);
 961   dotdotetcsize = 3 * dotdots + taillen + 1;
 962   if (dotdotetcsize <= linksize) {
 963     if (!result)
 964       result = emalloc(dotdotetcsize);
 965     for (i = 0; i < dotdots; i++)
 966       memcpy(result + 3 * i, "../", 3);
 967     memmove(result + 3 * dotdots, f + dir_len, taillen + 1);
 968   }
 969   return result;
 970 }
 971
 972 /* Hard link FROM to TO, following any symbolic links.
 973    Return 0 if successful, an error number otherwise.  */
 974 static int
 975 hardlinkerr(char const *from, char const *to)
 976 {
 977   int r = linkat(AT_FDCWD, from, AT_FDCWD, to, AT_SYMLINK_FOLLOW);
 978   return r == 0 ? 0 : errno;
 979 }
 980
 981 static void
 982 dolink(char const *fromfield, char const *tofield, bool staysymlink)
 983 {
 984         bool todirs_made = false;
 985         int link_errno;
 986
 987         /*
 988         ** We get to be careful here since
 989         ** there's a fair chance of root running us.
 990         */
 991         if (itsdir(fromfield)) {
 992                 fprintf(stderr, _("%s: link from %s/%s failed: %s\n"),
 993                         progname, directory, fromfield, strerror(EPERM));
 994                 exit(EXIT_FAILURE);
 995         }
 996         if (staysymlink)
 997           staysymlink = itssymlink(tofield);
 998         if (remove(tofield) == 0)
 999           todirs_made = true;
1000         else if (errno != ENOENT) {
1001           char const *e = strerror(errno);
1002           fprintf(stderr, _("%s: Can't remove %s/%s: %s\n"),
1003                   progname, directory, tofield, e);
1004           exit(EXIT_FAILURE);
1005         }
1006         link_errno = staysymlink ? ENOTSUP : hardlinkerr(fromfield, tofield);
1007         if (link_errno == ENOENT && !todirs_made) {
1008           mkdirs(tofield, true);
1009           todirs_made = true;
1010           link_errno = hardlinkerr(fromfield, tofield);
1011         }
1012         if (link_errno != 0) {
1013           bool absolute = *fromfield == '/';
1014           char *linkalloc = absolute ? NULL : relname(fromfield, tofield);
1015           char const *contents = absolute ? fromfield : linkalloc;
1016           int symlink_errno = symlink(contents, tofield) == 0 ? 0 : errno;
1017           if (!todirs_made
1018               && (symlink_errno == ENOENT || symlink_errno == ENOTSUP)) {
1019             mkdirs(tofield, true);
1020             if (symlink_errno == ENOENT)
1021               symlink_errno = symlink(contents, tofield) == 0 ? 0 : errno;
1022           }
1023           free(linkalloc);
1024           if (symlink_errno == 0) {
1025             if (link_errno != ENOTSUP)
1026               warning(_("symbolic link used because hard link failed: %s"),
1027                       strerror(link_errno));
1028           } else {
1029             FILE *fp, *tp;
1030             int c;
1031             fp = fopen(fromfield, "rb");
1032             if (!fp) {
1033               char const *e = strerror(errno);
1034               fprintf(stderr, _("%s: Can't read %s/%s: %s\n"),
1035                       progname, directory, fromfield, e);
1036               exit(EXIT_FAILURE);
1037             }
1038             tp = fopen(tofield, "wb");
1039             if (!tp) {
1040               char const *e = strerror(errno);
1041               fprintf(stderr, _("%s: Can't create %s/%s: %s\n"),
1042                       progname, directory, tofield, e);
1043               exit(EXIT_FAILURE);
1044             }
1045             while ((c = getc(fp)) != EOF)
1046               putc(c, tp);
1047             close_file(fp, directory, fromfield);
1048             close_file(tp, directory, tofield);
1049             if (link_errno != ENOTSUP)
1050               warning(_("copy used because hard link failed: %s"),
1051                       strerror(link_errno));
1052             else if (symlink_errno != ENOTSUP)
1053               warning(_("copy used because symbolic link failed: %s"),
1054                       strerror(symlink_errno));
1055           }
1056         }
1057 }
1058
1059 /* Return true if NAME is a directory.  */
1060 static bool
1061 itsdir(char const *name)
1062 {
1063         struct stat st;
1064         int res = stat(name, &st);
1065 #ifdef S_ISDIR
1066         if (res == 0)
1067                 return S_ISDIR(st.st_mode) != 0;
1068 #endif
1069         if (res == 0 || errno == EOVERFLOW) {
1070                 size_t n = strlen(name);
1071                 char *nameslashdot = emalloc(n + 3);
1072                 bool dir;
1073                 memcpy(nameslashdot, name, n);
1074                 strcpy(&nameslashdot[n], &"/."[! (n && name[n - 1] != '/')]);
1075                 dir = stat(nameslashdot, &st) == 0 || errno == EOVERFLOW;
1076                 free(nameslashdot);
1077                 return dir;
1078         }
1079         return false;
1080 }
1081
1082 /* Return true if NAME is a symbolic link.  */
1083 static bool
1084 itssymlink(char const *name)
1085 {
1086   char c;
1087   return 0 <= readlink(name, &c, 1);
1088 }
1089
1090 /*
1091 ** Associate sets of rules with zones.
1092 */
1093
1094 /*
1095 ** Sort by rule name.
1096 */
1097
1098 static int
1099 rcomp(const void *cp1, const void *cp2)
1100 {
1101         return strcmp(((const struct rule *) cp1)->r_name,
1102                 ((const struct rule *) cp2)->r_name);
1103 }
1104
1105 static void
1106 associate(void)
1107 {
1108         register struct zone *  zp;
1109         register struct rule *  rp;
1110         register ptrdiff_t i, j, base, out;
1111
1112         if (nrules != 0) {
1113                 qsort(rules, nrules, sizeof *rules, rcomp);
1114                 for (i = 0; i < nrules - 1; ++i) {
1115                         if (strcmp(rules[i].r_name,
1116                                 rules[i + 1].r_name) != 0)
1117                                         continue;
1118                         if (strcmp(rules[i].r_filename,
1119                                 rules[i + 1].r_filename) == 0)
1120                                         continue;
1121                         eat(rules[i].r_filename, rules[i].r_linenum);
1122                         warning(_("same rule name in multiple files"));
1123                         eat(rules[i + 1].r_filename, rules[i + 1].r_linenum);
1124                         warning(_("same rule name in multiple files"));
1125                         for (j = i + 2; j < nrules; ++j) {
1126                                 if (strcmp(rules[i].r_name,
1127                                         rules[j].r_name) != 0)
1128                                                 break;
1129                                 if (strcmp(rules[i].r_filename,
1130                                         rules[j].r_filename) == 0)
1131                                                 continue;
1132                                 if (strcmp(rules[i + 1].r_filename,
1133                                         rules[j].r_filename) == 0)
1134                                                 continue;
1135                                 break;
1136                         }
1137                         i = j - 1;
1138                 }
1139         }
1140         for (i = 0; i < nzones; ++i) {
1141                 zp = &zones[i];
1142                 zp->z_rules = NULL;
1143                 zp->z_nrules = 0;
1144         }
1145         for (base = 0; base < nrules; base = out) {
1146                 rp = &rules[base];
1147                 for (out = base + 1; out < nrules; ++out)
1148                         if (strcmp(rp->r_name, rules[out].r_name) != 0)
1149                                 break;
1150                 for (i = 0; i < nzones; ++i) {
1151                         zp = &zones[i];
1152                         if (strcmp(zp->z_rule, rp->r_name) != 0)
1153                                 continue;
1154                         zp->z_rules = rp;
1155                         zp->z_nrules = out - base;
1156                 }
1157         }
1158         for (i = 0; i < nzones; ++i) {
1159                 zp = &zones[i];
1160                 if (zp->z_nrules == 0) {
1161                         /*
1162                         ** Maybe we have a local standard time offset.
1163                         */
1164                         eat(zp->z_filename, zp->z_linenum);
1165                         zp->z_save = getsave(zp->z_rule, &zp->z_isdst);
1166                         /*
1167                         ** Note, though, that if there's no rule,
1168                         ** a '%s' in the format is a bad thing.
1169                         */
1170                         if (zp->z_format_specifier == 's')
1171                                 error("%s", _("%s in ruleless zone"));
1172                 }
1173         }
1174         if (errors)
1175                 exit(EXIT_FAILURE);
1176 }
1177
1178 static void
1179 infile(const char *name)
1180 {
1181         register FILE *                 fp;
1182         register char **                fields;
1183         register char *                 cp;
1184         register const struct lookup *  lp;
1185         register int                    nfields;
1186         register bool                   wantcont;
1187         register lineno                 num;
1188         char                            buf[BUFSIZ];
1189
1190         if (strcmp(name, "-") == 0) {
1191                 name = _("standard input");
1192                 fp = stdin;
1193         } else if ((fp = fopen(name, "r")) == NULL) {
1194                 const char *e = strerror(errno);
1195
1196                 fprintf(stderr, _("%s: Can't open %s: %s\n"),
1197                         progname, name, e);
1198                 exit(EXIT_FAILURE);
1199         }
1200         wantcont = false;
1201         for (num = 1; ; ++num) {
1202                 eat(name, num);
1203                 if (fgets(buf, sizeof buf, fp) != buf)
1204                         break;
1205                 cp = strchr(buf, '\n');
1206                 if (cp == NULL) {
1207                         error(_("line too long"));
1208                         exit(EXIT_FAILURE);
1209                 }
1210                 *cp = '\0';
1211                 fields = getfields(buf);
1212                 nfields = 0;
1213                 while (fields[nfields] != NULL) {
1214                         static char     nada;
1215
1216                         if (strcmp(fields[nfields], "-") == 0)
1217                                 fields[nfields] = &nada;
1218                         ++nfields;
1219                 }
1220                 if (nfields == 0) {
1221                   if (name == leapsec && *buf == '#')
1222                     sscanf(buf, "#expires %"SCNdZIC, &comment_leapexpires);
1223                 } else if (wantcont) {
1224                         wantcont = inzcont(fields, nfields);
1225                 } else {
1226                         struct lookup const *line_codes
1227                           = name == leapsec ? leap_line_codes : zi_line_codes;
1228                         lp = byword(fields[0], line_codes);
1229                         if (lp == NULL)
1230                                 error(_("input line of unknown type"));
1231                         else switch (lp->l_value) {
1232                                 case LC_RULE:
1233                                         inrule(fields, nfields);
1234                                         wantcont = false;
1235                                         break;
1236                                 case LC_ZONE:
1237                                         wantcont = inzone(fields, nfields);
1238                                         break;
1239                                 case LC_LINK:
1240                                         inlink(fields, nfields);
1241                                         wantcont = false;
1242                                         break;
1243                                 case LC_LEAP:
1244                                         inleap(fields, nfields);
1245                                         wantcont = false;
1246                                         break;
1247                                 case LC_EXPIRES:
1248                                         inexpires(fields, nfields);
1249                                         wantcont = false;
1250                                         break;
1251                                 default:        /* "cannot happen" */
1252                                         fprintf(stderr,
1253 _("%s: panic: Invalid l_value %d\n"),
1254                                                 progname, lp->l_value);
1255                                         exit(EXIT_FAILURE);
1256                         }
1257                 }
1258                 free(fields);
1259         }
1260         close_file(fp, NULL, filename);
1261         if (wantcont)
1262                 error(_("expected continuation line not found"));
1263 }
1264
1265 /*
1266 ** Convert a string of one of the forms
1267 **      h       -h      hh:mm   -hh:mm  hh:mm:ss        -hh:mm:ss
1268 ** into a number of seconds.
1269 ** A null string maps to zero.
1270 ** Call error with errstring and return zero on errors.
1271 */
1272
1273 static zic_t
1274 gethms(char const *string, char const *errstring)
1275 {
1276         zic_t   hh;
1277         int sign, mm = 0, ss = 0;
1278         char hhx, mmx, ssx, xr = '0', xs;
1279         int tenths = 0;
1280         bool ok = true;
1281
1282         if (string == NULL || *string == '\0')
1283                 return 0;
1284         if (*string == '-') {
1285                 sign = -1;
1286                 ++string;
1287         } else  sign = 1;
1288         switch (sscanf(string,
1289                        "%"SCNdZIC"%c%d%c%d%c%1d%*[0]%c%*[0123456789]%c",
1290                        &hh, &hhx, &mm, &mmx, &ss, &ssx, &tenths, &xr, &xs)) {
1291           default: ok = false; break;
1292           case 8:
1293             ok = '0' <= xr && xr <= '9';
1294             /* fallthrough */
1295           case 7:
1296             ok &= ssx == '.';
1297             if (ok && noise)
1298               warning(_("fractional seconds rejected by"
1299                         " pre-2018 versions of zic"));
1300             /* fallthrough */
1301           case 5: ok &= mmx == ':'; /* fallthrough */
1302           case 3: ok &= hhx == ':'; /* fallthrough */
1303           case 1: break;
1304         }
1305         if (!ok) {
1306                         error("%s", errstring);
1307                         return 0;
1308         }
1309         if (hh < 0 ||
1310                 mm < 0 || mm >= MINSPERHOUR ||
1311                 ss < 0 || ss > SECSPERMIN) {
1312                         error("%s", errstring);
1313                         return 0;
1314         }
1315         if (ZIC_MAX / SECSPERHOUR < hh) {
1316                 error(_("time overflow"));
1317                 return 0;
1318         }
1319         ss += 5 + ((ss ^ 1) & (xr == '0')) <= tenths; /* Round to even.  */
1320         if (noise && (hh > HOURSPERDAY ||
1321                 (hh == HOURSPERDAY && (mm != 0 || ss != 0))))
1322 warning(_("values over 24 hours not handled by pre-2007 versions of zic"));
1323         return oadd(sign * hh * SECSPERHOUR,
1324                     sign * (mm * SECSPERMIN + ss));
1325 }
1326
1327 static zic_t
1328 getsave(char *field, bool *isdst)
1329 {
1330   int dst = -1;
1331   zic_t save;
1332   size_t fieldlen = strlen(field);
1333   if (fieldlen != 0) {
1334     char *ep = field + fieldlen - 1;
1335     switch (*ep) {
1336       case 'd': dst = 1; *ep = '\0'; break;
1337       case 's': dst = 0; *ep = '\0'; break;
1338     }
1339   }
1340   save = gethms(field, _("invalid saved time"));
1341   *isdst = dst < 0 ? save != 0 : dst;
1342   return save;
1343 }
1344
1345 static void
1346 inrule(char **fields, int nfields)
1347 {
1348         static struct rule      r;
1349
1350         if (nfields != RULE_FIELDS) {
1351                 error(_("wrong number of fields on Rule line"));
1352                 return;
1353         }
1354         switch (*fields[RF_NAME]) {
1355           case '\0':
1356           case ' ': case '\f': case '\n': case '\r': case '\t': case '\v':
1357           case '+': case '-':
1358           case '0': case '1': case '2': case '3': case '4':
1359           case '5': case '6': case '7': case '8': case '9':
1360                 error(_("Invalid rule name \"%s\""), fields[RF_NAME]);
1361                 return;
1362         }
1363         r.r_filename = filename;
1364         r.r_linenum = linenum;
1365         r.r_save = getsave(fields[RF_SAVE], &r.r_isdst);
1366         rulesub(&r, fields[RF_LOYEAR], fields[RF_HIYEAR], fields[RF_COMMAND],
1367                 fields[RF_MONTH], fields[RF_DAY], fields[RF_TOD]);
1368         r.r_name = ecpyalloc(fields[RF_NAME]);
1369         r.r_abbrvar = ecpyalloc(fields[RF_ABBRVAR]);
1370         if (max_abbrvar_len < strlen(r.r_abbrvar))
1371                 max_abbrvar_len = strlen(r.r_abbrvar);
1372         rules = growalloc(rules, sizeof *rules, nrules, &nrules_alloc);
1373         rules[nrules++] = r;
1374 }
1375
1376 static bool
1377 inzone(char **fields, int nfields)
1378 {
1379         register ptrdiff_t i;
1380
1381         if (nfields < ZONE_MINFIELDS || nfields > ZONE_MAXFIELDS) {
1382                 error(_("wrong number of fields on Zone line"));
1383                 return false;
1384         }
1385         if (lcltime != NULL && strcmp(fields[ZF_NAME], tzdefault) == 0) {
1386                 error(
1387 _("\"Zone %s\" line and -l option are mutually exclusive"),
1388                         tzdefault);
1389                 return false;
1390         }
1391         if (strcmp(fields[ZF_NAME], TZDEFRULES) == 0 && psxrules != NULL) {
1392                 error(
1393 _("\"Zone %s\" line and -p option are mutually exclusive"),
1394                         TZDEFRULES);
1395                 return false;
1396         }
1397         for (i = 0; i < nzones; ++i)
1398                 if (zones[i].z_name != NULL &&
1399                         strcmp(zones[i].z_name, fields[ZF_NAME]) == 0) {
1400                                 error(_("duplicate zone name %s"
1401                                         " (file \"%s\", line %"PRIdMAX")"),
1402                                         fields[ZF_NAME],
1403                                         zones[i].z_filename,
1404                                         zones[i].z_linenum);
1405                                 return false;
1406                 }
1407         return inzsub(fields, nfields, false);
1408 }
1409
1410 static bool
1411 inzcont(char **fields, int nfields)
1412 {
1413         if (nfields < ZONEC_MINFIELDS || nfields > ZONEC_MAXFIELDS) {
1414                 error(_("wrong number of fields on Zone continuation line"));
1415                 return false;
1416         }
1417         return inzsub(fields, nfields, true);
1418 }
1419
1420 static bool
1421 inzsub(char **fields, int nfields, bool iscont)
1422 {
1423         register char *         cp;
1424         char *                  cp1;
1425         static struct zone      z;
1426         register int            i_stdoff, i_rule, i_format;
1427         register int            i_untilyear, i_untilmonth;
1428         register int            i_untilday, i_untiltime;
1429         register bool           hasuntil;
1430
1431         if (iscont) {
1432                 i_stdoff = ZFC_STDOFF;
1433                 i_rule = ZFC_RULE;
1434                 i_format = ZFC_FORMAT;
1435                 i_untilyear = ZFC_TILYEAR;
1436                 i_untilmonth = ZFC_TILMONTH;
1437                 i_untilday = ZFC_TILDAY;
1438                 i_untiltime = ZFC_TILTIME;
1439                 z.z_name = NULL;
1440         } else if (!namecheck(fields[ZF_NAME]))
1441                 return false;
1442         else {
1443                 i_stdoff = ZF_STDOFF;
1444                 i_rule = ZF_RULE;
1445                 i_format = ZF_FORMAT;
1446                 i_untilyear = ZF_TILYEAR;
1447                 i_untilmonth = ZF_TILMONTH;
1448                 i_untilday = ZF_TILDAY;
1449                 i_untiltime = ZF_TILTIME;
1450                 z.z_name = ecpyalloc(fields[ZF_NAME]);
1451         }
1452         z.z_filename = filename;
1453         z.z_linenum = linenum;
1454         z.z_stdoff = gethms(fields[i_stdoff], _("invalid UT offset"));
1455         if ((cp = strchr(fields[i_format], '%')) != 0) {
1456                 if ((*++cp != 's' && *cp != 'z') || strchr(cp, '%')
1457                     || strchr(fields[i_format], '/')) {
1458                         error(_("invalid abbreviation format"));
1459                         return false;
1460                 }
1461         }
1462         z.z_rule = ecpyalloc(fields[i_rule]);
1463         z.z_format = cp1 = ecpyalloc(fields[i_format]);
1464         z.z_format_specifier = cp ? *cp : '\0';
1465         if (z.z_format_specifier == 'z') {
1466           if (noise)
1467             warning(_("format '%s' not handled by pre-2015 versions of zic"),
1468                     z.z_format);
1469           cp1[cp - fields[i_format]] = 's';
1470         }
1471         if (max_format_len < strlen(z.z_format))
1472                 max_format_len = strlen(z.z_format);
1473         hasuntil = nfields > i_untilyear;
1474         if (hasuntil) {
1475                 z.z_untilrule.r_filename = filename;
1476                 z.z_untilrule.r_linenum = linenum;
1477                 rulesub(&z.z_untilrule,
1478                         fields[i_untilyear],
1479                         "only",
1480                         "",
1481                         (nfields > i_untilmonth) ?
1482                         fields[i_untilmonth] : "Jan",
1483                         (nfields > i_untilday) ? fields[i_untilday] : "1",
1484                         (nfields > i_untiltime) ? fields[i_untiltime] : "0");
1485                 z.z_untiltime = rpytime(&z.z_untilrule,
1486                         z.z_untilrule.r_loyear);
1487                 if (iscont && nzones > 0 &&
1488                         z.z_untiltime > min_time &&
1489                         z.z_untiltime < max_time &&
1490                         zones[nzones - 1].z_untiltime > min_time &&
1491                         zones[nzones - 1].z_untiltime < max_time &&
1492                         zones[nzones - 1].z_untiltime >= z.z_untiltime) {
1493                                 error(_(
1494 "Zone continuation line end time is not after end time of previous line"
1495                                         ));
1496                                 return false;
1497                 }
1498         }
1499         zones = growalloc(zones, sizeof *zones, nzones, &nzones_alloc);
1500         zones[nzones++] = z;
1501         /*
1502         ** If there was an UNTIL field on this line,
1503         ** there's more information about the zone on the next line.
1504         */
1505         return hasuntil;
1506 }
1507
1508 static zic_t
1509 getleapdatetime(char **fields, int nfields, bool expire_line)
1510 {
1511         register const char *           cp;
1512         register const struct lookup *  lp;
1513         register zic_t                  i, j;
1514         zic_t                           year;
1515         int                             month, day;
1516         zic_t                           dayoff, tod;
1517         zic_t                           t;
1518         char xs;
1519
1520         dayoff = 0;
1521         cp = fields[LP_YEAR];
1522         if (sscanf(cp, "%"SCNdZIC"%c", &year, &xs) != 1) {
1523                 /*
1524                 ** Leapin' Lizards!
1525                 */
1526                 error(_("invalid leaping year"));
1527                 return -1;
1528         }
1529         if (!expire_line) {
1530             if (!leapseen || leapmaxyear < year)
1531                 leapmaxyear = year;
1532             if (!leapseen || leapminyear > year)
1533                 leapminyear = year;
1534             leapseen = true;
1535         }
1536         j = EPOCH_YEAR;
1537         while (j != year) {
1538                 if (year > j) {
1539                         i = len_years[isleap(j)];
1540                         ++j;
1541                 } else {
1542                         --j;
1543                         i = -len_years[isleap(j)];
1544                 }
1545                 dayoff = oadd(dayoff, i);
1546         }
1547         if ((lp = byword(fields[LP_MONTH], mon_names)) == NULL) {
1548                 error(_("invalid month name"));
1549                 return -1;
1550         }
1551         month = lp->l_value;
1552         j = TM_JANUARY;
1553         while (j != month) {
1554                 i = len_months[isleap(year)][j];
1555                 dayoff = oadd(dayoff, i);
1556                 ++j;
1557         }
1558         cp = fields[LP_DAY];
1559         if (sscanf(cp, "%d%c", &day, &xs) != 1 ||
1560                 day <= 0 || day > len_months[isleap(year)][month]) {
1561                         error(_("invalid day of month"));
1562                         return -1;
1563         }
1564         dayoff = oadd(dayoff, day - 1);
1565         if (dayoff < min_time / SECSPERDAY) {
1566                 error(_("time too small"));
1567                 return -1;
1568         }
1569         if (dayoff > max_time / SECSPERDAY) {
1570                 error(_("time too large"));
1571                 return -1;
1572         }
1573         t = dayoff * SECSPERDAY;
1574         tod = gethms(fields[LP_TIME], _("invalid time of day"));
1575         t = tadd(t, tod);
1576         if (t < 0)
1577           error(_("leap second precedes Epoch"));
1578         return t;
1579 }
1580
1581 static void
1582 inleap(char **fields, int nfields)
1583 {
1584   if (nfields != LEAP_FIELDS)
1585     error(_("wrong number of fields on Leap line"));
1586   else {
1587     zic_t t = getleapdatetime(fields, nfields, false);
1588     if (0 <= t) {
1589       struct lookup const *lp = byword(fields[LP_ROLL], leap_types);
1590       if (!lp)
1591         error(_("invalid Rolling/Stationary field on Leap line"));
1592       else {
1593         int correction = 0;
1594         if (!fields[LP_CORR][0]) /* infile() turns "-" into "".  */
1595           correction = -1;
1596         else if (strcmp(fields[LP_CORR], "+") == 0)
1597           correction = 1;
1598         else
1599           error(_("invalid CORRECTION field on Leap line"));
1600         if (correction)
1601           leapadd(t, correction, lp->l_value);
1602       }
1603     }
1604   }
1605 }
1606
1607 static void
1608 inexpires(char **fields, int nfields)
1609 {
1610   if (nfields != EXPIRES_FIELDS)
1611     error(_("wrong number of fields on Expires line"));
1612   else if (0 <= leapexpires)
1613     error(_("multiple Expires lines"));
1614   else
1615     leapexpires = getleapdatetime(fields, nfields, true);
1616 }
1617
1618 static void
1619 inlink(char **fields, int nfields)
1620 {
1621         struct link     l;
1622
1623         if (nfields != LINK_FIELDS) {
1624                 error(_("wrong number of fields on Link line"));
1625                 return;
1626         }
1627         if (*fields[LF_FROM] == '\0') {
1628                 error(_("blank FROM field on Link line"));
1629                 return;
1630         }
1631         if (! namecheck(fields[LF_TO]))
1632           return;
1633         l.l_filename = filename;
1634         l.l_linenum = linenum;
1635         l.l_from = ecpyalloc(fields[LF_FROM]);
1636         l.l_to = ecpyalloc(fields[LF_TO]);
1637         links = growalloc(links, sizeof *links, nlinks, &nlinks_alloc);
1638         links[nlinks++] = l;
1639 }
1640
1641 static void
1642 rulesub(struct rule *rp, const char *loyearp, const char *hiyearp,
1643         const char *typep, const char *monthp, const char *dayp,
1644         const char *timep)
1645 {
1646         register const struct lookup *  lp;
1647         register const char *           cp;
1648         register char *                 dp;
1649         register char *                 ep;
1650         char xs;
1651
1652         if ((lp = byword(monthp, mon_names)) == NULL) {
1653                 error(_("invalid month name"));
1654                 return;
1655         }
1656         rp->r_month = lp->l_value;
1657         rp->r_todisstd = false;
1658         rp->r_todisut = false;
1659         dp = ecpyalloc(timep);
1660         if (*dp != '\0') {
1661                 ep = dp + strlen(dp) - 1;
1662                 switch (lowerit(*ep)) {
1663                         case 's':       /* Standard */
1664                                 rp->r_todisstd = true;
1665                                 rp->r_todisut = false;
1666                                 *ep = '\0';
1667                                 break;
1668                         case 'w':       /* Wall */
1669                                 rp->r_todisstd = false;
1670                                 rp->r_todisut = false;
1671                                 *ep = '\0';
1672                                 break;
1673                         case 'g':       /* Greenwich */
1674                         case 'u':       /* Universal */
1675                         case 'z':       /* Zulu */
1676                                 rp->r_todisstd = true;
1677                                 rp->r_todisut = true;
1678                                 *ep = '\0';
1679                                 break;
1680                 }
1681         }
1682         rp->r_tod = gethms(dp, _("invalid time of day"));
1683         free(dp);
1684         /*
1685         ** Year work.
1686         */
1687         cp = loyearp;
1688         lp = byword(cp, begin_years);
1689         rp->r_lowasnum = lp == NULL;
1690         if (!rp->r_lowasnum) switch (lp->l_value) {
1691                 case YR_MINIMUM:
1692                         rp->r_loyear = ZIC_MIN;
1693                         break;
1694                 case YR_MAXIMUM:
1695                         rp->r_loyear = ZIC_MAX;
1696                         break;
1697                 default:        /* "cannot happen" */
1698                         fprintf(stderr,
1699                                 _("%s: panic: Invalid l_value %d\n"),
1700                                 progname, lp->l_value);
1701                         exit(EXIT_FAILURE);
1702         } else if (sscanf(cp, "%"SCNdZIC"%c", &rp->r_loyear, &xs) != 1) {
1703                 error(_("invalid starting year"));
1704                 return;
1705         }
1706         cp = hiyearp;
1707         lp = byword(cp, end_years);
1708         rp->r_hiwasnum = lp == NULL;
1709         if (!rp->r_hiwasnum) switch (lp->l_value) {
1710                 case YR_MINIMUM:
1711                         rp->r_hiyear = ZIC_MIN;
1712                         break;
1713                 case YR_MAXIMUM:
1714                         rp->r_hiyear = ZIC_MAX;
1715                         break;
1716                 case YR_ONLY:
1717                         rp->r_hiyear = rp->r_loyear;
1718                         break;
1719                 default:        /* "cannot happen" */
1720                         fprintf(stderr,
1721                                 _("%s: panic: Invalid l_value %d\n"),
1722                                 progname, lp->l_value);
1723                         exit(EXIT_FAILURE);
1724         } else if (sscanf(cp, "%"SCNdZIC"%c", &rp->r_hiyear, &xs) != 1) {
1725                 error(_("invalid ending year"));
1726                 return;
1727         }
1728         if (rp->r_loyear > rp->r_hiyear) {
1729                 error(_("starting year greater than ending year"));
1730                 return;
1731         }
1732         if (*typep == '\0')
1733                 rp->r_yrtype = NULL;
1734         else {
1735                 if (rp->r_loyear == rp->r_hiyear) {
1736                         error(_("typed single year"));
1737                         return;
1738                 }
1739                 warning(_("year type \"%s\" is obsolete; use \"-\" instead"),
1740                         typep);
1741                 rp->r_yrtype = ecpyalloc(typep);
1742         }
1743         /*
1744         ** Day work.
1745         ** Accept things such as:
1746         **      1
1747         **      lastSunday
1748         **      last-Sunday (undocumented; warn about this)
1749         **      Sun<=20
1750         **      Sun>=7
1751         */
1752         dp = ecpyalloc(dayp);
1753         if ((lp = byword(dp, lasts)) != NULL) {
1754                 rp->r_dycode = DC_DOWLEQ;
1755                 rp->r_wday = lp->l_value;
1756                 rp->r_dayofmonth = len_months[1][rp->r_month];
1757         } else {
1758                 if ((ep = strchr(dp, '<')) != 0)
1759                         rp->r_dycode = DC_DOWLEQ;
1760                 else if ((ep = strchr(dp, '>')) != 0)
1761                         rp->r_dycode = DC_DOWGEQ;
1762                 else {
1763                         ep = dp;
1764                         rp->r_dycode = DC_DOM;
1765                 }
1766                 if (rp->r_dycode != DC_DOM) {
1767                         *ep++ = 0;
1768                         if (*ep++ != '=') {
1769                                 error(_("invalid day of month"));
1770                                 free(dp);
1771                                 return;
1772                         }
1773                         if ((lp = byword(dp, wday_names)) == NULL) {
1774                                 error(_("invalid weekday name"));
1775                                 free(dp);
1776                                 return;
1777                         }
1778                         rp->r_wday = lp->l_value;
1779                 }
1780                 if (sscanf(ep, "%d%c", &rp->r_dayofmonth, &xs) != 1 ||
1781                         rp->r_dayofmonth <= 0 ||
1782                         (rp->r_dayofmonth > len_months[1][rp->r_month])) {
1783                                 error(_("invalid day of month"));
1784                                 free(dp);
1785                                 return;
1786                 }
1787         }
1788         free(dp);
1789 }
1790
1791 static void
1792 convert(const int_fast32_t val, char *const buf)
1793 {
1794         register int    i;
1795         register int    shift;
1796         unsigned char *const b = (unsigned char *) buf;
1797
1798         for (i = 0, shift = 24; i < 4; ++i, shift -= 8)
1799                 b[i] = val >> shift;
1800 }
1801
1802 static void
1803 convert64(const zic_t val, char *const buf)
1804 {
1805         register int    i;
1806         register int    shift;
1807         unsigned char *const b = (unsigned char *) buf;
1808
1809         for (i = 0, shift = 56; i < 8; ++i, shift -= 8)
1810                 b[i] = val >> shift;
1811 }
1812
1813 static void
1814 puttzcode(const int_fast32_t val, FILE *const fp)
1815 {
1816         char    buf[4];
1817
1818         convert(val, buf);
1819         fwrite(buf, sizeof buf, 1, fp);
1820 }
1821
1822 static void
1823 puttzcodepass(zic_t val, FILE *fp, int pass)
1824 {
1825   if (pass == 1)
1826     puttzcode(val, fp);
1827   else {
1828         char    buf[8];
1829
1830         convert64(val, buf);
1831         fwrite(buf, sizeof buf, 1, fp);
1832   }
1833 }
1834
1835 static int
1836 atcomp(const void *avp, const void *bvp)
1837 {
1838         const zic_t     a = ((const struct attype *) avp)->at;
1839         const zic_t     b = ((const struct attype *) bvp)->at;
1840
1841         return (a < b) ? -1 : (a > b);
1842 }
1843
1844 struct timerange {
1845   int defaulttype;
1846   ptrdiff_t base, count;
1847   int leapbase, leapcount;
1848 };
1849
1850 static struct timerange
1851 limitrange(struct timerange r, zic_t lo, zic_t hi,
1852            zic_t const *ats, unsigned char const *types)
1853 {
1854   while (0 < r.count && ats[r.base] < lo) {
1855     r.defaulttype = types[r.base];
1856     r.count--;
1857     r.base++;
1858   }
1859   while (0 < r.leapcount && trans[r.leapbase] < lo) {
1860     r.leapcount--;
1861     r.leapbase++;
1862   }
1863
1864   if (hi < ZIC_MAX) {
1865     while (0 < r.count && hi + 1 < ats[r.base + r.count - 1])
1866       r.count--;
1867     while (0 < r.leapcount && hi + 1 < trans[r.leapbase + r.leapcount - 1])
1868       r.leapcount--;
1869   }
1870
1871   return r;
1872 }
1873
1874 static void
1875 writezone(const char *const name, const char *const string, char version,
1876           int defaulttype)
1877 {
1878         register FILE *                 fp;
1879         register ptrdiff_t              i, j;
1880         register int                    pass;
1881         static const struct tzhead      tzh0;
1882         static struct tzhead            tzh;
1883         bool dir_checked = false;
1884         zic_t one = 1;
1885         zic_t y2038_boundary = one << 31;
1886         ptrdiff_t nats = timecnt + WORK_AROUND_QTBUG_53071;
1887
1888         /* Allocate the ATS and TYPES arrays via a single malloc,
1889            as this is a bit faster.  */
1890         zic_t *ats = emalloc(align_to(size_product(nats, sizeof *ats + 1),
1891                                       _Alignof(zic_t)));
1892         void *typesptr = ats + nats;
1893         unsigned char *types = typesptr;
1894         struct timerange rangeall, range32, range64;
1895
1896         /*
1897         ** Sort.
1898         */
1899         if (timecnt > 1)
1900                 qsort(attypes, timecnt, sizeof *attypes, atcomp);
1901         /*
1902         ** Optimize.
1903         */
1904         {
1905                 ptrdiff_t fromi, toi;
1906
1907                 toi = 0;
1908                 fromi = 0;
1909                 for ( ; fromi < timecnt; ++fromi) {
1910                         if (toi != 0
1911                             && ((attypes[fromi].at
1912                                  + utoffs[attypes[toi - 1].type])
1913                                 <= (attypes[toi - 1].at
1914                                     + utoffs[toi == 1 ? 0
1915                                              : attypes[toi - 2].type]))) {
1916                                         attypes[toi - 1].type =
1917                                                 attypes[fromi].type;
1918                                         continue;
1919                         }
1920                         if (toi == 0
1921                             || attypes[fromi].dontmerge
1922                             || (utoffs[attypes[toi - 1].type]
1923                                 != utoffs[attypes[fromi].type])
1924                             || (isdsts[attypes[toi - 1].type]
1925                                 != isdsts[attypes[fromi].type])
1926                             || (desigidx[attypes[toi - 1].type]
1927                                 != desigidx[attypes[fromi].type]))
1928                                         attypes[toi++] = attypes[fromi];
1929                 }
1930                 timecnt = toi;
1931         }
1932
1933         if (noise && timecnt > 1200) {
1934           if (timecnt > TZ_MAX_TIMES)
1935                 warning(_("reference clients mishandle"
1936                           " more than %d transition times"),
1937                         TZ_MAX_TIMES);
1938           else
1939                 warning(_("pre-2014 clients may mishandle"
1940                           " more than 1200 transition times"));
1941         }
1942         /*
1943         ** Transfer.
1944         */
1945         for (i = 0; i < timecnt; ++i) {
1946                 ats[i] = attypes[i].at;
1947                 types[i] = attypes[i].type;
1948         }
1949
1950         /*
1951         ** Correct for leap seconds.
1952         */
1953         for (i = 0; i < timecnt; ++i) {
1954                 j = leapcnt;
1955                 while (--j >= 0)
1956                         if (ats[i] > trans[j] - corr[j]) {
1957                                 ats[i] = tadd(ats[i], corr[j]);
1958                                 break;
1959                         }
1960         }
1961
1962         /* Work around QTBUG-53071 for timestamps less than y2038_boundary - 1,
1963            by inserting a no-op transition at time y2038_boundary - 1.
1964            This works only for timestamps before the boundary, which
1965            should be good enough in practice as QTBUG-53071 should be
1966            long-dead by 2038.  Do this after correcting for leap
1967            seconds, as the idea is to insert a transition just before
1968            32-bit time_t rolls around, and this occurs at a slightly
1969            different moment if transitions are leap-second corrected.  */
1970         if (WORK_AROUND_QTBUG_53071 && timecnt != 0 && want_bloat()
1971             && ats[timecnt - 1] < y2038_boundary - 1 && strchr(string, '<')) {
1972           ats[timecnt] = y2038_boundary - 1;
1973           types[timecnt] = types[timecnt - 1];
1974           timecnt++;
1975         }
1976
1977         rangeall.defaulttype = defaulttype;
1978         rangeall.base = rangeall.leapbase = 0;
1979         rangeall.count = timecnt;
1980         rangeall.leapcount = leapcnt;
1981         range64 = limitrange(rangeall, lo_time, hi_time, ats, types);
1982         range32 = limitrange(range64, INT32_MIN, INT32_MAX, ats, types);
1983
1984         /*
1985         ** Remove old file, if any, to snap links.
1986         */
1987         if (remove(name) == 0)
1988                 dir_checked = true;
1989         else if (errno != ENOENT) {
1990                 const char *e = strerror(errno);
1991
1992                 fprintf(stderr, _("%s: Can't remove %s/%s: %s\n"),
1993                         progname, directory, name, e);
1994                 exit(EXIT_FAILURE);
1995         }
1996         fp = fopen(name, "wb");
1997         if (!fp) {
1998           int fopen_errno = errno;
1999           if (fopen_errno == ENOENT && !dir_checked) {
2000             mkdirs(name, true);
2001             fp = fopen(name, "wb");
2002             fopen_errno = errno;
2003           }
2004           if (!fp) {
2005             fprintf(stderr, _("%s: Can't create %s/%s: %s\n"),
2006                     progname, directory, name, strerror(fopen_errno));
2007             exit(EXIT_FAILURE);
2008           }
2009         }
2010         for (pass = 1; pass <= 2; ++pass) {
2011                 register ptrdiff_t thistimei, thistimecnt, thistimelim;
2012                 register int    thisleapi, thisleapcnt, thisleaplim;
2013                 int currenttype, thisdefaulttype;
2014                 bool locut, hicut;
2015                 zic_t lo;
2016                 int old0;
2017                 char            omittype[TZ_MAX_TYPES];
2018                 int             typemap[TZ_MAX_TYPES];
2019                 int             thistypecnt, stdcnt, utcnt;
2020                 char            thischars[TZ_MAX_CHARS];
2021                 int             thischarcnt;
2022                 bool            toomanytimes;
2023                 int             indmap[TZ_MAX_CHARS];
2024
2025                 if (pass == 1) {
2026                         /* Arguably the default time type in the 32-bit data
2027                            should be range32.defaulttype, which is suited for
2028                            timestamps just before INT32_MIN.  However, zic
2029                            traditionally used the time type of the indefinite
2030                            past instead.  Internet RFC 8532 says readers should
2031                            ignore 32-bit data, so this discrepancy matters only
2032                            to obsolete readers where the traditional type might
2033                            be more appropriate even if it's "wrong".  So, use
2034                            the historical zic value, unless -r specifies a low
2035                            cutoff that excludes some 32-bit timestamps.  */
2036                         thisdefaulttype = (lo_time <= INT32_MIN
2037                                            ? range64.defaulttype
2038                                            : range32.defaulttype);
2039
2040                         thistimei = range32.base;
2041                         thistimecnt = range32.count;
2042                         toomanytimes = thistimecnt >> 31 >> 1 != 0;
2043                         thisleapi = range32.leapbase;
2044                         thisleapcnt = range32.leapcount;
2045                         locut = INT32_MIN < lo_time;
2046                         hicut = hi_time < INT32_MAX;
2047                 } else {
2048                         thisdefaulttype = range64.defaulttype;
2049                         thistimei = range64.base;
2050                         thistimecnt = range64.count;
2051                         toomanytimes = thistimecnt >> 31 >> 31 >> 2 != 0;
2052                         thisleapi = range64.leapbase;
2053                         thisleapcnt = range64.leapcount;
2054                         locut = min_time < lo_time;
2055                         hicut = hi_time < max_time;
2056                 }
2057                 if (toomanytimes)
2058                   error(_("too many transition times"));
2059
2060                 /* Keep the last too-low transition if no transition is
2061                    exactly at LO.  The kept transition will be output as
2062                    a LO "transition"; see "Output a LO_TIME transition"
2063                    below.  This is needed when the output is truncated at
2064                    the start, and is also useful when catering to buggy
2065                    32-bit clients that do not use time type 0 for
2066                    timestamps before the first transition.  */
2067                 if (0 < thistimei && ats[thistimei] != lo_time) {
2068                   thistimei--;
2069                   thistimecnt++;
2070                   locut = false;
2071                 }
2072
2073                 thistimelim = thistimei + thistimecnt;
2074                 thisleaplim = thisleapi + thisleapcnt;
2075                 if (thistimecnt != 0) {
2076                   if (ats[thistimei] == lo_time)
2077                     locut = false;
2078                   if (hi_time < ZIC_MAX && ats[thistimelim - 1] == hi_time + 1)
2079                     hicut = false;
2080                 }
2081                 memset(omittype, true, typecnt);
2082                 omittype[thisdefaulttype] = false;
2083                 for (i = thistimei; i < thistimelim; i++)
2084                   omittype[types[i]] = false;
2085
2086                 /* Reorder types to make THISDEFAULTTYPE type 0.
2087                    Use TYPEMAP to swap OLD0 and THISDEFAULTTYPE so that
2088                    THISDEFAULTTYPE appears as type 0 in the output instead
2089                    of OLD0.  TYPEMAP also omits unused types.  */
2090                 old0 = strlen(omittype);
2091
2092 #ifndef LEAVE_SOME_PRE_2011_SYSTEMS_IN_THE_LURCH
2093                 /*
2094                 ** For some pre-2011 systems: if the last-to-be-written
2095                 ** standard (or daylight) type has an offset different from the
2096                 ** most recently used offset,
2097                 ** append an (unused) copy of the most recently used type
2098                 ** (to help get global "altzone" and "timezone" variables
2099                 ** set correctly).
2100                 */
2101                 if (want_bloat()) {
2102                         register int    mrudst, mrustd, hidst, histd, type;
2103
2104                         hidst = histd = mrudst = mrustd = -1;
2105                         for (i = thistimei; i < thistimelim; ++i)
2106                                 if (isdsts[types[i]])
2107                                         mrudst = types[i];
2108                                 else    mrustd = types[i];
2109                         for (i = old0; i < typecnt; i++) {
2110                           int h = (i == old0 ? thisdefaulttype
2111                                    : i == thisdefaulttype ? old0 : i);
2112                           if (!omittype[h]) {
2113                             if (isdsts[h])
2114                               hidst = i;
2115                             else
2116                               histd = i;
2117                           }
2118                         }
2119                         if (hidst >= 0 && mrudst >= 0 && hidst != mrudst &&
2120                                 utoffs[hidst] != utoffs[mrudst]) {
2121                                         isdsts[mrudst] = -1;
2122                                         type = addtype(utoffs[mrudst],
2123                                                 &chars[desigidx[mrudst]],
2124                                                 true,
2125                                                 ttisstds[mrudst],
2126                                                 ttisuts[mrudst]);
2127                                         isdsts[mrudst] = 1;
2128                                         omittype[type] = false;
2129                         }
2130                         if (histd >= 0 && mrustd >= 0 && histd != mrustd &&
2131                                 utoffs[histd] != utoffs[mrustd]) {
2132                                         isdsts[mrustd] = -1;
2133                                         type = addtype(utoffs[mrustd],
2134                                                 &chars[desigidx[mrustd]],
2135                                                 false,
2136                                                 ttisstds[mrustd],
2137                                                 ttisuts[mrustd]);
2138                                         isdsts[mrustd] = 0;
2139                                         omittype[type] = false;
2140                         }
2141                 }
2142 #endif /* !defined LEAVE_SOME_PRE_2011_SYSTEMS_IN_THE_LURCH */
2143                 thistypecnt = 0;
2144                 for (i = old0; i < typecnt; i++)
2145                   if (!omittype[i])
2146                     typemap[i == old0 ? thisdefaulttype
2147                             : i == thisdefaulttype ? old0 : i]
2148                       = thistypecnt++;
2149
2150                 for (i = 0; i < sizeof indmap / sizeof indmap[0]; ++i)
2151                         indmap[i] = -1;
2152                 thischarcnt = stdcnt = utcnt = 0;
2153                 for (i = old0; i < typecnt; i++) {
2154                         register char * thisabbr;
2155
2156                         if (omittype[i])
2157                                 continue;
2158                         if (ttisstds[i])
2159                           stdcnt = thistypecnt;
2160                         if (ttisuts[i])
2161                           utcnt = thistypecnt;
2162                         if (indmap[desigidx[i]] >= 0)
2163                                 continue;
2164                         thisabbr = &chars[desigidx[i]];
2165                         for (j = 0; j < thischarcnt; ++j)
2166                                 if (strcmp(&thischars[j], thisabbr) == 0)
2167                                         break;
2168                         if (j == thischarcnt) {
2169                                 strcpy(&thischars[thischarcnt], thisabbr);
2170                                 thischarcnt += strlen(thisabbr) + 1;
2171                         }
2172                         indmap[desigidx[i]] = j;
2173                 }
2174                 if (pass == 1 && !want_bloat()) {
2175                   utcnt = stdcnt = thisleapcnt = 0;
2176                   thistimecnt = - (locut + hicut);
2177                   thistypecnt = thischarcnt = 1;
2178                   thistimelim = thistimei;
2179                 }
2180 #define DO(field)       fwrite(tzh.field, sizeof tzh.field, 1, fp)
2181                 tzh = tzh0;
2182                 memcpy(tzh.tzh_magic, TZ_MAGIC, sizeof tzh.tzh_magic);
2183                 tzh.tzh_version[0] = version;
2184                 convert(utcnt, tzh.tzh_ttisutcnt);
2185                 convert(stdcnt, tzh.tzh_ttisstdcnt);
2186                 convert(thisleapcnt, tzh.tzh_leapcnt);
2187                 convert(locut + thistimecnt + hicut, tzh.tzh_timecnt);
2188                 convert(thistypecnt, tzh.tzh_typecnt);
2189                 convert(thischarcnt, tzh.tzh_charcnt);
2190                 DO(tzh_magic);
2191                 DO(tzh_version);
2192                 DO(tzh_reserved);
2193                 DO(tzh_ttisutcnt);
2194                 DO(tzh_ttisstdcnt);
2195                 DO(tzh_leapcnt);
2196                 DO(tzh_timecnt);
2197                 DO(tzh_typecnt);
2198                 DO(tzh_charcnt);
2199 #undef DO
2200                 if (pass == 1 && !want_bloat()) {
2201                   /* Output a minimal data block with just one time type.  */
2202                   puttzcode(0, fp);     /* utoff */
2203                   putc(0, fp);          /* dst */
2204                   putc(0, fp);          /* index of abbreviation */
2205                   putc(0, fp);          /* empty-string abbreviation */
2206                   continue;
2207                 }
2208
2209                 /* Output a LO_TIME transition if needed; see limitrange.
2210                    But do not go below the minimum representable value
2211                    for this pass.  */
2212                 lo = pass == 1 && lo_time < INT32_MIN ? INT32_MIN : lo_time;
2213
2214                 if (locut)
2215                   puttzcodepass(lo, fp, pass);
2216                 for (i = thistimei; i < thistimelim; ++i) {
2217                   zic_t at = ats[i] < lo ? lo : ats[i];
2218                   puttzcodepass(at, fp, pass);
2219                 }
2220                 if (hicut)
2221                   puttzcodepass(hi_time + 1, fp, pass);
2222                 currenttype = 0;
2223                 if (locut)
2224                   putc(currenttype, fp);
2225                 for (i = thistimei; i < thistimelim; ++i) {
2226                   currenttype = typemap[types[i]];
2227                   putc(currenttype, fp);
2228                 }
2229                 if (hicut)
2230                   putc(currenttype, fp);
2231
2232                 for (i = old0; i < typecnt; i++) {
2233                   int h = (i == old0 ? thisdefaulttype
2234                            : i == thisdefaulttype ? old0 : i);
2235                   if (!omittype[h]) {
2236                     puttzcode(utoffs[h], fp);
2237                     putc(isdsts[h], fp);
2238                     putc(indmap[desigidx[h]], fp);
2239                   }
2240                 }
2241                 if (thischarcnt != 0)
2242                         fwrite(thischars, sizeof thischars[0],
2243                                       thischarcnt, fp);
2244                 for (i = thisleapi; i < thisleaplim; ++i) {
2245                         register zic_t  todo;
2246
2247                         if (roll[i]) {
2248                                 if (timecnt == 0 || trans[i] < ats[0]) {
2249                                         j = 0;
2250                                         while (isdsts[j])
2251                                                 if (++j >= typecnt) {
2252                                                         j = 0;
2253                                                         break;
2254                                                 }
2255                                 } else {
2256                                         j = 1;
2257                                         while (j < timecnt &&
2258                                                 trans[i] >= ats[j])
2259                                                         ++j;
2260                                         j = types[j - 1];
2261                                 }
2262                                 todo = tadd(trans[i], -utoffs[j]);
2263                         } else  todo = trans[i];
2264                         puttzcodepass(todo, fp, pass);
2265                         puttzcode(corr[i], fp);
2266                 }
2267                 if (stdcnt != 0)
2268                   for (i = old0; i < typecnt; i++)
2269                         if (!omittype[i])
2270                                 putc(ttisstds[i], fp);
2271                 if (utcnt != 0)
2272                   for (i = old0; i < typecnt; i++)
2273                         if (!omittype[i])
2274                                 putc(ttisuts[i], fp);
2275         }
2276         fprintf(fp, "\n%s\n", string);
2277         close_file(fp, directory, name);
2278         free(ats);
2279 }
2280
2281 static char const *
2282 abbroffset(char *buf, zic_t offset)
2283 {
2284   char sign = '+';
2285   int seconds, minutes;
2286
2287   if (offset < 0) {
2288     offset = -offset;
2289     sign = '-';
2290   }
2291
2292   seconds = offset % SECSPERMIN;
2293   offset /= SECSPERMIN;
2294   minutes = offset % MINSPERHOUR;
2295   offset /= MINSPERHOUR;
2296   if (100 <= offset) {
2297     error(_("%%z UT offset magnitude exceeds 99:59:59"));
2298     return "%z";
2299   } else {
2300     char *p = buf;
2301     *p++ = sign;
2302     *p++ = '0' + offset / 10;
2303     *p++ = '0' + offset % 10;
2304     if (minutes | seconds) {
2305       *p++ = '0' + minutes / 10;
2306       *p++ = '0' + minutes % 10;
2307       if (seconds) {
2308         *p++ = '0' + seconds / 10;
2309         *p++ = '0' + seconds % 10;
2310       }
2311     }
2312     *p = '\0';
2313     return buf;
2314   }
2315 }
2316
2317 static size_t
2318 doabbr(char *abbr, struct zone const *zp, char const *letters,
2319        bool isdst, zic_t save, bool doquotes)
2320 {
2321         register char * cp;
2322         register char * slashp;
2323         register size_t len;
2324         char const *format = zp->z_format;
2325
2326         slashp = strchr(format, '/');
2327         if (slashp == NULL) {
2328           char letterbuf[PERCENT_Z_LEN_BOUND + 1];
2329           if (zp->z_format_specifier == 'z')
2330             letters = abbroffset(letterbuf, zp->z_stdoff + save);
2331           else if (!letters)
2332             letters = "%s";
2333           sprintf(abbr, format, letters);
2334         } else if (isdst) {
2335                 strcpy(abbr, slashp + 1);
2336         } else {
2337                 memcpy(abbr, format, slashp - format);
2338                 abbr[slashp - format] = '\0';
2339         }
2340         len = strlen(abbr);
2341         if (!doquotes)
2342                 return len;
2343         for (cp = abbr; is_alpha(*cp); cp++)
2344                 continue;
2345         if (len > 0 && *cp == '\0')
2346                 return len;
2347         abbr[len + 2] = '\0';
2348         abbr[len + 1] = '>';
2349         memmove(abbr + 1, abbr, len);
2350         abbr[0] = '<';
2351         return len + 2;
2352 }
2353
2354 static void
2355 updateminmax(const zic_t x)
2356 {
2357         if (min_year > x)
2358                 min_year = x;
2359         if (max_year < x)
2360                 max_year = x;
2361 }
2362
2363 static int
2364 stringoffset(char *result, zic_t offset)
2365 {
2366         register int    hours;
2367         register int    minutes;
2368         register int    seconds;
2369         bool negative = offset < 0;
2370         int len = negative;
2371
2372         if (negative) {
2373                 offset = -offset;
2374                 result[0] = '-';
2375         }
2376         seconds = offset % SECSPERMIN;
2377         offset /= SECSPERMIN;
2378         minutes = offset % MINSPERHOUR;
2379         offset /= MINSPERHOUR;
2380         hours = offset;
2381         if (hours >= HOURSPERDAY * DAYSPERWEEK) {
2382                 result[0] = '\0';
2383                 return 0;
2384         }
2385         len += sprintf(result + len, "%d", hours);
2386         if (minutes != 0 || seconds != 0) {
2387                 len += sprintf(result + len, ":%02d", minutes);
2388                 if (seconds != 0)
2389                         len += sprintf(result + len, ":%02d", seconds);
2390         }
2391         return len;
2392 }
2393
2394 static int
2395 stringrule(char *result, struct rule *const rp, zic_t save, zic_t stdoff)
2396 {
2397         register zic_t  tod = rp->r_tod;
2398         register int    compat = 0;
2399
2400         if (rp->r_dycode == DC_DOM) {
2401                 register int    month, total;
2402
2403                 if (rp->r_dayofmonth == 29 && rp->r_month == TM_FEBRUARY)
2404                         return -1;
2405                 total = 0;
2406                 for (month = 0; month < rp->r_month; ++month)
2407                         total += len_months[0][month];
2408                 /* Omit the "J" in Jan and Feb, as that's shorter.  */
2409                 if (rp->r_month <= 1)
2410                   result += sprintf(result, "%d", total + rp->r_dayofmonth - 1);
2411                 else
2412                   result += sprintf(result, "J%d", total + rp->r_dayofmonth);
2413         } else {
2414                 register int    week;
2415                 register int    wday = rp->r_wday;
2416                 register int    wdayoff;
2417
2418                 if (rp->r_dycode == DC_DOWGEQ) {
2419                         wdayoff = (rp->r_dayofmonth - 1) % DAYSPERWEEK;
2420                         if (wdayoff)
2421                                 compat = 2013;
2422                         wday -= wdayoff;
2423                         tod += wdayoff * SECSPERDAY;
2424                         week = 1 + (rp->r_dayofmonth - 1) / DAYSPERWEEK;
2425                 } else if (rp->r_dycode == DC_DOWLEQ) {
2426                         if (rp->r_dayofmonth == len_months[1][rp->r_month])
2427                                 week = 5;
2428                         else {
2429                                 wdayoff = rp->r_dayofmonth % DAYSPERWEEK;
2430                                 if (wdayoff)
2431                                         compat = 2013;
2432                                 wday -= wdayoff;
2433                                 tod += wdayoff * SECSPERDAY;
2434                                 week = rp->r_dayofmonth / DAYSPERWEEK;
2435                         }
2436                 } else  return -1;      /* "cannot happen" */
2437                 if (wday < 0)
2438                         wday += DAYSPERWEEK;
2439                 result += sprintf(result, "M%d.%d.%d",
2440                                   rp->r_month + 1, week, wday);
2441         }
2442         if (rp->r_todisut)
2443           tod += stdoff;
2444         if (rp->r_todisstd && !rp->r_isdst)
2445           tod += save;
2446         if (tod != 2 * SECSPERMIN * MINSPERHOUR) {
2447                 *result++ = '/';
2448                 if (! stringoffset(result, tod))
2449                         return -1;
2450                 if (tod < 0) {
2451                         if (compat < 2013)
2452                                 compat = 2013;
2453                 } else if (SECSPERDAY <= tod) {
2454                         if (compat < 1994)
2455                                 compat = 1994;
2456                 }
2457         }
2458         return compat;
2459 }
2460
2461 static int
2462 rule_cmp(struct rule const *a, struct rule const *b)
2463 {
2464         if (!a)
2465                 return -!!b;
2466         if (!b)
2467                 return 1;
2468         if (a->r_hiyear != b->r_hiyear)
2469                 return a->r_hiyear < b->r_hiyear ? -1 : 1;
2470         if (a->r_month - b->r_month != 0)
2471                 return a->r_month - b->r_month;
2472         return a->r_dayofmonth - b->r_dayofmonth;
2473 }
2474
2475 static int
2476 stringzone(char *result, struct zone const *zpfirst, ptrdiff_t zonecount)
2477 {
2478         register const struct zone *    zp;
2479         register struct rule *          rp;
2480         register struct rule *          stdrp;
2481         register struct rule *          dstrp;
2482         register ptrdiff_t              i;
2483         register const char *           abbrvar;
2484         register int                    compat = 0;
2485         register int                    c;
2486         size_t                          len;
2487         int                             offsetlen;
2488         struct rule                     stdr, dstr;
2489
2490         result[0] = '\0';
2491
2492         /* Internet RFC 8536 section 5.1 says to use an empty TZ string if
2493            future timestamps are truncated.  */
2494         if (hi_time < max_time)
2495           return -1;
2496
2497         zp = zpfirst + zonecount - 1;
2498         stdrp = dstrp = NULL;
2499         for (i = 0; i < zp->z_nrules; ++i) {
2500                 rp = &zp->z_rules[i];
2501                 if (rp->r_hiwasnum || rp->r_hiyear != ZIC_MAX)
2502                         continue;
2503                 if (rp->r_yrtype != NULL)
2504                         continue;
2505                 if (!rp->r_isdst) {
2506                         if (stdrp == NULL)
2507                                 stdrp = rp;
2508                         else    return -1;
2509                 } else {
2510                         if (dstrp == NULL)
2511                                 dstrp = rp;
2512                         else    return -1;
2513                 }
2514         }
2515         if (stdrp == NULL && dstrp == NULL) {
2516                 /*
2517                 ** There are no rules running through "max".
2518                 ** Find the latest std rule in stdabbrrp
2519                 ** and latest rule of any type in stdrp.
2520                 */
2521                 register struct rule *stdabbrrp = NULL;
2522                 for (i = 0; i < zp->z_nrules; ++i) {
2523                         rp = &zp->z_rules[i];
2524                         if (!rp->r_isdst && rule_cmp(stdabbrrp, rp) < 0)
2525                                 stdabbrrp = rp;
2526                         if (rule_cmp(stdrp, rp) < 0)
2527                                 stdrp = rp;
2528                 }
2529                 if (stdrp != NULL && stdrp->r_isdst) {
2530                         /* Perpetual DST.  */
2531                         dstr.r_month = TM_JANUARY;
2532                         dstr.r_dycode = DC_DOM;
2533                         dstr.r_dayofmonth = 1;
2534                         dstr.r_tod = 0;
2535                         dstr.r_todisstd = dstr.r_todisut = false;
2536                         dstr.r_isdst = stdrp->r_isdst;
2537                         dstr.r_save = stdrp->r_save;
2538                         dstr.r_abbrvar = stdrp->r_abbrvar;
2539                         stdr.r_month = TM_DECEMBER;
2540                         stdr.r_dycode = DC_DOM;
2541                         stdr.r_dayofmonth = 31;
2542                         stdr.r_tod = SECSPERDAY + stdrp->r_save;
2543                         stdr.r_todisstd = stdr.r_todisut = false;
2544                         stdr.r_isdst = false;
2545                         stdr.r_save = 0;
2546                         stdr.r_abbrvar
2547                           = (stdabbrrp ? stdabbrrp->r_abbrvar : "");
2548                         dstrp = &dstr;
2549                         stdrp = &stdr;
2550                 }
2551         }
2552         if (stdrp == NULL && (zp->z_nrules != 0 || zp->z_isdst))
2553                 return -1;
2554         abbrvar = (stdrp == NULL) ? "" : stdrp->r_abbrvar;
2555         len = doabbr(result, zp, abbrvar, false, 0, true);
2556         offsetlen = stringoffset(result + len, - zp->z_stdoff);
2557         if (! offsetlen) {
2558                 result[0] = '\0';
2559                 return -1;
2560         }
2561         len += offsetlen;
2562         if (dstrp == NULL)
2563                 return compat;
2564         len += doabbr(result + len, zp, dstrp->r_abbrvar,
2565                       dstrp->r_isdst, dstrp->r_save, true);
2566         if (dstrp->r_save != SECSPERMIN * MINSPERHOUR) {
2567           offsetlen = stringoffset(result + len,
2568                                    - (zp->z_stdoff + dstrp->r_save));
2569           if (! offsetlen) {
2570             result[0] = '\0';
2571             return -1;
2572           }
2573           len += offsetlen;
2574         }
2575         result[len++] = ',';
2576         c = stringrule(result + len, dstrp, dstrp->r_save, zp->z_stdoff);
2577         if (c < 0) {
2578                 result[0] = '\0';
2579                 return -1;
2580         }
2581         if (compat < c)
2582                 compat = c;
2583         len += strlen(result + len);
2584         result[len++] = ',';
2585         c = stringrule(result + len, stdrp, dstrp->r_save, zp->z_stdoff);
2586         if (c < 0) {
2587                 result[0] = '\0';
2588                 return -1;
2589         }
2590         if (compat < c)
2591                 compat = c;
2592         return compat;
2593 }
2594
2595 static void
2596 outzone(const struct zone *zpfirst, ptrdiff_t zonecount)
2597 {
2598         register const struct zone *    zp;
2599         register struct rule *          rp;
2600         register ptrdiff_t              i, j;
2601         register bool                   usestart, useuntil;
2602         register zic_t                  starttime, untiltime;
2603         register zic_t                  stdoff;
2604         register zic_t                  save;
2605         register zic_t                  year;
2606         register zic_t                  startoff;
2607         register bool                   startttisstd;
2608         register bool                   startttisut;
2609         register int                    type;
2610         register char *                 startbuf;
2611         register char *                 ab;
2612         register char *                 envvar;
2613         register int                    max_abbr_len;
2614         register int                    max_envvar_len;
2615         register bool                   prodstic; /* all rules are min to max */
2616         register int                    compat;
2617         register bool                   do_extend;
2618         register char                   version;
2619         ptrdiff_t lastatmax = -1;
2620         zic_t one = 1;
2621         zic_t y2038_boundary = one << 31;
2622         zic_t max_year0;
2623         int defaulttype = -1;
2624
2625         max_abbr_len = 2 + max_format_len + max_abbrvar_len;
2626         max_envvar_len = 2 * max_abbr_len + 5 * 9;
2627         startbuf = emalloc(max_abbr_len + 1);
2628         ab = emalloc(max_abbr_len + 1);
2629         envvar = emalloc(max_envvar_len + 1);
2630         INITIALIZE(untiltime);
2631         INITIALIZE(starttime);
2632         /*
2633         ** Now. . .finally. . .generate some useful data!
2634         */
2635         timecnt = 0;
2636         typecnt = 0;
2637         charcnt = 0;
2638         prodstic = zonecount == 1;
2639         /*
2640         ** Thanks to Earl Chew
2641         ** for noting the need to unconditionally initialize startttisstd.
2642         */
2643         startttisstd = false;
2644         startttisut = false;
2645         min_year = max_year = EPOCH_YEAR;
2646         if (leapseen) {
2647                 updateminmax(leapminyear);
2648                 updateminmax(leapmaxyear + (leapmaxyear < ZIC_MAX));
2649         }
2650         for (i = 0; i < zonecount; ++i) {
2651                 zp = &zpfirst[i];
2652                 if (i < zonecount - 1)
2653                         updateminmax(zp->z_untilrule.r_loyear);
2654                 for (j = 0; j < zp->z_nrules; ++j) {
2655                         rp = &zp->z_rules[j];
2656                         if (rp->r_lowasnum)
2657                                 updateminmax(rp->r_loyear);
2658                         if (rp->r_hiwasnum)
2659                                 updateminmax(rp->r_hiyear);
2660                         if (rp->r_lowasnum || rp->r_hiwasnum)
2661                                 prodstic = false;
2662                 }
2663         }
2664         /*
2665         ** Generate lots of data if a rule can't cover all future times.
2666         */
2667         compat = stringzone(envvar, zpfirst, zonecount);
2668         version = compat < 2013 ? ZIC_VERSION_PRE_2013 : ZIC_VERSION;
2669         do_extend = compat < 0;
2670         if (noise) {
2671                 if (!*envvar)
2672                         warning("%s %s",
2673                                 _("no POSIX environment variable for zone"),
2674                                 zpfirst->z_name);
2675                 else if (compat != 0) {
2676                         /* Circa-COMPAT clients, and earlier clients, might
2677                            not work for this zone when given dates before
2678                            1970 or after 2038.  */
2679                         warning(_("%s: pre-%d clients may mishandle"
2680                                   " distant timestamps"),
2681                                 zpfirst->z_name, compat);
2682                 }
2683         }
2684         if (do_extend) {
2685                 /*
2686                 ** Search through a couple of extra years past the obvious
2687                 ** 400, to avoid edge cases.  For example, suppose a non-POSIX
2688                 ** rule applies from 2012 onwards and has transitions in March
2689                 ** and September, plus some one-off transitions in November
2690                 ** 2013.  If zic looked only at the last 400 years, it would
2691                 ** set max_year=2413, with the intent that the 400 years 2014
2692                 ** through 2413 will be repeated.  The last transition listed
2693                 ** in the tzfile would be in 2413-09, less than 400 years
2694                 ** after the last one-off transition in 2013-11.  Two years
2695                 ** might be overkill, but with the kind of edge cases
2696                 ** available we're not sure that one year would suffice.
2697                 */
2698                 enum { years_of_observations = YEARSPERREPEAT + 2 };
2699
2700                 if (min_year >= ZIC_MIN + years_of_observations)
2701                         min_year -= years_of_observations;
2702                 else    min_year = ZIC_MIN;
2703                 if (max_year <= ZIC_MAX - years_of_observations)
2704                         max_year += years_of_observations;
2705                 else    max_year = ZIC_MAX;
2706                 /*
2707                 ** Regardless of any of the above,
2708                 ** for a "proDSTic" zone which specifies that its rules
2709                 ** always have and always will be in effect,
2710                 ** we only need one cycle to define the zone.
2711                 */
2712                 if (prodstic) {
2713                         min_year = 1900;
2714                         max_year = min_year + years_of_observations;
2715                 }
2716         }
2717         max_year0 = max_year;
2718         if (want_bloat()) {
2719           /* For the benefit of older systems,
2720              generate data from 1900 through 2038.  */
2721           if (min_year > 1900)
2722                 min_year = 1900;
2723           if (max_year < 2038)
2724                 max_year = 2038;
2725         }
2726
2727         for (i = 0; i < zonecount; ++i) {
2728                 struct rule *prevrp = NULL;
2729                 /*
2730                 ** A guess that may well be corrected later.
2731                 */
2732                 save = 0;
2733                 zp = &zpfirst[i];
2734                 usestart = i > 0 && (zp - 1)->z_untiltime > min_time;
2735                 useuntil = i < (zonecount - 1);
2736                 if (useuntil && zp->z_untiltime <= min_time)
2737                         continue;
2738                 stdoff = zp->z_stdoff;
2739                 eat(zp->z_filename, zp->z_linenum);
2740                 *startbuf = '\0';
2741                 startoff = zp->z_stdoff;
2742                 if (zp->z_nrules == 0) {
2743                         save = zp->z_save;
2744                         doabbr(startbuf, zp, NULL, zp->z_isdst, save, false);
2745                         type = addtype(oadd(zp->z_stdoff, save),
2746                                 startbuf, zp->z_isdst, startttisstd,
2747                                 startttisut);
2748                         if (usestart) {
2749                                 addtt(starttime, type);
2750                                 usestart = false;
2751                         } else
2752                                 defaulttype = type;
2753                 } else for (year = min_year; year <= max_year; ++year) {
2754                         if (useuntil && year > zp->z_untilrule.r_hiyear)
2755                                 break;
2756                         /*
2757                         ** Mark which rules to do in the current year.
2758                         ** For those to do, calculate rpytime(rp, year);
2759                         */
2760                         for (j = 0; j < zp->z_nrules; ++j) {
2761                                 rp = &zp->z_rules[j];
2762                                 eats(zp->z_filename, zp->z_linenum,
2763                                         rp->r_filename, rp->r_linenum);
2764                                 rp->r_todo = year >= rp->r_loyear &&
2765                                                 year <= rp->r_hiyear &&
2766                                                 yearistype(year, rp->r_yrtype);
2767                                 if (rp->r_todo) {
2768                                         rp->r_temp = rpytime(rp, year);
2769                                         rp->r_todo
2770                                           = (rp->r_temp < y2038_boundary
2771                                              || year <= max_year0);
2772                                 }
2773                         }
2774                         for ( ; ; ) {
2775                                 register ptrdiff_t k;
2776                                 register zic_t  jtime, ktime;
2777                                 register zic_t  offset;
2778
2779                                 INITIALIZE(ktime);
2780                                 if (useuntil) {
2781                                         /*
2782                                         ** Turn untiltime into UT
2783                                         ** assuming the current stdoff and
2784                                         ** save values.
2785                                         */
2786                                         untiltime = zp->z_untiltime;
2787                                         if (!zp->z_untilrule.r_todisut)
2788                                                 untiltime = tadd(untiltime,
2789                                                                  -stdoff);
2790                                         if (!zp->z_untilrule.r_todisstd)
2791                                                 untiltime = tadd(untiltime,
2792                                                                  -save);
2793                                 }
2794                                 /*
2795                                 ** Find the rule (of those to do, if any)
2796                                 ** that takes effect earliest in the year.
2797                                 */
2798                                 k = -1;
2799                                 for (j = 0; j < zp->z_nrules; ++j) {
2800                                         rp = &zp->z_rules[j];
2801                                         if (!rp->r_todo)
2802                                                 continue;
2803                                         eats(zp->z_filename, zp->z_linenum,
2804                                                 rp->r_filename, rp->r_linenum);
2805                                         offset = rp->r_todisut ? 0 : stdoff;
2806                                         if (!rp->r_todisstd)
2807                                                 offset = oadd(offset, save);
2808                                         jtime = rp->r_temp;
2809                                         if (jtime == min_time ||
2810                                                 jtime == max_time)
2811                                                         continue;
2812                                         jtime = tadd(jtime, -offset);
2813                                         if (k < 0 || jtime < ktime) {
2814                                                 k = j;
2815                                                 ktime = jtime;
2816                                         } else if (jtime == ktime) {
2817                                           char const *dup_rules_msg =
2818                                             _("two rules for same instant");
2819                                           eats(zp->z_filename, zp->z_linenum,
2820                                                rp->r_filename, rp->r_linenum);
2821                                           warning("%s", dup_rules_msg);
2822                                           rp = &zp->z_rules[k];
2823                                           eats(zp->z_filename, zp->z_linenum,
2824                                                rp->r_filename, rp->r_linenum);
2825                                           error("%s", dup_rules_msg);
2826                                         }
2827                                 }
2828                                 if (k < 0)
2829                                         break;  /* go on to next year */
2830                                 rp = &zp->z_rules[k];
2831                                 rp->r_todo = false;
2832                                 if (useuntil && ktime >= untiltime)
2833                                         break;
2834                                 save = rp->r_save;
2835                                 if (usestart && ktime == starttime)
2836                                         usestart = false;
2837                                 if (usestart) {
2838                                         if (ktime < starttime) {
2839                                                 startoff = oadd(zp->z_stdoff,
2840                                                                 save);
2841                                                 doabbr(startbuf, zp,
2842                                                         rp->r_abbrvar,
2843                                                         rp->r_isdst,
2844                                                         rp->r_save,
2845                                                         false);
2846                                                 continue;
2847                                         }
2848                                         if (*startbuf == '\0'
2849                                             && startoff == oadd(zp->z_stdoff,
2850                                                                 save)) {
2851                                                         doabbr(startbuf,
2852                                                                 zp,
2853                                                                 rp->r_abbrvar,
2854                                                                 rp->r_isdst,
2855                                                                 rp->r_save,
2856                                                                 false);
2857                                         }
2858                                 }
2859                                 eats(zp->z_filename, zp->z_linenum,
2860                                         rp->r_filename, rp->r_linenum);
2861                                 doabbr(ab, zp, rp->r_abbrvar,
2862                                        rp->r_isdst, rp->r_save, false);
2863                                 offset = oadd(zp->z_stdoff, rp->r_save);
2864                                 if (!want_bloat() && !useuntil && !do_extend
2865                                     && prevrp
2866                                     && rp->r_hiyear == ZIC_MAX
2867                                     && prevrp->r_hiyear == ZIC_MAX)
2868                                   break;
2869                                 type = addtype(offset, ab, rp->r_isdst,
2870                                         rp->r_todisstd, rp->r_todisut);
2871                                 if (defaulttype < 0 && !rp->r_isdst)
2872                                   defaulttype = type;
2873                                 if (rp->r_hiyear == ZIC_MAX
2874                                     && ! (0 <= lastatmax
2875                                           && ktime < attypes[lastatmax].at))
2876                                   lastatmax = timecnt;
2877                                 addtt(ktime, type);
2878                                 prevrp = rp;
2879                         }
2880                 }
2881                 if (usestart) {
2882                         if (*startbuf == '\0' &&
2883                                 zp->z_format != NULL &&
2884                                 strchr(zp->z_format, '%') == NULL &&
2885                                 strchr(zp->z_format, '/') == NULL)
2886                                         strcpy(startbuf, zp->z_format);
2887                         eat(zp->z_filename, zp->z_linenum);
2888                         if (*startbuf == '\0')
2889 error(_("can't determine time zone abbreviation to use just after until time"));
2890                         else {
2891                           bool isdst = startoff != zp->z_stdoff;
2892                           type = addtype(startoff, startbuf, isdst,
2893                                          startttisstd, startttisut);
2894                           if (defaulttype < 0 && !isdst)
2895                             defaulttype = type;
2896                           addtt(starttime, type);
2897                         }
2898                 }
2899                 /*
2900                 ** Now we may get to set starttime for the next zone line.
2901                 */
2902                 if (useuntil) {
2903                         startttisstd = zp->z_untilrule.r_todisstd;
2904                         startttisut = zp->z_untilrule.r_todisut;
2905                         starttime = zp->z_untiltime;
2906                         if (!startttisstd)
2907                           starttime = tadd(starttime, -save);
2908                         if (!startttisut)
2909                           starttime = tadd(starttime, -stdoff);
2910                 }
2911         }
2912         if (defaulttype < 0)
2913           defaulttype = 0;
2914         if (0 <= lastatmax)
2915           attypes[lastatmax].dontmerge = true;
2916         if (do_extend) {
2917                 /*
2918                 ** If we're extending the explicitly listed observations
2919                 ** for 400 years because we can't fill the POSIX-TZ field,
2920                 ** check whether we actually ended up explicitly listing
2921                 ** observations through that period.  If there aren't any
2922                 ** near the end of the 400-year period, add a redundant
2923                 ** one at the end of the final year, to make it clear
2924                 ** that we are claiming to have definite knowledge of
2925                 ** the lack of transitions up to that point.
2926                 */
2927                 struct rule xr;
2928                 struct attype *lastat;
2929                 xr.r_month = TM_JANUARY;
2930                 xr.r_dycode = DC_DOM;
2931                 xr.r_dayofmonth = 1;
2932                 xr.r_tod = 0;
2933                 for (lastat = attypes, i = 1; i < timecnt; i++)
2934                         if (attypes[i].at > lastat->at)
2935                                 lastat = &attypes[i];
2936                 if (!lastat || lastat->at < rpytime(&xr, max_year - 1)) {
2937                         addtt(rpytime(&xr, max_year + 1),
2938                               lastat ? lastat->type : defaulttype);
2939                         attypes[timecnt - 1].dontmerge = true;
2940                 }
2941         }
2942         writezone(zpfirst->z_name, envvar, version, defaulttype);
2943         free(startbuf);
2944         free(ab);
2945         free(envvar);
2946 }
2947
2948 static void
2949 addtt(zic_t starttime, int type)
2950 {
2951         attypes = growalloc(attypes, sizeof *attypes, timecnt, &timecnt_alloc);
2952         attypes[timecnt].at = starttime;
2953         attypes[timecnt].dontmerge = false;
2954         attypes[timecnt].type = type;
2955         ++timecnt;
2956 }
2957
2958 static int
2959 addtype(zic_t utoff, char const *abbr, bool isdst, bool ttisstd, bool ttisut)
2960 {
2961         register int    i, j;
2962
2963         if (! (-1L - 2147483647L <= utoff && utoff <= 2147483647L)) {
2964                 error(_("UT offset out of range"));
2965                 exit(EXIT_FAILURE);
2966         }
2967         if (!want_bloat())
2968           ttisstd = ttisut = false;
2969
2970         for (j = 0; j < charcnt; ++j)
2971                 if (strcmp(&chars[j], abbr) == 0)
2972                         break;
2973         if (j == charcnt)
2974                 newabbr(abbr);
2975         else {
2976           /* If there's already an entry, return its index.  */
2977           for (i = 0; i < typecnt; i++)
2978             if (utoff == utoffs[i] && isdst == isdsts[i] && j == desigidx[i]
2979                 && ttisstd == ttisstds[i] && ttisut == ttisuts[i])
2980               return i;
2981         }
2982         /*
2983         ** There isn't one; add a new one, unless there are already too
2984         ** many.
2985         */
2986         if (typecnt >= TZ_MAX_TYPES) {
2987                 error(_("too many local time types"));
2988                 exit(EXIT_FAILURE);
2989         }
2990         i = typecnt++;
2991         utoffs[i] = utoff;
2992         isdsts[i] = isdst;
2993         ttisstds[i] = ttisstd;
2994         ttisuts[i] = ttisut;
2995         desigidx[i] = j;
2996         return i;
2997 }
2998
2999 static void
3000 leapadd(zic_t t, int correction, int rolling)
3001 {
3002         register int i;
3003
3004         if (TZ_MAX_LEAPS <= leapcnt) {
3005                 error(_("too many leap seconds"));
3006                 exit(EXIT_FAILURE);
3007         }
3008         for (i = 0; i < leapcnt; ++i)
3009                 if (t <= trans[i])
3010                         break;
3011         memmove(&trans[i + 1], &trans[i], (leapcnt - i) * sizeof *trans);
3012         memmove(&corr[i + 1], &corr[i], (leapcnt - i) * sizeof *corr);
3013         memmove(&roll[i + 1], &roll[i], (leapcnt - i) * sizeof *roll);
3014         trans[i] = t;
3015         corr[i] = correction;
3016         roll[i] = rolling;
3017         ++leapcnt;
3018 }
3019
3020 static void
3021 adjleap(void)
3022 {
3023         register int    i;
3024         register zic_t  last = 0;
3025         register zic_t  prevtrans = 0;
3026
3027         /*
3028         ** propagate leap seconds forward
3029         */
3030         for (i = 0; i < leapcnt; ++i) {
3031                 if (trans[i] - prevtrans < 28 * SECSPERDAY) {
3032                   error(_("Leap seconds too close together"));
3033                   exit(EXIT_FAILURE);
3034                 }
3035                 prevtrans = trans[i];
3036                 trans[i] = tadd(trans[i], last);
3037                 last = corr[i] += last;
3038         }
3039
3040         if (leapexpires < 0) {
3041           leapexpires = comment_leapexpires;
3042           if (0 <= leapexpires)
3043             warning(_("\"#expires\" is obsolescent; use \"Expires\""));
3044         }
3045
3046         if (0 <= leapexpires) {
3047           leapexpires = oadd(leapexpires, last);
3048           if (! (leapcnt == 0 || (trans[leapcnt - 1] < leapexpires))) {
3049             error(_("last Leap time does not precede Expires time"));
3050             exit(EXIT_FAILURE);
3051           }
3052           if (leapexpires <= hi_time)
3053             hi_time = leapexpires - 1;
3054         }
3055 }
3056
3057 static char *
3058 shellquote(char *b, char const *s)
3059 {
3060   *b++ = '\'';
3061   while (*s) {
3062     if (*s == '\'')
3063       *b++ = '\'', *b++ = '\\', *b++ = '\'';
3064     *b++ = *s++;
3065   }
3066   *b++ = '\'';
3067   return b;
3068 }
3069
3070 static bool
3071 yearistype(zic_t year, const char *type)
3072 {
3073         char *buf;
3074         char *b;
3075         int result;
3076
3077         if (type == NULL || *type == '\0')
3078                 return true;
3079         buf = emalloc(1 + 4 * strlen(yitcommand) + 2
3080                       + INT_STRLEN_MAXIMUM(zic_t) + 2 + 4 * strlen(type) + 2);
3081         b = shellquote(buf, yitcommand);
3082         *b++ = ' ';
3083         b += sprintf(b, "%"PRIdZIC, year);
3084         *b++ = ' ';
3085         b = shellquote(b, type);
3086         *b = '\0';
3087         result = system(buf);
3088         if (WIFEXITED(result)) {
3089           int status = WEXITSTATUS(result);
3090           if (status <= 1) {
3091             free(buf);
3092             return status == 0;
3093           }
3094         }
3095         error(_("Wild result from command execution"));
3096         fprintf(stderr, _("%s: command was '%s', result was %d\n"),
3097                 progname, buf, result);
3098         exit(EXIT_FAILURE);
3099 }
3100
3101 /* Is A a space character in the C locale?  */
3102 static bool
3103 is_space(char a)
3104 {
3105         switch (a) {
3106           default:
3107                 return false;
3108           case ' ': case '\f': case '\n': case '\r': case '\t': case '\v':
3109                 return true;
3110         }
3111 }
3112
3113 /* Is A an alphabetic character in the C locale?  */
3114 static bool
3115 is_alpha(char a)
3116 {
3117         switch (a) {
3118           default:
3119                 return false;
3120           case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
3121           case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
3122           case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U':
3123           case 'V': case 'W': case 'X': case 'Y': case 'Z':
3124           case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
3125           case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
3126           case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u':
3127           case 'v': case 'w': case 'x': case 'y': case 'z':
3128                 return true;
3129         }
3130 }
3131
3132 /* If A is an uppercase character in the C locale, return its lowercase
3133    counterpart.  Otherwise, return A.  */
3134 static char
3135 lowerit(char a)
3136 {
3137         switch (a) {
3138           default: return a;
3139           case 'A': return 'a'; case 'B': return 'b'; case 'C': return 'c';
3140           case 'D': return 'd'; case 'E': return 'e'; case 'F': return 'f';
3141           case 'G': return 'g'; case 'H': return 'h'; case 'I': return 'i';
3142           case 'J': return 'j'; case 'K': return 'k'; case 'L': return 'l';
3143           case 'M': return 'm'; case 'N': return 'n'; case 'O': return 'o';
3144           case 'P': return 'p'; case 'Q': return 'q'; case 'R': return 'r';
3145           case 'S': return 's'; case 'T': return 't'; case 'U': return 'u';
3146           case 'V': return 'v'; case 'W': return 'w'; case 'X': return 'x';
3147           case 'Y': return 'y'; case 'Z': return 'z';
3148         }
3149 }
3150
3151 /* case-insensitive equality */
3152 static ATTRIBUTE_PURE bool
3153 ciequal(register const char *ap, register const char *bp)
3154 {
3155         while (lowerit(*ap) == lowerit(*bp++))
3156                 if (*ap++ == '\0')
3157                         return true;
3158         return false;
3159 }
3160
3161 static ATTRIBUTE_PURE bool
3162 itsabbr(register const char *abbr, register const char *word)
3163 {
3164         if (lowerit(*abbr) != lowerit(*word))
3165                 return false;
3166         ++word;
3167         while (*++abbr != '\0')
3168                 do {
3169                         if (*word == '\0')
3170                                 return false;
3171                 } while (lowerit(*word++) != lowerit(*abbr));
3172         return true;
3173 }
3174
3175 /* Return true if ABBR is an initial prefix of WORD, ignoring ASCII case.  */
3176
3177 static ATTRIBUTE_PURE bool
3178 ciprefix(char const *abbr, char const *word)
3179 {
3180   do
3181     if (!*abbr)
3182       return true;
3183   while (lowerit(*abbr++) == lowerit(*word++));
3184
3185   return false;
3186 }
3187
3188 static const struct lookup *
3189 byword(const char *word, const struct lookup *table)
3190 {
3191         register const struct lookup *  foundlp;
3192         register const struct lookup *  lp;
3193
3194         if (word == NULL || table == NULL)
3195                 return NULL;
3196
3197         /* If TABLE is LASTS and the word starts with "last" followed
3198            by a non-'-', skip the "last" and look in WDAY_NAMES instead.
3199            Warn about any usage of the undocumented prefix "last-".  */
3200         if (table == lasts && ciprefix("last", word) && word[4]) {
3201           if (word[4] == '-')
3202             warning(_("\"%s\" is undocumented; use \"last%s\" instead"),
3203                     word, word + 5);
3204           else {
3205             word += 4;
3206             table = wday_names;
3207           }
3208         }
3209
3210         /*
3211         ** Look for exact match.
3212         */
3213         for (lp = table; lp->l_word != NULL; ++lp)
3214                 if (ciequal(word, lp->l_word))
3215                         return lp;
3216         /*
3217         ** Look for inexact match.
3218         */
3219         foundlp = NULL;
3220         for (lp = table; lp->l_word != NULL; ++lp)
3221                 if (ciprefix(word, lp->l_word)) {
3222                         if (foundlp == NULL)
3223                                 foundlp = lp;
3224                         else    return NULL;    /* multiple inexact matches */
3225                 }
3226
3227         if (foundlp && noise) {
3228           /* Warn about any backward-compatibility issue with pre-2017c zic.  */
3229           bool pre_2017c_match = false;
3230           for (lp = table; lp->l_word; lp++)
3231             if (itsabbr(word, lp->l_word)) {
3232               if (pre_2017c_match) {
3233                 warning(_("\"%s\" is ambiguous in pre-2017c zic"), word);
3234                 break;
3235               }
3236               pre_2017c_match = true;
3237             }
3238         }
3239
3240         return foundlp;
3241 }
3242
3243 static char **
3244 getfields(register char *cp)
3245 {
3246         register char *         dp;
3247         register char **        array;
3248         register int            nsubs;
3249
3250         if (cp == NULL)
3251                 return NULL;
3252         array = emalloc(size_product(strlen(cp) + 1, sizeof *array));
3253         nsubs = 0;
3254         for ( ; ; ) {
3255                 while (is_space(*cp))
3256                                 ++cp;
3257                 if (*cp == '\0' || *cp == '#')
3258                         break;
3259                 array[nsubs++] = dp = cp;
3260                 do {
3261                         if ((*dp = *cp++) != '"')
3262                                 ++dp;
3263                         else while ((*dp = *cp++) != '"')
3264                                 if (*dp != '\0')
3265                                         ++dp;
3266                                 else {
3267                                   error(_("Odd number of quotation marks"));
3268                                   exit(EXIT_FAILURE);
3269                                 }
3270                 } while (*cp && *cp != '#' && !is_space(*cp));
3271                 if (is_space(*cp))
3272                         ++cp;
3273                 *dp = '\0';
3274         }
3275         array[nsubs] = NULL;
3276         return array;
3277 }
3278
3279 static _Noreturn void
3280 time_overflow(void)
3281 {
3282   error(_("time overflow"));
3283   exit(EXIT_FAILURE);
3284 }
3285
3286 static ATTRIBUTE_PURE zic_t
3287 oadd(zic_t t1, zic_t t2)
3288 {
3289         if (t1 < 0 ? t2 < ZIC_MIN - t1 : ZIC_MAX - t1 < t2)
3290           time_overflow();
3291         return t1 + t2;
3292 }
3293
3294 static ATTRIBUTE_PURE zic_t
3295 tadd(zic_t t1, zic_t t2)
3296 {
3297   if (t1 < 0) {
3298     if (t2 < min_time - t1) {
3299       if (t1 != min_time)
3300         time_overflow();
3301       return min_time;
3302     }
3303   } else {
3304     if (max_time - t1 < t2) {
3305       if (t1 != max_time)
3306         time_overflow();
3307       return max_time;
3308     }
3309   }
3310   return t1 + t2;
3311 }
3312
3313 /*
3314 ** Given a rule, and a year, compute the date (in seconds since January 1,
3315 ** 1970, 00:00 LOCAL time) in that year that the rule refers to.
3316 */
3317
3318 static zic_t
3319 rpytime(const struct rule *rp, zic_t wantedy)
3320 {
3321         register int    m, i;
3322         register zic_t  dayoff;                 /* with a nod to Margaret O. */
3323         register zic_t  t, y;
3324
3325         if (wantedy == ZIC_MIN)
3326                 return min_time;
3327         if (wantedy == ZIC_MAX)
3328                 return max_time;
3329         dayoff = 0;
3330         m = TM_JANUARY;
3331         y = EPOCH_YEAR;
3332         if (y < wantedy) {
3333           wantedy -= y;
3334           dayoff = (wantedy / YEARSPERREPEAT) * (SECSPERREPEAT / SECSPERDAY);
3335           wantedy %= YEARSPERREPEAT;
3336           wantedy += y;
3337         } else if (wantedy < 0) {
3338           dayoff = (wantedy / YEARSPERREPEAT) * (SECSPERREPEAT / SECSPERDAY);
3339           wantedy %= YEARSPERREPEAT;
3340         }
3341         while (wantedy != y) {
3342                 if (wantedy > y) {
3343                         i = len_years[isleap(y)];
3344                         ++y;
3345                 } else {
3346                         --y;
3347                         i = -len_years[isleap(y)];
3348                 }
3349                 dayoff = oadd(dayoff, i);
3350         }
3351         while (m != rp->r_month) {
3352                 i = len_months[isleap(y)][m];
3353                 dayoff = oadd(dayoff, i);
3354                 ++m;
3355         }
3356         i = rp->r_dayofmonth;
3357         if (m == TM_FEBRUARY && i == 29 && !isleap(y)) {
3358                 if (rp->r_dycode == DC_DOWLEQ)
3359                         --i;
3360                 else {
3361                         error(_("use of 2/29 in non leap-year"));
3362                         exit(EXIT_FAILURE);
3363                 }
3364         }
3365         --i;
3366         dayoff = oadd(dayoff, i);
3367         if (rp->r_dycode == DC_DOWGEQ || rp->r_dycode == DC_DOWLEQ) {
3368                 register zic_t  wday;
3369
3370 #define LDAYSPERWEEK    ((zic_t) DAYSPERWEEK)
3371                 wday = EPOCH_WDAY;
3372                 /*
3373                 ** Don't trust mod of negative numbers.
3374                 */
3375                 if (dayoff >= 0)
3376                         wday = (wday + dayoff) % LDAYSPERWEEK;
3377                 else {
3378                         wday -= ((-dayoff) % LDAYSPERWEEK);
3379                         if (wday < 0)
3380                                 wday += LDAYSPERWEEK;
3381                 }
3382                 while (wday != rp->r_wday)
3383                         if (rp->r_dycode == DC_DOWGEQ) {
3384                                 dayoff = oadd(dayoff, 1);
3385                                 if (++wday >= LDAYSPERWEEK)
3386                                         wday = 0;
3387                                 ++i;
3388                         } else {
3389                                 dayoff = oadd(dayoff, -1);
3390                                 if (--wday < 0)
3391                                         wday = LDAYSPERWEEK - 1;
3392                                 --i;
3393                         }
3394                 if (i < 0 || i >= len_months[isleap(y)][m]) {
3395                         if (noise)
3396                                 warning(_("rule goes past start/end of month; \
3397 will not work with pre-2004 versions of zic"));
3398                 }
3399         }
3400         if (dayoff < min_time / SECSPERDAY)
3401                 return min_time;
3402         if (dayoff > max_time / SECSPERDAY)
3403                 return max_time;
3404         t = (zic_t) dayoff * SECSPERDAY;
3405         return tadd(t, rp->r_tod);
3406 }
3407
3408 static void
3409 newabbr(const char *string)
3410 {
3411         register int    i;
3412
3413         if (strcmp(string, GRANDPARENTED) != 0) {
3414                 register const char *   cp;
3415                 const char *            mp;
3416
3417                 cp = string;
3418                 mp = NULL;
3419                 while (is_alpha(*cp) || ('0' <= *cp && *cp <= '9')
3420                        || *cp == '-' || *cp == '+')
3421                                 ++cp;
3422                 if (noise && cp - string < 3)
3423                   mp = _("time zone abbreviation has fewer than 3 characters");
3424                 if (cp - string > ZIC_MAX_ABBR_LEN_WO_WARN)
3425                   mp = _("time zone abbreviation has too many characters");
3426                 if (*cp != '\0')
3427 mp = _("time zone abbreviation differs from POSIX standard");
3428                 if (mp != NULL)
3429                         warning("%s (%s)", mp, string);
3430         }
3431         i = strlen(string) + 1;
3432         if (charcnt + i > TZ_MAX_CHARS) {
3433                 error(_("too many, or too long, time zone abbreviations"));
3434                 exit(EXIT_FAILURE);
3435         }
3436         strcpy(&chars[charcnt], string);
3437         charcnt += i;
3438 }
3439
3440 /* Ensure that the directories of ARGNAME exist, by making any missing
3441    ones.  If ANCESTORS, do this only for ARGNAME's ancestors; otherwise,
3442    do it for ARGNAME too.  Exit with failure if there is trouble.
3443    Do not consider an existing non-directory to be trouble.  */
3444 static void
3445 mkdirs(char const *argname, bool ancestors)
3446 {
3447         register char * name;
3448         register char * cp;
3449
3450         cp = name = ecpyalloc(argname);
3451
3452         /* On MS-Windows systems, do not worry about drive letters or
3453            backslashes, as this should suffice in practice.  Time zone
3454            names do not use drive letters and backslashes.  If the -d
3455            option of zic does not name an already-existing directory,
3456            it can use slashes to separate the already-existing
3457            ancestor prefix from the to-be-created subdirectories.  */
3458
3459         /* Do not mkdir a root directory, as it must exist.  */
3460         while (*cp == '/')
3461           cp++;
3462
3463         while (cp && ((cp = strchr(cp, '/')) || !ancestors)) {
3464                 if (cp)
3465                   *cp = '\0';
3466                 /*
3467                 ** Try to create it.  It's OK if creation fails because
3468                 ** the directory already exists, perhaps because some
3469                 ** other process just created it.  For simplicity do
3470                 ** not check first whether it already exists, as that
3471                 ** is checked anyway if the mkdir fails.
3472                 */
3473                 if (mkdir(name, MKDIR_UMASK) != 0) {
3474                         /* For speed, skip itsdir if errno == EEXIST.  Since
3475                            mkdirs is called only after open fails with ENOENT
3476                            on a subfile, EEXIST implies itsdir here.  */
3477                         int err = errno;
3478                         if (err != EEXIST && !itsdir(name)) {
3479                                 error(_("%s: Can't create directory %s: %s"),
3480                                       progname, name, strerror(err));
3481                                 exit(EXIT_FAILURE);
3482                         }
3483                 }
3484                 if (cp)
3485                   *cp++ = '/';
3486         }
3487         free(name);
3488 }