Index: lib/libc/time/README =================================================================== RCS file: /cvsroot/src/lib/libc/time/README,v retrieving revision 1.5 diff -u -r1.5 README --- lib/libc/time/README 29 Jan 2002 12:40:33 -0000 1.5 +++ lib/libc/time/README 31 Dec 2009 20:52:24 -0000 @@ -1,4 +1,6 @@ -@(#)README 7.11 +@(#)README 8.3 +This file is in the public domain, so clarified as of +2009-05-17 by Arthur David Olson. "What time is it?" -- Richard Deacon as The King "Any time you want it to be." -- Frank Baxter as The Scientist @@ -52,8 +54,10 @@ To use the new functions, use a "-ltz" option when compiling or linking. -Historical local time information has been included here not because it -is particularly useful, but rather to: +Historical local time information has been included here to: + +* provide a compendium of data about the history of civil time + that is useful even if the data are not 100% accurate; * give an idea of the variety of local time rules that have existed in the past and thus an idea of the variety that may be @@ -63,7 +67,9 @@ system. The information in the time zone data files is by no means authoritative; -if you know that the rules are different from those in a file, by all means +the files currently do not even attempt to cover all time stamps before +1970, and there are undoubtedly errors even for time stamps since 1970. +If you know that the rules are different from those in a file, by all means feel free to change file (and please send the changed version to tz@elsie.nci.nih.gov for use in the future). Europeans take note! Index: lib/libc/time/Theory =================================================================== RCS file: /cvsroot/src/lib/libc/time/Theory,v retrieving revision 1.8 diff -u -r1.8 Theory --- lib/libc/time/Theory 27 May 2004 20:39:49 -0000 1.8 +++ lib/libc/time/Theory 31 Dec 2009 20:52:24 -0000 @@ -1,6 +1,7 @@ # $NetBSD: Theory,v 1.8 2004/05/27 20:39:49 kleink Exp $ -@(#)Theory 7.15 - +@(#)Theory 8.3 +This file is in the public domain, so clarified as of +2009-05-17 by Arthur David Olson. ----- Outline ----- @@ -10,29 +11,29 @@ Calendrical issues Time and time zones on Mars - ----- Time and date functions ----- -These time and date functions are upwards compatible with POSIX.1, +These time and date functions are upwards compatible with POSIX, an international standard for UNIX-like systems. -As of this writing, the current edition of POSIX.1 is: +As of this writing, the current edition of POSIX is: - Information technology --Portable Operating System Interface (POSIX (R)) - -- Part 1: System Application Program Interface (API) [C Language] - ISO/IEC 9945-1:1996 - ANSI/IEEE Std 1003.1, 1996 Edition - 1996-07-12 + Standard for Information technology + -- Portable Operating System Interface (POSIX (R)) + -- System Interfaces + IEEE Std 1003.1, 2004 Edition + + -POSIX.1 has the following properties and limitations. +POSIX has the following properties and limitations. -* In POSIX.1, time display in a process is controlled by the - environment variable TZ. Unfortunately, the POSIX.1 TZ string takes +* In POSIX, time display in a process is controlled by the + environment variable TZ. Unfortunately, the POSIX TZ string takes a form that is hard to describe and is error-prone in practice. - Also, POSIX.1 TZ strings can't deal with other (for example, Israeli) + Also, POSIX TZ strings can't deal with other (for example, Israeli) daylight saving time rules, or situations where more than two time zone abbreviations are used in an area. - The POSIX.1 TZ string takes the following form: + The POSIX TZ string takes the following form: stdoffset[dst[offset],date[/time],date[/time]] @@ -41,6 +42,9 @@ std and dst are 3 or more characters specifying the standard and daylight saving time (DST) zone names. + Starting with POSIX.1-2001, std and dst may also be + in a quoted form like ""; this allows + "+" and "-" in the names. offset is of the form `[-]hh:[mm[:ss]]' and specifies the offset west of UTC. The default DST offset is one hour @@ -63,14 +67,25 @@ and `5' stands for the last week in which day d appears (which may be either the 4th or 5th week). -* In POSIX.1, when a TZ value like "EST5EDT" is parsed, - typically the current US DST rules are used, + Here is an example POSIX TZ string, for US Pacific time using rules + appropriate from 1987 through 2006: + + TZ='PST8PDT,M4.1.0/02:00,M10.5.0/02:00' + + This POSIX TZ string is hard to remember, and mishandles time stamps + before 1987 and after 2006. With this package you can use this + instead: + + TZ='America/Los_Angeles' + +* POSIX does not define the exact meaning of TZ values like "EST5EDT". + Typically the current US DST rules are used to interpret such values, but this means that the US DST rules are compiled into each program that does time conversion. This means that when US time conversion rules change (as in the United States in 1987), all programs that do time conversion must be recompiled to ensure proper results. -* In POSIX.1, there's no tamper-proof way for a process to learn the +* In POSIX, there's no tamper-proof way for a process to learn the system's best idea of local wall clock. (This is important for applications that an administrator wants used only at certain times-- without regard to whether the user has fiddled the "TZ" environment @@ -79,9 +94,9 @@ daylight saving time shifts--as might be required to limit phone calls to off-peak hours.) -* POSIX.1 requires that systems ignore leap seconds. +* POSIX requires that systems ignore leap seconds. -These are the extensions that have been made to the POSIX.1 functions: +These are the extensions that have been made to the POSIX functions: * The "TZ" environment variable is used in generating the name of a file from which time zone information is read (or is interpreted a la @@ -109,7 +124,7 @@ * To handle places where more than two time zone abbreviations are used, the functions "localtime" and "gmtime" set tzname[tmp->tm_isdst] (where "tmp" is the value the function returns) to the time zone - abbreviation to be used. This differs from POSIX.1, where the elements + abbreviation to be used. This differs from POSIX, where the elements of tzname are only changed as a result of calls to tzset. * Since the "TZ" environment variable can now be used to control time @@ -132,8 +147,7 @@ environment variable; portable applications should not, however, rely on this behavior since it's not the way SVR2 systems behave.) -* These functions can account for leap seconds, thanks to Bradley White - (bww@k.cs.cmu.edu). +* These functions can account for leap seconds, thanks to Bradley White. Points of interest to folks with other systems: @@ -174,9 +188,9 @@ beyond those provided here. The absence of such functions from this package is not meant to discourage the development, standardization, or use of such functions. Rather, their absence reflects the decision to make this package -contain valid extensions to POSIX.1, to ensure its broad -acceptability. If more powerful time conversion functions can be standardized, -so much the better. +contain valid extensions to POSIX, to ensure its broad acceptability. If +more powerful time conversion functions can be standardized, so much the +better. ----- Names of time zone rule files ----- @@ -229,6 +243,8 @@ Include at least one location per time zone rule set per country. One such location is enough. Use ISO 3166 (see the file iso3166.tab) to help decide whether something is a country. + However, uninhabited ISO 3166 regions like Bouvet Island + do not need locations, since local time is not defined there. If all the clocks in a country's region have agreed since 1970, don't bother to include more than one location even if subregions' clocks disagreed before 1970. @@ -264,7 +280,8 @@ If a name is changed, put its old spelling in the `backward' file. The file `zone.tab' lists the geographical locations used to name -time zone rule files. +time zone rule files. It is intended to be an exhaustive list +of canonical names for geographic regions. Older versions of this package used a different naming scheme, and these older names are still supported. @@ -278,7 +295,7 @@ ----- Time zone abbreviations ----- When this package is installed, it generates time zone abbreviations -like `EST' to be compatible with human tradition and POSIX.1. +like `EST' to be compatible with human tradition and POSIX. Here are the general rules used for choosing time zone abbreviations, in decreasing order of importance: @@ -293,17 +310,16 @@ preferred "ChST", so the rule has been relaxed. This rule guarantees that all abbreviations could have - been specified by a POSIX.1 TZ string. POSIX.1 + been specified by a POSIX TZ string. POSIX requires at least three characters for an - abbreviation. POSIX.1-1996 says that an abbreviation + abbreviation. POSIX through 2000 says that an abbreviation cannot start with ':', and cannot contain ',', '-', - '+', NUL, or a digit. Draft 7 of POSIX 1003.1-200x - changes this rule to say that an abbreviation can - contain only '-', '+', and alphanumeric characters in - the current locale. To be portable to both sets of + '+', NUL, or a digit. POSIX from 2001 on changes this + rule to say that an abbreviation can contain only '-', '+', + and alphanumeric characters from the portable character set + in the current locale. To be portable to both sets of rules, an abbreviation must therefore use only ASCII - letters, as these are the only letters that are - alphabetic in all locales. + letters. Use abbreviations that are in common use among English-speakers, e.g. `EST' for Eastern Standard Time in North America. @@ -329,8 +345,9 @@ and then append `T', `ST', etc. as before; e.g. `VLAST' for VLAdivostok Summer Time. - Use "zzz" for locations while uninhabited. The mnemonic is that - these locations are, in some sense, asleep. + Use UTC (with time zone abbreviation "zzz") for locations while + uninhabited. The "zzz" mnemonic is that these locations are, + in some sense, asleep. Application writers should note that these abbreviations are ambiguous in practice: e.g. `EST' has a different meaning in Australia than @@ -344,10 +361,10 @@ Calendrical issues are a bit out of scope for a time zone database, but they indicate the sort of problems that we would run into if we extended the time zone database further into the past. An excellent -resource in this area is Nachum Dershowitz and Edward M. Reingold, - -Calendrical Calculations -, Cambridge University Press (1997). Other information and +resource in this area is Edward M. Reingold and Nachum Dershowitz, + +Calendrical Calculations: The Millennium Edition +, Cambridge University Press (2001). Other information and sources are given below. They sometimes disagree. @@ -360,7 +377,7 @@ Russia -From Chris Carrier <72157.3334@CompuServe.COM> (1996-12-02): +From Chris Carrier (1996-12-02): On 1929-10-01 the Soviet Union instituted an ``Eternal Calendar'' with 30-day months plus 5 holidays, with a 5-day week. On 1931-12-01 it changed to a 6-day week; in 1934 it reverted to the @@ -375,7 +392,7 @@ From: Petteri Sulonen (via Usenet) Date: 14 Jan 1999 00:00:00 GMT -Message-ID: +... If your source is correct, how come documents between 1929 -- 1940 were still dated using the conventional, Gregorian calendar? @@ -388,7 +405,7 @@ Sweden (and Finland) -From: msb@sq.com (Mark Brader) +From: Mark Brader Subject: Re: Gregorian reform -- a part of locale? @@ -416,11 +433,11 @@ Grotefend's data -From: "Michael Palmer" [with one obvious typo fixed] +From: "Michael Palmer" [with one obvious typo fixed] Subject: Re: Gregorian Calendar (was Re: Another FHC related question Newsgroups: soc.genealogy.german Date: Tue, 9 Feb 1999 02:32:48 -800 -Message-ID: <199902091032.CAA09644@netcom10.netcom.com> +... The following is a(n incomplete) listing, arranged chronologically, of European states, with the date they converted from the Julian to the @@ -547,7 +564,7 @@ Michael Allison and Robert Schmunk, "Technical Notes on Mars Solar Time as Adopted by the Mars24 Sunclock" - (2004-03-15). + (2004-07-30). Jia-Rui Chong, "Workdays Fit for a Martian", Los Angeles Times (2004-01-14), pp A1, A20-A21. Index: lib/libc/time/asctime.c =================================================================== RCS file: /cvsroot/src/lib/libc/time/asctime.c,v retrieving revision 1.12 diff -u -r1.12 asctime.c --- lib/libc/time/asctime.c 15 Oct 2006 15:32:42 -0000 1.12 +++ lib/libc/time/asctime.c 31 Dec 2009 20:52:24 -0000 @@ -2,13 +2,19 @@ /* ** This file is in the public domain, so clarified as of -** 1996-06-05 by Arthur David Olson (arthur_david_olson@nih.gov). +** 1996-06-05 by Arthur David Olson. +*/ + +/* +** Avoid the temptation to punt entirely to strftime; +** the output of strftime is supposed to be locale specific +** whereas the output of asctime is supposed to be constant. */ #include #if defined(LIBC_SCCS) && !defined(lint) #if 0 -static char elsieid[] = "@(#)asctime.c 7.9"; +static char elsieid[] = "@(#)asctime.c 8.2"; #else __RCSID("$NetBSD: asctime.c,v 1.12 2006/10/15 15:32:42 perry Exp $"); #endif @@ -25,7 +31,57 @@ #endif /* -** A la ISO/IEC 9945-1, ANSI/IEEE Std 1003.1, Second Edition, 1996-07-12. +** Some systems only handle "%.2d"; others only handle "%02d"; +** "%02.2d" makes (most) everybody happy. +** At least some versions of gcc warn about the %02.2d; +** we conditionalize below to avoid the warning. +*/ +/* +** All years associated with 32-bit time_t values are exactly four digits long; +** some years associated with 64-bit time_t values are not. +** Vintage programs are coded for years that are always four digits long +** and may assume that the newline always lands in the same place. +** For years that are less than four digits, we pad the output with +** leading zeroes to get the newline in the traditional place. +** The -4 ensures that we get four characters of output even if +** we call a strftime variant that produces fewer characters for some years. +** The ISO C 1999 and POSIX 1003.1-2004 standards prohibit padding the year, +** but many implementations pad anyway; most likely the standards are buggy. +*/ +#ifdef __GNUC__ +#define ASCTIME_FMT "%.3s %.3s%3d %2.2d:%2.2d:%2.2d %-4s\n" +#else /* !defined __GNUC__ */ +#define ASCTIME_FMT "%.3s %.3s%3d %02.2d:%02.2d:%02.2d %-4s\n" +#endif /* !defined __GNUC__ */ +/* +** For years that are more than four digits we put extra spaces before the year +** so that code trying to overwrite the newline won't end up overwriting +** a digit within a year and truncating the year (operating on the assumption +** that no output is better than wrong output). +*/ +#ifdef __GNUC__ +#define ASCTIME_FMT_B "%.3s %.3s%3d %2.2d:%2.2d:%2.2d %s\n" +#else /* !defined __GNUC__ */ +#define ASCTIME_FMT_B "%.3s %.3s%3d %02.2d:%02.2d:%02.2d %s\n" +#endif /* !defined __GNUC__ */ + +#define STD_ASCTIME_BUF_SIZE 26 +/* +** Big enough for something such as +** ??? ???-2147483648 -2147483648:-2147483648:-2147483648 -2147483648\n +** (two three-character abbreviations, five strings denoting integers, +** seven explicit spaces, two explicit colons, a newline, +** and a trailing ASCII nul). +** The values above are for systems where an int is 32 bits and are provided +** as an example; the define below calculates the maximum for the system at +** hand. +*/ +#define MAX_ASCTIME_BUF_SIZE (2*3+5*INT_STRLEN_MAXIMUM(int)+7+2+1+1) + +static char buf_asctime[MAX_ASCTIME_BUF_SIZE]; + +/* +** A la ISO/IEC 9945-1, ANSI/IEEE Std 1003.1, 2004 Edition. */ /* @@ -51,6 +107,8 @@ }; register const char * wn; register const char * mn; + char year[INT_STRLEN_MAXIMUM(int) + 2]; + char result[MAX_ASCTIME_BUF_SIZE]; if (timeptr->tm_wday < 0 || timeptr->tm_wday >= DAYSPERWEEK) wn = "???"; @@ -59,29 +117,39 @@ mn = "???"; else mn = mon_name[timeptr->tm_mon]; /* - ** The X3J11-suggested format is - ** "%.3s %.3s%3d %02.2d:%02.2d:%02.2d %d\n" - ** Since the .2 in 02.2d is ignored, we drop it. + ** Use strftime's %Y to generate the year, to avoid overflow problems + ** when computing timeptr->tm_year + TM_YEAR_BASE. + ** Assume that strftime is unaffected by other out-of-range members + ** (e.g., timeptr->tm_mday) when processing "%Y". */ - (void)snprintf(buf, - sizeof (char[ASCTIME_BUFLEN]), - "%.3s %.3s%3d %02d:%02d:%02d %d\n", + (void) strftime(year, sizeof year, "%Y", timeptr); + (void) snprintf(result, + sizeof(result), + ((strlen(year) <= 4) ? ASCTIME_FMT : ASCTIME_FMT_B), wn, mn, timeptr->tm_mday, timeptr->tm_hour, timeptr->tm_min, timeptr->tm_sec, - TM_YEAR_BASE + timeptr->tm_year); - return buf; + year); + if (strlen(result) < STD_ASCTIME_BUF_SIZE || buf == buf_asctime) { + (void) strcpy(buf, result); + return buf; + } else { +#ifdef EOVERFLOW + errno = EOVERFLOW; +#else /* !defined EOVERFLOW */ + errno = EINVAL; +#endif /* !defined EOVERFLOW */ + return NULL; + } } /* -** A la X3J11, with core dump avoidance. +** A la ISO/IEC 9945-1, ANSI/IEEE Std 1003.1, 2004 Edition. */ char * asctime(timeptr) register const struct tm * timeptr; { - static char result[ASCTIME_BUFLEN]; - - return asctime_r(timeptr, result); + return asctime_r(timeptr, buf_asctime); } Index: lib/libc/time/checktab.awk =================================================================== RCS file: /cvsroot/src/lib/libc/time/checktab.awk,v retrieving revision 1.3 diff -u -r1.3 checktab.awk --- lib/libc/time/checktab.awk 10 Nov 1999 20:32:31 -0000 1.3 +++ lib/libc/time/checktab.awk 31 Dec 2009 20:52:24 -0000 @@ -2,9 +2,9 @@ # Check tz tables for consistency. -# @(#)checktab.awk 1.6 +# @(#)checktab.awk 8.1 -# Contributed by Paul Eggert . +# Contributed by Paul Eggert. BEGIN { FS = "\t" Index: lib/libc/time/ctime.3 =================================================================== RCS file: /cvsroot/src/lib/libc/time/ctime.3,v retrieving revision 1.27 diff -u -r1.27 ctime.3 --- lib/libc/time/ctime.3 16 Apr 2003 13:34:58 -0000 1.27 +++ lib/libc/time/ctime.3 31 Dec 2009 20:52:24 -0000 @@ -42,21 +42,31 @@ .Sh DESCRIPTION .Fn ctime converts a long integer, pointed to by -.Fa clock , -representing the time in seconds since 00:00:00 UTC, 1970-01-01, -and returns a pointer to a 26-character string of the form -.Dl Thu Nov 24 18:22:48 1986\en\e0 -All the fields have constant width. -.Pp -The -.Fn ctime_r -function provides the same functionality as -.Fn ctime -differing in that the caller must supply a buffer area -.Fa buf -with a size of at least 26 bytes, in which the result is stored. -.Pp -.Fn localtime +.IR clock , +representing the time in seconds since +00:00:00 UTC, 1970-01-01, +and returns a pointer to a +string of the form +.br +.ce +.eo +Thu Nov 24 18:22:48 1986\n\0 +.br +.ec +Years requiring fewer than four characters are padded with leading zeroes. +For years longer than four characters, the string is of the form +.br +.ce +.eo +Thu Nov 24 18:22:48 81986\n\0 +.ec +.br +with five spaces before the year. +These unusual formats are designed to make it less likely that older +software that expects exactly 26 bytes of output will mistakenly output +misleading values for out-of-range years. +.PP +.I Localtime\^ and .Fn gmtime return pointers to @@ -69,6 +79,11 @@ .Va tm structure, .Fn localtime +(such as Daylight Saving Time in the United States). +After filling in the +.Va tm +structure, +.I localtime sets the .Fa tm_isdst Ns 'th element of @@ -99,20 +114,13 @@ .Pp .Fn asctime converts a time value contained in a -.Va tm -structure to a 26-character string, as shown in the above example, +``tm'' structure to a string, +as shown in the above example, and returns a pointer to the string. -.Pp -The -.Fn asctime_r -function provides the same functionality as -.Fn asctime -differing in that the caller must supply a buffer area -.Fa buf -with a size of at least 26 bytes, in which the result is stored. -.Pp -.Fn mktime -converts the broken-down time, expressed as local time, +.PP +.I Mktime\^ +converts the broken-down time, +expressed as local time, in the structure pointed to by .Fa tm into a calendar time value with the same encoding as that of the values @@ -138,7 +146,9 @@ causes the .Fn mktime function to attempt to divine whether summer time is in effect -for the specified time.) +for the specified time; in this case it does not use a consistent +rule and may give a different answer when later +presented with the same argument.) On successful completion, the values of the .Fa tm_wday and @@ -243,11 +253,28 @@ .Fa tm_zone field of a returned .Va "struct tm" -points to a static array of characters, which will also be overwritten -at the next call (and by calls to -.Xr tzset 3 ) . -.Pp +points to a static array of characters, which +will also be overwritten at the next call +(and by calls to +.Xr tzset 3 ). +.PP +.I Asctime\^ +and +.I ctime\^ +behave strangely for years before 1000 or after 9999. +The 1989 and 1999 editions of the C Standard say +that years from \-99 through 999 are converted without +extra spaces, but this conflicts with longstanding +tradition and with this implementation. +Traditional implementations of these two functions are +restricted to years in the range 1900 through 2099. +To avoid this portability mess, new programs should use +.I strftime\^ +instead. +.PP Avoid using out-of-range values with .Fn mktime when setting up lunch with promptness sticklers in Riyadh. -.\" @(#)newctime.3 7.14 +.\" @(#)newctime.3 8.3 +.\" This file is in the public domain, so clarified as of +.\" 2009-05-17 by Arthur David Olson. Index: lib/libc/time/difftime.c =================================================================== RCS file: /cvsroot/src/lib/libc/time/difftime.c,v retrieving revision 1.9 diff -u -r1.9 difftime.c --- lib/libc/time/difftime.c 29 Jan 2002 12:58:32 -0000 1.9 +++ lib/libc/time/difftime.c 31 Dec 2009 20:52:24 -0000 @@ -2,94 +2,73 @@ /* ** This file is in the public domain, so clarified as of -** June 5, 1996 by Arthur David Olson (arthur_david_olson@nih.gov). +** 1996-06-05 by Arthur David Olson. */ #include #if defined(LIBC_SCCS) && !defined(lint) #if 0 -static char elsieid[] = "@(#)difftime.c 7.9"; +static char elsieid[] = "@(#)difftime.c 8.1"; #else __RCSID("$NetBSD: difftime.c,v 1.9 2002/01/29 12:58:32 kleink Exp $"); #endif #endif /* LIBC_SCCS and not lint */ - /*LINTLIBRARY*/ -#include "private.h" - -/* -** Algorithm courtesy Paul Eggert (eggert@twinsun.com). -*/ - -#ifdef HAVE_LONG_DOUBLE -#define long_double long double -#endif /* defined HAVE_LONG_DOUBLE */ -#ifndef HAVE_LONG_DOUBLE -#define long_double double -#endif /* !defined HAVE_LONG_DOUBLE */ +#include "private.h" /* for time_t, TYPE_INTEGRAL, and TYPE_SIGNED */ double difftime(time1, time0) const time_t time1; const time_t time0; { - time_t delta; - time_t hibit; - - { - time_t tt; - double d; - long_double ld; - -#ifdef __lint__ - /* LINTED unused warning bug */&tt; - /* LINTED unused warning bug */&d; - /* LINTED unused warning bug */&ld; -#endif - - if (/* LINTED constant */sizeof tt < sizeof d) - return (double) time1 - (double) time0; - if (/* LINTED constant */sizeof tt < sizeof ld) - return (long_double) time1 - (long_double) time0; + /* + ** If (sizeof (double) > sizeof (time_t)) simply convert and subtract + ** (assuming that the larger type has more precision). + ** This is the common real-world case circa 2004. + */ +/* LINTED constant */ + if (sizeof (double) > sizeof (time_t)) + return (double) time1 - (double) time0; +/* LINTED constant */ + if (!TYPE_INTEGRAL(time_t)) { + /* + ** time_t is floating. + */ + return time1 - time0; + } +/* LINTED constant */ + if (!TYPE_SIGNED(time_t)) { + /* + ** time_t is integral and unsigned. + ** The difference of two unsigned values can't overflow + ** if the minuend is greater than or equal to the subtrahend. + */ + if (time1 >= time0) + return time1 - time0; + else return -((double) (time0 - time1)); } - if (time1 < time0) - return -difftime(time0, time1); /* - ** As much as possible, avoid loss of precision - ** by computing the difference before converting to double. + ** time_t is integral and signed. + ** Handle cases where both time1 and time0 have the same sign + ** (meaning that their difference cannot overflow). */ - delta = time1 - time0; - if (delta >= 0) - return delta; + if ((time1 < 0) == (time0 < 0)) + return time1 - time0; /* - ** Repair delta overflow. + ** time1 and time0 have opposite signs. + ** Punt if unsigned long is too narrow. */ - hibit = (~ (time_t) 0) << (TYPE_BIT(time_t) - 1); +/* CONSTCOND */ + if (sizeof (unsigned long) < sizeof (time_t)) + return (double) time1 - (double) time0; /* - ** The following expression rounds twice, which means - ** the result may not be the closest to the true answer. - ** For example, suppose time_t is 64-bit signed int, - ** long_double is IEEE 754 double with default rounding, - ** time1 = 9223372036854775807 and time0 = -1536. - ** Then the true difference is 9223372036854777343, - ** which rounds to 9223372036854777856 - ** with a total error of 513. - ** But delta overflows to -9223372036854774273, - ** which rounds to -9223372036854774784, and correcting - ** this by subtracting 2 * (long_double) hibit - ** (i.e. by adding 2**64 = 18446744073709551616) - ** yields 9223372036854776832, which - ** rounds to 9223372036854775808 - ** with a total error of 1535 instead. - ** This problem occurs only with very large differences. - ** It's too painful to fix this portably. - ** We are not alone in this problem; - ** some C compilers round twice when converting - ** large unsigned types to small floating types, - ** so if time_t is unsigned the "return delta" above - ** has the same double-rounding problem with those compilers. + ** Stay calm...decent optimizers will eliminate the complexity below. */ - return delta - 2 * (long_double) hibit; + if (time1 >= 0 /* && time0 < 0 */) + return (unsigned long) time1 + + (unsigned long) (-(time0 + 1)) + 1; + return -(double) ((unsigned long) time0 + + (unsigned long) (-(time1 + 1)) + 1); } Index: lib/libc/time/ialloc.c =================================================================== RCS file: /cvsroot/src/lib/libc/time/ialloc.c,v retrieving revision 1.5 diff -u -r1.5 ialloc.c --- lib/libc/time/ialloc.c 13 Jul 1997 20:26:49 -0000 1.5 +++ lib/libc/time/ialloc.c 31 Dec 2009 20:52:24 -0000 @@ -1,17 +1,16 @@ /* $NetBSD: ialloc.c,v 1.5 1997/07/13 20:26:49 christos Exp $ */ +/* +** This file is in the public domain, so clarified as of +** 2006-07-17 by Arthur David Olson. +*/ #include -#ifndef lint -#ifndef NOID + #if 0 -static char elsieid[] = "@(#)ialloc.c 8.29"; +static char elsieid[] = "@(#)ialloc.c 8.30"; #else __RCSID("$NetBSD: ialloc.c,v 1.5 1997/07/13 20:26:49 christos Exp $"); #endif -#endif /* !defined NOID */ -#endif /* !defined lint */ - -/*LINTLIBRARY*/ #include "private.h" Index: lib/libc/time/localtime.c =================================================================== RCS file: /cvsroot/src/lib/libc/time/localtime.c,v retrieving revision 1.44 diff -u -r1.44 localtime.c --- lib/libc/time/localtime.c 24 Oct 2009 17:01:04 -0000 1.44 +++ lib/libc/time/localtime.c 31 Dec 2009 20:52:24 -0000 @@ -2,22 +2,21 @@ /* ** This file is in the public domain, so clarified as of -** 1996-06-05 by Arthur David Olson (arthur_david_olson@nih.gov). +** 1996-06-05 by Arthur David Olson. */ #include #if defined(LIBC_SCCS) && !defined(lint) #if 0 -static char elsieid[] = "@(#)localtime.c 7.78"; +static char elsieid[] = "@(#)localtime.c 8.9"; #else __RCSID("$NetBSD: localtime.c,v 1.44 2009/10/24 17:01:04 mlelstv Exp $"); #endif #endif /* LIBC_SCCS and not lint */ /* -** Leap second handling from Bradley White (bww@k.gp.cs.cmu.edu). -** POSIX-style TZ environment variable handling from Guy Harris -** (guy@auspex.com). +** Leap second handling from Bradley White. +** POSIX-style TZ environment variable handling from Guy Harris. */ /*LINTLIBRARY*/ @@ -35,6 +34,21 @@ __weak_alias(tzsetwall,_tzsetwall) #endif +#include "float.h" /* for FLT_MAX and DBL_MAX */ + +#ifndef TZ_ABBR_MAX_LEN +#define TZ_ABBR_MAX_LEN 16 +#endif /* !defined TZ_ABBR_MAX_LEN */ + +#ifndef TZ_ABBR_CHAR_SET +#define TZ_ABBR_CHAR_SET \ + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 :+-._" +#endif /* !defined TZ_ABBR_CHAR_SET */ + +#ifndef TZ_ABBR_ERR_CHAR +#define TZ_ABBR_ERR_CHAR '_' +#endif /* !defined TZ_ABBR_ERR_CHAR */ + /* ** SunOS 4.1.1 headers lack O_BINARY. */ @@ -60,16 +74,16 @@ ** 5. They might reference tm.TM_ZONE after calling offtime. ** What's best to do in the above cases is open to debate; ** for now, we just set things up so that in any of the five cases -** WILDABBR is used. Another possibility: initialize tzname[0] to the +** WILDABBR is used. Another possibility: initialize tzname[0] to the ** string "tzname[0] used before set", and similarly for the other cases. -** And another: initialize tzname[0] to "ERA", with an explanation in the +** And another: initialize tzname[0] to "ERA", with an explanation in the ** manual page of what this "time zone abbreviation" means (doing this so ** that tzname[0] has the "normal" length of three characters). */ #define WILDABBR " " #endif /* !defined WILDABBR */ -static const char wildabbr[] = "WILDABBR"; +static const char wildabbr[] = WILDABBR; static const char gmt[] = "GMT"; @@ -111,7 +125,9 @@ int timecnt; int typecnt; int charcnt; - time_t ats[TZ_MAX_TIMES]; /* time_t */ + int goback; + int goahead; + time_t ats[TZ_MAX_TIMES]; unsigned char types[TZ_MAX_TIMES]; struct ttinfo ttis[TZ_MAX_TYPES]; char chars[/*CONSTCOND*/BIGGEST(BIGGEST(TZ_MAX_CHARS + 1, sizeof gmt), @@ -135,48 +151,55 @@ ** Prototypes for static functions. */ -static long detzcode P((const char * codep)); -static const char * __getzname P((const char * strp)); -static const char * getnum P((const char * strp, int * nump, int min, - int max)); -static const char * getsecs P((const char * strp, long * secsp)); -static const char * __getoffset P((const char * strp, long * offsetp)); -static const char * __getrule P((const char * strp, struct rule * rulep)); -static void __gmtload P((struct state * sp)); -static void gmtsub P((const time_t * timep, long offset, - struct tm * tmp)); -static void localsub P((const time_t * timep, long offset, - struct tm * tmp)); -static int increment_overflow P((int * number, int delta)); -static int normalize_overflow P((int * tensptr, int * unitsptr, - int base)); -static void __settzname P((void)); -static time_t time1 P((struct tm * tmp, - void(*funcp) P((const time_t *, - long, struct tm *)), - long offset)); -static time_t time2 P((struct tm *tmp, - void(*funcp) P((const time_t *, - long, struct tm*)), - long offset, int * okayp)); -static time_t time2sub P((struct tm *tmp, - void(*funcp) P((const time_t *, - long, struct tm*)), - long offset, int * okayp, int do_norm_secs)); -static void timesub P((const time_t * timep, long offset, - const struct state * sp, struct tm * tmp)); -static int tmcomp P((const struct tm * atmp, - const struct tm * btmp)); -static time_t __transtime P((time_t janfirst, int year, - const struct rule * rulep, long offset)); -static int __tzload P((const char * name, struct state * sp)); -static int __tzparse P((const char * name, struct state * sp, - int lastditch)); -static void __tzset_unlocked P((void)); -static void __tzsetwall_unlocked P((void)); -#ifdef STD_INSPIRED -static long leapcorr P((time_t * timep)); -#endif +static long detzcode(const char * codep); +static time_t detzcode64(const char * codep); +static int differ_by_repeat(time_t t1, time_t t0); +static const char * getzname(const char * strp); +static const char * getqzname(const char * strp, const int delim); +static const char * getnum(const char * strp, int * nump, int min, + int max); +static const char * getsecs(const char * strp, long * secsp); +static const char * getoffset(const char * strp, long * offsetp); +static const char * getrule(const char * strp, struct rule * rulep); +static void gmtload(struct state * sp); +static struct tm * gmtsub(const time_t * timep, long offset, + struct tm * tmp); +static struct tm * localsub(const time_t * timep, long offset, + struct tm * tmp); +static int increment_overflow(int * number, int delta); +static int leaps_thru_end_of(int y); +static int long_increment_overflow(long * number, int delta); +static int long_normalize_overflow(long * tensptr, + int * unitsptr, int base); +static int normalize_overflow(int * tensptr, int * unitsptr, + int base); +static void settzname(void); +static time_t time1(struct tm * tmp, + struct tm * (*funcp)(const time_t *, + long, struct tm *), + long offset); +static time_t time2(struct tm *tmp, + struct tm * (*funcp)(const time_t *, + long, struct tm*), + long offset, int * okayp); +static time_t time2sub(struct tm *tmp, + struct tm * (*funcp)(const time_t *, + long, struct tm*), + long offset, int * okayp, int do_norm_secs); +static struct tm * timesub(const time_t * timep, long offset, + const struct state * sp, struct tm * tmp); +static int tmcomp(const struct tm * atmp, + const struct tm * btmp); +static time_t transtime(time_t janfirst, int year, + const struct rule * rulep, long offset); +static int typesequiv(const struct state * sp, int a, int b); +static int tzload(const char * name, struct state * sp, + int doextend); +static int tzparse(const char * name, struct state * sp, + int lastditch); +static void tzset_unlocked(void); +static void tzsetwall_unlocked(void); +static long leapcorr(time_t * timep); #ifdef ALL_STATE static struct state * lclptr; @@ -194,10 +217,9 @@ #define TZ_STRLEN_MAX 255 #endif /* !defined TZ_STRLEN_MAX */ - -static char __lcl_TZname[TZ_STRLEN_MAX + 1]; -static int __lcl_is_set; -static int __gmt_is_set; +static char lcl_TZname[TZ_STRLEN_MAX + 1]; +static int lcl_is_set; +static int gmt_is_set; #if !defined(__LIBC12_SOURCE__) @@ -213,7 +235,7 @@ #endif #ifdef _REENTRANT -static rwlock_t __lcl_lock = RWLOCK_INITIALIZER; +static rwlock_t lcl_lock = RWLOCK_INITIALIZER; #endif /* @@ -221,7 +243,7 @@ ** Except for the strftime function, these functions [asctime, ** ctime, gmtime, localtime] return values in one of two static ** objects: a broken-down time structure and an array of char. -** Thanks to Paul Eggert (eggert@twinsun.com) for noting this. +** Thanks to Paul Eggert for noting this. */ static struct tm tm; @@ -245,25 +267,29 @@ const char * const codep; { register long result; + register int i; - /* - ** The first character must be sign extended on systems with >32bit - ** longs. This was solved differently in the master tzcode sources - ** (the fix first appeared in tzcode95c.tar.gz). But I believe - ** that this implementation is superior. - */ - -#define SIGN_EXTEND_CHAR(x) ((signed char) x) - - result = (SIGN_EXTEND_CHAR(codep[0]) << 24) \ - | (codep[1] & 0xff) << 16 \ - | (codep[2] & 0xff) << 8 - | (codep[3] & 0xff); + result = (codep[0] & 0x80) ? ~0L : 0; + for (i = 0; i < 4; ++i) + result = (result << 8) | (codep[i] & 0xff); return result; } -void -__settzname P((void)) +static time_t +detzcode64(codep) +const char * const codep; +{ + register time_t result; + register int i; + + result = (codep[0] & 0x80) ? -1 : 0; + for (i = 0; i < 8; ++i) + result = result * 256 + (codep[i] & 0xff); + return result; +} + +static void +settzname(void) { register struct state * const sp = lclptr; register int i; @@ -288,6 +314,16 @@ tzname[ttisp->tt_isdst] = &sp->chars[ttisp->tt_abbrind]; +#ifdef USG_COMPAT + if (ttisp->tt_isdst) + daylight = 1; + if (i == 0 || !ttisp->tt_isdst) + timezone = -(ttisp->tt_gmtoff); +#endif /* defined USG_COMPAT */ +#ifdef ALTZONE + if (i == 0 || ttisp->tt_isdst) + altzone = -(ttisp->tt_gmtoff); +#endif /* defined ALTZONE */ } /* ** And to get the latest zone names into tzname. . . @@ -299,31 +335,59 @@ tzname[ttisp->tt_isdst] = &sp->chars[ttisp->tt_abbrind]; -#ifdef USG_COMPAT - if (ttisp->tt_isdst) - daylight = 1; - if (i == 0 || !ttisp->tt_isdst) - timezone = -(ttisp->tt_gmtoff); -#endif /* defined USG_COMPAT */ -#ifdef ALTZONE - if (i == 0 || ttisp->tt_isdst) - altzone = -(ttisp->tt_gmtoff); -#endif /* defined ALTZONE */ + } + /* + ** Finally, scrub the abbreviations. + ** First, replace bogus characters. + */ + for (i = 0; i < sp->charcnt; ++i) + if (strchr(TZ_ABBR_CHAR_SET, sp->chars[i]) == NULL) + sp->chars[i] = TZ_ABBR_ERR_CHAR; + /* + ** Second, truncate long abbreviations. + */ + for (i = 0; i < sp->typecnt; ++i) { + register const struct ttinfo * const ttisp = &sp->ttis[i]; + register char * cp = &sp->chars[ttisp->tt_abbrind]; + + if (strlen(cp) > TZ_ABBR_MAX_LEN && + strcmp(cp, GRANDPARENTED) != 0) + *(cp + TZ_ABBR_MAX_LEN) = '\0'; } } -int -__tzload(name, sp) +static int +differ_by_repeat(t1, t0) +const time_t t1; +const time_t t0; +{ +/* CONSTCOND */ + if (TYPE_INTEGRAL(time_t) && + TYPE_BIT(time_t) - TYPE_SIGNED(time_t) < SECSPERREPEAT_BITS) + return 0; + return (int_fast64_t)t1 - (int_fast64_t)t0 == SECSPERREPEAT; +} + +static int +tzload(name, sp, doextend) register const char * name; register struct state * const sp; +register const int doextend; { - register const char * p; - register int i; - register int fid; + register const char * p; + register int i; + register int fid; + register int stored; + register int nread; + union { + struct tzhead tzhead; + char buf[2 * sizeof(struct tzhead) + + 2 * sizeof *sp + + 4 * TZ_MAX_TIMES]; + } u; if (name == NULL && (name = TZDEFAULT) == NULL) return -1; - { register int doaccess; /* @@ -364,18 +428,13 @@ if ((fid = open(name, OPEN_MODE)) == -1) return -1; } - { - struct tzhead * tzhp; - union { - struct tzhead tzhead; - char buf[sizeof *sp + sizeof *tzhp]; - } u; + nread = read(fid, u.buf, sizeof u.buf); + if (close(fid) < 0 || nread <= 0) + return -1; + for (stored = 4; stored <= 8; stored *= 2) { int ttisstdcnt; int ttisgmtcnt; - i = read(fid, u.buf, sizeof u.buf); - if (close(fid) != 0) - return -1; ttisstdcnt = (int) detzcode(u.tzhead.tzh_ttisstdcnt); ttisgmtcnt = (int) detzcode(u.tzhead.tzh_ttisgmtcnt); sp->leapcnt = (int) detzcode(u.tzhead.tzh_leapcnt); @@ -390,17 +449,19 @@ (ttisstdcnt != sp->typecnt && ttisstdcnt != 0) || (ttisgmtcnt != sp->typecnt && ttisgmtcnt != 0)) return -1; - if (i - (p - u.buf) < sp->timecnt * 4 + /* ats */ + if (nread - (p - u.buf) < + sp->timecnt * stored + /* ats */ sp->timecnt + /* types */ - sp->typecnt * (4 + 2) + /* ttinfos */ + sp->typecnt * 6 + /* ttinfos */ sp->charcnt + /* chars */ - sp->leapcnt * (4 + 4) + /* lsinfos */ + sp->leapcnt * (stored + 4) + /* lsinfos */ ttisstdcnt + /* ttisstds */ ttisgmtcnt) /* ttisgmts */ return -1; for (i = 0; i < sp->timecnt; ++i) { - sp->ats[i] = detzcode(p); - p += 4; + sp->ats[i] = (stored == 4) ? + detzcode(p) : detzcode64(p); + p += stored; } for (i = 0; i < sp->timecnt; ++i) { sp->types[i] = (unsigned char) *p++; @@ -428,8 +489,9 @@ register struct lsinfo * lsisp; lsisp = &sp->lsis[i]; - lsisp->ls_trans = detzcode(p); - p += 4; + lsisp->ls_trans = (stored == 4) ? + detzcode(p) : detzcode64(p); + p += stored; lsisp->ls_corr = detzcode(p); p += 4; } @@ -459,10 +521,130 @@ return -1; } } + /* + ** Out-of-sort ats should mean we're running on a + ** signed time_t system but using a data file with + ** unsigned values (or vice versa). + */ + for (i = 0; i < sp->timecnt - 2; ++i) + if (sp->ats[i] > sp->ats[i + 1]) { + ++i; +/* CONSTCOND */ + if (TYPE_SIGNED(time_t)) { + /* + ** Ignore the end (easy). + */ + sp->timecnt = i; + } else { + /* + ** Ignore the beginning (harder). + */ + register int j; + + for (j = 0; j + i < sp->timecnt; ++j) { + sp->ats[j] = sp->ats[j + i]; + sp->types[j] = sp->types[j + i]; + } + sp->timecnt = j; + } + break; + } + /* + ** If this is an old file, we're done. + */ + if (u.tzhead.tzh_version[0] == '\0') + break; + nread -= p - u.buf; + for (i = 0; i < nread; ++i) + u.buf[i] = p[i]; + /* + ** If this is a narrow integer time_t system, we're done. + */ + if (stored >= (int) sizeof(time_t) +/* CONSTCOND */ + && TYPE_INTEGRAL(time_t)) + break; + } + if (doextend && nread > 2 && + u.buf[0] == '\n' && u.buf[nread - 1] == '\n' && + sp->typecnt + 2 <= TZ_MAX_TYPES) { + struct state ts; + register int result; + + u.buf[nread - 1] = '\0'; + result = tzparse(&u.buf[1], &ts, FALSE); + if (result == 0 && ts.typecnt == 2 && + sp->charcnt + ts.charcnt <= TZ_MAX_CHARS) { + for (i = 0; i < 2; ++i) + ts.ttis[i].tt_abbrind += + sp->charcnt; + for (i = 0; i < ts.charcnt; ++i) + sp->chars[sp->charcnt++] = + ts.chars[i]; + i = 0; + while (i < ts.timecnt && + ts.ats[i] <= + sp->ats[sp->timecnt - 1]) + ++i; + while (i < ts.timecnt && + sp->timecnt < TZ_MAX_TIMES) { + sp->ats[sp->timecnt] = + ts.ats[i]; + sp->types[sp->timecnt] = + sp->typecnt + + ts.types[i]; + ++sp->timecnt; + ++i; + } + sp->ttis[sp->typecnt++] = ts.ttis[0]; + sp->ttis[sp->typecnt++] = ts.ttis[1]; + } + } + sp->goback = sp->goahead = FALSE; + if (sp->timecnt > 1) { + for (i = 1; i < sp->timecnt; ++i) + if (typesequiv(sp, sp->types[i], sp->types[0]) && + differ_by_repeat(sp->ats[i], sp->ats[0])) { + sp->goback = TRUE; + break; + } + for (i = sp->timecnt - 2; i >= 0; --i) + if (typesequiv(sp, sp->types[sp->timecnt - 1], + sp->types[i]) && + differ_by_repeat(sp->ats[sp->timecnt - 1], + sp->ats[i])) { + sp->goahead = TRUE; + break; + } } return 0; } +static int +typesequiv(sp, a, b) +const struct state * const sp; +const int a; +const int b; +{ + register int result; + + if (sp == NULL || + a < 0 || a >= sp->typecnt || + b < 0 || b >= sp->typecnt) + result = FALSE; + else { + register const struct ttinfo * ap = &sp->ttis[a]; + register const struct ttinfo * bp = &sp->ttis[b]; + result = ap->tt_gmtoff == bp->tt_gmtoff && + ap->tt_isdst == bp->tt_isdst && + ap->tt_ttisstd == bp->tt_ttisstd && + ap->tt_ttisgmt == bp->tt_ttisgmt && + strcmp(&sp->chars[ap->tt_abbrind], + &sp->chars[bp->tt_abbrind]) == 0; + } + return result; +} + static const int mon_lengths[2][MONSPERYEAR] = { { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }, { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 } @@ -474,12 +656,12 @@ /* ** Given a pointer into a time zone string, scan until a character that is not -** a valid character in a zone name is found. Return a pointer to that +** a valid character in a zone name is found. Return a pointer to that ** character. */ static const char * -__getzname(strp) +getzname(strp) register const char * strp; { register char c; @@ -491,6 +673,25 @@ } /* +** Given a pointer into an extended time zone string, scan until the ending +** delimiter of the zone name is located. Return a pointer to the delimiter. +** +** As with getzname above, the legal character set is actually quite +** restricted, with other characters producing undefined results. +** We don't do any checking here; checking is done later in common-case code. +*/ + +static const char * +getqzname(register const char *strp, const int delim) +{ + register int c; + + while ((c = *strp) != '\0' && c != delim) + ++strp; + return strp; +} + +/* ** Given a pointer into a time zone string, extract a number from that string. ** Check that the number is within a specified range; if it is not, return ** NULL. @@ -555,7 +756,7 @@ *secsp += num * SECSPERMIN; if (*strp == ':') { ++strp; - /* `SECSPERMIN' allows for leap seconds. */ + /* `SECSPERMIN' allows for leap seconds. */ strp = getnum(strp, &num, 0, SECSPERMIN); if (strp == NULL) return NULL; @@ -573,7 +774,7 @@ */ static const char * -__getoffset(strp, offsetp) +getoffset(strp, offsetp) register const char * strp; long * const offsetp; { @@ -594,13 +795,13 @@ /* ** Given a pointer into a time zone string, extract a rule in the form -** date[/time]. See POSIX section 8 for the format of "date" and "time". +** date[/time]. See POSIX section 8 for the format of "date" and "time". ** If a valid rule is not found, return NULL. ** Otherwise, return a pointer to the first character not part of the rule. */ static const char * -__getrule(strp, rulep) +getrule(strp, rulep) const char * strp; register struct rule * const rulep; { @@ -654,7 +855,7 @@ */ static time_t -__transtime(janfirst, year, rulep, offset) +transtime(janfirst, year, rulep, offset) const time_t janfirst; const int year; register const struct rule * const rulep; @@ -713,7 +914,7 @@ dow += DAYSPERWEEK; /* - ** "dow" is the day-of-week of the first day of the month. Get + ** "dow" is the day-of-week of the first day of the month. Get ** the day-of-month (zero-origin) of the first "dow" day of the ** month. */ @@ -736,7 +937,7 @@ /* ** "value" is the Epoch-relative time of 00:00:00 UTC on the day in - ** question. To get the Epoch-relative time of the specified local + ** question. To get the Epoch-relative time of the specified local ** time on that day, add the transition time and the current offset ** from UTC. */ @@ -749,7 +950,7 @@ */ static int -__tzparse(name, sp, lastditch) +tzparse(name, sp, lastditch) const char * name; register struct state * const sp; const int lastditch; @@ -774,27 +975,42 @@ stdlen = (sizeof sp->chars) - 1; stdoffset = 0; } else { - name = __getzname(name); - stdlen = name - stdname; - if (stdlen < 3) - return -1; + if (*name == '<') { + name++; + stdname = name; + name = getqzname(name, '>'); + if (*name != '>') + return (-1); + stdlen = name - stdname; + name++; + } else { + name = getzname(name); + stdlen = name - stdname; + } if (*name == '\0') return -1; - name = __getoffset(name, &stdoffset); + name = getoffset(name, &stdoffset); if (name == NULL) return -1; } - load_result = __tzload(TZDEFRULES, sp); + load_result = tzload(TZDEFRULES, sp, FALSE); if (load_result != 0) sp->leapcnt = 0; /* so, we're off a little */ if (*name != '\0') { - dstname = name; - name = __getzname(name); - dstlen = name - dstname; /* length of DST zone name */ - if (dstlen < 3) - return -1; + if (*name == '<') { + dstname = ++name; + name = getqzname(name, '>'); + if (*name != '>') + return -1; + dstlen = name - dstname; + name++; + } else { + dstname = name; + name = getzname(name); + dstlen = name - dstname; /* length of DST zone name */ + } if (*name != '\0' && *name != ',' && *name != ';') { - name = __getoffset(name, &dstoffset); + name = getoffset(name, &dstoffset); if (name == NULL) return -1; } else dstoffset = stdoffset - SECSPERHOUR; @@ -809,21 +1025,18 @@ time_t endtime; ++name; - if ((name = __getrule(name, &start)) == NULL) + if ((name = getrule(name, &start)) == NULL) return -1; if (*name++ != ',') return -1; - if ((name = __getrule(name, &end)) == NULL) + if ((name = getrule(name, &end)) == NULL) return -1; if (*name != '\0') return -1; sp->typecnt = 2; /* standard time and DST */ /* - ** Two transitions per year, from EPOCH_YEAR to 2037. + ** Two transitions per year, from EPOCH_YEAR forward. */ - sp->timecnt = 2 * (2037 - EPOCH_YEAR + 1); - if (sp->timecnt > TZ_MAX_TIMES) - return -1; sp->ttis[0].tt_gmtoff = -dstoffset; sp->ttis[0].tt_isdst = 1; sp->ttis[0].tt_abbrind = stdlen + 1; @@ -833,10 +1046,15 @@ atp = sp->ats; typep = sp->types; janfirst = 0; - for (year = EPOCH_YEAR; year <= 2037; ++year) { - starttime = __transtime(janfirst, year, &start, + sp->timecnt = 0; + for (year = EPOCH_YEAR; + sp->timecnt + 2 <= TZ_MAX_TIMES; + ++year) { + time_t newfirst; + + starttime = transtime(janfirst, year, &start, stdoffset); - endtime = __transtime(janfirst, year, &end, + endtime = transtime(janfirst, year, &end, dstoffset); if (starttime > endtime) { *atp++ = endtime; @@ -849,12 +1067,19 @@ *atp++ = endtime; *typep++ = 1; /* DST ends */ } - janfirst += year_lengths[isleap(year)] * + sp->timecnt += 2; + newfirst = janfirst; + newfirst += year_lengths[isleap(year)] * SECSPERDAY; + if (newfirst <= janfirst) + break; + janfirst = newfirst; } } else { register long theirstdoffset; + register long theirdstoffset; register long theiroffset; + register int isdst; register int i; register int j; @@ -872,9 +1097,19 @@ break; } } + theirdstoffset = 0; + for (i = 0; i < sp->timecnt; ++i) { + j = sp->types[i]; + if (sp->ttis[j].tt_isdst) { + theirdstoffset = + -sp->ttis[j].tt_gmtoff; + break; + } + } /* ** Initially we're assumed to be in standard time. */ + isdst = FALSE; theiroffset = theirstdoffset; /* ** Now juggle transition times and types @@ -900,12 +1135,18 @@ ** POSIX provides for only one DST ** offset. */ - sp->ats[i] += stdoffset - - theirstdoffset; + if (isdst && !sp->ttis[j].tt_ttisstd) { + sp->ats[i] += dstoffset - + theirdstoffset; + } else { + sp->ats[i] += stdoffset - + theirstdoffset; + } } theiroffset = -sp->ttis[j].tt_gmtoff; if (!sp->ttis[j].tt_isdst) theirstdoffset = theiroffset; + else theirdstoffset = theiroffset; } /* ** Finally, fill in ttis. @@ -944,19 +1185,19 @@ } static void -__gmtload(sp) +gmtload(sp) struct state * const sp; { - if (__tzload(gmt, sp) != 0) - (void) __tzparse(gmt, sp, TRUE); + if (tzload(gmt, sp, TRUE) != 0) + (void) tzparse(gmt, sp, TRUE); } static void -__tzsetwall_unlocked P((void)) +tzsetwall_unlocked(void) { - if (__lcl_is_set < 0) + if (lcl_is_set < 0) return; - __lcl_is_set = -1; + lcl_is_set = -1; #ifdef ALL_STATE if (lclptr == NULL) { @@ -964,14 +1205,14 @@ lclptr = (struct state *) malloc(sizeof *lclptr); errno = saveerrno; if (lclptr == NULL) { - __settzname(); /* all we can do */ + settzname(); /* all we can do */ return; } } #endif /* defined ALL_STATE */ - if (__tzload((char *) NULL, lclptr) != 0) - __gmtload(lclptr); - __settzname(); + if (tzload((char *) NULL, lclptr, TRUE) != 0) + gmtload(lclptr); + settzname(); } #ifndef STD_INSPIRED @@ -982,15 +1223,22 @@ static #endif /* !defined STD_INSPIRED */ void -tzsetwall P((void)) +tzsetwall(void) { - rwlock_wrlock(&__lcl_lock); - __tzsetwall_unlocked(); - rwlock_unlock(&__lcl_lock); + rwlock_wrlock(&lcl_lock); + tzsetwall_unlocked(); + rwlock_unlock(&lcl_lock); } -static void -__tzset_unlocked P((void)) +#ifndef STD_INSPIRED +/* +** A non-static declaration of tzsetwall in a system header file +** may cause a warning about this upcoming static declaration... +*/ +static +#endif /* !defined STD_INSPIRED */ +void +tzset_unlocked(void) { register const char * name; int saveerrno; @@ -999,15 +1247,15 @@ name = getenv("TZ"); errno = saveerrno; if (name == NULL) { - __tzsetwall_unlocked(); + tzsetwall_unlocked(); return; } - if (__lcl_is_set > 0 && strcmp(__lcl_TZname, name) == 0) + if (lcl_is_set > 0 && strcmp(lcl_TZname, name) == 0) return; - __lcl_is_set = strlen(name) < sizeof __lcl_TZname; - if (__lcl_is_set) - (void)strlcpy(__lcl_TZname, name, sizeof(__lcl_TZname)); + lcl_is_set = strlen(name) < sizeof lcl_TZname; + if (lcl_is_set) + (void)strlcpy(lcl_TZname, name, sizeof(lcl_TZname)); #ifdef ALL_STATE if (lclptr == NULL) { @@ -1015,7 +1263,7 @@ lclptr = (struct state *) malloc(sizeof *lclptr); errno = saveerrno; if (lclptr == NULL) { - __settzname(); /* all we can do */ + settzname(); /* all we can do */ return; } } @@ -1030,32 +1278,32 @@ lclptr->ttis[0].tt_isdst = 0; lclptr->ttis[0].tt_gmtoff = 0; lclptr->ttis[0].tt_abbrind = 0; - (void)strlcpy(lclptr->chars, gmt, sizeof(lclptr->chars)); - } else if (__tzload(name, lclptr) != 0) - if (name[0] == ':' || __tzparse(name, lclptr, FALSE) != 0) - (void) __gmtload(lclptr); - __settzname(); + (void) strlcpy(lclptr->chars, gmt, sizeof(lclptr->chars)); + } else if (tzload(name, lclptr, TRUE) != 0) + if (name[0] == ':' || tzparse(name, lclptr, FALSE) != 0) + (void) gmtload(lclptr); + settzname(); } void -tzset P((void)) +tzset(void) { - rwlock_wrlock(&__lcl_lock); - __tzset_unlocked(); - rwlock_unlock(&__lcl_lock); + rwlock_wrlock(&lcl_lock); + tzset_unlocked(); + rwlock_unlock(&lcl_lock); } /* ** The easy way to behave "as if no library function calls" localtime ** is to not call it--so we drop its guts into "localsub", which can be -** freely called. (And no, the PANS doesn't require the above behavior-- +** freely called. (And no, the PANS doesn't require the above behavior-- ** but it *is* desirable.) ** ** The unused offset argument is for the benefit of mktime variants. */ /*ARGSUSED*/ -static void +static struct tm * localsub(timep, offset, tmp) const time_t * const timep; const long offset; @@ -1064,15 +1312,53 @@ register struct state * sp; register const struct ttinfo * ttisp; register int i; + register struct tm * result; const time_t t = *timep; sp = lclptr; #ifdef ALL_STATE - if (sp == NULL) { - gmtsub(timep, offset, tmp); - return; - } + if (sp == NULL) + return gmtsub(timep, offset, tmp); #endif /* defined ALL_STATE */ + if ((sp->goback && t < sp->ats[0]) || + (sp->goahead && t > sp->ats[sp->timecnt - 1])) { + time_t newt = t; + register time_t seconds; + register time_t tcycles; + register int_fast64_t icycles; + + if (t < sp->ats[0]) + seconds = sp->ats[0] - t; + else seconds = t - sp->ats[sp->timecnt - 1]; + --seconds; + tcycles = seconds / YEARSPERREPEAT / AVGSECSPERYEAR; + ++tcycles; + icycles = tcycles; + if (tcycles - icycles >= 1 || icycles - tcycles >= 1) + return NULL; + seconds = (time_t) icycles; + seconds *= YEARSPERREPEAT; + seconds *= AVGSECSPERYEAR; + if (t < sp->ats[0]) + newt += seconds; + else newt -= seconds; + if (newt < sp->ats[0] || + newt > sp->ats[sp->timecnt - 1]) + return NULL; /* "cannot happen" */ + result = localsub(&newt, offset, tmp); + if (result == tmp) { + register time_t newy; + + newy = tmp->tm_year; + if (t < sp->ats[0]) + newy -= (time_t)icycles * YEARSPERREPEAT; + else newy += (time_t)icycles * YEARSPERREPEAT; + tmp->tm_year = (int)newy; + if (tmp->tm_year != newy) + return NULL; + } + return result; + } if (sp->timecnt == 0 || t < sp->ats[0]) { i = 0; while (sp->ttis[i].tt_isdst) @@ -1081,10 +1367,17 @@ break; } } else { - for (i = 1; i < sp->timecnt; ++i) - if (t < sp->ats[i]) - break; - i = sp->types[i - 1]; + register int lo = 1; + register int hi = sp->timecnt; + + while (lo < hi) { + register int mid = (lo + hi) / 2; + + if (t < sp->ats[mid]) + hi = mid; + else lo = mid + 1; + } + i = (int) sp->types[lo - 1]; } ttisp = &sp->ttis[i]; /* @@ -1093,23 +1386,26 @@ ** t += ttisp->tt_gmtoff; ** timesub(&t, 0L, sp, tmp); */ - timesub(&t, ttisp->tt_gmtoff, sp, tmp); + result = timesub(&t, ttisp->tt_gmtoff, sp, tmp); tmp->tm_isdst = ttisp->tt_isdst; tzname[tmp->tm_isdst] = &sp->chars[ttisp->tt_abbrind]; #ifdef TM_ZONE tmp->TM_ZONE = &sp->chars[ttisp->tt_abbrind]; #endif /* defined TM_ZONE */ + return result; } struct tm * localtime(timep) const time_t * const timep; { - rwlock_wrlock(&__lcl_lock); - __tzset_unlocked(); - localsub(timep, 0L, &tm); - rwlock_unlock(&__lcl_lock); - return &tm; + struct tm *result; + + rwlock_wrlock(&lcl_lock); + tzset_unlocked(); + result = localsub(timep, 0L, &tm); + rwlock_unlock(&lcl_lock); + return result; } /* @@ -1121,43 +1417,46 @@ const time_t * const timep; struct tm * tmp; { - rwlock_rdlock(&__lcl_lock); - __tzset_unlocked(); - localsub(timep, 0L, tmp); - rwlock_unlock(&__lcl_lock); - return tmp; + struct tm *result; + + rwlock_rdlock(&lcl_lock); + tzset_unlocked(); + result = localsub(timep, 0L, tmp); + rwlock_unlock(&lcl_lock); + return result; } /* ** gmtsub is to gmtime as localsub is to localtime. */ -static void +static struct tm * gmtsub(timep, offset, tmp) const time_t * const timep; const long offset; struct tm * const tmp; { + register struct tm * result; #ifdef _REENTRANT static mutex_t gmt_mutex = MUTEX_INITIALIZER; #endif mutex_lock(&gmt_mutex); - if (!__gmt_is_set) { + if (!gmt_is_set) { #ifdef ALL_STATE int saveerrno; #endif - __gmt_is_set = TRUE; + gmt_is_set = TRUE; #ifdef ALL_STATE saveerrno = errno; gmtptr = (struct state *) malloc(sizeof *gmtptr); errno = saveerrno; if (gmtptr != NULL) #endif /* defined ALL_STATE */ - __gmtload(gmtptr); + gmtload(gmtptr); } mutex_unlock(&gmt_mutex); - timesub(timep, offset, gmtptr, tmp); + result = timesub(timep, offset, gmtptr, tmp); #ifdef TM_ZONE /* ** Could get fancy here and deliver something such as @@ -1177,14 +1476,14 @@ #endif /* State Farm */ } #endif /* defined TM_ZONE */ + return result; } struct tm * gmtime(timep) const time_t * const timep; { - gmtsub(timep, 0L, &tm); - return &tm; + return gmtsub(timep, 0L, &tm); } /* @@ -1196,8 +1495,7 @@ const time_t * const timep; struct tm * tmp; { - gmtsub(timep, 0L, tmp); - return tmp; + return gmtsub(timep, 0L, tmp); } #ifdef STD_INSPIRED @@ -1207,13 +1505,25 @@ const time_t * const timep; const long offset; { - gmtsub(timep, offset, &tm); - return &tm; + return gmtsub(timep, offset, &tm); } #endif /* defined STD_INSPIRED */ -static void +/* +** Return the number of leap years through the end of the given year +** where, to make the math easy, the answer for year zero is defined as zero. +*/ + +static int +leaps_thru_end_of(y) +register const int y; +{ + return (y >= 0) ? (y / 4 - y / 100 + y / 400) : + -(leaps_thru_end_of(-(y + 1)) + 1); +} + +static struct tm * timesub(timep, offset, sp, tmp) const time_t * const timep; const long offset; @@ -1221,10 +1531,10 @@ register struct tm * const tmp; { register const struct lsinfo * lp; - register time_t days; - register time_t rem; - register time_t y; - register int yleap; + register time_t tdays; + register int idays; /* unsigned would be so 2003 */ + register long rem; + int y; register const int * ip; register long corr; register int hit; @@ -1258,59 +1568,93 @@ break; } } - days = *timep / SECSPERDAY; - rem = *timep % SECSPERDAY; -#ifdef mc68k - if (*timep == (((time_t)1) << (TYPE_BITS(time_t) - 1))) { - /* - ** A 3B1 muffs the division on the most negative number. - */ - days = -24855; - rem = -11648; + y = EPOCH_YEAR; + tdays = *timep / SECSPERDAY; + rem = (long) (*timep - tdays * SECSPERDAY); + while (tdays < 0 || tdays >= year_lengths[isleap(y)]) { + int newy; + register time_t tdelta; + register int idelta; + register int leapdays; + + tdelta = tdays / DAYSPERLYEAR; + idelta = (int) tdelta; + if (tdelta - idelta >= 1 || idelta - tdelta >= 1) + return NULL; + if (idelta == 0) + idelta = (tdays < 0) ? -1 : 1; + newy = y; + if (increment_overflow(&newy, idelta)) + return NULL; + leapdays = leaps_thru_end_of(newy - 1) - + leaps_thru_end_of(y - 1); + tdays -= ((time_t) newy - y) * DAYSPERNYEAR; + tdays -= leapdays; + y = newy; } -#endif /* defined mc68k */ - rem += (offset - corr); + { + register long seconds; + + seconds = tdays * SECSPERDAY + 0.5; + tdays = seconds / SECSPERDAY; + rem += (long) (seconds - tdays * SECSPERDAY); + } + /* + ** Given the range, we can now fearlessly cast... + */ + idays = (int) tdays; + rem += offset - corr; while (rem < 0) { rem += SECSPERDAY; - --days; + --idays; } while (rem >= SECSPERDAY) { rem -= SECSPERDAY; - ++days; + ++idays; + } + while (idays < 0) { + if (increment_overflow(&y, -1)) + return NULL; + idays += year_lengths[isleap(y)]; } + while (idays >= year_lengths[isleap(y)]) { + idays -= year_lengths[isleap(y)]; + if (increment_overflow(&y, 1)) + return NULL; + } + tmp->tm_year = y; + if (increment_overflow(&tmp->tm_year, -TM_YEAR_BASE)) + return NULL; + tmp->tm_yday = idays; + /* + ** The "extra" mods below avoid overflow problems. + */ + tmp->tm_wday = EPOCH_WDAY + + ((y - EPOCH_YEAR) % DAYSPERWEEK) * + (DAYSPERNYEAR % DAYSPERWEEK) + + leaps_thru_end_of(y - 1) - + leaps_thru_end_of(EPOCH_YEAR - 1) + + idays; + tmp->tm_wday %= DAYSPERWEEK; + if (tmp->tm_wday < 0) + tmp->tm_wday += DAYSPERWEEK; tmp->tm_hour = (int) (rem / SECSPERHOUR); - rem = rem % SECSPERHOUR; + rem %= SECSPERHOUR; tmp->tm_min = (int) (rem / SECSPERMIN); /* ** A positive leap second requires a special - ** representation. This uses "... ??:59:60" et seq. + ** representation. This uses "... ??:59:60" et seq. */ tmp->tm_sec = (int) (rem % SECSPERMIN) + hit; - tmp->tm_wday = (int) ((EPOCH_WDAY + days) % DAYSPERWEEK); - if (tmp->tm_wday < 0) - tmp->tm_wday += DAYSPERWEEK; - y = EPOCH_YEAR; -#define LEAPS_THRU_END_OF(y) ((y) < 0 ? ((y)-3)/4 - ((y)-99)/100 + ((y)-399)/400 : (y)/4 - (y)/100 + (y)/400) - while (days < 0 || days >= (long) year_lengths[yleap = isleap(y)]) { - register time_t newy; - newy = (y + days / DAYSPERNYEAR); - if (days < 0) - --newy; - days -= (newy - y) * DAYSPERNYEAR + - LEAPS_THRU_END_OF(newy - 1) - - LEAPS_THRU_END_OF(y - 1); - y = newy; - } - tmp->tm_year = (int) y - TM_YEAR_BASE; - tmp->tm_yday = (int) days; - ip = mon_lengths[yleap]; - for (tmp->tm_mon = 0; days >= (long) ip[tmp->tm_mon]; ++(tmp->tm_mon)) - days = days - (long) ip[tmp->tm_mon]; - tmp->tm_mday = (int) (days + 1); + ip = mon_lengths[isleap(y)]; + for (tmp->tm_mon = 0; idays >= ip[tmp->tm_mon]; ++(tmp->tm_mon)) + idays -= ip[tmp->tm_mon]; + tmp->tm_mday = (int) (idays + 1); tmp->tm_isdst = 0; #ifdef TM_GMTOFF tmp->TM_GMTOFF = offset; #endif /* defined TM_GMTOFF */ + return tmp; } char * @@ -1320,7 +1664,7 @@ /* ** Section 4.12.3.2 of X3.159-1989 requires that ** The ctime function converts the calendar time pointed to by timer -** to local time in the form of a string. It is equivalent to +** to local time in the form of a string. It is equivalent to ** asctime(localtime(timer)) */ return asctime(localtime(timep)); @@ -1331,17 +1675,16 @@ const time_t * const timep; char * buf; { - struct tm tmp; + struct tm mytm; - return asctime_r(localtime_r(timep, &tmp), buf); + return asctime_r(localtime_r(timep, &mytm), buf); } /* ** Adapted from code provided by Robert Elz, who writes: ** The "best" way to do mktime I think is based on an idea of Bob ** Kridle's (so its said...) from a long time ago. -** [kridle@xinet.com as of 1996-01-16.] -** It does a binary search of the time_t space. Since time_t's are +** It does a binary search of the time_t space. Since time_t's are ** just 32 bits, its a max of 32 iterations (even at 64 bits it ** would still be very reasonable). */ @@ -1351,7 +1694,7 @@ #endif /* !defined WRONG */ /* -** Simplified normalize logic courtesy Paul Eggert (eggert@twinsun.com). +** Simplified normalize logic courtesy Paul Eggert. */ static int @@ -1367,6 +1710,18 @@ } static int +long_increment_overflow(number, delta) +long * number; +int delta; +{ + long number0; + + number0 = *number; + *number += delta; + return (*number < number0) != (delta < 0); +} + +static int normalize_overflow(tensptr, unitsptr, base) int * const tensptr; int * const unitsptr; @@ -1382,6 +1737,21 @@ } static int +long_normalize_overflow(tensptr, unitsptr, base) +long * const tensptr; +int * const unitsptr; +const int base; +{ + register int tensdelta; + + tensdelta = (*unitsptr >= 0) ? + (*unitsptr / base) : + (-1 - (-1 - *unitsptr) / base); + *unitsptr -= tensdelta * base; + return long_increment_overflow(tensptr, tensdelta); +} + +static int tmcomp(atmp, btmp) register const struct tm * const atmp; register const struct tm * const btmp; @@ -1400,16 +1770,19 @@ static time_t time2sub(tmp, funcp, offset, okayp, do_norm_secs) struct tm * const tmp; -void (* const funcp) P((const time_t*, long, struct tm*)); +struct tm * (* const funcp)(const time_t*, long, struct tm*); const long offset; int * const okayp; const int do_norm_secs; { register const struct state * sp; register int dir; - register int bits; - register int i, j ; + register int i, j; register int saved_seconds; + register long li; + register time_t lo; + register time_t hi; + long y; time_t newt; time_t t; struct tm yourtm, mytm; @@ -1425,42 +1798,46 @@ return WRONG; if (normalize_overflow(&yourtm.tm_mday, &yourtm.tm_hour, HOURSPERDAY)) return WRONG; - if (normalize_overflow(&yourtm.tm_year, &yourtm.tm_mon, MONSPERYEAR)) + y = yourtm.tm_year; + if (long_normalize_overflow(&y, &yourtm.tm_mon, MONSPERYEAR)) return WRONG; /* - ** Turn yourtm.tm_year into an actual year number for now. + ** Turn y into an actual year number for now. ** It is converted back to an offset from TM_YEAR_BASE later. */ - if (increment_overflow(&yourtm.tm_year, TM_YEAR_BASE)) + if (long_increment_overflow(&y, TM_YEAR_BASE)) return WRONG; while (yourtm.tm_mday <= 0) { - if (increment_overflow(&yourtm.tm_year, -1)) + if (long_increment_overflow(&y, -1)) return WRONG; - i = yourtm.tm_year + (1 < yourtm.tm_mon); - yourtm.tm_mday += year_lengths[isleap(i)]; + li = y + (1 < yourtm.tm_mon); + yourtm.tm_mday += year_lengths[isleap(li)]; } while (yourtm.tm_mday > DAYSPERLYEAR) { - i = yourtm.tm_year + (1 < yourtm.tm_mon); - yourtm.tm_mday -= year_lengths[isleap(i)]; - if (increment_overflow(&yourtm.tm_year, 1)) + li = y + (1 < yourtm.tm_mon); + yourtm.tm_mday -= year_lengths[isleap(li)]; + if (long_increment_overflow(&y, 1)) return WRONG; } for ( ; ; ) { - i = mon_lengths[isleap(yourtm.tm_year)][yourtm.tm_mon]; + i = mon_lengths[isleap(y)][yourtm.tm_mon]; if (yourtm.tm_mday <= i) break; yourtm.tm_mday -= i; if (++yourtm.tm_mon >= MONSPERYEAR) { yourtm.tm_mon = 0; - if (increment_overflow(&yourtm.tm_year, 1)) + if (long_increment_overflow(&y, 1)) return WRONG; } } - if (increment_overflow(&yourtm.tm_year, -TM_YEAR_BASE)) + if (long_increment_overflow(&y, -TM_YEAR_BASE)) + return WRONG; + yourtm.tm_year = y; + if (yourtm.tm_year != y) return WRONG; if (yourtm.tm_sec >= 0 && yourtm.tm_sec < SECSPERMIN) saved_seconds = 0; - else if (yourtm.tm_year + TM_YEAR_BASE < EPOCH_YEAR) { + else if (y + TM_YEAR_BASE < EPOCH_YEAR) { /* ** We can't set tm_sec to 0, because that might push the ** time below the minimum representable time. @@ -1478,36 +1855,58 @@ yourtm.tm_sec = 0; } /* - ** Divide the search space in half - ** (this works whether time_t is signed or unsigned). + ** Do a binary search (this works whatever time_t's type is). */ - bits = TYPE_BIT(time_t) - 1; - /* - * "tm_year" in "struct tm" is a signed 32-bit integer. It will - * overflow if a time_t > 2^31*60*60*24*365 is converted, - * causing tmcomp() to give wrong results and thus the - * binary search below to fail. - */ - if (bits > 55) - bits = 55; /* could be 56 for signed time_t */ - /* - ** If time_t is signed, then 0 is just above the median, - ** assuming two's complement arithmetic. - ** If time_t is unsigned, then (1 << bits) is just above the median. - */ - /*CONSTCOND*/ - t = TYPE_SIGNED(time_t) ? 0 : (((time_t) 1) << bits); +/* LINTED constant */ + if (!TYPE_SIGNED(time_t)) { + lo = 0; + hi = lo - 1; +/* LINTED constant */ + } else if (!TYPE_INTEGRAL(time_t)) { +/* CONSTCOND */ + if (sizeof(time_t) > sizeof(float)) +/* LINTED assumed double */ + hi = (time_t) DBL_MAX; +/* LINTED assumed float */ + else hi = (time_t) FLT_MAX; + lo = -hi; + } else { + lo = 1; + for (i = 0; i < (int) TYPE_BIT(time_t) - 1; ++i) + lo *= 2; + hi = -(lo + 1); + } for ( ; ; ) { - (*funcp)(&t, offset, &mytm); - dir = tmcomp(&mytm, &yourtm); + t = lo / 2 + hi / 2; + if (t < lo) + t = lo; + else if (t > hi) + t = hi; + if ((*funcp)(&t, offset, &mytm) == NULL) { + /* + ** Assume that t is too extreme to be represented in + ** a struct tm; arrange things so that it is less + ** extreme on the next pass. + */ + dir = (t > 0) ? 1 : -1; + } else dir = tmcomp(&mytm, &yourtm); if (dir != 0) { - if (bits-- < 0) + if (t == lo) { + ++t; + if (t <= lo) + return WRONG; + ++lo; + } else if (t == hi) { + --t; + if (t >= hi) + return WRONG; + --hi; + } + if (lo > hi) return WRONG; - if (bits < 0) - --t; /* may be needed if new t is minimal */ - else if (dir > 0) - t -= ((time_t) 1) << bits; - else t += ((time_t) 1) << bits; + if (dir > 0) + hi = t; + else lo = t; continue; } if (yourtm.tm_isdst < 0 || mytm.tm_isdst == yourtm.tm_isdst) @@ -1518,12 +1917,8 @@ ** It's okay to guess wrong since the guess ** gets checked. */ - /* - ** The (void *) casts are the benefit of SunOS 3.3 on Sun 2's. - */ sp = (const struct state *) - (((void *) funcp == (void *) localsub) ? - lclptr : gmtptr); + ((funcp == localsub) ? lclptr : gmtptr); #ifdef ALL_STATE if (sp == NULL) return WRONG; @@ -1536,7 +1931,8 @@ continue; newt = t + sp->ttis[j].tt_gmtoff - sp->ttis[i].tt_gmtoff; - (*funcp)(&newt, offset, &mytm); + if ((*funcp)(&newt, offset, &mytm) == NULL) + continue; if (tmcomp(&mytm, &yourtm) != 0) continue; if (mytm.tm_isdst != yourtm.tm_isdst) @@ -1555,15 +1951,15 @@ if ((newt < t) != (saved_seconds < 0)) return WRONG; t = newt; - (*funcp)(&t, offset, tmp); - *okayp = TRUE; + if ((*funcp)(&t, offset, tmp)) + *okayp = TRUE; return t; } static time_t time2(tmp, funcp, offset, okayp) struct tm * const tmp; -void (* const funcp) P((const time_t*, long, struct tm*)); +struct tm * (* const funcp)(const time_t*, long, struct tm*); const long offset; int * const okayp; { @@ -1581,7 +1977,7 @@ static time_t time1(tmp, funcp, offset) struct tm * const tmp; -void (* const funcp) P((const time_t *, long, struct tm *)); +struct tm * (* const funcp)(const time_t *, long, struct tm *); const long offset; { register time_t t; @@ -1599,7 +1995,7 @@ t = time2(tmp, funcp, offset, &okay); #ifdef PCTS /* - ** PCTS code courtesy Grant Sullivan (grant@osf.org). + ** PCTS code courtesy Grant Sullivan. */ if (okay) return t; @@ -1616,11 +2012,7 @@ ** We try to divine the type they started from and adjust to the ** type they need. */ - /* - ** The (void *) casts are the benefit of SunOS 3.3 on Sun 2's. - */ - sp = (const struct state *) (((void *) funcp == (void *) localsub) ? - lclptr : gmtptr); + sp = (const struct state *) ((funcp == localsub) ? lclptr : gmtptr); #ifdef ALL_STATE if (sp == NULL) return WRONG; @@ -1661,10 +2053,10 @@ { time_t result; - rwlock_wrlock(&__lcl_lock); - __tzset_unlocked(); + rwlock_wrlock(&lcl_lock); + tzset_unlocked(); result = time1(tmp, localsub, 0L); - rwlock_unlock(&__lcl_lock); + rwlock_unlock(&lcl_lock); return (result); } @@ -1755,10 +2147,10 @@ { time_t result; - rwlock_wrlock(&__lcl_lock); - __tzset_unlocked(); + rwlock_wrlock(&lcl_lock); + tzset_unlocked(); result = t - leapcorr(&t); - rwlock_unlock(&__lcl_lock); + rwlock_unlock(&lcl_lock); return (result); } @@ -1769,11 +2161,11 @@ time_t x; time_t y; - rwlock_wrlock(&__lcl_lock); - __tzset_unlocked(); + rwlock_wrlock(&lcl_lock); + tzset_unlocked(); /* ** For a positive leap second hit, the result - ** is not unique. For a negative leap second + ** is not unique. For a negative leap second ** hit, the corresponding time doesn't exist, ** so we return an adjacent second. */ @@ -1785,7 +2177,7 @@ y = x - leapcorr(&x); } while (y < t); if (t != y) { - rwlock_unlock(&__lcl_lock); + rwlock_unlock(&lcl_lock); return x - 1; } } else if (y > t) { @@ -1794,11 +2186,11 @@ y = x - leapcorr(&x); } while (y > t); if (t != y) { - rwlock_unlock(&__lcl_lock); + rwlock_unlock(&lcl_lock); return x + 1; } } - rwlock_unlock(&__lcl_lock); + rwlock_unlock(&lcl_lock); return x; } Index: lib/libc/time/private.h =================================================================== RCS file: /cvsroot/src/lib/libc/time/private.h,v retrieving revision 1.24 diff -u -r1.24 private.h --- lib/libc/time/private.h 20 Dec 2003 00:12:05 -0000 1.24 +++ lib/libc/time/private.h 31 Dec 2009 20:52:24 -0000 @@ -16,7 +16,7 @@ /* ** This file is in the public domain, so clarified as of -** 1996-06-05 by Arthur David Olson (arthur_david_olson@nih.gov). +** 1996-06-05 by Arthur David Olson. */ /* @@ -34,11 +34,13 @@ #ifndef lint #ifndef NOID #if 0 -static char privatehid[] = "@(#)private.h 7.53"; +static char privatehid[] = "@(#)private.h 8.6"; #endif #endif /* !defined NOID */ #endif /* !defined lint */ +#define GRANDPARENTED "Local time zone must be set--see zic manual page" + /* ** Defaults for preprocessor symbols. ** You can override these in your C compiler options, e.g. `-DHAVE_ADJTIME=0'. @@ -60,10 +62,6 @@ #define HAVE_SETTIMEOFDAY 3 #endif /* !defined HAVE_SETTIMEOFDAY */ -#ifndef HAVE_STRERROR -#define HAVE_STRERROR 1 -#endif /* !defined HAVE_STRERROR */ - #ifndef HAVE_SYMLINK #define HAVE_SYMLINK 1 #endif /* !defined HAVE_SYMLINK */ @@ -101,17 +99,17 @@ #include "stdio.h" #include "errno.h" #include "string.h" -#include "limits.h" /* for CHAR_BIT */ +#include "limits.h" /* for CHAR_BIT et al. */ #include "time.h" #include "stdlib.h" -#if HAVE_GETTEXT - 0 +#if HAVE_GETTEXT #include "libintl.h" -#endif /* HAVE_GETTEXT - 0 */ +#endif /* HAVE_GETTEXT */ -#if HAVE_SYS_WAIT_H - 0 +#if HAVE_SYS_WAIT_H #include /* for WIFEXITED and WEXITSTATUS */ -#endif /* HAVE_SYS_WAIT_H - 0 */ +#endif /* HAVE_SYS_WAIT_H */ #ifndef WIFEXITED #define WIFEXITED(status) (((status) & 0xff) == 0) @@ -120,104 +118,82 @@ #define WEXITSTATUS(status) (((status) >> 8) & 0xff) #endif /* !defined WEXITSTATUS */ -#if HAVE_UNISTD_H - 0 -#include "unistd.h" /* for F_OK and R_OK */ -#endif /* HAVE_UNISTD_H - 0 */ +#if HAVE_UNISTD_H +#include "unistd.h" /* for F_OK, R_OK, and other POSIX goodness */ +#endif /* HAVE_UNISTD_H */ -#if !(HAVE_UNISTD_H - 0) #ifndef F_OK #define F_OK 0 #endif /* !defined F_OK */ #ifndef R_OK #define R_OK 4 #endif /* !defined R_OK */ -#endif /* !(HAVE_UNISTD_H - 0) */ -/* Unlike 's isdigit, this also works if c < 0 | c > UCHAR_MAX. */ +/* Unlike 's isdigit, this also works if c < 0 | c > UCHAR_MAX. */ #define is_digit(c) ((unsigned)(c) - '0' <= 9) /* -** Workarounds for compilers/systems. -*/ - -/* -** SunOS 4.1.1 cc lacks prototypes. -*/ - -#ifndef P -#define P(x) x -#endif /* !defined P */ +** Define HAVE_STDINT_H's default value here, rather than at the +** start, since __GLIBC__'s value depends on previously-included +** files. +** (glibc 2.1 and later have stdint.h, even with pre-C99 compilers.) +*/ +#ifndef HAVE_STDINT_H +#define HAVE_STDINT_H \ + (199901 <= __STDC_VERSION__ || \ + 2 < (__GLIBC__ + (0 < __GLIBC_MINOR__))) +#endif /* !defined HAVE_STDINT_H */ + +#if HAVE_STDINT_H +#include "stdint.h" +#endif /* !HAVE_STDINT_H */ + +#ifndef INT_FAST64_MAX +/* Pre-C99 GCC compilers define __LONG_LONG_MAX__ instead of LLONG_MAX. */ +#if defined LLONG_MAX || defined __LONG_LONG_MAX__ +typedef long long int_fast64_t; +#else /* ! (defined LLONG_MAX || defined __LONG_LONG_MAX__) */ +#if (LONG_MAX >> 31) < 0xffffffff +Please use a compiler that supports a 64-bit integer type (or wider); +you may need to compile with "-DHAVE_STDINT_H". +#endif /* (LONG_MAX >> 31) < 0xffffffff */ +typedef long int_fast64_t; +#endif /* ! (defined LLONG_MAX || defined __LONG_LONG_MAX__) */ +#endif /* !defined INT_FAST64_MAX */ + +#ifndef INT32_MAX +#define INT32_MAX 0x7fffffff +#endif /* !defined INT32_MAX */ +#ifndef INT32_MIN +#define INT32_MIN (-1 - INT32_MAX) +#endif /* !defined INT32_MIN */ /* -** SunOS 4.1.1 headers lack EXIT_SUCCESS. -*/ - -#ifndef EXIT_SUCCESS -#define EXIT_SUCCESS 0 -#endif /* !defined EXIT_SUCCESS */ - -/* -** SunOS 4.1.1 headers lack EXIT_FAILURE. +** Workarounds for compilers/systems. */ -#ifndef EXIT_FAILURE -#define EXIT_FAILURE 1 -#endif /* !defined EXIT_FAILURE */ - /* -** SunOS 4.1.1 headers lack FILENAME_MAX. -*/ - -#ifndef FILENAME_MAX - -#ifndef MAXPATHLEN -#ifdef unix -#include "sys/param.h" -#endif /* defined unix */ -#endif /* !defined MAXPATHLEN */ - -#ifdef MAXPATHLEN -#define FILENAME_MAX MAXPATHLEN -#endif /* defined MAXPATHLEN */ -#ifndef MAXPATHLEN -#define FILENAME_MAX 1024 /* Pure guesswork */ -#endif /* !defined MAXPATHLEN */ - -#endif /* !defined FILENAME_MAX */ - -/* -** SunOS 4.1.1 libraries lack remove. +** Some time.h implementations don't declare asctime_r. +** Others might define it as a macro. +** Fix the former without affecting the latter. */ -#ifndef __NetBSD__ -#ifndef remove -extern int unlink P((const char * filename)); -#define remove unlink -#endif /* !defined remove */ +#ifndef asctime_r +extern char * asctime_r(struct tm const *, char *); #endif /* -** Some ancient errno.h implementations don't declare errno. -** But some newer errno.h implementations define it as a macro. -** Fix the former without affecting the latter. -*/ -#ifndef errno -extern int errno; -#endif /* !defined errno */ - -/* ** Private function declarations. */ -char * icalloc P((int nelem, int elsize)); -char * icatalloc P((char * old, const char * new)); -char * icpyalloc P((const char * string)); -char * imalloc P((int n)); -void * irealloc P((void * pointer, int size)); -void icfree P((char * pointer)); -void ifree P((char * pointer)); -char * scheck P((const char *string, const char *format)) - __attribute__((__format_arg__(2))); +char * icalloc(int nelem, int elsize); +char * icatalloc(char * old, const char * new); +char * icpyalloc(const char * string); +char * imalloc(int n); +void * irealloc(void * pointer, int size); +void icfree(char * pointer); +void ifree(char * pointer); +const char * scheck(const char * string, const char * format); /* ** Finally, some convenience items. @@ -239,6 +215,15 @@ #define TYPE_SIGNED(type) (((type) -1) < 0) #endif /* !defined TYPE_SIGNED */ +/* +** Since the definition of TYPE_INTEGRAL contains floating point numbers, +** it cannot be used in preprocessor directives. +*/ + +#ifndef TYPE_INTEGRAL +#define TYPE_INTEGRAL(type) (((type) 0.5) != 0.5) +#endif /* !defined TYPE_INTEGRAL */ + #ifndef INT_STRLEN_MAXIMUM /* ** 302 / 1000 is log10(2.0) rounded up. @@ -247,7 +232,8 @@ ** add one more for a minus sign if the type is signed. */ #define INT_STRLEN_MAXIMUM(type) \ - ((TYPE_BIT(type) - TYPE_SIGNED(type)) * 302 / 1000 + 1 + TYPE_SIGNED(type)) + ((TYPE_BIT(type) - TYPE_SIGNED(type)) * 302 / 1000 + \ + 1 + TYPE_SIGNED(type)) #endif /* !defined INT_STRLEN_MAXIMUM */ /* @@ -281,11 +267,11 @@ */ #ifndef _ -#if HAVE_GETTEXT - 0 +#if HAVE_GETTEXT #define _(msgid) gettext(msgid) -#else /* !(HAVE_GETTEXT - 0) */ +#else /* !HAVE_GETTEXT */ #define _(msgid) msgid -#endif /* !(HAVE_GETTEXT - 0) */ +#endif /* !HAVE_GETTEXT */ #endif /* !defined _ */ #ifndef TZ_DOMAIN @@ -295,10 +281,30 @@ #if HAVE_INCOMPATIBLE_CTIME_R #undef asctime_r #undef ctime_r -char *asctime_r P((struct tm const *, char *)); -char *ctime_r P((time_t const *, char *)); +char *asctime_r(struct tm const *, char *); +char *ctime_r(time_t const *, char *); #endif /* HAVE_INCOMPATIBLE_CTIME_R */ +#ifndef YEARSPERREPEAT +#define YEARSPERREPEAT 400 /* years before a Gregorian repeat */ +#endif /* !defined YEARSPERREPEAT */ + +/* +** The Gregorian year averages 365.2425 days, which is 31556952 seconds. +*/ + +#ifndef AVGSECSPERYEAR +#define AVGSECSPERYEAR 31556952L +#endif /* !defined AVGSECSPERYEAR */ + +#ifndef SECSPERREPEAT +#define SECSPERREPEAT ((int_fast64_t) YEARSPERREPEAT * (int_fast64_t) AVGSECSPERYEAR) +#endif /* !defined SECSPERREPEAT */ + +#ifndef SECSPERREPEAT_BITS +#define SECSPERREPEAT_BITS 34 /* ceil(log2(SECSPERREPEAT)) */ +#endif /* !defined SECSPERREPEAT_BITS */ + /* ** UNIX was a registered trademark of The Open Group in 2003. */ Index: lib/libc/time/scheck.c =================================================================== RCS file: /cvsroot/src/lib/libc/time/scheck.c,v retrieving revision 1.6 diff -u -r1.6 scheck.c --- lib/libc/time/scheck.c 5 Sep 1997 02:11:58 -0000 1.6 +++ lib/libc/time/scheck.c 31 Dec 2009 20:52:24 -0000 @@ -1,10 +1,16 @@ /* $NetBSD: scheck.c,v 1.6 1997/09/05 02:11:58 jtc Exp $ */ +/* +** This file is in the public domain, so clarified as of +** 2006-07-17 by Arthur David Olson. +*/ + #include + #ifndef lint #ifndef NOID #if 0 -static char elsieid[] = "@(#)scheck.c 8.15"; +static char elsieid[] = "@(#)scheck.c 8.19"; #else __RCSID("$NetBSD: scheck.c,v 1.6 1997/09/05 02:11:58 jtc Exp $"); #endif @@ -15,7 +21,7 @@ #include "private.h" -char * +const char * scheck(string, format) const char * const string; const char * const format; @@ -24,11 +30,10 @@ register const char * fp; register char * tp; register int c; - register char * result; + register const char * result; char dummy; - static char nada; - result = &nada; + result = ""; if (string == NULL || format == NULL) return result; fbuf = imalloc((int) (2 * strlen(format) + 4)); Index: lib/libc/time/strftime.c =================================================================== RCS file: /cvsroot/src/lib/libc/time/strftime.c,v retrieving revision 1.19 diff -u -r1.19 strftime.c --- lib/libc/time/strftime.c 11 Jan 2009 02:46:30 -0000 1.19 +++ lib/libc/time/strftime.c 31 Dec 2009 20:52:24 -0000 @@ -4,6 +4,7 @@ #if defined(LIBC_SCCS) && !defined(lint) #if 0 static char elsieid[] = "@(#)strftime.c 7.64"; +static char elsieid[] = "@(#)strftime.c 8.3"; #else __RCSID("$NetBSD: strftime.c,v 1.19 2009/01/11 02:46:30 christos Exp $"); #endif @@ -74,18 +75,20 @@ #include "sys/localedef.h" #define Locale _CurrentTimeLocale +#define c_fmt d_t_fmt -static char * _add P((const char *, char *, const char *)); -static char * _conv P((int, const char *, char *, const char *)); -static char * _fmt P((const char *, const struct tm *, char *, const char *, int *)); +static char * _add(const char *, char *, const char *); +static char * _conv(int, const char *, char *, const char *); +static char * _fmt(const char *, const struct tm *, char *, const char *, + int *); +static char * _yconv(int, int, int, int, char *, const char *); -#define NO_RUN_TIME_WARNINGS_ABOUT_YEAR_2000_PROBLEMS_THANK_YOU +extern char * tzname[]; #ifndef YEAR_2000_NAME #define YEAR_2000_NAME "CHECK_STRFTIME_FORMATS_FOR_TWO_DIGIT_YEARS" #endif /* !defined YEAR_2000_NAME */ - #define IN_NONE 0 #define IN_SOME 1 #define IN_THIS 2 @@ -174,14 +177,14 @@ ** something completely different. ** (ado, 1993-05-24) */ - pt = _conv((t->tm_year + TM_YEAR_BASE) / 100, - "%02d", pt, ptlim); + pt = _yconv(t->tm_year, TM_YEAR_BASE, 1, 0, + pt, ptlim); continue; case 'c': { int warn2 = IN_SOME; - pt = _fmt(Locale->d_t_fmt, t, pt, ptlim, &warn2); + pt = _fmt(Locale->c_fmt, t, pt, ptlim, &warn2); if (warn2 == IN_ALL) warn2 = IN_THIS; if (warn2 > *warnp) @@ -230,7 +233,7 @@ ** t->tm_hour % 12 : 12, 2, ' '); ** ...and has been changed to the below to ** match SunOS 4.1.1 and Arnold Robbins' - ** strftime version 3.0. That is, "%k" and + ** strftime version 3.0. That is, "%k" and ** "%l" have been swapped. ** (ado, 1993-05-24) */ @@ -250,7 +253,7 @@ ** _conv(t->tm_hour, 2, ' '); ** ...and has been changed to the below to ** match SunOS 4.1.1 and Arnold Robbin's - ** strftime version 3.0. That is, "%k" and + ** strftime version 3.0. That is, "%k" and ** "%l" have been swapped. ** (ado, 1993-05-24) */ @@ -328,7 +331,7 @@ case 'G': /* ISO 8601 year (four digits) */ case 'g': /* ISO 8601 year (two digits) */ /* -** From Arnold Robbins' strftime version 3.0: "the week number of the +** From Arnold Robbins' strftime version 3.0: "the week number of the ** year (the first Monday as the first day of week 1) as a decimal number ** (01-53)." ** (ado, 1993-05-24) @@ -341,17 +344,19 @@ ** might also contain days from the previous year and the week before week ** 01 of a year is the last week (52 or 53) of the previous year even if ** it contains days from the new year. A week starts with Monday (day 1) -** and ends with Sunday (day 7). For example, the first week of the year +** and ends with Sunday (day 7). For example, the first week of the year ** 1997 lasts from 1996-12-30 to 1997-01-05..." ** (ado, 1996-01-02) */ { int year; + int base; int yday; int wday; int w; - year = t->tm_year + TM_YEAR_BASE; + year = t->tm_year; + base = TM_YEAR_BASE; yday = t->tm_yday; wday = t->tm_wday; for ( ; ; ) { @@ -359,7 +364,7 @@ int bot; int top; - len = isleap(year) ? + len = isleap_sum(year, base) ? DAYSPERLYEAR : DAYSPERNYEAR; /* @@ -378,7 +383,7 @@ top += DAYSPERWEEK; top += len; if (yday >= top) { - ++year; + ++base; w = 1; break; } @@ -387,26 +392,26 @@ DAYSPERWEEK); break; } - --year; - yday += isleap(year) ? + --base; + yday += isleap_sum(year, base) ? DAYSPERLYEAR : DAYSPERNYEAR; } #ifdef XPG4_1994_04_09 - if ((w == 52 - && t->tm_mon == TM_JANUARY) - || (w == 1 - && t->tm_mon == TM_DECEMBER)) - w = 53; + if ((w == 52 && + t->tm_mon == TM_JANUARY) || + (w == 1 && + t->tm_mon == TM_DECEMBER)) + w = 53; #endif /* defined XPG4_1994_04_09 */ if (*format == 'V') pt = _conv(w, "%02d", pt, ptlim); else if (*format == 'g') { *warnp = IN_ALL; - pt = _conv(year % 100, "%02d", + pt = _yconv(year, base, 0, 1, pt, ptlim); - } else pt = _conv(year, "%04d", + } else pt = _yconv(year, base, 1, 1, pt, ptlim); } continue; @@ -444,11 +449,11 @@ continue; case 'y': *warnp = IN_ALL; - pt = _conv((t->tm_year + TM_YEAR_BASE) % 100, - "%02d", pt, ptlim); + pt = _yconv(t->tm_year, TM_YEAR_BASE, 0, 1, + pt, ptlim); continue; case 'Y': - pt = _conv(t->tm_year + TM_YEAR_BASE, "%04d", + pt = _yconv(t->tm_year, TM_YEAR_BASE, 1, 1, pt, ptlim); continue; case 'Z': @@ -479,12 +484,12 @@ /* ** C99 says that the UTC offset must ** be computed by looking only at - ** tm_isdst. This requirement is + ** tm_isdst. This requirement is ** incorrect, since it means the code ** must rely on magic (in this case ** altzone and timezone), and the ** magic might not have the correct - ** offset. Doing things correctly is + ** offset. Doing things correctly is ** tricky and requires disobeying C99; ** see GNU C strftime for details. ** For now, punt and conform to the @@ -543,9 +548,10 @@ diff = -diff; } else sign = "+"; pt = _add(sign, pt, ptlim); - diff /= 60; - pt = _conv((diff/60)*100 + diff%60, - "%04d", pt, ptlim); + diff /= SECSPERMIN; + diff = (diff / MINSPERHOUR) * 100 + + (diff % MINSPERHOUR); + pt = _conv(diff, "%04d", pt, ptlim); } continue; #if 0 @@ -557,7 +563,7 @@ case '%': /* ** X311J/88-090 (4.12.3.5): if conversion char is - ** undefined, behavior is undefined. Print out the + ** undefined, behavior is undefined. Print out the ** character itself as printf(3) also does. */ default: @@ -594,3 +600,165 @@ ++pt; return pt; } + +/* +** POSIX and the C Standard are unclear or inconsistent about +** what %C and %y do if the year is negative or exceeds 9999. +** Use the convention that %C concatenated with %y yields the +** same output as %Y, and that %Y contains at least 4 bytes, +** with more only if necessary. +*/ + +static char * +_yconv(a, b, convert_top, convert_yy, pt, ptlim) +const int a; +const int b; +const int convert_top; +const int convert_yy; +char * pt; +const char * const ptlim; +{ + register int lead; + register int trail; + +#define DIVISOR 100 + trail = a % DIVISOR + b % DIVISOR; + lead = a / DIVISOR + b / DIVISOR + trail / DIVISOR; + trail %= DIVISOR; + if (trail < 0 && lead > 0) { + trail += DIVISOR; + --lead; + } else if (lead < 0 && trail > 0) { + trail -= DIVISOR; + ++lead; + } + if (convert_top) { + if (lead == 0 && trail < 0) + pt = _add("-0", pt, ptlim); + else pt = _conv(lead, "%02d", pt, ptlim); + } + if (convert_yy) + pt = _conv(((trail < 0) ? -trail : trail), "%02d", pt, ptlim); + return pt; +} + +#ifdef LOCALE_HOME +static struct lc_time_T * +_loc(void) +{ + static const char locale_home[] = LOCALE_HOME; + static const char lc_time[] = "LC_TIME"; + static char * locale_buf; + + int fd; + int oldsun; /* "...ain't got nothin' to do..." */ + char * lbuf; + char * name; + char * p; + const char ** ap; + const char * plim; + char filename[FILENAME_MAX]; + struct stat st; + size_t namesize; + size_t bufsize; + + /* + ** Use localebuf.mon[0] to signal whether locale is already set up. + */ + if (localebuf.mon[0]) + return &localebuf; + name = setlocale(LC_TIME, (char *) NULL); + if (name == NULL || *name == '\0') + goto no_locale; + /* + ** If the locale name is the same as our cache, use the cache. + */ + lbuf = locale_buf; + if (lbuf != NULL && strcmp(name, lbuf) == 0) { + p = lbuf; + for (ap = (const char **) &localebuf; + ap < (const char **) (&localebuf + 1); + ++ap) + *ap = p += strlen(p) + 1; + return &localebuf; + } + /* + ** Slurp the locale file into the cache. + */ + namesize = strlen(name) + 1; + if (sizeof filename < + ((sizeof locale_home) + namesize + (sizeof lc_time))) + goto no_locale; + oldsun = 0; + (void) sprintf(filename, "%s/%s/%s", locale_home, name, lc_time); + fd = open(filename, O_RDONLY); + if (fd < 0) { + /* + ** Old Sun systems have a different naming and data convention. + */ + oldsun = 1; + (void) sprintf(filename, "%s/%s/%s", locale_home, + lc_time, name); + fd = open(filename, O_RDONLY); + if (fd < 0) + goto no_locale; + } + if (fstat(fd, &st) != 0) + goto bad_locale; + if (st.st_size <= 0) + goto bad_locale; + bufsize = namesize + st.st_size; + locale_buf = NULL; + lbuf = (lbuf == NULL) ? malloc(bufsize) : realloc(lbuf, bufsize); + if (lbuf == NULL) + goto bad_locale; + (void) strcpy(lbuf, name); + p = lbuf + namesize; + plim = p + st.st_size; + if (read(fd, p, (size_t) st.st_size) != st.st_size) + goto bad_lbuf; + if (close(fd) != 0) + goto bad_lbuf; + /* + ** Parse the locale file into localebuf. + */ + if (plim[-1] != '\n') + goto bad_lbuf; + for (ap = (const char **) &localebuf; + ap < (const char **) (&localebuf + 1); + ++ap) { + if (p == plim) + goto bad_lbuf; + *ap = p; + while (*p != '\n') + ++p; + *p++ = '\0'; + } + if (oldsun) { + /* + ** SunOS 4 used an obsolescent format; see localdtconv(3). + ** c_fmt had the ``short format for dates and times together'' + ** (SunOS 4 date, "%a %b %e %T %Z %Y" in the C locale); + ** date_fmt had the ``long format for dates'' + ** (SunOS 4 strftime %C, "%A, %B %e, %Y" in the C locale). + ** Discard the latter in favor of the former. + */ + localebuf.date_fmt = localebuf.c_fmt; + } + /* + ** Record the successful parse in the cache. + */ + locale_buf = lbuf; + + return &localebuf; + +bad_lbuf: + free(lbuf); +bad_locale: + (void) close(fd); +no_locale: + localebuf = C_time_locale; + locale_buf = NULL; + return &localebuf; +} +#endif /* defined LOCALE_HOME */ Index: lib/libc/time/time2posix.3 =================================================================== RCS file: /cvsroot/src/lib/libc/time/time2posix.3,v retrieving revision 1.14 diff -u -r1.14 time2posix.3 --- lib/libc/time/time2posix.3 11 Apr 2009 16:29:09 -0000 1.14 +++ lib/libc/time/time2posix.3 31 Dec 2009 20:52:25 -0000 @@ -119,4 +119,4 @@ .Xr time 3 .\" @(#)time2posix.3 7.7 .\" This file is in the public domain, so clarified as of -.\" 1996-06-05 by Arthur David Olson (arthur_david_olson@nih.gov). +.\" 1996-06-05 by Arthur David Olson. Index: lib/libc/time/tz-link.htm =================================================================== RCS file: /cvsroot/src/lib/libc/time/tz-link.htm,v retrieving revision 1.5 diff -u -r1.5 tz-link.htm --- lib/libc/time/tz-link.htm 27 May 2004 20:39:49 -0000 1.5 +++ lib/libc/time/tz-link.htm 31 Dec 2009 20:52:25 -0000 @@ -1,78 +1,98 @@ - - + PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> + Sources for Time Zone and Daylight Saving Time Data - - - - - + + + + + - + content="Sources of information about time zones and daylight saving time"> + + content="database,daylight saving,DST,time zone,timezone,tz,zoneinfo">

Sources for Time Zone and Daylight Saving Time Data

-@(#)tz-link.htm 7.42 +@(#)tz-link.htm 8.22

-Please send corrections to this web page to the -time zone mailing list. +This file is in the public domain, so clarified as of +2009-05-17 by Arthur David Olson.

+

+Please send corrections to this web page to the +time zone mailing list.

The tz database

-The public-domain time zone database contains code and data +The public-domain +time zone database contains code and data that represent the history of local time for many representative locations around the globe. It is updated periodically to reflect changes made by political bodies -to UTC offsets and daylight-saving rules. -This database (often called tz or zoneinfo) +to time zone +boundaries, UTC offsets, and +daylight-saving +rules. +This database (often called tz or zoneinfo) is used by several implementations, including -the GNU C Library used in -GNU/Linux, +the +GNU +C Library used in +GNU/Linux, FreeBSD, -NetBSD, -OpenBSD, -Cygwin, -DJGPP, -HP-UX, -IRIX, +NetBSD, +OpenBSD, +Cygwin, +DJGPP, +AIX, Mac OS X, OpenVMS, -Solaris, -Tru64, and -UnixWare.

+Oracle Database, +Solaris, +Tru64, and +UnixWare.

Each location in the database represents a national region where all clocks keeping local time have agreed since 1970. Locations are identified by continent or ocean and then by the name of the location, which is typically the largest city within the region. For example, America/New_York -represents most of the US eastern time zone; -America/Indianapolis represents most of Indiana, which -uses eastern time without daylight saving time (DST); +represents most of the US eastern time zone; +America/Phoenix represents most of Arizona, which +uses mountain time without daylight saving time (DST); America/Detroit represents most of Michigan, which uses -eastern time but with different DST rules in 1975; +eastern time but with different DST rules in 1975; and other entries represent smaller regions like Starke County, -Kentucky, which switched from central to eastern time in 1991. -To use the database, set the TZ environment variable to +Indiana, which switched from central to eastern time in 1991 +and switched back in 2006. +To use the database on an extended POSIX +implementation set the TZ environment variable to the location's full name, e.g., TZ="America/New_York".

In the tz database's -FTP distribution, +FTP distribution the code is in the file tzcodeC.tar.gz, where C is the code's version; similarly, the data are in tzdataD.tar.gz, where D is the data's version. -The following shell commands download -these files to a GNU/Linux or similar host; see the downloaded +The following shell commands download +these files to a GNU/Linux or similar host; +see the downloaded README file for what to do next.

wget 'ftp://elsie.nci.nih.gov/pub/tz*.tar.gz'
 gzip -dc tzcode*.tar.gz | tar -xf -
@@ -87,148 +107,238 @@
 The data are by no means authoritative. If you find errors, please
 send changes to the time zone
 mailing list. You can also subscribe to the
-mailing list, retrieve the archive of old
+href="http://news.gmane.org/gmane.comp.time.tz">browse recent
+messages sent to the mailing list, subscribe to it,
+retrieve the full archive of old
 messages (in gzip compressed format), or retrieve archived older versions of code
+href="ftp://munnari.oz.au/pub/oldtz">archived older versions of code
 and data.

 

 The Web has several other sources for time zone and daylight saving time data.
 Here are some recent links that may be of interest.
 

 
Web pages using recent versions of the tz database

+

+These are listed roughly in ascending order of complexity and fanciness.
+

 
 
Other time zone database formats

 
 
Other tz compilers

 
 
Other tz binary file readers

 
-
Other tz-based time zone conversion software

-
    
+It is freely available under the LGPL.
+
  • Tcl, mentioned above, also contains a
+tz binary file reader.
    • 
+

+
Other tz-based time zone software

+
    
+
  • FoxClocks
+is an extension for Mozilla
+Toolkit applications like Firefox, Thunderbird, and
+Sunbird.
+It displays multiple clocks in the application window, and has a mapping
+interface to Google Earth.
+It is freely available under the GPL.
    • 
+
  • International
+clock (intclock) is a multi-timezone clock for
+GNU/Linux and similar systems. It is freely available
+under the GPL.
    • 
+
  • PublicDomain
+has a copy of a recent tz database, accessed via a C# library. As its
+name suggests, it is in the public domain. Only current time stamps
+are well supported; historical data are compiled into the runtime but
+are not easily accessible.
    • 
 
  • Sun Java releases since 1.4
-contain a copy of a recent tz database in a Java-specific
-format.
    • 
+contain a copy of a subset of a recent tz database in a
+Java-specific format.
+
  • Time Zone is
+a WordPress plugin. It is freely
+available under a BSD-style license.
    • 
 
  • HyperCard
-time zones calculator is a HyperCard stack.
    • 
+href="http://veladg.com/velaterra.html">VelaTerra is
+a Mac OS X program. Its developers
+offer free
+licenses to tz contributors.
 
  • World Time Explorer is a
+href="http://worldtimeexplorer.com/">World Time Explorer is a
 Microsoft Windows program.
    • 
 

 
Other time zone databases

 
 
Maps

 
 
Time zone boundaries

 
 
Civil time concepts and history

 
 
National histories of legal time

 

 
Australia

-
The Community Relations Division of the New South Wales (NSW)
-Attorney General's Department maintains a history of
-daylight saving in NSW.

-
Austria

-
The Federal Office of Metrology and Surveying publishes a
-table of daylight saving time in Austria (in German).

+
The Parliamentary Library has commissioned research
+note on daylight saving time in Australia.
+The Bureau of Meteorology publishes a list of
+Implementation Dates of Daylight Savings Time within Australia.

 
Belgium

 
The Royal Observatory of Belgium maintains a table of Canada
 
The Institute for National Measurement Standards publishes current
 and some older information about Time
-Zones and Daylight Saving Time.

+href="http://inms-ienm.nrc-cnrc.gc.ca/time_services/daylight_saving_e.html">Time
+Zones & Daylight Saving Time.
 
Chile

-
WebExhibits publishes a history of official time (in Spanish) originally
-written by the Chilean Hydrographic and Oceanographic Service.

+
The Chilean Hydrographic and Oceanographic Service publishes a  history of
+official time (in Spanish).

 
Germany

 
The National Institute for Science and Technology maintains the Realisation of
 Legal Time in Germany.

 
Israel

 
The Interior Ministry periodically issues announcements (in Hebrew).

 
Mexico

 
The Investigation and Analysis Service of the Mexican Library of
@@ -331,10 +460,15 @@
 covers the history of local time in the Netherlands from ancient times.

 
New Zealand

 
The Department of Internal Affairs maintains a brief history about
-daylight saving. The privately-maintained Time Changes in
-New Zealand has more details.

+href="http://dia.govt.nz/diawebsite.nsf/wpg_URL/Resource-material-Information-We-Provide-About-Daylight-Saving">About
+Daylight Saving. The privately-maintained History of New Zealand
+time has more details.
+
Norway

+
The Norwegian Meteorological Institute lists
+Summer
+time in Norway (in Norwegian), citing the
+Institute of Theoretical Astrophysics, Oslo.

 
Singapore

 
Why
@@ -346,56 +480,86 @@
 legal time in Britain discusses in detail the country
 with perhaps the best-documented history of clock adjustments.
 The National Physical Laboratory also maintains an archive
-of summer time dates.

+href="http://www.npl.co.uk/server.php?show=ConWebDoc.2714">Archive
+of Summer time dates.
 

 
Precision timekeeping

 
 
Time notation

@@ -403,41 +567,82 @@
 
  • 
 A Summary of
 the International Standard Date and Time Notation is a good
-summary of ISO
-8601:1988 - Data elements and interchange formats - Information interchange
-- Representation of dates and times (which has been superseded by
-ISO 8601:2000).
    • 
+summary of
+ISO
+8601:2004 -- Data elements and interchange formats -- Information
+interchange -- Representation of dates and times.
+
  • 
+XML
+Schema: Datatypes - dateTime specifies a format inspired by
+ISO 8601 that is in common use in XML data.
    • 
 
  • 
-Section 3.3 of Internet RFC 2822
+Internet
+Message Format (Internet RFC 2822) §3.3
 specifies the time notation used in email and HTTP headers.
    • 
+href="ftp://ftp.rfc-editor.org/in-notes/rfc2616.txt">HTTP
+headers.
 
  • 
-Internet RFC
-3339 specifies an ISO 8601 profile for use in new Internet
+Date and Time
+on the Internet: Timestamps (Internet RFC 3339)
+specifies an ISO 8601
+profile for use in new Internet
 protocols.
    • 
 
  • 
-The
+Date & Time
+Formats on the Web surveys web- and Internet-oriented date and time
+formats.
    • 
+
  • 
+The
 Best of Dates, the Worst of Dates covers many problems encountered
 by software developers when handling dates and time stamps.
    • 
-
  • 
-Alphabetic time zone abbreviations should not be used as unique
-identifiers for UTC offsets as they are ambiguous in practice. For
-example, "EST" denotes 5 hours behind UTC in English-speaking North
-America, but it denotes 10 or 11 hours ahead of UTC in Australia;
-and French-speaking North Americans prefer "HNE" to "EST". For
-compatibility with POSIX the
-tz database contains English abbreviations for all time
-stamps but in many cases these are merely inventions of the database
+
  • The Unicode Common Locale Data Repository
+(CLDR) Project has localizations for time zone names,
+abbreviations, identifiers, and formats. For example, it contains
+French translations for "Eastern European Summer Time", "EEST", and
+"Bucharest". By-Type
+Chart: names.metazone shows these values for many locales.
+ICU contains a mechanism for using this data.
    • 
+
  • Alphabetic time zone abbreviations should not be used as unique
+identifiers for UTC offsets as they are ambiguous in
+practice. For example, "EST" denotes 5 hours behind
+UTC in English-speaking North America, but it denotes 10
+or 11 hours ahead of UTC in Australia; and
+French-speaking North Americans prefer
+"HNE" to
+"EST". For POSIX the tz
+database contains English abbreviations for all time stamps but in
+many cases these are merely inventions of the database
 maintainers.
    • 
+
  • Numeric time zone abbreviations typically count hours east of
+UTC, e.g., +09 for Japan and
+-10 for Hawaii. However, the POSIX
+TZ environment variable uses the opposite convention. For
+example, one might use TZ="JST-9" and
+TZ="HST10" for Japan and Hawaii, respectively. If the
+tz database is available, it is usually better to use
+settings like TZ="Asia/Tokyo" and
+TZ="Pacific/Honolulu" instead, as this should avoid
+confusion, handle old time stamps better, and insulate you better from
+any future changes to the rules. One should never set
+POSIX TZ to a value like
+"GMT-9", though, since this would falsely claim that
+local time is nine hours ahead of UTC and the time zone
+is called "GMT".
    • 
 
 
    Related indexes
    
 
 
 
Index: lib/libc/time/tzfile.5
===================================================================
RCS file: /cvsroot/src/lib/libc/time/tzfile.5,v
retrieving revision 1.13
diff -u -r1.13 tzfile.5
--- lib/libc/time/tzfile.5	9 Mar 2009 19:24:27 -0000	1.13
+++ lib/libc/time/tzfile.5	31 Dec 2009 20:52:25 -0000
@@ -17,7 +17,9 @@
 begin with the magic characters
 .Dq TZif
 to identify them as time zone information files,
-followed by sixteen bytes reserved for future use,
+followed by a character identifying the version of the file's format
+(as of 2005, either an ASCII NUL or a '2')
+followed by fifteen bytes containing zeroes reserved for future use,
 followed by six four-byte values of type
 .Fa long ,
 written in a
@@ -65,7 +67,10 @@
 transition time.
 These values serve as indices into an array of
 .Fa ttinfo
-structures that appears next in the file;
+.I ttinfo
+structures (with
+.I tzh_typecnt
+entries) that appears next in the file;
 these structures are defined as follows:
 .Bd -literal
 struct ttinfo {
@@ -136,7 +141,20 @@
 .Va tzh_timecnt
 is zero or the time argument is less than the first transition time recorded
 in the file.
+.PP
+For version-2-format time zone files,
+the above header and data is followed by a second header and data,
+identical in format except that
+eight bytes are used for each transition time or leap second time.
+After the second header and data comes a newline-enclosed,
+POSIX-TZ-environment-variable-style string for use in handling instants
+after the last transition time stored in the file
+(with nothing between the newlines if there is no POSIX representation for
+such instants).
 .Sh SEE ALSO
 .Xr ctime 3 ,
 .Xr localtime 3 ,
 .Xr time 3
+.\" @(#)tzfile.5	8.2
+.\" This file is in the public domain, so clarified as of
+.\" 1996-06-05 by Arthur David Olson.
Index: lib/libc/time/tzfile.h
===================================================================
RCS file: /cvsroot/src/lib/libc/time/tzfile.h,v
retrieving revision 1.8
diff -u -r1.8 tzfile.h
--- lib/libc/time/tzfile.h	22 Jan 1998 07:06:59 -0000	1.8
+++ lib/libc/time/tzfile.h	31 Dec 2009 20:52:25 -0000
@@ -5,7 +5,7 @@
 
 /*
 ** This file is in the public domain, so clarified as of
-** 1996-06-05 by Arthur David Olson (arthur_david_olson@nih.gov).
+** 1996-06-05 by Arthur David Olson.
 */
 
 /*
@@ -23,7 +23,7 @@
 #ifndef lint
 #ifndef NOID
 #if 0
-static char	tzfilehid[] = "@(#)tzfile.h	7.14";
+static char	tzfilehid[] = "@(#)tzfile.h	8.1";
 #endif
 #endif /* !defined NOID */
 #endif /* !defined lint */
@@ -51,8 +51,9 @@
 #define	TZ_MAGIC	"TZif"
 
 struct tzhead {
- 	char	tzh_magic[4];		/* TZ_MAGIC */
-	char	tzh_reserved[16];	/* reserved for future use */
+	char	tzh_magic[4];		/* TZ_MAGIC */
+	char	tzh_version[1];		/* '\0' or '2' as of 2005 */
+	char	tzh_reserved[15];	/* reserved--must be zero */
 	char	tzh_ttisgmtcnt[4];	/* coded number of trans. time flags */
 	char	tzh_ttisstdcnt[4];	/* coded number of trans. time flags */
 	char	tzh_leapcnt[4];		/* coded number of leap seconds */
@@ -87,18 +88,22 @@
 */
 
 /*
+** If tzh_version is '2' or greater, the above is followed by a second instance
+** of tzhead and a second instance of the data in which each coded transition
+** time uses 8 rather than 4 chars,
+** then a POSIX-TZ-environment-variable-style string for use in handling
+** instants after the last transition time stored in the file
+** (with nothing between the newlines if there is no POSIX representation for
+** such instants).
+*/
+
+/*
 ** In the current implementation, "tzset()" refuses to deal with files that
 ** exceed any of the limits below.
 */
 
 #ifndef TZ_MAX_TIMES
-/*
-** The TZ_MAX_TIMES value below is enough to handle a bit more than a
-** year's worth of solar time (corrected daily to the nearest second) or
-** 138 years of Pacific Presidential Election time
-** (where there are three time zone transitions every fourth year).
-*/
-#define TZ_MAX_TIMES	370
+#define TZ_MAX_TIMES	1200
 #endif /* !defined TZ_MAX_TIMES */
 
 #ifndef TZ_MAX_TYPES
@@ -108,7 +113,7 @@
 #ifdef NOSOLAR
 /*
 ** Must be at least 14 for Europe/Riga as of Jan 12 1995,
-** as noted by Earl Chew .
+** as noted by Earl Chew.
 */
 #define TZ_MAX_TYPES	20	/* Maximum number of local time types */
 #endif /* !defined NOSOLAR */
@@ -159,33 +164,20 @@
 #define EPOCH_YEAR	1970
 #define EPOCH_WDAY	TM_THURSDAY
 
-/*
-** Accurate only for the past couple of centuries;
-** that will probably do.
-*/
-
 #define isleap(y) (((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0))
 
-#ifndef USG
-
 /*
-** Use of the underscored variants may cause problems if you move your code to
-** certain System-V-based systems; for maximum portability, use the
-** underscore-free variants.  The underscored variants are provided for
-** backward compatibility only; they may disappear from future versions of
-** this file.
-*/
-
-#define SECS_PER_MIN	SECSPERMIN
-#define MINS_PER_HOUR	MINSPERHOUR
-#define HOURS_PER_DAY	HOURSPERDAY
-#define DAYS_PER_WEEK	DAYSPERWEEK
-#define DAYS_PER_NYEAR	DAYSPERNYEAR
-#define DAYS_PER_LYEAR	DAYSPERLYEAR
-#define SECS_PER_HOUR	SECSPERHOUR
-#define SECS_PER_DAY	SECSPERDAY
-#define MONS_PER_YEAR	MONSPERYEAR
+** Since everything in isleap is modulo 400 (or a factor of 400), we know that
+**	isleap(y) == isleap(y % 400)
+** and so
+**	isleap(a + b) == isleap((a + b) % 400)
+** or
+**	isleap(a + b) == isleap(a % 400 + b % 400)
+** This is true even if % means modulo rather than Fortran remainder
+** (which is allowed by C89 but not C99).
+** We use this to avoid addition overflow problems.
+*/
 
-#endif /* !defined USG */
+#define isleap_sum(a, b)	isleap((a) % 400 + (b) % 400)
 
 #endif /* !defined TZFILE_H */
Index: lib/libc/time/tzselect.8
===================================================================
RCS file: /cvsroot/src/lib/libc/time/tzselect.8,v
retrieving revision 1.3
diff -u -r1.3 tzselect.8
--- lib/libc/time/tzselect.8	10 Nov 1999 20:32:31 -0000	1.3
+++ lib/libc/time/tzselect.8	31 Dec 2009 20:52:25 -0000
@@ -40,4 +40,6 @@
 nonzero otherwise.
 .SH "SEE ALSO"
 newctime(3), tzfile(5), zdump(8), zic(8)
-.\" @(#)tzselect.8	1.3
+.\" @(#)tzselect.8	8.2
+.\" This file is in the public domain, so clarified as of
+.\" 2009-05-17 by Arthur David Olson.
Index: lib/libc/time/tzselect.ksh
===================================================================
RCS file: /cvsroot/src/lib/libc/time/tzselect.ksh,v
retrieving revision 1.5
diff -u -r1.5 tzselect.ksh
--- lib/libc/time/tzselect.ksh	10 Nov 1999 20:32:31 -0000	1.5
+++ lib/libc/time/tzselect.ksh	31 Dec 2009 20:52:25 -0000
@@ -2,12 +2,12 @@
 #
 #	$NetBSD: tzselect.ksh,v 1.5 1999/11/10 20:32:31 kleink Exp $
 #
-# '@(#)tzselect.ksh	1.7'
+VERSION='@(#)tzselect.ksh	8.2'
 
 # Ask the user about the time zone, and output the resulting TZ value to stdout.
 # Interact with the user via stderr and stdin.
 
-# Contributed by Paul Eggert .
+# Contributed by Paul Eggert.
 
 # Porting notes:
 #
@@ -47,6 +47,21 @@
 	exit 1
 }
 
+if [ "$1" = "--help" ]; then
+    cat <
 #ifndef lint
@@ -7,7 +11,7 @@
 #endif /* !defined NOID */
 #endif /* !defined lint */
 
-static char	elsieid[] = "@(#)zdump.c	7.31";
+static char	elsieid[] = "@(#)zdump.c	8.9";
 
 /*
 ** This code has been made independent of the rest of the time
@@ -21,6 +25,19 @@
 #include "time.h"	/* for struct tm */
 #include "stdlib.h"	/* for exit, malloc, atoi */
 #include 
+#include "float.h"	/* for FLT_MAX and DBL_MAX */
+#include "ctype.h"	/* for isalpha et al. */
+#ifndef isascii
+#define isascii(x) 1
+#endif /* !defined isascii */
+
+#ifndef ZDUMP_LO_YEAR
+#define ZDUMP_LO_YEAR	(-500)
+#endif /* !defined ZDUMP_LO_YEAR */
+
+#ifndef ZDUMP_HI_YEAR
+#define ZDUMP_HI_YEAR	2500
+#endif /* !defined ZDUMP_HI_YEAR */
 
 #ifndef MAX_STRING_LENGTH
 #define MAX_STRING_LENGTH	1024
@@ -71,19 +88,32 @@
 #endif /* !defined DAYSPERNYEAR */
 
 #ifndef isleap
-#define isleap(y) ((((y) % 4) == 0 && ((y) % 100) != 0) || ((y) % 400) == 0)
+#define isleap(y) (((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0))
 #endif /* !defined isleap */
 
-#if HAVE_GETTEXT - 0
+#ifndef isleap_sum
+/*
+** See tzfile.h for details on isleap_sum.
+*/
+#define isleap_sum(a, b)	isleap((a) % 400 + (b) % 400)
+#endif /* !defined isleap_sum */
+
+#define SECSPERDAY	((long) SECSPERHOUR * HOURSPERDAY)
+#define SECSPERNYEAR	(SECSPERDAY * DAYSPERNYEAR)
+#define SECSPERLYEAR	(SECSPERNYEAR + SECSPERDAY)
+
+#ifndef HAVE_GETTEXT
+#define HAVE_GETTEXT 0
+#endif
+#if HAVE_GETTEXT
 #include "locale.h"	/* for setlocale */
 #include "libintl.h"
-#endif /* HAVE_GETTEXT - 0 */
+#endif /* HAVE_GETTEXT */
 
 #ifndef GNUC_or_lint
 #ifdef lint
 #define GNUC_or_lint
-#endif /* defined lint */
-#ifndef lint
+#else /* !defined lint */
 #ifdef __GNUC__
 #define GNUC_or_lint
 #endif /* defined __GNUC__ */
@@ -93,8 +123,7 @@
 #ifndef INITIALIZE
 #ifdef GNUC_or_lint
 #define INITIALIZE(x)	((x) = 0)
-#endif /* defined GNUC_or_lint */
-#ifndef GNUC_or_lint
+#else /* !defined GNUC_or_lint */
 #define INITIALIZE(x)
 #endif /* !defined GNUC_or_lint */
 #endif /* !defined INITIALIZE */
@@ -106,34 +135,125 @@
 */
 
 #ifndef _
-#if HAVE_GETTEXT - 0
+#if HAVE_GETTEXT
 #define _(msgid) gettext(msgid)
-#else /* !(HAVE_GETTEXT - 0) */
-#define _(msgid) msgid
-#endif /* !(HAVE_GETTEXT - 0) */
+#else /* !HAVE_GETTEXT */
+#define _(msgid) __UNCONST(msgid)
+#endif /* !HAVE_GETTEXT */
 #endif /* !defined _ */
 
 #ifndef TZ_DOMAIN
 #define TZ_DOMAIN "tz"
 #endif /* !defined TZ_DOMAIN */
 
-#ifndef P
-#define P(x)	x
-#endif /* !defined P */
-
 extern char **	environ;
-extern int	getopt P((int argc, char * const argv[],
-			  const char * options));
+extern int	getopt(int argc, char * const argv[],
+			const char * options);
 extern char *	optarg;
 extern int	optind;
 
-static const char *	abbr P((struct tm * tmp));
-static long	delta P((struct tm * newp, struct tm * oldp));
-static time_t	hunt P((char * name, time_t lot, time_t	hit));
-int		main P((int, char **));
+static time_t	absolute_min_time;
+static time_t	absolute_max_time;
 static size_t	longest;
 static char *	progname;
-static void	show P((char * zone, time_t t, int v));
+static int	warned;
+
+static const char *	abbr(struct tm * tmp);
+static void	abbrok(const char * abbrp, const char * zone);
+static long	delta(struct tm * newp, struct tm * oldp);
+static void	dumptime(const struct tm * tmp);
+static time_t	hunt(char * name, time_t lot, time_t	hit);
+int		main(int, char **);
+static void	setabsolutes(void);
+static void	show(char * zone, time_t t, int v);
+static const char *	tformat(void);
+static time_t	yeartot(long y);
+
+#ifndef TYPECHECK
+#define my_localtime	localtime
+#else /* !defined TYPECHECK */
+static struct tm *
+my_localtime(tp)
+time_t *	tp;
+{
+	register struct tm *	tmp;
+
+	tmp = localtime(tp);
+	if (tp != NULL && tmp != NULL) {
+		struct tm	tm;
+		register time_t	t;
+
+		tm = *tmp;
+		t = mktime(&tm);
+		if (t - *tp >= 1 || *tp - t >= 1) {
+			(void) fflush(stdout);
+			(void) fprintf(stderr, "\n%s: ", progname);
+			(void) fprintf(stderr, tformat(), *tp);
+			(void) fprintf(stderr, " ->");
+			(void) fprintf(stderr, " year=%d", tmp->tm_year);
+			(void) fprintf(stderr, " mon=%d", tmp->tm_mon);
+			(void) fprintf(stderr, " mday=%d", tmp->tm_mday);
+			(void) fprintf(stderr, " hour=%d", tmp->tm_hour);
+			(void) fprintf(stderr, " min=%d", tmp->tm_min);
+			(void) fprintf(stderr, " sec=%d", tmp->tm_sec);
+			(void) fprintf(stderr, " isdst=%d", tmp->tm_isdst);
+			(void) fprintf(stderr, " -> ");
+			(void) fprintf(stderr, tformat(), t);
+			(void) fprintf(stderr, "\n");
+		}
+	}
+	return tmp;
+}
+#endif /* !defined TYPECHECK */
+
+static void
+abbrok(abbrp, zone)
+const char * const	abbrp;
+const char * const	zone;
+{
+	register const char *	cp;
+	register char *		wp;
+
+	if (warned)
+		return;
+	cp = abbrp;
+	wp = NULL;
+	while (isascii((unsigned char) *cp) && isalpha((unsigned char) *cp))
+		++cp;
+	if (cp - abbrp == 0)
+		wp = _("lacks alphabetic at start");
+	else if (cp - abbrp < 3)
+		wp = _("has fewer than 3 alphabetics");
+	else if (cp - abbrp > 6)
+		wp = _("has more than 6 alphabetics");
+	if (wp == NULL && (*cp == '+' || *cp == '-')) {
+		++cp;
+		if (isascii((unsigned char) *cp) &&
+			isdigit((unsigned char) *cp))
+				if (*cp++ == '1' && *cp >= '0' && *cp <= '4')
+					++cp;
+		if (*cp != '\0')
+			wp = _("differs from POSIX standard");
+	}
+	if (wp == NULL)
+		return;
+	(void) fflush(stdout);
+	(void) fprintf(stderr,
+		_("%s: warning: zone \"%s\" abbreviation \"%s\" %s\n"),
+		progname, zone, abbrp, wp);
+	warned = TRUE;
+}
+
+static void
+usage(const char *xprogname, FILE *stream, int status)
+{
+	(void) fprintf(stream,
+_("%s: usage is %s [ --version ] [ --help ] [ -v ] [ -c [loyear,]hiyear ] zonename ...\n\
+\n\
+Report bugs to tz@elsie.nci.nih.gov.\n"),
+		       xprogname, xprogname);
+	exit(status);
+}
 
 int
 main(argc, argv)
@@ -143,65 +263,79 @@
 	register int		i;
 	register int		c;
 	register int		vflag;
-	register char *		cutoff;
-	register int		cutyear;
-	register long		cuttime;
-	char **			fakeenv;
+	register char *		cutarg;
+	register long		cutloyear = ZDUMP_LO_YEAR;
+	register long		cuthiyear = ZDUMP_HI_YEAR;
+	register time_t		cutlotime;
+	register time_t		cuthitime;
+	register char **	fakeenv;
 	time_t			now;
 	time_t			t;
 	time_t			newt;
-	time_t			hibit;
 	struct tm		tm;
 	struct tm		newtm;
+	register struct tm *	tmp;
+	register struct tm *	newtmp;
 
-	INITIALIZE(cuttime);
-#if HAVE_GETTEXT - 0
-	(void) setlocale(LC_MESSAGES, "");
+	INITIALIZE(cutlotime);
+	INITIALIZE(cuthitime);
+#if HAVE_GETTEXT
+	(void) setlocale(LC_ALL, "");
 #ifdef TZ_DOMAINDIR
 	(void) bindtextdomain(TZ_DOMAIN, TZ_DOMAINDIR);
-#endif /* defined(TEXTDOMAINDIR) */
+#endif /* defined TEXTDOMAINDIR */
 	(void) textdomain(TZ_DOMAIN);
-#endif /* HAVE_GETTEXT - 0 */
+#endif /* HAVE_GETTEXT */
 	progname = argv[0];
 	for (i = 1; i < argc; ++i)
 		if (strcmp(argv[i], "--version") == 0) {
 			(void) printf("%s\n", elsieid);
-			(void) exit(EXIT_SUCCESS);
+			exit(EXIT_SUCCESS);
+		} else if (strcmp(argv[i], "--help") == 0) {
+			usage(progname, stdout, EXIT_SUCCESS);
 		}
 	vflag = 0;
-	cutoff = NULL;
+	cutarg = NULL;
 	while ((c = getopt(argc, argv, "c:v")) == 'c' || c == 'v')
 		if (c == 'v')
 			vflag = 1;
-		else	cutoff = optarg;
+		else	cutarg = optarg;
 	if ((c != EOF && c != -1) ||
 		(optind == argc - 1 && strcmp(argv[optind], "=") == 0)) {
-			(void) fprintf(stderr,
-_("%s: usage is %s [ --version ] [ -v ] [ -c cutoff ] zonename ...\n"),
-				argv[0], argv[0]);
-			(void) exit(EXIT_FAILURE);
-	}
-	if (cutoff != NULL) {
-		int	y;
-
-		cutyear = atoi(cutoff);
-		cuttime = 0;
-		for (y = EPOCH_YEAR; y < cutyear; ++y)
-			cuttime += DAYSPERNYEAR + isleap(y);
-		cuttime *= SECSPERHOUR * HOURSPERDAY;
+			usage(progname, stderr, EXIT_FAILURE);
+	}
+	if (vflag) {
+		if (cutarg != NULL) {
+			long	lo;
+			long	hi;
+			char	dummy;
+
+			if (sscanf(cutarg, "%ld%c", &hi, &dummy) == 1) {
+				cuthiyear = hi;
+			} else if (sscanf(cutarg, "%ld,%ld%c",
+				&lo, &hi, &dummy) == 2) {
+					cutloyear = lo;
+					cuthiyear = hi;
+			} else {
+(void) fprintf(stderr, _("%s: wild -c argument %s\n"),
+					progname, cutarg);
+				exit(EXIT_FAILURE);
+			}
+		}
+		setabsolutes();
+		cutlotime = yeartot(cutloyear);
+		cuthitime = yeartot(cuthiyear);
 	}
 	(void) time(&now);
 	longest = 0;
 	for (i = optind; i < argc; ++i)
 		if (strlen(argv[i]) > longest)
 			longest = strlen(argv[i]);
-	for (hibit = 1; (hibit << 1) != 0; hibit <<= 1)
-		continue;
 	{
 		register int	from;
 		register int	to;
 
-		for (i = 0;  environ[i] != NULL;  ++i)
+		for (i = 0; environ[i] != NULL; ++i)
 			continue;
 		fakeenv = (char **) malloc((size_t) ((i + 2) *
 			sizeof *fakeenv));
@@ -226,43 +360,43 @@
 			show(argv[i], now, FALSE);
 			continue;
 		}
-		/*
-		** Get lowest value of t.
-		*/
-		t = hibit;
-		if (t > 0)		/* time_t is unsigned */
-			t = 0;
+		warned = FALSE;
+		t = absolute_min_time;
 		show(argv[i], t, TRUE);
 		t += SECSPERHOUR * HOURSPERDAY;
 		show(argv[i], t, TRUE);
-		tm = *localtime(&t);
-		(void) strlcpy(buf, abbr(&tm), (sizeof buf));
+		if (t < cutlotime)
+			t = cutlotime;
+		tmp = my_localtime(&t);
+		if (tmp != NULL) {
+			tm = *tmp;
+			(void) strncpy(buf, abbr(&tm), (sizeof buf) - 1);
+		}
 		for ( ; ; ) {
-			if (cutoff != NULL && t >= cuttime)
+			if (t >= cuthitime || t >= cuthitime - SECSPERHOUR * 12)
 				break;
 			newt = t + SECSPERHOUR * 12;
-			if (cutoff != NULL && newt >= cuttime)
-				break;
-			if (newt <= t)
-				break;
-			newtm = *localtime(&newt);
-			if (delta(&newtm, &tm) != (newt - t) ||
+			newtmp = localtime(&newt);
+			if (newtmp != NULL)
+				newtm = *newtmp;
+			if ((tmp == NULL || newtmp == NULL) ? (tmp != newtmp) :
+				(delta(&newtm, &tm) != (newt - t) ||
 				newtm.tm_isdst != tm.tm_isdst ||
-				strcmp(abbr(&newtm), buf) != 0) {
+				strcmp(abbr(&newtm), buf) != 0)) {
 					newt = hunt(argv[i], t, newt);
-					newtm = *localtime(&newt);
-					(void) strlcpy(buf, abbr(&newtm),
-						(sizeof buf));
+					newtmp = localtime(&newt);
+					if (newtmp != NULL) {
+						newtm = *newtmp;
+						(void) strncpy(buf,
+							abbr(&newtm),
+							(sizeof buf) - 1);
+					}
 			}
 			t = newt;
 			tm = newtm;
+			tmp = newtmp;
 		}
-		/*
-		** Get highest value of t.
-		*/
-		t = ~((time_t) 0);
-		if (t < 0)		/* time_t is signed */
-			t &= ~hibit;
+		t = absolute_max_time;
 		t -= SECSPERHOUR * HOURSPERDAY;
 		show(argv[i], t, TRUE);
 		t += SECSPERHOUR * HOURSPERDAY;
@@ -272,37 +406,123 @@
 		err(EXIT_FAILURE, _("Error writing standard output"));
 	}
 	exit(EXIT_SUCCESS);
+	/* If exit fails to exit... */
+	return EXIT_FAILURE;
+}
 
-	/* gcc -Wall pacifier */
-	for ( ; ; )
-		continue;
+static void
+setabsolutes(void)
+{
+	if (0.5 == (time_t) 0.5) {
+		/*
+		** time_t is floating.
+		*/
+		if (sizeof (time_t) == sizeof (float)) {
+			absolute_min_time = (time_t) -FLT_MAX;
+			absolute_max_time = (time_t) FLT_MAX;
+		} else if (sizeof (time_t) == sizeof (double)) {
+			absolute_min_time = (time_t) -DBL_MAX;
+			absolute_max_time = (time_t) DBL_MAX;
+		} else {
+			(void) fprintf(stderr,
+_("%s: use of -v on system with floating time_t other than float or double\n"),
+				progname);
+			exit(EXIT_FAILURE);
+		}
+	} else if (0 > (time_t) -1) {
+		/*
+		** time_t is signed.  Assume overflow wraps around.
+		*/
+		time_t t = 0;
+		time_t t1 = 1;
+
+		while (t < t1) {
+			t = t1;
+			t1 = 2 * t1 + 1;
+		}
+
+		absolute_max_time = t;
+		t = -t;
+		absolute_min_time = t - 1;
+		if (t < absolute_min_time)
+			absolute_min_time = t;
+	} else {
+		/*
+		** time_t is unsigned.
+		*/
+		absolute_min_time = 0;
+		absolute_max_time = absolute_min_time - 1;
+	}
 }
 
 static time_t
-hunt(name, lot, hit)
-char *	name;
-time_t	lot;
-time_t	hit;
-{
-	time_t		t;
-	struct tm	lotm;
-	struct tm	tm;
-	static char	loab[MAX_STRING_LENGTH];
-
-	lotm = *localtime(&lot);
-	(void) strlcpy(loab, abbr(&lotm), (sizeof loab));
-	while ((hit - lot) >= 2) {
-		t = lot / 2 + hit / 2;
+yeartot(y)
+const long	y;
+{
+	register long	myy;
+	register long	seconds;
+	register time_t	t;
+
+	myy = EPOCH_YEAR;
+	t = 0;
+	while (myy != y) {
+		if (myy < y) {
+			seconds = isleap(myy) ? SECSPERLYEAR : SECSPERNYEAR;
+			++myy;
+			if (t > absolute_max_time - seconds) {
+				t = absolute_max_time;
+				break;
+			}
+			t += seconds;
+		} else {
+			--myy;
+			seconds = isleap(myy) ? SECSPERLYEAR : SECSPERNYEAR;
+			if (t < absolute_min_time + seconds) {
+				t = absolute_min_time;
+				break;
+			}
+			t -= seconds;
+		}
+	}
+	return t;
+}
+
+static time_t
+hunt(char *name, time_t lot, time_t hit)
+{
+	time_t			t;
+	long			diff;
+	struct tm		lotm;
+	register struct tm *	lotmp;
+	struct tm		tm;
+	register struct tm *	tmp;
+	char			loab[MAX_STRING_LENGTH];
+
+	lotmp = my_localtime(&lot);
+	if (lotmp != NULL) {
+		lotm = *lotmp;
+		(void) strncpy(loab, abbr(&lotm), (sizeof loab) - 1);
+	}
+	for ( ; ; ) {
+		diff = (long) (hit - lot);
+		if (diff < 2)
+			break;
+		t = lot;
+		t += diff / 2;
 		if (t <= lot)
 			++t;
 		else if (t >= hit)
 			--t;
-		tm = *localtime(&t);
-		if (delta(&tm, &lotm) == (t - lot) &&
+		tmp = my_localtime(&t);
+		if (tmp != NULL)
+			tm = *tmp;
+		if ((lotmp == NULL || tmp == NULL) ? (lotmp == tmp) :
+			(delta(&tm, &lotm) == (t - lot) &&
 			tm.tm_isdst == lotm.tm_isdst &&
-			strcmp(abbr(&tm), loab) == 0) {
+			strcmp(abbr(&tm), loab) == 0)) {
 				lot = t;
 				lotm = tm;
+				lotmp = tmp;
 		} else	hit = t;
 	}
 	show(name, lot, TRUE);
@@ -311,7 +531,7 @@
 }
 
 /*
-** Thanks to Paul Eggert (eggert@twinsun.com) for logic used in delta.
+** Thanks to Paul Eggert for logic used in delta.
 */
 
 static long
@@ -319,14 +539,14 @@
 struct tm *	newp;
 struct tm *	oldp;
 {
-	long	result;
-	int	tmy;
+	register long	result;
+	register int	tmy;
 
 	if (newp->tm_year < oldp->tm_year)
 		return -delta(oldp, newp);
 	result = 0;
 	for (tmy = oldp->tm_year; tmy < newp->tm_year; ++tmy)
-		result += DAYSPERNYEAR + isleap(tmy + TM_YEAR_BASE);
+		result += DAYSPERNYEAR + isleap_sum(tmy, TM_YEAR_BASE);
 	result += newp->tm_yday - oldp->tm_yday;
 	result *= HOURSPERDAY;
 	result += newp->tm_hour - oldp->tm_hour;
@@ -338,27 +558,36 @@
 }
 
 static void
-show(zone, t, v)
-char *	zone;
-time_t	t;
-int	v;
+show(char *zone, time_t t, int v)
 {
-	struct tm *	tmp;
+	register struct tm *	tmp;
 
 	(void) printf("%-*s  ", (int) longest, zone);
-	if (v)
-		(void) printf("%.24s UTC = ", asctime(gmtime(&t)));
-	tmp = localtime(&t);
-	(void) printf("%.24s", asctime(tmp));
-	if (*abbr(tmp) != '\0')
-		(void) printf(" %s", abbr(tmp));
 	if (v) {
-		(void) printf(" isdst=%d", tmp->tm_isdst);
+		tmp = gmtime(&t);
+		if (tmp == NULL) {
+			(void) printf(tformat(), t);
+		} else {
+			dumptime(tmp);
+			(void) printf(" UTC");
+		}
+		(void) printf(" = ");
+	}
+	tmp = my_localtime(&t);
+	dumptime(tmp);
+	if (tmp != NULL) {
+		if (*abbr(tmp) != '\0')
+			(void) printf(" %s", abbr(tmp));
+		if (v) {
+			(void) printf(" isdst=%d", tmp->tm_isdst);
 #ifdef TM_GMTOFF
-		(void) printf(" gmtoff=%ld", tmp->TM_GMTOFF);
+			(void) printf(" gmtoff=%ld", tmp->TM_GMTOFF);
 #endif /* defined TM_GMTOFF */
+		}
 	}
 	(void) printf("\n");
+	if (tmp != NULL && *abbr(tmp) != '\0')
+		abbrok(abbr(tmp), zone);
 }
 
 static const char *
@@ -373,3 +602,84 @@
 	result = tzname[tmp->tm_isdst];
 	return (result == NULL) ? &nada : result;
 }
+
+/*
+** The code below can fail on certain theoretical systems;
+** it works on all known real-world systems as of 2004-12-30.
+*/
+
+static const char *
+tformat(void)
+{
+	if (0.5 == (time_t) 0.5) {	/* floating */
+		if (sizeof (time_t) > sizeof (double))
+			return "%Lg";
+		return "%g";
+	}
+	if (0 > (time_t) -1) {		/* signed */
+		if (sizeof (time_t) > sizeof (long))
+			return "%lld";
+		if (sizeof (time_t) > sizeof (int))
+			return "%ld";
+		return "%d";
+	}
+	if (sizeof (time_t) > sizeof (unsigned long))
+		return "%llu";
+	if (sizeof (time_t) > sizeof (unsigned int))
+		return "%lu";
+	return "%u";
+}
+
+static void
+dumptime(timeptr)
+register const struct tm *	timeptr;
+{
+	static const char	wday_name[][3] = {
+		"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
+	};
+	static const char	mon_name[][3] = {
+		"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+		"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+	};
+	register const char *	wn;
+	register const char *	mn;
+	register int		lead;
+	register int		trail;
+
+	if (timeptr == NULL) {
+		(void) printf("NULL");
+		return;
+	}
+	/*
+	** The packaged versions of localtime and gmtime never put out-of-range
+	** values in tm_wday or tm_mon, but since this code might be compiled
+	** with other (perhaps experimental) versions, paranoia is in order.
+	*/
+	if (timeptr->tm_wday < 0 || timeptr->tm_wday >=
+		(int) (sizeof wday_name / sizeof wday_name[0]))
+			wn = "???";
+	else		wn = wday_name[timeptr->tm_wday];
+	if (timeptr->tm_mon < 0 || timeptr->tm_mon >=
+		(int) (sizeof mon_name / sizeof mon_name[0]))
+			mn = "???";
+	else		mn = mon_name[timeptr->tm_mon];
+	(void) printf("%.3s %.3s%3d %.2d:%.2d:%.2d ",
+		wn, mn,
+		timeptr->tm_mday, timeptr->tm_hour,
+		timeptr->tm_min, timeptr->tm_sec);
+#define DIVISOR	10
+	trail = timeptr->tm_year % DIVISOR + TM_YEAR_BASE % DIVISOR;
+	lead = timeptr->tm_year / DIVISOR + TM_YEAR_BASE / DIVISOR +
+		trail / DIVISOR;
+	trail %= DIVISOR;
+	if (trail < 0 && lead > 0) {
+		trail += DIVISOR;
+		--lead;
+	} else if (lead < 0 && trail > 0) {
+		trail -= DIVISOR;
+		++lead;
+	}
+	if (lead == 0)
+		(void) printf("%d", trail);
+	else	(void) printf("%d%d", lead, ((trail < 0) ? -trail : trail));
+}
Index: lib/libc/time/zic.8
===================================================================
RCS file: /cvsroot/src/lib/libc/time/zic.8,v
retrieving revision 1.15
diff -u -r1.15 zic.8
--- lib/libc/time/zic.8	9 Mar 2009 19:24:27 -0000	1.15
+++ lib/libc/time/zic.8	31 Dec 2009 20:52:25 -0000
@@ -222,7 +222,12 @@
 .El
 .Pp
 A zone line has the form
-.Dl Zone	NAME		GMTOFF	RULES/SAVE	FORMAT	[UNTIL]
+.sp
+.nf
+.ti +.5i
+.ta \w'Zone\0\0'u +\w'Australia/Adelaide\0\0'u +\w'GMTOFF\0\0'u +\w'RULES/SAVE\0\0'u +\w'FORMAT\0\0'u
+Zone	NAME	GMTOFF	RULES/SAVE	FORMAT	[UNTILYEAR [MONTH [DAY [TIME]]]]
+.sp
 For example:
 .Dl Zone	Australia/Adelaide	9:30	Aus	CST	1971 Oct 31 2:00
 The fields that make up a zone line are:
@@ -256,16 +261,17 @@
 a slash
 .Pq \&/
 separates standard and daylight abbreviations.
-.It UNTIL
+.TP
+.B UNTILYEAR [MONTH [DAY [TIME]]]
 The time at which the UTC offset or the rule(s) change for a location.
 It is specified as a year, a month, a day, and a time of day.
 If this is specified,
 the time zone information is generated from the given UTC offset
 and rule change until the time specified.
 The month, day, and time of day have the same format as the IN, ON, and AT
-columns of a rule; trailing columns can be omitted, and default to the
-earliest possible value for the missing columns.
-.El
+fields of a rule; trailing fields can be omitted, and default to the
+earliest possible value for the missing fields.
+.IP
 The next line must be a
 .Dq continuation
 line; this has the same form as a zone line except that the
@@ -273,11 +279,11 @@
 .Dq Zone
 and the name are omitted, as the continuation line will
 place information starting at the time specified as the
-.Em UNTIL
-field in the previous line in the file used by the previous line.
-Continuation lines may contain an
-.Em UNTIL
-field, just as zone lines do, indicating that the next line is a further
+.q until
+information in the previous line in the file used by the previous line.
+Continuation lines may contain
+.q until
+information, just as zone lines do, indicating that the next line is a further
 continuation.
 .Pp
 A link line has the form
@@ -338,13 +344,81 @@
 .Dq Rolling
 if the leap second time given by the other fields should be interpreted as
 local wall clock time.
-.El
-.Sh NOTES
+.SH "EXTENDED EXAMPLE"
+Here is an extended example of
+.I zic
+input, intended to illustrate many of its features.
+.br
+.ne 22
+.nf
+.in +2m
+.ta \w'# Rule\0\0'u +\w'NAME\0\0'u +\w'FROM\0\0'u +\w'1973\0\0'u +\w'TYPE\0\0'u +\w'Apr\0\0'u +\w'lastSun\0\0'u +\w'2:00\0\0'u +\w'SAVE\0\0'u
+.sp
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	Swiss	1940	only	-	Nov	2	0:00	1:00	S
+Rule	Swiss	1940	only	-	Dec	31	0:00	0	-
+Rule	Swiss	1941	1942	-	May	Sun>=1	2:00	1:00	S
+Rule	Swiss	1941	1942	-	Oct	Sun>=1	0:00	0
+.sp .5
+Rule	EU	1977	1980	-	Apr	Sun>=1	1:00u	1:00	S
+Rule	EU	1977	only	-	Sep	lastSun	1:00u	0	-
+Rule	EU	1978	only	-	Oct	 1	1:00u	0	-
+Rule	EU	1979	1995	-	Sep	lastSun	1:00u	0	-
+Rule	EU	1981	max	-	Mar	lastSun	1:00u	1:00	S
+Rule	EU	1996	max	-	Oct	lastSun	1:00u	0	-
+.sp
+.ta \w'# Zone\0\0'u +\w'Europe/Zurich\0\0'u +\w'0:34:08\0\0'u +\w'RULES/SAVE\0\0'u +\w'FORMAT\0\0'u
+# Zone	NAME	GMTOFF	RULES	FORMAT	UNTIL
+Zone	Europe/Zurich	0:34:08	-	LMT	1848 Sep 12
+		0:29:44	-	BMT	1894 Jun
+		1:00	Swiss	CE%sT	1981
+		1:00	EU	CE%sT
+.sp
+Link	Europe/Zurich	Switzerland
+.sp
+.in
+.fi
+In this example, the zone is named Europe/Zurich but it has an alias
+as Switzerland.  Zurich was 34 minutes and 8 seconds west of GMT until
+1848-09-12 at 00:00, when the offset changed to 29 minutes and 44
+seconds.  After 1894-06-01 at 00:00 Swiss daylight saving rules (defined
+with lines beginning with "Rule Swiss") apply, and the GMT offset
+became one hour.  From 1981 to the present, EU daylight saving rules have
+applied, and the UTC offset has remained at one hour.
+.PP
+In 1940, daylight saving time applied from November 2 at 00:00 to
+December 31 at 00:00.  In 1941 and 1942, daylight saving time applied
+from the first Sunday in May at 02:00 to the first Sunday in October
+at 00:00.
+The pre-1981 EU daylight-saving rules have no effect
+here, but are included for completeness.  Since 1981, daylight
+saving has begun on the last Sunday in March at 01:00 UTC.
+Until 1995 it ended the last Sunday in September at 01:00 UTC,
+but this changed to the last Sunday in October starting in 1996.
+.PP
+For purposes of
+display, "LMT" and "BMT" were initially used, respectively.  Since
+Swiss rules and later EU rules were applied, the display name for the
+timezone has been CET for standard time and CEST for daylight saving
+time.
+.SH NOTES
 For areas with more than two types of local time,
 you may need to use local standard time in the
 .Em AT
 field of the earliest transition time's rule to ensure that
 the earliest transition time recorded in the compiled file is correct.
+.PP
+If,
+for a particular zone,
+a clock advance caused by the start of daylight saving
+coincides with and is equal to
+a clock retreat caused by a change in UTC offset,
+.IR zic
+produces a single transition to daylight saving at the new UTC offset
+(without any change in wall clock time).
+To get separate transitions
+use multiple zone continuation lines
+specifying transition instants using universal time.
 .Sh FILES
 .Pa /usr/share/zoneinfo
 - standard directory used for created files
@@ -352,3 +426,6 @@
 .Xr ctime 3 ,
 .Xr tzfile 5 ,
 .Xr zdump 8
+.\" @(#)zic.8	8.5
+.\" This file is in the public domain, so clarified as of
+.\" 2009-05-17 by Arthur David Olson.
Index: lib/libc/time/zic.c
===================================================================
RCS file: /cvsroot/src/lib/libc/time/zic.c,v
retrieving revision 1.24
diff -u -r1.24 zic.c
--- lib/libc/time/zic.c	23 Apr 2009 01:39:47 -0000	1.24
+++ lib/libc/time/zic.c	31 Dec 2009 20:52:25 -0000
@@ -1,4 +1,8 @@
 /*	$NetBSD: zic.c,v 1.24 2009/04/23 01:39:47 lukem Exp $	*/
+/*
+** This file is in the public domain, so clarified as of
+** 2006-07-17 by Arthur David Olson.
+*/
 
 #include 
 #ifndef lint
@@ -7,12 +11,20 @@
 #endif /* !defined NOID */
 #endif /* !defined lint */
 
-static char	elsieid[] = "@(#)zic.c	7.116";
+static char	elsieid[] = "@(#)zic.c	8.20";
 
 #include "private.h"
 #include "locale.h"
 #include "tzfile.h"
 
+#define	ZIC_VERSION	'2'
+
+typedef int_fast64_t	zic_t;
+
+#ifndef ZIC_MAX_ABBR_LEN_WO_WARN
+#define ZIC_MAX_ABBR_LEN_WO_WARN	6
+#endif /* !defined ZIC_MAX_ABBR_LEN_WO_WARN */
+
 #if HAVE_SYS_STAT_H
 #include "sys/stat.h"
 #endif
@@ -26,7 +38,7 @@
 
 /*
 ** On some ancient hosts, predicates like `isspace(C)' are defined
-** only if isascii(C) || C == EOF.  Modern hosts obey the C Standard,
+** only if isascii(C) || C == EOF. Modern hosts obey the C Standard,
 ** which says they are defined only if C == ((unsigned char) C) || C == EOF.
 ** Neither the C Standard nor Posix require that `isascii' exist.
 ** For portability, we check both ancient and modern requirements.
@@ -37,6 +49,11 @@
 #define isascii(x) 1
 #endif
 
+#define OFFSET_STRLEN_MAXIMUM	(7 + INT_STRLEN_MAXIMUM(long))
+#define RULE_STRLEN_MAXIMUM	8	/* "Mdd.dd.d" */
+
+#define end(cp)	(strchr((cp), '\0'))
+
 struct rule {
 	const char *	r_filename;
 	int		r_linenum;
@@ -45,6 +62,8 @@
 	int		r_loyear;	/* for example, 1986 */
 	int		r_hiyear;	/* for example, 1986 */
 	const char *	r_yrtype;
+	int		r_lowasnum;
+	int		r_hiwasnum;
 
 	int		r_month;	/* 0..11 */
 
@@ -61,7 +80,7 @@
 	const char *	r_abbrvar;	/* variable part of abbreviation */
 
 	int		r_todo;		/* a rule to do (used in outzone) */
-	time_t		r_temp;		/* used in outzone */
+	zic_t		r_temp;		/* used in outzone */
 };
 
 /*
@@ -87,80 +106,88 @@
 	int		z_nrules;
 
 	struct rule	z_untilrule;
-	time_t		z_untiltime;
+	zic_t		z_untiltime;
 };
 
-extern int	getopt P((int argc, char * const argv[],
-			const char * options));
-extern int	link P((const char * fromname, const char * toname));
+extern int	getopt(int argc, char * const argv[],
+			const char * options);
+extern int	link(const char * fromname, const char * toname);
 extern char *	optarg;
 extern int	optind;
 
-static int	atcomp P((const void *, const void *));
-static void	addtt P((time_t starttime, int type));
-static int	addtype P((long gmtoff, const char * abbr, int isdst,
-				int ttisstd, int ttisgmt));
-static void	leapadd P((time_t t, int positive, int rolling, int count));
-static void	adjleap P((void));
-static void	associate P((void));
-static int	ciequal P((const char * ap, const char * bp));
-static void	convert P((long val, char * buf));
-static void	dolink P((const char * fromfile, const char * tofile));
-static void	doabbr P((char * abbr, int abbrlen, const char * format,
-			const char * letters, int isdst));
-static void	eat P((const char * name, int num));
-static void	eats P((const char * name, int num,
-			const char * rname, int rnum));
-static long	eitol P((int i));
-static void	error P((const char * message));
-static char **	getfields P((char * buf));
-static long	gethms P((const char * string, const char * errstrng,
-			int signable));
-static void	infile P((const char * filename));
-static void	inleap P((char ** fields, int nfields));
-static void	inlink P((char ** fields, int nfields));
-static void	inrule P((char ** fields, int nfields));
-static int	inzcont P((char ** fields, int nfields));
-static int	inzone P((char ** fields, int nfields));
-static int	inzsub P((char ** fields, int nfields, int iscont));
-static int	itsabbr P((const char * abbr, const char * word));
-static int	itsdir P((const char * name));
-static int	lowerit P((int c));
-int		main P((int, char **));
-static char *	memcheck P((char * tocheck));
-static int	mkdirs P((char * filename));
-static void	newabbr P((const char * abbr));
-static long	oadd P((long t1, long t2));
-static void	outzone P((const struct zone * zp, int ntzones));
-static void	puttzcode P((long code, FILE * fp));
-static int	rcomp P((const void * leftp, const void * rightp));
-static time_t	rpytime P((const struct rule * rp, int wantedy));
-static void	rulesub P((struct rule * rp,
+static void	addtt(zic_t starttime, int type);
+static int	addtype(long gmtoff, const char * abbr, int isdst,
+				int ttisstd, int ttisgmt);
+static void	leapadd(zic_t t, int positive, int rolling, int count);
+static void	adjleap(void);
+static void	associate(void);
+static int	ciequal(const char * ap, const char * bp);
+static void	convert(long val, char * buf);
+static void	convert64(zic_t val, char * buf);
+static void	dolink(const char * fromfield, const char * tofield);
+static void	doabbr(char * abbr, const int, const char * format,
+			const char * letters, int isdst, int doquotes);
+static void	eat(const char * name, int num);
+static void	eats(const char * name, int num,
+			const char * rname, int rnum);
+static long	eitol(int i);
+static void	error(const char * message);
+static char **	getfields(char * buf);
+static long	gethms(const char * string, const char * errstrng,
+			int signable);
+static void	infile(const char * filename);
+static void	inleap(char ** fields, int nfields);
+static void	inlink(char ** fields, int nfields);
+static void	inrule(char ** fields, int nfields);
+static int	inzcont(char ** fields, int nfields);
+static int	inzone(char ** fields, int nfields);
+static int	inzsub(char ** fields, int nfields, int iscont);
+static int	is32(zic_t x);
+static int	itsabbr(const char * abbr, const char * word);
+static int	itsdir(const char * name);
+static int	lowerit(int c);
+int		main(int, char **);
+static char *	memcheck(char * tocheck);
+static int	mkdirs(char * filename);
+static void	newabbr(const char * abbr);
+static long	oadd(long t1, long t2);
+static void	outzone(const struct zone * zp, int ntzones);
+static void	puttzcode(long code, FILE * fp);
+static void	puttzcode64(zic_t code, FILE * fp);
+static int	rcomp(const void * leftp, const void * rightp);
+static zic_t	rpytime(const struct rule * rp, int wantedy);
+static void	rulesub(struct rule * rp,
 			const char * loyearp, const char * hiyearp,
 			const char * typep, const char * monthp,
-			const char * dayp, const char * timep));
-static void	setboundaries P((void));
-static time_t	tadd P((time_t t1, long t2));
-static void	usage P((void));
-static void	warning P((const char * const));
-static void	writezone P((const char * name));
-static int	yearistype P((int year, const char * type));
-
-#if !(HAVE_STRERROR - 0)
-static char *	strerror P((int));
-#endif /* !(HAVE_STRERROR - 0) */
+			const char * dayp, const char * timep);
+static int 	stringoffset(char * result, long offset);
+static int	stringrule(char * result, const struct rule * rp,
+			long dstoff, long gmtoff);
+static void 	stringzone(char * result, const int,
+			const struct zone * zp, int ntzones);
+static void	setboundaries(void);
+static zic_t	tadd(zic_t t1, long t2);
+static void	usage(FILE *stream, int status);
+static void	warning(const char * const);
+static void	writezone(const char * name, const char * string);
+static int	yearistype(int year, const char * type);
+static int	atcomp(const void *avp, const void *bvp);
+static void	updateminmax(int x);
 
 static int		charcnt;
 static int		errors;
 static const char *	filename;
 static int		leapcnt;
+static int		leapseen;
+static int		leapminyear;
+static int		leapmaxyear;
 static int		linenum;
-static time_t		max_time;
+static int		max_abbrvar_len;
+static int		max_format_len;
+static zic_t		max_time;
 static int		max_year;
-static int		max_year_representable;
-static time_t		min_time;
+static zic_t		min_time;
 static int		min_year;
-static int		min_year_representable;
 static int		noise;
 static const char *	rfilename;
 static int		rlinenum;
@@ -270,8 +297,8 @@
 	const int	l_value;
 };
 
-static struct lookup const *	byword P((const char * string,
-					const struct lookup * lp));
+static struct lookup const *	byword(const char * string,
+					const struct lookup * lp);
 
 static struct lookup const	line_codes[] = {
 	{ "Rule",	LC_RULE },
@@ -348,7 +375,7 @@
 };
 
 static struct attype {
-	time_t		at;
+	zic_t		at;
 	unsigned char	type;
 }			attypes[TZ_MAX_TIMES];
 static long		gmtoffs[TZ_MAX_TYPES];
@@ -357,7 +384,7 @@
 static char		ttisstds[TZ_MAX_TYPES];
 static char		ttisgmts[TZ_MAX_TYPES];
 static char		chars[TZ_MAX_CHARS];
-static time_t		trans[TZ_MAX_LEAPS];
+static zic_t		trans[TZ_MAX_LEAPS];
 static long		corr[TZ_MAX_LEAPS];
 static char		roll[TZ_MAX_LEAPS];
 
@@ -374,7 +401,7 @@
 
 		(void) fprintf(stderr, _("%s: Memory exhausted: %s\n"),
 			progname, e);
-		(void) exit(EXIT_FAILURE);
+		exit(EXIT_FAILURE);
 	}
 	return ptr;
 }
@@ -388,19 +415,6 @@
 ** Error handling.
 */
 
-#if !(HAVE_STRERROR - 0)
-static char *
-strerror(errnum)
-int	errnum;
-{
-	extern char *	sys_errlist[];
-	extern int	sys_nerr;
-
-	return (errnum > 0 && errnum <= sys_nerr) ?
-		sys_errlist[errnum] : _("Unknown system error");
-}
-#endif /* !(HAVE_STRERROR - 0) */
-
 static void
 eats(name, num, rname, rnum)
 const char * const	name;
@@ -454,11 +468,15 @@
 }
 
 static void
-usage P((void))
+usage(FILE *stream, int status)
 {
-	(void) fprintf(stderr, _("%s: usage is %s [ --version ] [ -s ] [ -v ] [ -l localtime ] [ -p posixrules ] \\\n\t[ -d directory ] [ -L leapseconds ] [ -y yearistype ] [ filename ... ]\n"),
-		progname, progname);
-	(void) exit(EXIT_FAILURE);
+	(void) fprintf(stream, _("%s: usage is %s \
+[ --version ] [ --help ] [ -v ] [ -l localtime ] [ -p posixrules ] \\\n\
+\t[ -d directory ] [ -L leapseconds ] [ -y yearistype ] [ filename ... ]\n\
+\n\
+Report bugs to tz@elsie.nci.nih.gov.\n"),
+		       progname, progname);
+	exit(status);
 }
 
 static const char *	psxrules;
@@ -466,7 +484,6 @@
 static const char *	directory;
 static const char *	leapsec;
 static const char *	yitcommand;
-static int		sflag = FALSE;
 
 int
 main(argc, argv)
@@ -486,17 +503,24 @@
 	(void) bindtextdomain(TZ_DOMAIN, TZ_DOMAINDIR);
 #endif /* defined TEXTDOMAINDIR */
 	(void) textdomain(TZ_DOMAIN);
-#endif /* HAVE_GETTEXT - 0 */
+#endif /* HAVE_GETTEXT */
 	progname = argv[0];
+	if (TYPE_BIT(zic_t) < 64) {
+		(void) fprintf(stderr, "%s: %s\n", progname,
+			_("wild compilation-time specification of zic_t"));
+		exit(EXIT_FAILURE);
+	}
 	for (i = 1; i < argc; ++i)
 		if (strcmp(argv[i], "--version") == 0) {
 			(void) printf("%s\n", elsieid);
-			(void) exit(EXIT_SUCCESS);
+			exit(EXIT_SUCCESS);
+		} else if (strcmp(argv[i], "--help") == 0) {
+			usage(stdout, EXIT_SUCCESS);
 		}
 	while ((c = getopt(argc, argv, "d:l:p:L:vsy:")) != EOF && c != -1)
 		switch (c) {
 			default:
-				usage();
+				usage(stderr, EXIT_FAILURE);
 			case 'd':
 				if (directory == NULL)
 					directory = optarg;
@@ -504,7 +528,7 @@
 					(void) fprintf(stderr,
 _("%s: More than one -d option specified\n"),
 						progname);
-					(void) exit(EXIT_FAILURE);
+					exit(EXIT_FAILURE);
 				}
 				break;
 			case 'l':
@@ -514,7 +538,7 @@
 					(void) fprintf(stderr,
 _("%s: More than one -l option specified\n"),
 						progname);
-					(void) exit(EXIT_FAILURE);
+					exit(EXIT_FAILURE);
 				}
 				break;
 			case 'p':
@@ -524,7 +548,7 @@
 					(void) fprintf(stderr,
 _("%s: More than one -p option specified\n"),
 						progname);
-					(void) exit(EXIT_FAILURE);
+					exit(EXIT_FAILURE);
 				}
 				break;
 			case 'y':
@@ -534,7 +558,7 @@
 					(void) fprintf(stderr,
 _("%s: More than one -y option specified\n"),
 						progname);
-					(void) exit(EXIT_FAILURE);
+					exit(EXIT_FAILURE);
 				}
 				break;
 			case 'L':
@@ -544,18 +568,18 @@
 					(void) fprintf(stderr,
 _("%s: More than one -L option specified\n"),
 						progname);
-					(void) exit(EXIT_FAILURE);
+					exit(EXIT_FAILURE);
 				}
 				break;
 			case 'v':
 				noise = TRUE;
 				break;
 			case 's':
-				sflag = TRUE;
+				(void) printf("%s: -s ignored\n", progname);
 				break;
 		}
 	if (optind == argc - 1 && strcmp(argv[optind], "=") == 0)
-		usage();	/* usage message by request */
+		usage(stderr, EXIT_FAILURE);	/* usage message by request */
 	if (directory == NULL)
 		directory = TZDIR;
 	if (yitcommand == NULL)
@@ -571,7 +595,7 @@
 	for (i = optind; i < argc; ++i)
 		infile(argv[i]);
 	if (errors)
-		(void) exit(EXIT_FAILURE);
+		exit(EXIT_FAILURE);
 	associate();
 	for (i = 0; i < nzones; i = j) {
 		/*
@@ -587,6 +611,11 @@
 	for (i = 0; i < nlinks; ++i) {
 		eat(links[i].l_filename, links[i].l_linenum);
 		dolink(links[i].l_from, links[i].l_to);
+		if (noise)
+			for (j = 0; j < nlinks; ++j)
+				if (strcmp(links[i].l_to,
+					links[j].l_from) == 0)
+						warning(_("link to link"));
 	}
 	if (lcltime != NULL) {
 		eat("command line", 1);
@@ -600,26 +629,26 @@
 }
 
 static void
-dolink(fromfile, tofile)
-const char * const	fromfile;
-const char * const	tofile;
+dolink(fromfield, tofield)
+const char * const	fromfield;
+const char * const	tofield;
 {
 	register char *	fromname;
 	register char *	toname;
 
-	if (fromfile[0] == '/')
-		fromname = ecpyalloc(fromfile);
+	if (fromfield[0] == '/')
+		fromname = ecpyalloc(fromfield);
 	else {
 		fromname = ecpyalloc(directory);
 		fromname = ecatalloc(fromname, "/");
-		fromname = ecatalloc(fromname, fromfile);
+		fromname = ecatalloc(fromname, fromfield);
 	}
-	if (tofile[0] == '/')
-		toname = ecpyalloc(tofile);
+	if (tofield[0] == '/')
+		toname = ecpyalloc(tofield);
 	else {
 		toname = ecpyalloc(directory);
 		toname = ecatalloc(toname, "/");
-		toname = ecatalloc(toname, tofile);
+		toname = ecatalloc(toname, tofield);
 	}
 	/*
 	** We get to be careful here since
@@ -631,75 +660,54 @@
 		int	result;
 
 		if (mkdirs(toname) != 0)
-			(void) exit(EXIT_FAILURE);
+			exit(EXIT_FAILURE);
 
 		result = link(fromname, toname);
-#if (HAVE_SYMLINK - 0)
+#if HAVE_SYMLINK
 		if (result != 0 &&
-		    access(fromname, F_OK) == 0 &&
-		    !itsdir(fromname)) {
-		        const char *s = tofile;
-		        register char * symlinkcontents = NULL;
-		        while ((s = strchr(s+1, '/')) != NULL)
-			        symlinkcontents = ecatalloc(symlinkcontents, "../");
-			symlinkcontents = ecatalloc(symlinkcontents, fromfile);
-
-			result = symlink(symlinkcontents, toname);
-			if (result == 0)
+			access(fromname, F_OK) == 0 &&
+			!itsdir(fromname)) {
+				const char *s = tofield;
+				register char * symlinkcontents = NULL;
+
+				while ((s = strchr(s+1, '/')) != NULL)
+					symlinkcontents =
+						ecatalloc(symlinkcontents,
+						"../");
+				symlinkcontents =
+					ecatalloc(symlinkcontents,
+					fromname);
+				result = symlink(symlinkcontents,
+					toname);
+				if (result == 0)
 warning(_("hard link failed, symbolic link used"));
-			ifree(symlinkcontents);
+				ifree(symlinkcontents);
 		}
-#endif
+#endif /* HAVE_SYMLINK */
 		if (result != 0) {
 			const char *e = strerror(errno);
 
 			(void) fprintf(stderr,
 				_("%s: Can't link from %s to %s: %s\n"),
 				progname, fromname, toname, e);
-			(void) exit(EXIT_FAILURE);
+			exit(EXIT_FAILURE);
 		}
 	}
 	ifree(fromname);
 	ifree(toname);
 }
 
-#ifndef INT_MAX
-#define INT_MAX	((int) (((unsigned)~0)>>1))
-#endif /* !defined INT_MAX */
-
-#ifndef INT_MIN
-#define INT_MIN	((int) ~(((unsigned)~0)>>1))
-#endif /* !defined INT_MIN */
-
-/*
-** The tz file format currently allows at most 32-bit quantities.
-** This restriction should be removed before signed 32-bit values
-** wrap around in 2038, but unfortunately this will require a
-** change to the tz file format.
-*/
-
-#define MAX_BITS_IN_FILE	32
-#define TIME_T_BITS_IN_FILE	((TYPE_BIT(time_t) < MAX_BITS_IN_FILE) ? TYPE_BIT(time_t) : MAX_BITS_IN_FILE)
+#define TIME_T_BITS_IN_FILE	64
 
 static void
-setboundaries P((void))
+setboundaries(void)
 {
-	if (TYPE_SIGNED(time_t)) {
-		min_time = ~ (time_t) 0;
-		min_time <<= TIME_T_BITS_IN_FILE - 1;
-		max_time = ~ (time_t) 0 - min_time;
-		if (sflag)
-			min_time = 0;
-	} else {
-		min_time = 0;
-		max_time = 2 - sflag;
-		max_time <<= TIME_T_BITS_IN_FILE - 1;
-		--max_time;
-	}
-	min_year = TM_YEAR_BASE + gmtime(&min_time)->tm_year;
-	max_year = TM_YEAR_BASE + gmtime(&max_time)->tm_year;
-	min_year_representable = min_year;
-	max_year_representable = max_year;
+	register int	i;
+
+	min_time = -1;
+	for (i = 0; i < TIME_T_BITS_IN_FILE - 1; ++i)
+		min_time *= 2;
+	max_time = -(min_time + 1);
 }
 
 static int
@@ -734,7 +742,7 @@
 }
 
 static void
-associate P((void))
+associate(void)
 {
 	register struct zone *	zp;
 	register struct rule *	rp;
@@ -796,7 +804,7 @@
 			*/
 			eat(zp->z_filename, zp->z_linenum);
 			zp->z_stdoff = gethms(zp->z_rule, _("unruly zone"),
-					      TRUE);
+				TRUE);
 			/*
 			** Note, though, that if there's no rule,
 			** a '%s' in the format is a bad thing.
@@ -806,7 +814,7 @@
 		}
 	}
 	if (errors)
-		(void) exit(EXIT_FAILURE);
+		exit(EXIT_FAILURE);
 }
 
 static void
@@ -830,7 +838,7 @@
 
 		(void) fprintf(stderr, _("%s: Can't open %s: %s\n"),
 			progname, name, e);
-		(void) exit(EXIT_FAILURE);
+		exit(EXIT_FAILURE);
 	}
 	wantcont = FALSE;
 	for (num = 1; ; ++num) {
@@ -840,7 +848,7 @@
 		cp = strchr(buf, '\n');
 		if (cp == NULL) {
 			error(_("line too long"));
-			(void) exit(EXIT_FAILURE);
+			exit(EXIT_FAILURE);
 		}
 		*cp = '\0';
 		fields = getfields(buf);
@@ -884,7 +892,7 @@
 					(void) fprintf(stderr,
 _("%s: panic: Invalid l_value %d\n"),
 						progname, lp->l_value);
-					(void) exit(EXIT_FAILURE);
+					exit(EXIT_FAILURE);
 			}
 		}
 		ifree((char *) fields);
@@ -892,14 +900,14 @@
 	if (ferror(fp)) {
 		(void) fprintf(stderr, _("%s: Error reading %s\n"),
 			progname, filename);
-		(void) exit(EXIT_FAILURE);
+		exit(EXIT_FAILURE);
 	}
 	if (fp != stdin && fclose(fp)) {
 		const char *e = strerror(errno);
 
 		(void) fprintf(stderr, _("%s: Error closing %s: %s\n"),
 			progname, filename, e);
-		(void) exit(EXIT_FAILURE);
+		exit(EXIT_FAILURE);
 	}
 	if (wantcont)
 		error(_("expected continuation line not found"));
@@ -919,7 +927,8 @@
 const char * const	errstring;
 const int		signable;
 {
-	int	hh, mm, ss, sign;
+	long	hh;
+	int	mm, ss, sign;
 
 	if (string == NULL || *string == '\0')
 		return 0;
@@ -929,27 +938,32 @@
 		sign = -1;
 		++string;
 	} else	sign = 1;
-	if (sscanf(string, scheck(string, "%d"), &hh) == 1)
+	if (sscanf(string, scheck(string, "%ld"), &hh) == 1)
 		mm = ss = 0;
-	else if (sscanf(string, scheck(string, "%d:%d"), &hh, &mm) == 2)
+	else if (sscanf(string, scheck(string, "%ld:%d"), &hh, &mm) == 2)
 		ss = 0;
-	else if (sscanf(string, scheck(string, "%d:%d:%d"),
+	else if (sscanf(string, scheck(string, "%ld:%d:%d"),
 		&hh, &mm, &ss) != 3) {
 			error(errstring);
 			return 0;
 	}
-	if ((hh < 0 || hh >= HOURSPERDAY ||
+	if (hh < 0 ||
 		mm < 0 || mm >= MINSPERHOUR ||
-		ss < 0 || ss > SECSPERMIN) &&
-		!(hh == HOURSPERDAY && mm == 0 && ss == 0)) {
+		ss < 0 || ss > SECSPERMIN) {
 			error(errstring);
 			return 0;
 	}
-	if (noise && hh == HOURSPERDAY)
+	if (LONG_MAX / SECSPERHOUR < hh) {
+		error(_("time overflow"));
+		return 0;
+	}
+	if (noise && hh == HOURSPERDAY && mm == 0 && ss == 0)
 		warning(_("24:00 not handled by pre-1998 versions of zic"));
-	return eitol(sign) *
-		(eitol(hh * MINSPERHOUR + mm) *
-		eitol(SECSPERMIN) + eitol(ss));
+	if (noise && (hh > HOURSPERDAY ||
+		(hh == HOURSPERDAY && (mm != 0 || ss != 0))))
+warning(_("values over 24 hours not handled by pre-2007 versions of zic"));
+	return oadd(eitol(sign) * hh * eitol(SECSPERHOUR),
+		    eitol(sign) * (eitol(mm) * eitol(SECSPERMIN) + eitol(ss)));
 }
 
 static void
@@ -974,6 +988,8 @@
 		fields[RF_MONTH], fields[RF_DAY], fields[RF_TOD]);
 	r.r_name = ecpyalloc(fields[RF_NAME]);
 	r.r_abbrvar = ecpyalloc(fields[RF_ABBRVAR]);
+	if (max_abbrvar_len < strlen(r.r_abbrvar))
+		max_abbrvar_len = strlen(r.r_abbrvar);
 	rules = (struct rule *) (void *) erealloc((char *) rules,
 		(int) ((nrules + 1) * sizeof *rules));
 	rules[nrules++] = r;
@@ -1079,6 +1095,8 @@
 	}
 	z.z_rule = ecpyalloc(fields[i_rule]);
 	z.z_format = ecpyalloc(fields[i_format]);
+	if (max_format_len < strlen(z.z_format))
+		max_format_len = strlen(z.z_format);
 	hasuntil = nfields > i_untilyear;
 	if (hasuntil) {
 		z.z_untilrule.r_filename = filename;
@@ -1099,7 +1117,9 @@
 			zones[nzones - 1].z_untiltime > min_time &&
 			zones[nzones - 1].z_untiltime < max_time &&
 			zones[nzones - 1].z_untiltime >= z.z_untiltime) {
-				error(_("Zone continuation line end time is not after end time of previous line"));
+				error(_(
+"Zone continuation line end time is not after end time of previous line"
+					));
 				return FALSE;
 		}
 	}
@@ -1123,7 +1143,7 @@
 	register int			i, j;
 	int				year, month, day;
 	long				dayoff, tod;
-	time_t				t;
+	zic_t				t;
 
 	if (nfields != LEAP_FIELDS) {
 		error(_("wrong number of fields on Leap line"));
@@ -1132,12 +1152,17 @@
 	dayoff = 0;
 	cp = fields[LP_YEAR];
 	if (sscanf(cp, scheck(cp, "%d"), &year) != 1) {
-			/*
-			 * Leapin' Lizards!
-			 */
-			error(_("invalid leaping year"));
-			return;
+		/*
+		** Leapin' Lizards!
+		*/
+		error(_("invalid leaping year"));
+		return;
 	}
+	if (!leapseen || leapmaxyear < year)
+		leapmaxyear = year;
+	if (!leapseen || leapminyear > year)
+		leapminyear = year;
+	leapseen = TRUE;
 	j = EPOCH_YEAR;
 	while (j != year) {
 		if (year > j) {
@@ -1167,7 +1192,7 @@
 			return;
 	}
 	dayoff = oadd(dayoff, eitol(day - 1));
-	if (dayoff < 0 && !TYPE_SIGNED(time_t)) {
+	if (dayoff < 0 && !TYPE_SIGNED(zic_t)) {
 		error(_("time before zero"));
 		return;
 	}
@@ -1179,7 +1204,7 @@
 		error(_("time too large"));
 		return;
 	}
-	t = (time_t) dayoff * SECSPERDAY;
+	t = (zic_t) dayoff * SECSPERDAY;
 	tod = gethms(fields[LP_TIME], _("invalid time of day"), FALSE);
 	cp = fields[LP_CORR];
 	{
@@ -1203,7 +1228,9 @@
 			return;
 		}
 		if ((lp = byword(fields[LP_ROLL], leap_types)) == NULL) {
-			error(_("illegal Rolling/Stationary field on Leap line"));
+			error(_(
+				"illegal Rolling/Stationary field on Leap line"
+				));
 			return;
 		}
 		leapadd(tadd(t, tod), positive, lp->l_value, count);
@@ -1290,7 +1317,8 @@
 	*/
 	cp = loyearp;
 	lp = byword(cp, begin_years);
-	if (lp != NULL) switch ((int) lp->l_value) {
+	rp->r_lowasnum = lp == NULL;
+	if (!rp->r_lowasnum) switch ((int) lp->l_value) {
 		case YR_MINIMUM:
 			rp->r_loyear = INT_MIN;
 			break;
@@ -1301,18 +1329,15 @@
 			(void) fprintf(stderr,
 				_("%s: panic: Invalid l_value %d\n"),
 				progname, lp->l_value);
-			(void) exit(EXIT_FAILURE);
+			exit(EXIT_FAILURE);
 	} else if (sscanf(cp, scheck(cp, "%d"), &rp->r_loyear) != 1) {
 		error(_("invalid starting year"));
 		return;
-	} else if (noise) {
-		if (rp->r_loyear < min_year_representable)
-			warning(_("starting year too low to be represented"));
-		else if (rp->r_loyear > max_year_representable)
-			warning(_("starting year too high to be represented"));
 	}
 	cp = hiyearp;
-	if ((lp = byword(cp, end_years)) != NULL) switch ((int) lp->l_value) {
+	lp = byword(cp, end_years);
+	rp->r_hiwasnum = lp == NULL;
+	if (!rp->r_hiwasnum) switch ((int) lp->l_value) {
 		case YR_MINIMUM:
 			rp->r_hiyear = INT_MIN;
 			break;
@@ -1326,15 +1351,10 @@
 			(void) fprintf(stderr,
 				_("%s: panic: Invalid l_value %d\n"),
 				progname, lp->l_value);
-			(void) exit(EXIT_FAILURE);
+			exit(EXIT_FAILURE);
 	} else if (sscanf(cp, scheck(cp, "%d"), &rp->r_hiyear) != 1) {
 		error(_("invalid ending year"));
 		return;
-	} else if (noise) {
-		if (rp->r_loyear < min_year_representable)
-			warning(_("ending year too low to be represented"));
-		else if (rp->r_loyear > max_year_representable)
-			warning(_("ending year too high to be represented"));
 	}
 	if (rp->r_loyear > rp->r_hiyear) {
 		error(_("starting year greater than ending year"));
@@ -1349,8 +1369,6 @@
 		}
 		rp->r_yrtype = ecpyalloc(typep);
 	}
-	if (rp->r_loyear < min_year && rp->r_loyear > 0)
-		min_year = rp->r_loyear;
 	/*
 	** Day work.
 	** Accept things such as:
@@ -1404,13 +1422,25 @@
 char * const	buf;
 {
 	register int	i;
-	register long	shift;
+	register int	shift;
 
 	for (i = 0, shift = 24; i < 4; ++i, shift -= 8)
 		buf[i] = val >> shift;
 }
 
 static void
+convert64(val, buf)
+const zic_t	val;
+char * const	buf;
+{
+	register int	i;
+	register int	shift;
+
+	for (i = 0, shift = 56; i < 8; ++i, shift -= 8)
+		buf[i] = val >> shift;
+}
+
+static void
 puttzcode(val, fp)
 const long	val;
 FILE * const	fp;
@@ -1421,28 +1451,50 @@
 	(void) fwrite((void *) buf, (size_t) sizeof buf, (size_t) 1, fp);
 }
 
+static void
+puttzcode64(val, fp)
+const zic_t	val;
+FILE * const	fp;
+{
+	char	buf[8];
+
+	convert64(val, buf);
+	(void) fwrite((void *) buf, (size_t) sizeof buf, (size_t) 1, fp);
+}
+
 static int
 atcomp(avp, bvp)
 const void *	avp;
 const void *	bvp;
 {
-	if (((const struct attype *) avp)->at < ((const struct attype *) bvp)->at)
-		return -1;
-	else if (((const struct attype *) avp)->at > ((const struct attype *) bvp)->at)
-		return 1;
-	else	return 0;
+	const zic_t	a = ((const struct attype *) avp)->at;
+	const zic_t	b = ((const struct attype *) bvp)->at;
+
+	return (a < b) ? -1 : (a > b);
+}
+
+static int
+is32(x)
+const zic_t	x;
+{
+	return INT32_MIN <= x && x <= INT32_MAX;
 }
 
 static void
-writezone(name)
+writezone(name, string)
 const char * const	name;
+const char * const	string;
 {
-	register FILE *		fp;
-	register int		i, j;
-	static char *		fullname;
-	static struct tzhead	tzh;
-	time_t			ats[TZ_MAX_TIMES];
-	unsigned char		types[TZ_MAX_TIMES];
+	register FILE *			fp;
+	register int			i, j;
+	register int			leapcnt32, leapi32;
+	register int			timecnt32, timei32;
+	register int			pass;
+	static char *			fullname;
+	static const struct tzhead	tzh0;
+	static struct tzhead		tzh;
+	zic_t				ats[TZ_MAX_TIMES];
+	unsigned char			types[TZ_MAX_TIMES];
 
 	/*
 	** Sort.
@@ -1465,14 +1517,13 @@
 			while (fromi < timecnt && attypes[fromi].type == 0)
 				++fromi;	/* handled by default rule */
 		for ( ; fromi < timecnt; ++fromi) {
-			if (toi != 0
-			    && ((attypes[fromi].at
-				 + gmtoffs[attypes[toi - 1].type])
-				<= (attypes[toi - 1].at
-				    + gmtoffs[toi == 1 ? 0
-					      : attypes[toi - 2].type]))) {
-				attypes[toi - 1].type = attypes[fromi].type;
-				continue;
+			if (toi != 0 && ((attypes[fromi].at +
+				gmtoffs[attypes[toi - 1].type]) <=
+				(attypes[toi - 1].at + gmtoffs[toi == 1 ? 0
+				: attypes[toi - 2].type]))) {
+					attypes[toi - 1].type =
+						attypes[fromi].type;
+					continue;
 			}
 			if (toi == 0 ||
 				attypes[toi - 1].type != attypes[fromi].type)
@@ -1487,6 +1538,36 @@
 		ats[i] = attypes[i].at;
 		types[i] = attypes[i].type;
 	}
+	/*
+	** Correct for leap seconds.
+	*/
+	for (i = 0; i < timecnt; ++i) {
+		j = leapcnt;
+		while (--j >= 0)
+			if (ats[i] > trans[j] - corr[j]) {
+				ats[i] = tadd(ats[i], corr[j]);
+				break;
+			}
+	}
+	/*
+	** Figure out 32-bit-limited starts and counts.
+	*/
+	timecnt32 = timecnt;
+	timei32 = 0;
+	leapcnt32 = leapcnt;
+	leapi32 = 0;
+	while (timecnt32 > 0 && !is32(ats[timecnt32 - 1]))
+		--timecnt32;
+	while (timecnt32 > 0 && !is32(ats[timei32])) {
+		--timecnt32;
+		++timei32;
+	}
+	while (leapcnt32 > 0 && !is32(trans[leapcnt32 - 1]))
+		--leapcnt32;
+	while (leapcnt32 > 0 && !is32(trans[leapi32])) {
+		--leapcnt32;
+		++leapi32;
+	}
 	fullname = erealloc(fullname,
 		(int) (strlen(directory) + 1 + strlen(name) + 1));
 	(void) sprintf(fullname, "%s/%s", directory, name);	/* XXX: sprintf is safe */
@@ -1498,104 +1579,391 @@
 
 		(void) fprintf(stderr, _("%s: Can't remove %s: %s\n"),
 			progname, fullname, e);
-		(void) exit(EXIT_FAILURE);
+		exit(EXIT_FAILURE);
 	}
 	if ((fp = fopen(fullname, "wb")) == NULL) {
 		if (mkdirs(fullname) != 0)
-			(void) exit(EXIT_FAILURE);
+			exit(EXIT_FAILURE);
 		if ((fp = fopen(fullname, "wb")) == NULL) {
 			const char *e = strerror(errno);
 
 			(void) fprintf(stderr, _("%s: Can't create %s: %s\n"),
 				progname, fullname, e);
-			(void) exit(EXIT_FAILURE);
+			exit(EXIT_FAILURE);
 		}
 	}
-	convert(eitol(typecnt), tzh.tzh_ttisgmtcnt);
-	convert(eitol(typecnt), tzh.tzh_ttisstdcnt);
-	convert(eitol(leapcnt), tzh.tzh_leapcnt);
-	convert(eitol(timecnt), tzh.tzh_timecnt);
-	convert(eitol(typecnt), tzh.tzh_typecnt);
-	convert(eitol(charcnt), tzh.tzh_charcnt);
-	(void) strncpy(tzh.tzh_magic, TZ_MAGIC, sizeof tzh.tzh_magic);
-#define DO(field)	(void) fwrite((void *) tzh.field, (size_t) sizeof tzh.field, (size_t) 1, fp)
-	DO(tzh_magic);
-	DO(tzh_reserved);
-	DO(tzh_ttisgmtcnt);
-	DO(tzh_ttisstdcnt);
-	DO(tzh_leapcnt);
-	DO(tzh_timecnt);
-	DO(tzh_typecnt);
-	DO(tzh_charcnt);
+	for (pass = 1; pass <= 2; ++pass) {
+		register int	thistimei, thistimecnt;
+		register int	thisleapi, thisleapcnt;
+		register int	thistimelim, thisleaplim;
+		int		writetype[TZ_MAX_TIMES];
+		int		typemap[TZ_MAX_TYPES];
+		register int	thistypecnt;
+		char		thischars[TZ_MAX_CHARS];
+		char		thischarcnt;
+		int 		indmap[TZ_MAX_CHARS];
+
+		if (pass == 1) {
+			thistimei = timei32;
+			thistimecnt = timecnt32;
+			thisleapi = leapi32;
+			thisleapcnt = leapcnt32;
+		} else {
+			thistimei = 0;
+			thistimecnt = timecnt;
+			thisleapi = 0;
+			thisleapcnt = leapcnt;
+		}
+		thistimelim = thistimei + thistimecnt;
+		thisleaplim = thisleapi + thisleapcnt;
+		for (i = 0; i < typecnt; ++i)
+			writetype[i] = thistimecnt == timecnt;
+		if (thistimecnt == 0) {
+			/*
+			** No transition times fall in the current
+			** (32- or 64-bit) window.
+			*/
+			if (typecnt != 0)
+				writetype[typecnt - 1] = TRUE;
+		} else {
+			for (i = thistimei - 1; i < thistimelim; ++i)
+				if (i >= 0)
+					writetype[types[i]] = TRUE;
+			/*
+			** For America/Godthab and Antarctica/Palmer
+			*/
+			if (thistimei == 0)
+				writetype[0] = TRUE;
+		}
+		thistypecnt = 0;
+		for (i = 0; i < typecnt; ++i)
+			typemap[i] = writetype[i] ?  thistypecnt++ : -1;
+		for (i = 0; i < sizeof indmap / sizeof indmap[0]; ++i)
+			indmap[i] = -1;
+		thischarcnt = 0;
+		for (i = 0; i < typecnt; ++i) {
+			register char *	thisabbr;
+
+			if (!writetype[i])
+				continue;
+			if (indmap[abbrinds[i]] >= 0)
+				continue;
+			thisabbr = &chars[abbrinds[i]];
+			for (j = 0; j < thischarcnt; ++j)
+				if (strcmp(&thischars[j], thisabbr) == 0)
+					break;
+			if (j == thischarcnt) {
+				(void) strcpy(&thischars[(int) thischarcnt],
+					thisabbr);
+				thischarcnt += strlen(thisabbr) + 1;
+			}
+			indmap[abbrinds[i]] = j;
+		}
+#define DO(field)	(void) fwrite((void *) tzh.field, \
+				(size_t) sizeof tzh.field, (size_t) 1, fp)
+		tzh = tzh0;
+		(void) strncpy(tzh.tzh_magic, TZ_MAGIC, sizeof tzh.tzh_magic);
+		tzh.tzh_version[0] = ZIC_VERSION;
+		convert(eitol(thistypecnt), tzh.tzh_ttisgmtcnt);
+		convert(eitol(thistypecnt), tzh.tzh_ttisstdcnt);
+		convert(eitol(thisleapcnt), tzh.tzh_leapcnt);
+		convert(eitol(thistimecnt), tzh.tzh_timecnt);
+		convert(eitol(thistypecnt), tzh.tzh_typecnt);
+		convert(eitol(thischarcnt), tzh.tzh_charcnt);
+		DO(tzh_magic);
+		DO(tzh_version);
+		DO(tzh_reserved);
+		DO(tzh_ttisgmtcnt);
+		DO(tzh_ttisstdcnt);
+		DO(tzh_leapcnt);
+		DO(tzh_timecnt);
+		DO(tzh_typecnt);
+		DO(tzh_charcnt);
 #undef DO
-	for (i = 0; i < timecnt; ++i) {
-		j = leapcnt;
-		while (--j >= 0)
-			if (ats[i] >= trans[j]) {
-				ats[i] = tadd(ats[i], corr[j]);
-				break;
+		for (i = thistimei; i < thistimelim; ++i)
+			if (pass == 1)
+				puttzcode((long) ats[i], fp);
+			else	puttzcode64(ats[i], fp);
+		for (i = thistimei; i < thistimelim; ++i) {
+			unsigned char	uc;
+
+			uc = typemap[types[i]];
+			(void) fwrite((void *) &uc,
+				(size_t) sizeof uc,
+				(size_t) 1,
+				fp);
+		}
+		for (i = 0; i < typecnt; ++i)
+			if (writetype[i]) {
+				puttzcode(gmtoffs[i], fp);
+				(void) putc(isdsts[i], fp);
+				(void) putc((unsigned char) indmap[abbrinds[i]], fp);
 			}
-		puttzcode((long) ats[i], fp);
+		if (thischarcnt != 0)
+			(void) fwrite((void *) thischars,
+				(size_t) sizeof thischars[0],
+				(size_t) thischarcnt, fp);
+		for (i = thisleapi; i < thisleaplim; ++i) {
+			register zic_t	todo;
+
+			if (roll[i]) {
+				if (timecnt == 0 || trans[i] < ats[0]) {
+					j = 0;
+					while (isdsts[j])
+						if (++j >= typecnt) {
+							j = 0;
+							break;
+						}
+				} else {
+					j = 1;
+					while (j < timecnt &&
+						trans[i] >= ats[j])
+							++j;
+					j = types[j - 1];
+				}
+				todo = tadd(trans[i], -gmtoffs[j]);
+			} else	todo = trans[i];
+			if (pass == 1)
+				puttzcode((long) todo, fp);
+			else	puttzcode64(todo, fp);
+			puttzcode(corr[i], fp);
+		}
+		for (i = 0; i < typecnt; ++i)
+			if (writetype[i])
+				(void) putc(ttisstds[i], fp);
+		for (i = 0; i < typecnt; ++i)
+			if (writetype[i])
+				(void) putc(ttisgmts[i], fp);
 	}
-	if (timecnt > 0)
-		(void) fwrite((void *) types, (size_t) sizeof types[0],
-			(size_t) timecnt, fp);
-	for (i = 0; i < typecnt; ++i) {
-		puttzcode((long) gmtoffs[i], fp);
-		(void) putc(isdsts[i], fp);
-		(void) putc(abbrinds[i], fp);
-	}
-	if (charcnt != 0)
-		(void) fwrite((void *) chars, (size_t) sizeof chars[0],
-			(size_t) charcnt, fp);
-	for (i = 0; i < leapcnt; ++i) {
-		if (roll[i]) {
-			if (timecnt == 0 || trans[i] < ats[0]) {
-				j = 0;
-				while (isdsts[j])
-					if (++j >= typecnt) {
-						j = 0;
-						break;
-					}
-			} else {
-				j = 1;
-				while (j < timecnt && trans[i] >= ats[j])
-					++j;
-				j = types[j - 1];
-			}
-			puttzcode((long) tadd(trans[i], -gmtoffs[j]), fp);
-		} else	puttzcode((long) trans[i], fp);
-		puttzcode((long) corr[i], fp);
-	}
-	for (i = 0; i < typecnt; ++i)
-		(void) putc(ttisstds[i], fp);
-	for (i = 0; i < typecnt; ++i)
-		(void) putc(ttisgmts[i], fp);
+	(void) fprintf(fp, "\n%s\n", string);
 	if (ferror(fp) || fclose(fp)) {
 		(void) fprintf(stderr, _("%s: Error writing %s\n"),
 			progname, fullname);
-		(void) exit(EXIT_FAILURE);
+		exit(EXIT_FAILURE);
 	}
 }
 
 static void
-doabbr(abbr, abbrlen, format, letters, isdst)
+doabbr(abbr, abbrlen, format, letters, isdst, doquotes)
 char * const		abbr;
 const int		abbrlen;
 const char * const	format;
 const char * const	letters;
 const int		isdst;
+const int		doquotes;
 {
-	if (strchr(format, '/') == NULL) {
+	register char *	cp;
+	register char *	slashp;
+	register int	len;
+
+	slashp = strchr(format, '/');
+	if (slashp == NULL) {
 		if (letters == NULL)
-			(void)strncpy(abbr, format, abbrlen - 1);
-		else	
-			(void)snprintf(abbr, abbrlen, format, letters);
-	} else if (isdst)
-		(void)strncpy(abbr, strchr(format, '/') + 1, abbrlen - 1);
-	else {
-		(void)strncpy(abbr, format, abbrlen - 1);
-		*strchr(abbr, '/') = '\0';
+			(void) strlcpy(abbr, format, abbrlen);
+		else	(void) snprintf(abbr, abbrlen, format, letters);
+	} else if (isdst) {
+		(void) strlcpy(abbr, slashp + 1, abbrlen);
+	} else {
+		if (slashp > format)
+			(void) strncpy(abbr, format,
+				(unsigned) (slashp - format));
+		abbr[slashp - format] = '\0';
+	}
+	if (!doquotes)
+		return;
+	for (cp = abbr; *cp != '\0'; ++cp)
+		if (strchr("ABCDEFGHIJKLMNOPQRSTUVWXYZ", *cp) == NULL &&
+			strchr("abcdefghijklmnopqrstuvwxyz", *cp) == NULL)
+				break;
+	len = strlen(abbr);
+	if (len > 0 && *cp == '\0')
+		return;
+	abbr[len + 2] = '\0';
+	abbr[len + 1] = '>';
+	for ( ; len > 0; --len)
+		abbr[len] = abbr[len - 1];
+	abbr[0] = '<';
+}
+
+static void
+updateminmax(x)
+const int	x;
+{
+	if (min_year > x)
+		min_year = x;
+	if (max_year < x)
+		max_year = x;
+}
+
+static int
+stringoffset(result, offset)
+char *	result;
+long	offset;
+{
+	register int	hours;
+	register int	minutes;
+	register int	seconds;
+
+	result[0] = '\0';
+	if (offset < 0) {
+		(void) strcpy(result, "-");
+		offset = -offset;
+	}
+	seconds = offset % SECSPERMIN;
+	offset /= SECSPERMIN;
+	minutes = offset % MINSPERHOUR;
+	offset /= MINSPERHOUR;
+	hours = offset;
+	if (hours >= HOURSPERDAY) {
+		result[0] = '\0';
+		return -1;
+	}
+	(void) sprintf(end(result), "%d", hours);
+	if (minutes != 0 || seconds != 0) {
+		(void) sprintf(end(result), ":%02d", minutes);
+		if (seconds != 0)
+			(void) sprintf(end(result), ":%02d", seconds);
+	}
+	return 0;
+}
+
+static int
+stringrule(result, rp, dstoff, gmtoff)
+char *				result;
+const struct rule * const	rp;
+const long			dstoff;
+const long			gmtoff;
+{
+	register long	tod;
+
+	result = end(result);
+	if (rp->r_dycode == DC_DOM) {
+		register int	month, total;
+
+		if (rp->r_dayofmonth == 29 && rp->r_month == TM_FEBRUARY)
+			return -1;
+		total = 0;
+		for (month = 0; month < rp->r_month; ++month)
+			total += len_months[0][month];
+		(void) sprintf(result, "J%d", total + rp->r_dayofmonth);
+	} else {
+		register int	week;
+
+		if (rp->r_dycode == DC_DOWGEQ) {
+			week = 1 + rp->r_dayofmonth / DAYSPERWEEK;
+			if ((week - 1) * DAYSPERWEEK + 1 != rp->r_dayofmonth)
+				return -1;
+		} else if (rp->r_dycode == DC_DOWLEQ) {
+			if (rp->r_dayofmonth == len_months[1][rp->r_month])
+				week = 5;
+			else {
+				week = 1 + rp->r_dayofmonth / DAYSPERWEEK;
+				if (week * DAYSPERWEEK - 1 != rp->r_dayofmonth)
+					return -1;
+			}
+		} else	return -1;	/* "cannot happen" */
+		(void) sprintf(result, "M%d.%d.%d",
+			rp->r_month + 1, week, rp->r_wday);
+	}
+	tod = rp->r_tod;
+	if (rp->r_todisgmt)
+		tod += gmtoff;
+	if (rp->r_todisstd && rp->r_stdoff == 0)
+		tod += dstoff;
+	if (tod < 0) {
+		result[0] = '\0';
+		return -1;
+	}
+	if (tod != 2 * SECSPERMIN * MINSPERHOUR) {
+		(void) strcat(result, "/");
+		if (stringoffset(end(result), tod) != 0)
+			return -1;
+	}
+	return 0;
+}
+
+static void
+stringzone(result, resultlen, zpfirst, zonecount)
+char *				result;
+const int			resultlen;
+const struct zone * const	zpfirst;
+const int			zonecount;
+{
+	register const struct zone *	zp;
+	register struct rule *		rp;
+	register struct rule *		stdrp;
+	register struct rule *		dstrp;
+	register int			i;
+	register const char *		abbrvar;
+
+	result[0] = '\0';
+	zp = zpfirst + zonecount - 1;
+	stdrp = dstrp = NULL;
+	for (i = 0; i < zp->z_nrules; ++i) {
+		rp = &zp->z_rules[i];
+		if (rp->r_hiwasnum || rp->r_hiyear != INT_MAX)
+			continue;
+		if (rp->r_yrtype != NULL)
+			continue;
+		if (rp->r_stdoff == 0) {
+			if (stdrp == NULL)
+				stdrp = rp;
+			else	return;
+		} else {
+			if (dstrp == NULL)
+				dstrp = rp;
+			else	return;
+		}
+	}
+	if (stdrp == NULL && dstrp == NULL) {
+		/*
+		** There are no rules running through "max".
+		** Let's find the latest rule.
+		*/
+		for (i = 0; i < zp->z_nrules; ++i) {
+			rp = &zp->z_rules[i];
+			if (stdrp == NULL || rp->r_hiyear > stdrp->r_hiyear ||
+				(rp->r_hiyear == stdrp->r_hiyear &&
+				rp->r_month > stdrp->r_month))
+					stdrp = rp;
+		}
+		if (stdrp != NULL && stdrp->r_stdoff != 0)
+			return;	/* We end up in DST (a POSIX no-no). */
+		/*
+		** Horrid special case: if year is 2037,
+		** presume this is a zone handled on a year-by-year basis;
+		** do not try to apply a rule to the zone.
+		*/
+		if (stdrp != NULL && stdrp->r_hiyear == 2037)
+			return;
+	}
+	if (stdrp == NULL && (zp->z_nrules != 0 || zp->z_stdoff != 0))
+		return;
+	abbrvar = (stdrp == NULL) ? "" : stdrp->r_abbrvar;
+	doabbr(result, resultlen, zp->z_format, abbrvar, FALSE, TRUE);
+	if (stringoffset(end(result), -zp->z_gmtoff) != 0) {
+		result[0] = '\0';
+		return;
+	}
+	if (dstrp == NULL)
+		return;
+	doabbr(end(result), resultlen - strlen(result),
+		zp->z_format, dstrp->r_abbrvar, TRUE, TRUE);
+	if (dstrp->r_stdoff != SECSPERMIN * MINSPERHOUR)
+		if (stringoffset(end(result),
+			-(zp->z_gmtoff + dstrp->r_stdoff)) != 0) {
+				result[0] = '\0';
+				return;
+		}
+	(void) strcat(result, ",");
+	if (stringrule(result, dstrp, dstrp->r_stdoff, zp->z_gmtoff) != 0) {
+		result[0] = '\0';
+		return;
+	}
+	(void) strcat(result, ",");
+	if (stringrule(result, stdrp, dstrp->r_stdoff, zp->z_gmtoff) != 0) {
+		result[0] = '\0';
+		return;
 	}
 }
 
@@ -1608,7 +1976,7 @@
 	register struct rule *		rp;
 	register int			i, j;
 	register int			usestart, useuntil;
-	register time_t			starttime, untiltime;
+	register zic_t			starttime, untiltime;
 	register long			gmtoff;
 	register long			stdoff;
 	register int			year;
@@ -1616,8 +1984,17 @@
 	register int			startttisstd;
 	register int			startttisgmt;
 	register int			type;
-	char				startbuf[BUFSIZ];
-
+	register char *			startbuf;
+	register char *			ab;
+	register char *			envvar;
+	register int			max_abbr_len;
+	register int			max_envvar_len;
+
+	max_abbr_len = 2 + max_format_len + max_abbrvar_len;
+	max_envvar_len = 2 * max_abbr_len + 5 * 9;
+	startbuf = emalloc(max_abbr_len + 1);
+	ab = emalloc(max_abbr_len + 1);
+	envvar = emalloc(max_envvar_len + 1);
 	INITIALIZE(untiltime);
 	INITIALIZE(starttime);
 	/*
@@ -1627,11 +2004,57 @@
 	typecnt = 0;
 	charcnt = 0;
 	/*
-	** Thanks to Earl Chew (earl@dnd.icp.nec.com.au)
+	** Thanks to Earl Chew
 	** for noting the need to unconditionally initialize startttisstd.
 	*/
 	startttisstd = FALSE;
 	startttisgmt = FALSE;
+	min_year = max_year = EPOCH_YEAR;
+	if (leapseen) {
+		updateminmax(leapminyear);
+		updateminmax(leapmaxyear + (leapmaxyear < INT_MAX));
+	}
+	for (i = 0; i < zonecount; ++i) {
+		zp = &zpfirst[i];
+		if (i < zonecount - 1)
+			updateminmax(zp->z_untilrule.r_loyear);
+		for (j = 0; j < zp->z_nrules; ++j) {
+			rp = &zp->z_rules[j];
+			if (rp->r_lowasnum)
+				updateminmax(rp->r_loyear);
+			if (rp->r_hiwasnum)
+				updateminmax(rp->r_hiyear);
+		}
+	}
+	/*
+	** Generate lots of data if a rule can't cover all future times.
+	*/
+	stringzone(envvar, max_envvar_len+1, zpfirst, zonecount);
+	if (noise && envvar[0] == '\0') {
+		register char *	wp;
+
+wp = ecpyalloc(_("no POSIX environment variable for zone"));
+		wp = ecatalloc(wp, " ");
+		wp = ecatalloc(wp, zpfirst->z_name);
+		warning(wp);
+		ifree(wp);
+	}
+	if (envvar[0] == '\0') {
+		if (min_year >= INT_MIN + YEARSPERREPEAT)
+			min_year -= YEARSPERREPEAT;
+		else	min_year = INT_MIN;
+		if (max_year <= INT_MAX - YEARSPERREPEAT)
+			max_year += YEARSPERREPEAT;
+		else	max_year = INT_MAX;
+	}
+	/*
+	** For the benefit of older systems,
+	** generate data from 1900 through 2037.
+	*/
+	if (min_year > 1900)
+		min_year = 1900;
+	if (max_year < 2037)
+		max_year = 2037;
 	for (i = 0; i < zonecount; ++i) {
 		/*
 		** A guess that may well be corrected later.
@@ -1648,8 +2071,8 @@
 		startoff = zp->z_gmtoff;
 		if (zp->z_nrules == 0) {
 			stdoff = zp->z_stdoff;
-			doabbr(startbuf, sizeof startbuf, zp->z_format,
-				(char *) NULL, stdoff != 0);
+			doabbr(startbuf, max_abbr_len + 1, zp->z_format,
+				(char *) NULL, stdoff != 0, FALSE);
 			type = addtype(oadd(zp->z_gmtoff, stdoff),
 				startbuf, stdoff != 0, startttisstd,
 				startttisgmt);
@@ -1677,9 +2100,8 @@
 			}
 			for ( ; ; ) {
 				register int	k;
-				register time_t	jtime, ktime;
+				register zic_t	jtime, ktime;
 				register long	offset;
-				char		buf[BUFSIZ];
 
 				INITIALIZE(ktime);
 				if (useuntil) {
@@ -1733,27 +2155,32 @@
 					if (ktime < starttime) {
 						startoff = oadd(zp->z_gmtoff,
 							stdoff);
-						doabbr(startbuf,sizeof startbuf,
+						doabbr(startbuf,
+							max_abbr_len + 1,
 							zp->z_format,
 							rp->r_abbrvar,
-							rp->r_stdoff != 0);
+							rp->r_stdoff != 0,
+							FALSE);
 						continue;
 					}
 					if (*startbuf == '\0' &&
-					    startoff == oadd(zp->z_gmtoff,
-					    stdoff)) {
-						doabbr(startbuf,sizeof startbuf,
-							zp->z_format,
-							rp->r_abbrvar,
-							rp->r_stdoff != 0);
+						startoff == oadd(zp->z_gmtoff,
+						stdoff)) {
+							doabbr(startbuf,
+								max_abbr_len + 1,
+								zp->z_format,
+								rp->r_abbrvar,
+								rp->r_stdoff !=
+								0,
+								FALSE);
 					}
 				}
 				eats(zp->z_filename, zp->z_linenum,
 					rp->r_filename, rp->r_linenum);
-				doabbr(buf, sizeof buf, zp->z_format,
-					rp->r_abbrvar, rp->r_stdoff != 0);
+				doabbr(ab, max_abbr_len+1, zp->z_format, rp->r_abbrvar,
+					rp->r_stdoff != 0, FALSE);
 				offset = oadd(zp->z_gmtoff, rp->r_stdoff);
-				type = addtype(offset, buf, rp->r_stdoff != 0,
+				type = addtype(offset, ab, rp->r_stdoff != 0,
 					rp->r_todisstd, rp->r_todisgmt);
 				addtt(ktime, type);
 			}
@@ -1764,7 +2191,7 @@
 				strchr(zp->z_format, '%') == NULL &&
 				strchr(zp->z_format, '/') == NULL)
 					(void)strncpy(startbuf, zp->z_format,
-					    sizeof(startbuf) - 1);
+					    max_abbr_len + 1 - 1);
 			eat(zp->z_filename, zp->z_linenum);
 			if (*startbuf == '\0')
 error(_("can't determine time zone abbreviation to use just after until time"));
@@ -1787,12 +2214,15 @@
 				starttime = tadd(starttime, -gmtoff);
 		}
 	}
-	writezone(zpfirst->z_name);
+	writezone(zpfirst->z_name, envvar);
+	ifree(startbuf);
+	ifree(ab);
+	ifree(envvar);
 }
 
 static void
 addtt(starttime, type)
-const time_t	starttime;
+const zic_t	starttime;
 int		type;
 {
 	if (starttime <= min_time ||
@@ -1811,7 +2241,7 @@
 	}
 	if (timecnt >= TZ_MAX_TIMES) {
 		error(_("too many transitions?!"));
-		(void) exit(EXIT_FAILURE);
+		exit(EXIT_FAILURE);
 	}
 	attypes[timecnt].at = starttime;
 	attypes[timecnt].type = type;
@@ -1830,15 +2260,15 @@
 
 	if (isdst != TRUE && isdst != FALSE) {
 		error(_("internal error - addtype called with bad isdst"));
-		(void) exit(EXIT_FAILURE);
+		exit(EXIT_FAILURE);
 	}
 	if (ttisstd != TRUE && ttisstd != FALSE) {
 		error(_("internal error - addtype called with bad ttisstd"));
-		(void) exit(EXIT_FAILURE);
+		exit(EXIT_FAILURE);
 	}
 	if (ttisgmt != TRUE && ttisgmt != FALSE) {
 		error(_("internal error - addtype called with bad ttisgmt"));
-		(void) exit(EXIT_FAILURE);
+		exit(EXIT_FAILURE);
 	}
 	/*
 	** See if there's already an entry for this zone type.
@@ -1857,7 +2287,11 @@
 	*/
 	if (typecnt >= TZ_MAX_TYPES) {
 		error(_("too many local time types"));
-		(void) exit(EXIT_FAILURE);
+		exit(EXIT_FAILURE);
+	}
+	if (! (-1L - 2147483647L <= gmtoff && gmtoff <= 2147483647L)) {
+		error(_("UTC offset out of range"));
+		exit(EXIT_FAILURE);
 	}
 	gmtoffs[i] = gmtoff;
 	isdsts[i] = isdst;
@@ -1876,7 +2310,7 @@
 
 static void
 leapadd(t, positive, rolling, count)
-const time_t	t;
+const zic_t	t;
 const int	positive;
 const int	rolling;
 int		count;
@@ -1885,13 +2319,13 @@
 
 	if (leapcnt + (positive ? count : 1) > TZ_MAX_LEAPS) {
 		error(_("too many leap seconds"));
-		(void) exit(EXIT_FAILURE);
+		exit(EXIT_FAILURE);
 	}
 	for (i = 0; i < leapcnt; ++i)
 		if (t <= trans[i]) {
 			if (t == trans[i]) {
 				error(_("repeated leap second moment"));
-				(void) exit(EXIT_FAILURE);
+				exit(EXIT_FAILURE);
 			}
 			break;
 		}
@@ -1909,7 +2343,7 @@
 }
 
 static void
-adjleap P((void))
+adjleap(void)
 {
 	register int	i;
 	register long	last = 0;
@@ -1946,7 +2380,7 @@
 	(void) fprintf(stderr, _("%s: command was '%s', result was %d\n"),
 		progname, buf, result);
 	for ( ; ; )
-		(void) exit(EXIT_FAILURE);
+		exit(EXIT_FAILURE);
 }
 
 static int
@@ -2027,8 +2461,9 @@
 		emalloc((int) ((strlen(cp) + 1) * sizeof *array));
 	nsubs = 0;
 	for ( ; ; ) {
-		while (isascii(*cp) && isspace((unsigned char) *cp))
-			++cp;
+		while (isascii((unsigned char) *cp) &&
+			isspace((unsigned char) *cp))
+				++cp;
 		if (*cp == '\0' || *cp == '#')
 			break;
 		array[nsubs++] = dp = cp;
@@ -2038,7 +2473,12 @@
 			else while ((*dp = *cp++) != '"')
 				if (*dp != '\0')
 					++dp;
-				else	error(_("Odd number of quotation marks"));
+				else {
+					error(_(
+						"Odd number of quotation marks"
+						));
+					exit(1);
+				}
 		} while (*cp != '\0' && *cp != '#' &&
 			(!isascii(*cp) || !isspace((unsigned char) *cp)));
 		if (isascii(*cp) && isspace((unsigned char) *cp))
@@ -2059,17 +2499,17 @@
 	t = t1 + t2;
 	if ((t2 > 0 && t <= t1) || (t2 < 0 && t >= t1)) {
 		error(_("time overflow"));
-		(void) exit(EXIT_FAILURE);
+		exit(EXIT_FAILURE);
 	}
 	return t;
 }
 
-static time_t
+static zic_t
 tadd(t1, t2)
-const time_t	t1;
+const zic_t	t1;
 const long	t2;
 {
-	register time_t	t;
+	register zic_t	t;
 
 	if (t1 == max_time && t2 > 0)
 		return max_time;
@@ -2078,7 +2518,7 @@
 	t = t1 + t2;
 	if ((t2 > 0 && t <= t1) || (t2 < 0 && t >= t1)) {
 		error(_("time overflow"));
-		(void) exit(EXIT_FAILURE);
+		exit(EXIT_FAILURE);
 	}
 	return t;
 }
@@ -2088,14 +2528,14 @@
 ** 1970, 00:00 LOCAL time - in that year that the rule refers to.
 */
 
-static time_t
+static zic_t
 rpytime(rp, wantedy)
 register const struct rule * const	rp;
 register const int			wantedy;
 {
 	register int	y, m, i;
 	register long	dayoff;			/* with a nod to Margaret O. */
-	register time_t	t;
+	register zic_t	t;
 
 	if (wantedy == INT_MIN)
 		return min_time;
@@ -2125,7 +2565,7 @@
 			--i;
 		else {
 			error(_("use of 2/29 in non leap-year"));
-			(void) exit(EXIT_FAILURE);
+			exit(EXIT_FAILURE);
 		}
 	}
 	--i;
@@ -2159,16 +2599,15 @@
 			}
 		if (i < 0 || i >= len_months[isleap(y)][m]) {
 			if (noise)
-				warning(_("rule goes past start/end of month--will not work with pre-2004 versions of zic"));
+				warning(_("rule goes past start/end of month--\
+will not work with pre-2004 versions of zic"));
 		}
 	}
-	if (dayoff < 0 && !TYPE_SIGNED(time_t))
-		return min_time;
 	if (dayoff < min_time / SECSPERDAY)
 		return min_time;
 	if (dayoff > max_time / SECSPERDAY)
 		return max_time;
-	t = (time_t) dayoff * SECSPERDAY;
+	t = (zic_t) dayoff * SECSPERDAY;
 	return tadd(t, rp->r_tod);
 }
 
@@ -2178,10 +2617,48 @@
 {
 	register int	i;
 
+	if (strcmp(string, GRANDPARENTED) != 0) {
+		register const char *	cp;
+		register char *		wp;
+
+		/*
+		** Want one to ZIC_MAX_ABBR_LEN_WO_WARN alphabetics
+		** optionally followed by a + or - and a number from 1 to 14.
+		*/
+		cp = string;
+		wp = NULL;
+		while (isascii((unsigned char) *cp) &&
+			isalpha((unsigned char) *cp))
+				++cp;
+		if (cp - string == 0)
+wp = _("time zone abbreviation lacks alphabetic at start");
+		if (noise && cp - string > 3)
+wp = _("time zone abbreviation has more than 3 alphabetics");
+		if (cp - string > ZIC_MAX_ABBR_LEN_WO_WARN)
+wp = _("time zone abbreviation has too many alphabetics");
+		if (wp == NULL && (*cp == '+' || *cp == '-')) {
+			++cp;
+			if (isascii((unsigned char) *cp) &&
+				isdigit((unsigned char) *cp))
+					if (*cp++ == '1' &&
+						*cp >= '0' && *cp <= '4')
+							++cp;
+		}
+		if (*cp != '\0')
+wp = _("time zone abbreviation differs from POSIX standard");
+		if (wp != NULL) {
+			wp = ecpyalloc(wp);
+			wp = ecatalloc(wp, " (");
+			wp = ecatalloc(wp, string);
+			wp = ecatalloc(wp, ")");
+			warning(wp);
+			ifree(wp);
+		}
+	}
 	i = strlen(string) + 1;
 	if (charcnt + i > TZ_MAX_CHARS) {
 		error(_("too many, or too long, time zone abbreviations"));
-		(void) exit(EXIT_FAILURE);
+		exit(EXIT_FAILURE);
 	}
 	(void)strncpy(&chars[charcnt], string, sizeof(chars) - charcnt - 1);
 	charcnt += eitol(i);
@@ -2189,7 +2666,7 @@
 
 static int
 mkdirs(argname)
-char * const	argname;
+char *		argname;
 {
 	register char *	name;
 	register char *	cp;
@@ -2245,7 +2722,7 @@
 		(void) fprintf(stderr,
 			_("%s: %d did not sign extend correctly\n"),
 			progname, i);
-		(void) exit(EXIT_FAILURE);
+		exit(EXIT_FAILURE);
 	}
 	return l;
 }