X-Authentication-Warning: delorie.com: mail set sender to djgpp-workers-bounces using -f
X-Recipient: djgpp-workers AT delorie DOT com
Message-ID: <520FA8C9.40909@gmx.de>
Date: Sat, 17 Aug 2013 18:46:01 +0200
From: Juan Manuel Guerrero <juan DOT guerrero AT gmx DOT de>
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:16.0) Gecko/20121025 Thunderbird/16.0.2
MIME-Version: 1.0
To: djgpp-workers AT delorie DOT com
Subject: Re: zoneinfo not able to recognize if daylight saving time is in
 effect.
References: <51F2C9B5 DOT 3090202 AT gmx DOT de>
In-Reply-To: <51F2C9B5.3090202@gmx.de>
Content-Type: text/plain; charset=ISO-8859-15; format=flowed
Content-Transfer-Encoding: 7bit
X-Provags-ID:  V03:K0:X8QHEcScmYsdfis2TPg6GIlcIGz6mfxoyeHatMttWZs4xZCtpws
 ZhB6w/C78Y1yvYzUam5OtX1nh0l/UJhknZGHq0nJO34j9Bx7aIFispO0Eaew9vw03PvUDNB
 ma1IW7IgdwhF12k4K/gYCXFHhZdCw6ui5vGS1DeDe8krN90f5awoF+guYe8hIhNIDZEDFKQ
 LiGihouzESTeiZHI9U9nA==
Reply-To: djgpp-workers AT delorie DOT com

Am 26.07.2013 21:10, schrieb Juan Manuel Guerrero:
[snip]

With the original djgpp code of djgpp/src/libc/ansi/time/ctime.c and
zic with date before 2013-01-30 (aka djdev204 and previous) I was not
able to compile the tzdata2006d tz-database and later.  I got error
messages like this:
./host-zic  -y ./yearistype -d ../../zoneinfo -L /dev/null africa antarctica asi
a australasia europe northamerica southamerica pacificnew etcetera factory backw
ard systemv solar87 solar88 solar89
"northamerica", line 1638: can't determine time zone abbreviation to use just af
ter until time
"northamerica", line 1646: can't determine time zone abbreviation to use just af
ter until time
make.exe: *** [posix_only] Error 1

I was not willing to waste my time investigating this issue and to figure out
how that very old code works, so I preferred to invested the time to update
djgpp/src/libc/ansi/time/ctime.c and djgpp/src/libc/ansi/time/posixrul.h to the
functionality provided by tz[code|data]2013d.  I have also updated all the code
in /djgpp/zoneinfo/src to tz[code|data]2013d so that the new zic and ctime and
family of functions use the same set of auxiliary functions to encode and decode
the zoneinfo database.  I have also added a small test program that checks for
some TZ that I am aware of.  This test program is based on the sample code I
send in my first post and if someone wants to contribute with test data it will
be welcome.  The new djgpp port of zic does not create the version 2 of data
base files that support 64 bit time_t.  This makes no sense for djgpp and
bloats the zoneinfo files to be installed.  It has been adjusted to continue
producing the old version 0 (32 bit time_t) tz database files.


Regards,
Juan M. Guerrero



2013-08-17  Juan Manuel Guerrero <juan DOT guerrero AT gmx DOT de>

     * djgpp/tests/libc/ansi/time/makefile: Added tzinfo2.c

     * djgpp/tests/libc/ansi/time/tzinfo2.c: Checks for timezone files.


2013-08-09  Juan Manuel Guerrero <juan DOT guerrero AT gmx DOT de>

     * djgpp/include/tzfile.h: Update to tzcode2013d functionality.

     * djgpp/src/libc/ansi/time/ctime.c: Update to tzcode2013d functionality.

     * djgpp/src/libc/ansi/time/posixrul.h: Update to tzdata2013d posix rules
     as default.






diff -aprNU5 djgpp.orig/include/tzfile.h djgpp/include/tzfile.h
--- djgpp.orig/include/tzfile.h    2012-09-23 07:49:12 +0100
+++ djgpp/include/tzfile.h    2013-08-17 16:02:38 +0100
@@ -1,5 +1,6 @@
+/* Copyright (C) 2013 DJ Delorie, see COPYING.DJ for details */
  /* Copyright (C) 2003 DJ Delorie, see COPYING.DJ for details */
  /* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */
  #ifndef __dj_include_tzfile_h__
  #define __dj_include_tzfile_h__

@@ -45,34 +46,39 @@ extern "C" {
  /*
  ** Information about time zone files.
  */

                          /* Time zone object file directory */
-#define TZDIR           "/usr/share/zoneinfo"
-#define TZDEFAULT       "/etc/localtime"
+#define TZDIR           "/dev/env/DJDIR/share/zoneinfo"
+#define TZDEFAULT       "/dev/env/DJDIR/etc/localtime"
  #define TZDEFRULES      "posixrules"

  /*
  ** Each file begins with. . .
  */

+#define TZ_MAGIC  "TZif"
+
  struct tzhead {
-        char    tzh_reserved[24];       /* reserved for future use */
-        char    tzh_ttisstdcnt[4];      /* coded number of trans. time flags */
-        char    tzh_leapcnt[4];         /* coded number of leap seconds */
-        char    tzh_timecnt[4];         /* coded number of transition times */
-        char    tzh_typecnt[4];         /* coded number of local time types */
-        char    tzh_charcnt[4];         /* coded number of abbr. chars */
+  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 */
+  char tzh_timecnt[4];         /* coded number of transition times */
+  char tzh_typecnt[4];         /* coded number of local time types */
+  char tzh_charcnt[4];         /* coded number of abbr. chars */
  };

  /*
  ** . . .followed by. . .
  **
  **      tzh_timecnt (char [4])s         coded transition times a la time(2)
  **      tzh_timecnt (unsigned char)s    types of local time starting at above
  **      tzh_typecnt repetitions of
-**              one (char [4])          coded GMT offset in seconds
+**              one (char [4])          coded UTC offset in seconds
  **              one (unsigned char)     used to set tm_isdst
  **              one (unsigned char)     that's an abbreviation list index
  **      tzh_charcnt (char)s             '\0'-terminated zone abbreviations
  **      tzh_leapcnt repetitions of
  **              one (char [4])          coded leap second transition times
@@ -80,24 +86,34 @@ struct tzhead {
  **      tzh_ttisstdcnt (char)s          indexed by type; if TRUE, transition
  **                                      time is standard time, if FALSE,
  **                                      transition time is wall clock time
  **                                      if absent, transition times are
  **                                      assumed to be wall clock time
+**      tzh_ttisgmtcnt (char)s          indexed by type; if TRUE, transition
+**                                      time is UTC, if FALSE,
+**                                      transition time is local time
+**                                      if absent, transition times are
+**                                      assumed to be local time
  */

  /*
-** In the current implementation, "tzset()" refuses to deal with files that
-** exceed any of the limits below.
+** 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).
+** DJGPP does not support version 2 or higher.
  */

  /*
-** 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).
+** In the current implementation, "tzset()" refuses to deal with files that
+** exceed any of the limits below.
  */
-#define TZ_MAX_TIMES    370
+
+#define TZ_MAX_TIMES    1200

  #define NOSOLAR                 /* 4BSD doesn't currently handle solar time */

  #ifndef NOSOLAR
  #define TZ_MAX_TYPES    256     /* Limited by what (unsigned char)'s can hold */
diff -aprNU5 djgpp.orig/src/libc/ansi/time/ctime.c djgpp/src/libc/ansi/time/ctime.c
--- djgpp.orig/src/libc/ansi/time/ctime.c    2005-01-09 14:56:12 +0100
+++ djgpp/src/libc/ansi/time/ctime.c    2013-08-17 16:02:38 +0100
@@ -1,5 +1,6 @@
+/* Copyright (C) 2013 DJ Delorie, see COPYING.DJ for details */
  /* Copyright (C) 2005 DJ Delorie, see COPYING.DJ for details */
  /* Copyright (C) 1998 DJ Delorie, see COPYING.DJ for details */
  /* Copyright (C) 1997 DJ Delorie, see COPYING.DJ for details */
  /* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */
  /* This file has been modified by DJ Delorie.  These modifications are
@@ -38,209 +39,259 @@ static char sccsid[] = "@(#)ctime.c    5.23
  ** POSIX-style TZ environment variable handling from Guy Harris
  ** (guy AT auspex DOT com).
  */

  #include <libc/stubs.h>
+#include <errno.h>
  #include <fcntl.h>
  #include <time.h>
  #include <string.h>
  #include <ctype.h>
  #include <stdio.h>
  #include <stdlib.h>
+#include <stdint.h>
  #include <unistd.h>
+#include <limits.h>
+#include <float.h>
  #include <tzfile.h>

  #include <libc/unconst.h>
  #include <libc/bss.h>
  #include <libc/environ.h>

  #include "posixrul.h"

-#define P(s)        s
-#define alloc_size_t    size_t
-#define qsort_size_t    size_t
-#define fread_size_t    size_t
-#define fwrite_size_t    size_t
+#if ((__GNUC__ == 2) && (__GNUC_MINOR__ >= 96)) || (__GNUC__ >= 3)
+# define ATTRIBUTE_CONST __attribute__ ((const))
+# define ATTRIBUTE_PURE  __attribute__ ((__pure__))
+#else
+# define ATTRIBUTE_CONST /* empty */
+# define ATTRIBUTE_PURE  /* empty */
+#endif
+
+#define GRANDPARENTED        "Local time zone must be set--see zic manual page"
+#define TZ_ABBR_MAX_LEN      16
+#define TZ_ABBR_CHAR_SET "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 :+-._"
+#define TZ_ABBR_ERR_CHAR     '_'
+
+#define TYPE_BIT(type)       (sizeof (type) * CHAR_BIT)
+#define TYPE_SIGNED(type)    (((type) -1) < 0)
+#define TYPE_INTEGRAL(type)  (((type) 0.5) != 0.5)
+
+#define AVGSECSPERYEAR       31556952L   /* The Gregorian year averages 365.2425 days, which is 31556952 seconds.  */
+#define YEARSPERREPEAT       400         /* Years before a Gregorian repeat */
+#define SECSPERREPEAT        ((int_fast64_t) YEARSPERREPEAT * (int_fast64_t) AVGSECSPERYEAR)
+#define SECSPERREPEAT_BITS   34          /* ceil(log2(SECSPERREPEAT)) */
+
+#define ACCESS_MODE          (O_RDONLY|O_BINARY)
+#define OPEN_MODE            (O_RDONLY|O_BINARY)
+#define IS_ABSOLUTE(n)       ((n)[0] == '/' || (n)[0] == '\\' || (n)[1] == ':')
+#define INITIALIZE(x)        ((x) = 0)
+
+/* Unlike <ctype.h>'s isdigit, this also works if c < 0 | c > UCHAR_MAX. */
+#define is_digit(c)          ((unsigned)(c) - '0' <= 9)

-#define ACCESS_MODE    O_RDONLY|O_BINARY
-#define OPEN_MODE    O_RDONLY|O_BINARY

  /*
  ** Someone might make incorrect use of a time zone abbreviation:
-**    1.    They might reference tzname[0] before calling tzset (explicitly
-**         or implicitly).
-**    2.    They might reference tzname[1] before calling tzset (explicitly
-**         or implicitly).
-**    3.    They might reference tzname[1] after setting to a time zone
-**        in which Daylight Saving Time is never observed.
-**    4.    They might reference tzname[0] after setting to a time zone
-**        in which Standard Time is never observed.
-**    5.    They might reference tm.TM_ZONE after calling offtime.
+**      1.      They might reference tzname[0] before calling tzset (explicitly
+**              or implicitly).
+**      2.      They might reference tzname[1] before calling tzset (explicitly
+**              or implicitly).
+**      3.      They might reference tzname[1] after setting to a time zone
+**              in which Daylight Saving Time is never observed.
+**      4.      They might reference tzname[0] after setting to a time zone
+**              in which Standard Time is never observed.
+**      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
  ** string "tzname[0] used before set", and similarly for the other cases.
  ** 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).
  */
-static char WILDABBR[] = "   ";
+static char wildabbr[] = "   ";

  #ifndef TRUE
-#define TRUE        1
-#define FALSE        0
+#define TRUE   1
+#define FALSE  0
  #endif /* !defined TRUE */

-static const char GMT[] = "GMT";
+static const char gmt[] = "GMT";

-struct ttinfo {        /* time type information */
-  long tt_gmtoff;    /* GMT offset in seconds */
-  int tt_isdst;        /* used to set tm_isdst */
-  int tt_abbrind;    /* abbreviation list index */
-  int tt_ttisstd;    /* TRUE if transition is std time */
+/*
+** The DST rules to use if TZ has no rules and we can't load TZDEFRULES.
+** We default to US rules as of 1999-08-17.
+** POSIX 1003.1 section 8.1.1 says that the default DST rules are
+** implementation dependent; for historical reasons, US rules are a
+** common default.
+*/
+#ifndef TZDEFRULESTRING
+#define TZDEFRULESTRING ",M4.1.0,M10.5.0"
+#endif /* !defined TZDEFDST */
+
+struct ttinfo {             /* time type information */
+  int_fast32_t tt_gmtoff;   /* UTC offset in seconds */
+  int tt_isdst;             /* used to set tm_isdst */
+  int tt_abbrind;           /* abbreviation list index */
+  int tt_ttisstd;           /* TRUE if transition is std time */
+  int tt_ttisgmt;           /* TRUE if transition is UTC */
  };

-struct lsinfo {        /* leap second information */
-  time_t ls_trans;    /* transition time */
-  long ls_corr;        /* correction to apply */
+struct lsinfo {             /* leap second information */
+  time_t ls_trans;          /* transition time */
+  int_fast64_t ls_corr;     /* correction to apply */
  };

+#define BIGGEST(a, b)   (((a) > (b)) ? (a) : (b))
+
+#ifdef TZNAME_MAX
+#define MY_TZNAME_MAX   TZNAME_MAX
+#endif /* defined TZNAME_MAX */
+#ifndef TZNAME_MAX
+#define MY_TZNAME_MAX   255
+#endif /* !defined TZNAME_MAX */
+
  struct state {
    int leapcnt;
    int timecnt;
    int typecnt;
    int charcnt;
+  int goback;
+  int goahead;
    time_t ats[TZ_MAX_TIMES];
    unsigned char types[TZ_MAX_TIMES];
    struct ttinfo ttis[TZ_MAX_TYPES];
-  char chars[(TZ_MAX_CHARS + 1 > sizeof GMT) ? TZ_MAX_CHARS + 1 : sizeof GMT];
+  char chars[BIGGEST(BIGGEST(TZ_MAX_CHARS + 1, sizeof gmt), (2 * (MY_TZNAME_MAX + 1)))];
    struct lsinfo lsis[TZ_MAX_LEAPS];
+  int defaulttype;  /* for early times or if no transitions */
  };

  struct rule {
-  int r_type;        /* type of rule--see below */
-  int r_day;        /* day number of rule */
-  int r_week;        /* week number of rule */
-  int r_mon;        /* month number of rule */
-  long r_time;        /* transition time of rule */
+  int r_type;           /* type of rule--see below */
+  int r_day;            /* day number of rule */
+  int r_week;           /* week number of rule */
+  int r_mon;            /* month number of rule */
+  int_fast32_t r_time;  /* transition time of rule */
  };

-#define    JULIAN_DAY        0    /* Jn - Julian day */
-#define    DAY_OF_YEAR        1    /* n - day of year */
-#define    MONTH_NTH_DAY_OF_WEEK    2    /* Mm.n.d - month, week, day of week */
+#define JULIAN_DAY             0        /* Jn - Julian day */
+#define DAY_OF_YEAR            1        /* n - day of year */
+#define MONTH_NTH_DAY_OF_WEEK  2        /* Mm.n.d - month, week, day of week */

  /*
  ** 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 void        normalize P((int * tensptr, int * unitsptr, int base));
-static void        settzname P((void));
-static time_t        time1 P((struct tm * tmp, void (* funcp)(const time_t * const, const long, struct tm * const),
-                long offset));
-static time_t        time2 P((struct tm *tmp, void (* funcp)(const time_t * const, const long, struct tm * const),
-                long offset, int * okayp));
-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 void        tmnormalize P((struct tm * tmp));
-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));
-
-#ifdef ALL_STATE
-static struct state *lclptr;
-static struct state *gmtptr;
-#endif /* defined ALL_STATE */
+static int_fast32_t  detzcode(const char *codep);
+static int           differ_by_repeat(time_t t1, time_t t0);
+static const char   *getnum(const char *strp, int *nump, int min, int max);
+static const char   *getqzname(const char * strp, const int delim) ATTRIBUTE_PURE;
+static const char   *getzname(const char *strp) ATTRIBUTE_PURE;
+static const char   *getsecs(const char *strp, int_fast32_t *const secsp);
+static const char   *getoffset(const char *strp, int_fast32_t *const offsetp);
+static const char   *getrule(const char *strp, struct rule *rulep);
+static void          gmtload(struct state *sp);
+static struct tm    *gmtsub(const time_t *const timep, const int_fast32_t offset, struct tm *const tmp);
+static int           increment_overflow(int *const ip, int j);
+static struct tm    *localsub(const time_t *const timep, const int_fast32_t offset, struct tm *const tmp);
+static void          settzname(void);
+static time_t        time1(struct tm *const tmp, struct tm *(*const funcp) (const time_t *, int_fast32_t, struct tm *), const int_fast32_t offset);
+static time_t        time2(struct tm *const tmp, struct tm *(*const funcp)(const time_t *, int_fast32_t, struct tm *), const int_fast32_t offset, int *const okayp);
+static struct tm    *timesub(const time_t *const timep, const int_fast32_t offset, register const struct state *const sp, register struct tm *const 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, int_fast32_t offset) ATTRIBUTE_PURE;
+static int           typesequiv(const struct state *const sp, const int a, const int b);
+static int           tzload(const char *name, struct state *const sp, const int doextend);
+static int           tzparse(const char *name, struct state *sp, int lastditch);

-#ifndef ALL_STATE
  static struct state lclmem;
  static struct state gmtmem;
  #define lclptr (&lclmem)
  #define gmtptr (&gmtmem)
-#endif /* State Farm */

-static int lcl_is_set;    /* 0: no, 1: set by tzset, -1: set by tzsetwall */
+#ifndef TZ_STRLEN_MAX
+#define TZ_STRLEN_MAX  255
+#endif /* !defined TZ_STRLEN_MAX */
+
+static char lcl_TZname[TZ_STRLEN_MAX + 1];
+static int lcl_is_set;  /* 0: no, 1: set by tzset, -1: set by tzsetwall */
  static int gmt_is_set;
-static char lcl_tzstr[512];

-char * tzname[2] = {
-  WILDABBR,
-  WILDABBR
+char *tzname[2] = {
+  wildabbr,
+  wildabbr
  };

-static long
-detzcode(const char * const codep)
+static int_fast32_t
+detzcode(const char *const codep)
  {
-  long result;
-  int i;
+  register int_fast32_t result;
+  register int i;

-  result = 0;
+  result = (codep[0] & 0x80) ? -1 : 0;
    for (i = 0; i < 4; ++i)
      result = (result << 8) | (codep[i] & 0xff);
    return result;
  }

  static void
  settzname(void)
  {
-  const struct state * const sp = lclptr;
+  register struct state *const sp = lclptr;
    int i;

-  tzname[0] = WILDABBR;
-  tzname[1] = WILDABBR;
-#ifdef ALL_STATE
-  if (sp == NULL)
-  {
-    tzname[0] = tzname[1] = GMT;
-    return;
-  }
-#endif /* defined ALL_STATE */
-  for (i = 0; i < sp->typecnt; ++i)
-  {
-    register const struct ttinfo * const ttisp = &sp->ttis[i];
+  tzname[0] = wildabbr;
+  tzname[1] = wildabbr;

-    tzname[ttisp->tt_isdst] =
-      unconst(&sp->chars[ttisp->tt_abbrind], char *);
-#if 0
-    if (ttisp->tt_isdst)
-      _daylight = 1;
-    if (i == 0 || !ttisp->tt_isdst)
-      _timezone = -(ttisp->tt_gmtoff);
-    if (i == 0 || ttisp->tt_isdst)
-      _altzone = -(ttisp->tt_gmtoff);
-#endif
-  }
    /*
     ** And to get the latest zone names into tzname. . .
     */
+  for (i = 0; i < sp->typecnt; ++i)
+  {
+    register const struct ttinfo *const ttisp = &sp->ttis[i];
+
+    tzname[ttisp->tt_isdst] = unconst(&sp->chars[ttisp->tt_abbrind], char *);
+  }
    for (i = 0; i < sp->timecnt; ++i)
    {
-    const struct ttinfo * const ttisp = &sp->ttis[sp->types[i]];
+    register const struct ttinfo *const ttisp = &sp->ttis[sp->types[i]];

      tzname[ttisp->tt_isdst] = unconst(&sp->chars[ttisp->tt_abbrind], char *);
    }
+  /*
+  ** 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 = unconst(&sp->chars[ttisp->tt_abbrind], char *);
+    if (strlen(cp) > TZ_ABBR_MAX_LEN && strcmp(cp, GRANDPARENTED) != 0)
+      *(cp + TZ_ABBR_MAX_LEN) = '\0';
+  }
+}
+
+static int
+differ_by_repeat(const time_t t1, const time_t t0)
+{
+  if (TYPE_INTEGRAL(time_t) && TYPE_BIT(time_t) - TYPE_SIGNED(time_t) < SECSPERREPEAT_BITS)
+    return 0;
+  return t1 - t0 == SECSPERREPEAT;
  }

  static char *
  tzdir(void)
  {
-  static char dir[FILENAME_MAX + 1]={0}, *cp;
+  static char *cp, dir[FILENAME_MAX + 1] = {0};
    static int tzdir_bss_count = -1;

    /* Force recomputation of cached values (Emacs).  */
    if (tzdir_bss_count != __bss_count)
    {
@@ -263,26 +314,28 @@ tzdir(void)
    }
    return dir;
  }

  static int
-tzload(const char *name, struct state * const sp)
+tzload(const char *name, struct state *const sp, const int doextend)
  {
-  const char * p;
+  const char *p;
    int i;
    int fid;
+  int nread = 0;
    char fullname[FILENAME_MAX + 1];
-  const struct tzhead * tzhp;
-  char buf[sizeof *sp + sizeof *tzhp];
-  int ttisstdcnt;
+  const struct tzhead *tzhp;
+  char buf[sizeof *tzhp + sizeof *sp + 2 * TZ_MAX_TIMES];
+  int ttisgmtcnt, ttisstdcnt;

+  sp->goback = sp->goahead = FALSE;
    if (name == NULL && (name = TZDEFAULT) == NULL)
      return -1;

    if (name[0] == ':')
      ++name;
-  if (name[0] && name[0] != '/' && name[0] != '\\' && name[1] != ':')
+  if (name[0] && !IS_ABSOLUTE(name))
    {
      if ((p = tzdir()) == NULL)
        return -1;
      if ((strlen(p) + strlen(name) + 1) >= sizeof fullname)
        return -1;
@@ -311,33 +364,37 @@ tzload(const char *name, struct state *
      memcpy(buf, _posixrules_data, sizeof(_posixrules_data));
      i = sizeof(_posixrules_data);
    }
    else
    {
-    i = read(fid, buf, sizeof buf);
-    if (close(fid) != 0 || i < (int)sizeof *tzhp)
+    nread = read(fid, buf, sizeof buf);
+    if (close(fid) != 0 || nread < (int)sizeof *tzhp)
        return -1;
    }

    tzhp = (struct tzhead *) buf;
+  ttisgmtcnt = (int) detzcode(tzhp->tzh_ttisgmtcnt);
    ttisstdcnt = (int) detzcode(tzhp->tzh_ttisstdcnt);
    sp->leapcnt = (int) detzcode(tzhp->tzh_leapcnt);
    sp->timecnt = (int) detzcode(tzhp->tzh_timecnt);
    sp->typecnt = (int) detzcode(tzhp->tzh_typecnt);
    sp->charcnt = (int) detzcode(tzhp->tzh_charcnt);
    if (sp->leapcnt < 0 || sp->leapcnt > TZ_MAX_LEAPS ||
        sp->typecnt <= 0 || sp->typecnt > TZ_MAX_TYPES ||
        sp->timecnt < 0 || sp->timecnt > TZ_MAX_TIMES ||
        sp->charcnt < 0 || sp->charcnt > TZ_MAX_CHARS ||
-      (ttisstdcnt != sp->typecnt && ttisstdcnt != 0))
+      (ttisstdcnt != sp->typecnt && ttisstdcnt != 0) ||
+      (ttisgmtcnt != sp->typecnt && ttisgmtcnt != 0))
      return -1;
-  if (i < (int)( sizeof *tzhp +
-      sp->timecnt * (4 + sizeof (char)) +
-      sp->typecnt * (4 + 2 * sizeof (char)) +
-      sp->charcnt * sizeof (char) +
-      sp->leapcnt * 2 * 4 +
-      ttisstdcnt * sizeof (char) ))
+  if (nread < (int)(sizeof *tzhp +
+      sp->timecnt * 4 +                        /* ats */
+      sp->timecnt * sizeof(char) +             /* types */
+      sp->typecnt * (4 + 2 * sizeof(char)) +   /* ttinfos */
+      sp->charcnt * sizeof(char) +             /* chars */
+      sp->leapcnt * 2 * 4 +                    /* lsinfos */
+      ttisstdcnt * sizeof(char) +              /* ttisstds */
+      ttisgmtcnt * sizeof(char)))              /* ttisgmts */
      return -1;
    p = buf + sizeof *tzhp;
    for (i = 0; i < sp->timecnt; ++i)
    {
      sp->ats[i] = detzcode(p);
@@ -349,67 +406,227 @@ tzload(const char *name, struct state *
      if (sp->types[i] >= sp->typecnt)
        return -1;
    }
    for (i = 0; i < sp->typecnt; ++i)
    {
-    struct ttinfo * ttisp;
+    register struct ttinfo *ttisp;

      ttisp = &sp->ttis[i];
      ttisp->tt_gmtoff = detzcode(p);
      p += 4;
      ttisp->tt_isdst = (unsigned char) *p++;
      if (ttisp->tt_isdst != 0 && ttisp->tt_isdst != 1)
        return -1;
      ttisp->tt_abbrind = (unsigned char) *p++;
-    if (ttisp->tt_abbrind < 0 ||
-    ttisp->tt_abbrind > sp->charcnt)
+    if (ttisp->tt_abbrind < 0 || ttisp->tt_abbrind > sp->charcnt)
        return -1;
    }
    for (i = 0; i < sp->charcnt; ++i)
      sp->chars[i] = *p++;
-  sp->chars[i] = '\0';        /* ensure '\0' at end */
+  sp->chars[i] = '\0';         /* ensure '\0' at end */
    for (i = 0; i < sp->leapcnt; ++i)
    {
-    struct lsinfo * lsisp;
+    register struct lsinfo *lsisp;

      lsisp = &sp->lsis[i];
      lsisp->ls_trans = detzcode(p);
      p += 4;
      lsisp->ls_corr = detzcode(p);
      p += 4;
    }
    for (i = 0; i < sp->typecnt; ++i)
    {
-    struct ttinfo * ttisp;
+    register struct ttinfo *ttisp;

      ttisp = &sp->ttis[i];
      if (ttisstdcnt == 0)
        ttisp->tt_ttisstd = FALSE;
      else
      {
        ttisp->tt_ttisstd = *p++;
        if (ttisp->tt_ttisstd != TRUE &&
-      ttisp->tt_ttisstd != FALSE)
-    return -1;
+          ttisp->tt_ttisstd != FALSE)
+        return -1;
+    }
+  }
+  for (i = 0; i < sp->typecnt; ++i)
+  {
+    register struct ttinfo *ttisp;
+
+    ttisp = &sp->ttis[i];
+    if (ttisgmtcnt == 0)
+      ttisp->tt_ttisgmt = FALSE;
+    else
+    {
+      ttisp->tt_ttisgmt = *p++;
+      if (ttisp->tt_ttisgmt != TRUE &&
+          ttisp->tt_ttisgmt != FALSE)
+        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; ++i)
+    if ((i < sp->timecnt - 1 && sp->ats[i] > sp->ats[i + 1]) ||
+      (i == sp->timecnt - 1 && !TYPE_SIGNED(time_t) && sp->ats[i] > INT32_MAX))
+    {
+      if (TYPE_SIGNED(time_t))
+      {
+        /*
+         ** Ignore the end (easy).
+         */
+        sp->timecnt = i + 1;
+      }
+      else
+      {
+        /*
+        ** Ignore the beginning (harder).
+        */
+        register int j;
+
+        /*
+        ** Keep the record right before the
+        ** epoch boundary,
+        ** but tweak it so that it starts
+        ** right with the epoch
+        ** (thanks to Doug Bailey).
+        */
+        sp->ats[i] = 0;
+        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;
+    }
+
+  /*
+  ** DJGPP only supports old files (version 0).
+  */
+#if 0
+  if (tzhp->tzh_version[0] != '\0')
+    return -1;
+#endif
+
+  if (doextend && nread > 2 &&
+      buf[0] == '\n' && buf[nread - 1] == '\n' &&
+      sp->typecnt + 2 <= TZ_MAX_TYPES)
+  {
+    struct state ts;
+    register int result;
+
+    buf[nread - 1] = '\0';
+    result = tzparse(&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];
+    }
+  }
+  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;
+      }
+  }
+  /*
+  ** If type 0 is unused in transitions,
+  ** it's the type to use for early times.
+  */
+  for (i = 0; i < sp->typecnt; ++i)
+    if (sp->types[i] == 0)
+      break;
+  i = (i >= sp->typecnt) ? 0 : -1;
+  /*
+  ** Absent the above,
+  ** if there are transition times
+  ** and the first transition is to a daylight time
+  ** find the standard type less than and closest to
+  ** the type of the first transition.
+  */
+  if (i < 0 && sp->timecnt > 0 && sp->ttis[sp->types[0]].tt_isdst)
+  {
+    i = sp->types[0];
+    while (--i > -1)
+      if (!sp->ttis[i].tt_isdst)
+        break;
+  }
+  /*
+  ** If no result yet, find the first standard type.
+  ** If there is none, punt to type zero.
+  */
+  if (i < 0)
+  {
+    i = 0;
+    while (sp->ttis[i].tt_isdst)
+      if (++i >= sp->typecnt)
+      {
+        i = 0;
+        break;
+      }
+  }
+  sp->defaulttype = i;
    return 0;
  }

+static int
+typesequiv(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 }
+  {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
+  {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
  };

  static const int year_lengths[2] = {
-DAYSPERNYEAR, DAYSPERLYEAR
-};
-
-static const long n_year_lengths[3] = {
-  3*DAYSPERNYEAR + DAYSPERLYEAR,         /* 4-year cycle length */
-  25*(3*DAYSPERNYEAR + DAYSPERLYEAR) - 1,     /* 100-year cycle length */
-  4*(25*(3*DAYSPERNYEAR + DAYSPERLYEAR) - 1) + 1 /* 400-year cycle length */
+  DAYSPERNYEAR, DAYSPERLYEAR
  };

  /*
  ** 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
@@ -419,12 +636,30 @@ static const long n_year_lengths[3] = {
  static const char *
  getzname(const char *strp)
  {
    unsigned char c;

-  while ((c = *strp) != '\0' && !isdigit(c) && c != ',' && c != '-' &&
-     c != '+')
+  while ((c = *strp) != '\0' && !is_digit(c) && c != ',' && c != '-' && c != '+')
+    ++strp;
+  return strp;
+}
+
+/*
+** 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(const char *strp, const int delim)
+{
+  register int c;
+
+  while ((c = *strp) != '\0' && c != delim)
      ++strp;
    return strp;
  }

  /*
@@ -433,27 +668,27 @@ getzname(const char *strp)
  ** NULL.
  ** Otherwise, return a pointer to the first character not part of the number.
  */

  static const char *
-getnum(const char *strp, int * const nump, const int min, const int max)
+getnum(const char *strp, int *const nump, const int min, const int max)
  {
    unsigned char c;
    int num;

-  if (strp == NULL || !isdigit((unsigned char)*strp))
+  if (strp == NULL || !is_digit((unsigned char)*strp))
      return NULL;
    num = 0;
-  while ((c = *strp) != '\0' && isdigit(c))
+  while ((c = *strp) != '\0' && is_digit(c))
    {
      num = num * 10 + (c - '0');
      if (num > max)
-      return NULL;
+      return NULL;  /* illegal value */
      ++strp;
    }
    if (num < min)
-    return NULL;
+    return NULL;  /* illegal value */
    *nump = num;
    return strp;
  }

  /*
@@ -463,31 +698,38 @@ getnum(const char *strp, int * const num
  ** Otherwise, return a pointer to the first character not part of the number
  ** of seconds.
  */

  static const char *
-getsecs(const char *strp, long * const secsp)
+getsecs(const char *strp, int_fast32_t *const secsp)
  {
    int num;

-  strp = getnum(strp, &num, 0, HOURSPERDAY);
+  /*
+  ** `HOURSPERDAY * DAYSPERWEEK - 1' allows quasi-Posix rules like
+  ** "M10.4.6/26", which does not conform to Posix,
+  ** but which specifies the equivalent of
+  ** ``02:00 on the first Sunday on or after 23 Oct''.
+  */
+  strp = getnum(strp, &num, 0, HOURSPERDAY * DAYSPERWEEK - 1);
    if (strp == NULL)
      return NULL;
-  *secsp = num * SECSPERHOUR;
+  *secsp = num * (int_fast32_t)SECSPERHOUR;
    if (*strp == ':')
    {
      ++strp;
      strp = getnum(strp, &num, 0, MINSPERHOUR - 1);
      if (strp == NULL)
        return NULL;
      *secsp += num * SECSPERMIN;
      if (*strp == ':')
      {
        ++strp;
-      strp = getnum(strp, &num, 0, SECSPERMIN - 1);
+      /* `SECSPERMIN' allows for leap seconds. */
+      strp = getnum(strp, &num, 0, SECSPERMIN);
        if (strp == NULL)
-    return NULL;
+        return NULL;
        *secsp += num;
      }
    }
    return strp;
  }
@@ -498,23 +740,21 @@ getsecs(const char *strp, long * const s
  ** If any error occurs, return NULL.
  ** Otherwise, return a pointer to the first character not part of the time.
  */

  static const char *
-getoffset(const char *strp, long * const offsetp)
+getoffset(const char *strp, int_fast32_t *const offsetp)
  {
-  int neg;
+  int neg = 0;

    if (*strp == '-')
    {
      neg = 1;
      ++strp;
    }
-  else if (isdigit((unsigned char)*strp) || *strp++ == '+')
-    neg = 0;
-  else
-    return NULL; /* illegal offset */
+  else if (*strp == '+')
+    ++strp;
    strp = getsecs(strp, offsetp);
    if (strp == NULL)
      return NULL; /* illegal time */
    if (neg)
      *offsetp = -*offsetp;
@@ -527,11 +767,11 @@ getoffset(const char *strp, long * const
  ** 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(const char *strp, struct rule * const rulep)
+getrule(const char *strp, struct rule *const rulep)
  {
    if (*strp == 'J')
    {
      /*
       ** Julian day.
@@ -557,20 +797,20 @@ getrule(const char *strp, struct rule *
        return NULL;
      if (*strp++ != '.')
        return NULL;
      strp = getnum(strp, &rulep->r_day, 0, DAYSPERWEEK - 1);
    }
-  else if (isdigit((unsigned char)*strp))
+  else if (is_digit((unsigned char)*strp))
    {
      /*
       ** Day of year.
       */
      rulep->r_type = DAY_OF_YEAR;
      strp = getnum(strp, &rulep->r_day, 0, DAYSPERLYEAR - 1);
    }
    else
-    return NULL;        /* invalid format */
+    return NULL;                      /* invalid format */
    if (strp == NULL)
      return NULL;
    if (*strp == '/')
    {
      /*
@@ -578,28 +818,29 @@ getrule(const char *strp, struct rule *
       */
      ++strp;
      strp = getsecs(strp, &rulep->r_time);
    }
    else
-    rulep->r_time = 2 * SECSPERHOUR; /* default = 2:00:00 */
+    rulep->r_time = 2 * SECSPERHOUR;  /* default = 2:00:00 */
    return strp;
  }

  /*
-** Given the Epoch-relative time of January 1, 00:00:00 GMT, in a year, the
-** year, a rule, and the offset from GMT at the time that rule takes effect,
+** Given the Epoch-relative time of January 1, 00:00:00 UTC, in a year, the
+** year, a rule, and the offset from UTC at the time that rule takes effect,
  ** calculate the Epoch-relative time that rule takes effect.
  */

  static time_t
-transtime(const time_t janfirst, const int year, const struct rule * const rulep, const long offset)
+transtime(const time_t janfirst, const int year, const struct rule *const rulep, const int_fast32_t offset)
  {
    int leapyear;
-  time_t value=0;
+  time_t value;
    int i;
    int d, m1, yy0, yy1, yy2, dow;

+  INITIALIZE(value);
    leapyear = isleap(year);
    switch (rulep->r_type)
    {

    case JULIAN_DAY:
@@ -638,12 +879,11 @@ transtime(const time_t janfirst, const i
       */
      m1 = (rulep->r_mon + 9) % 12 + 1;
      yy0 = (rulep->r_mon <= 2) ? (year - 1) : year;
      yy1 = yy0 / 100;
      yy2 = yy0 % 100;
-    dow = ((26 * m1 - 2) / 10 +
-       1 + yy2 + yy2 / 4 + yy1 / 4 - 2 * yy1) % 7;
+    dow = ((26 * m1 - 2) / 10 + 1 + yy2 + yy2 / 4 + yy1 / 4 - 2 * yy1) % 7;
      if (dow < 0)
        dow += DAYSPERWEEK;

      /*
       ** "dow" is the day-of-week of the first day of the month. Get
@@ -653,13 +893,12 @@ transtime(const time_t janfirst, const i
      d = rulep->r_day - dow;
      if (d < 0)
        d += DAYSPERWEEK;
      for (i = 1; i < rulep->r_week; ++i)
      {
-      if (d + DAYSPERWEEK >=
-      mon_lengths[leapyear][rulep->r_mon - 1])
-    break;
+      if (d + DAYSPERWEEK >= mon_lengths[leapyear][rulep->r_mon - 1])
+        break;
        d += DAYSPERWEEK;
      }

      /*
       ** "d" is the day-of-month (zero-origin) of the day we want.
@@ -667,78 +906,100 @@ transtime(const time_t janfirst, const i
      value += d * SECSPERDAY;
      break;
    }

    /*
-   ** "value" is the Epoch-relative time of 00:00:00 GMT on the day in
+   ** "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
     ** time on that day, add the transition time and the current offset
-   ** from GMT.
+   ** from UTC.
     */
    return value + rulep->r_time + offset;
  }

  /*
  ** Given a POSIX section 8-style TZ string, fill in the rule tables as
  ** appropriate.
  */

  static int
-tzparse(const char *name, struct state * const sp, const int lastditch)
+tzparse(const char *name, struct state *const sp, const int lastditch)
  {
-  const char * stdname;
-  const char * dstname=0;
+  const char *stdname;
+  const char *dstname;
    size_t stdlen;
-  int dstlen;
-  long stdoffset;
-  long dstoffset;
-  time_t * atp;
-  unsigned char * typep;
-  char * cp;
+  size_t dstlen;
+  int_fast32_t stdoffset;
+  int_fast32_t dstoffset;
+  time_t *atp;
+  unsigned char *typep;
+  char *cp;
    int load_result;
+  static struct ttinfo zttinfo;

+  INITIALIZE(dstname);
    stdname = name;
    if (lastditch)
    {
-    stdlen = strlen(name);    /* length of standard zone name */
+    stdlen = strlen(name);     /* length of standard zone name */
      name += stdlen;
      if (stdlen >= sizeof sp->chars)
        stdlen = (sizeof sp->chars) - 1;
    }
    else
    {
-    name = getzname(name);
-    stdlen = name - stdname;
-    if (stdlen < 3)
+    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;
-  }
-  if (*name == '\0')
-    return -1;
-  else
-  {
      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 */
+    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);
        if (name == NULL)
-    return -1;
+        return -1;
      }
      else
        dstoffset = stdoffset - SECSPERHOUR;
+    if (*name == '\0' && load_result != 0)
+      name = TZDEFRULESTRING;
      if (*name == ',' || *name == ';')
      {
        struct rule start;
        struct rule end;
        int year;
@@ -746,146 +1007,153 @@ tzparse(const char *name, struct state *
        time_t starttime;
        time_t endtime;

        ++name;
        if ((name = getrule(name, &start)) == NULL)
-    return -1;
+        return -1;
        if (*name++ != ',')
-    return -1;
+        return -1;
        if ((name = getrule(name, &end)) == NULL)
-    return -1;
+        return -1;
        if (*name != '\0')
-    return -1;
-      sp->typecnt = 2;        /* standard time and DST */
+        return -1;
+      sp->typecnt = 2;           /* standard time and DST */
        /*
-       ** Two transitions per year, from EPOCH_YEAR to 2037.
-       */
-      sp->timecnt = 2 * (2037 - EPOCH_YEAR + 1);
-      if (sp->timecnt > TZ_MAX_TIMES)
-    return -1;
+      ** Two transitions per year, from EPOCH_YEAR forward.
+      */
+      sp->ttis[0] = sp->ttis[1] = zttinfo;
        sp->ttis[0].tt_gmtoff = -dstoffset;
        sp->ttis[0].tt_isdst = 1;
        sp->ttis[0].tt_abbrind = stdlen + 1;
        sp->ttis[1].tt_gmtoff = -stdoffset;
        sp->ttis[1].tt_isdst = 0;
        sp->ttis[1].tt_abbrind = 0;
        atp = sp->ats;
        typep = sp->types;
        janfirst = 0;
-      for (year = EPOCH_YEAR; year <= 2037; ++year)
+      sp->timecnt = 0;
+      for (year = EPOCH_YEAR; sp->timecnt + 2 <= TZ_MAX_TIMES; ++year)
        {
-    starttime = transtime(janfirst, year, &start,
-                  stdoffset);
-    endtime = transtime(janfirst, year, &end,
-                dstoffset);
-    if (starttime > endtime)
-    {
-      *atp++ = endtime;
-      *typep++ = 1;        /* DST ends */
-      *atp++ = starttime;
-      *typep++ = 0;        /* DST begins */
-    }
-    else
-    {
-      *atp++ = starttime;
-      *typep++ = 0;        /* DST begins */
-      *atp++ = endtime;
-      *typep++ = 1;        /* DST ends */
-    }
-    janfirst +=
-      year_lengths[isleap(year)] * SECSPERDAY;
+        time_t newfirst;
+        starttime = transtime(janfirst, year, &start, stdoffset);
+        endtime = transtime(janfirst, year, &end, dstoffset);
+        if (starttime > endtime)
+        {
+          *atp++ = endtime;
+          *typep++ = 1;          /* DST ends */
+          *atp++ = starttime;
+          *typep++ = 0;          /* DST begins */
+        }
+        else
+        {
+          *atp++ = starttime;
+          *typep++ = 0;          /* DST begins */
+          *atp++ = endtime;
+          *typep++ = 1;          /* DST ends */
+        }
+        sp->timecnt += 2;
+        newfirst = janfirst;
+        newfirst += year_lengths[isleap(year)] * SECSPERDAY;
+        if (newfirst <= janfirst)
+          break;
+        janfirst = newfirst;
        }
      }
      else
      {
-      int sawstd;
-      int sawdst;
-      long stdfix;
-      long dstfix;
-      long oldfix;
+      register int_fast32_t theirstdoffset;
+      register int_fast32_t theirdstoffset;
+      register int_fast32_t theiroffset;
        int isdst;
-      int i;
+      int i, j;

        if (*name != '\0')
-    return -1;
-      if (load_result != 0)
-    return -1;
+        return -1;
        /*
-       ** Compute the difference between the real and
-       ** prototype standard and summer time offsets
-       ** from GMT, and put the real standard and summer
-       ** time offsets into the rules in place of the
-       ** prototype offsets.
-       */
-      sawstd = FALSE;
-      sawdst = FALSE;
-      stdfix = 0;
-      dstfix = 0;
-      for (i = 0; i < sp->typecnt; ++i)
+      ** Initial values of theirstdoffset and theirdstoffset.
+      */
+      theirstdoffset = 0;
+      for (i = 0; i < sp->timecnt; ++i)
+      {
+        j = sp->types[i];
+        if (!sp->ttis[j].tt_isdst)
+        {
+          theirstdoffset = -sp->ttis[j].tt_gmtoff;
+          break;
+        }
+      }
+      theirdstoffset = 0;
+      for (i = 0; i < sp->timecnt; ++i)
        {
-    if (sp->ttis[i].tt_isdst)
-    {
-      oldfix = dstfix;
-      dstfix =
-        sp->ttis[i].tt_gmtoff + dstoffset;
-      if (sawdst && (oldfix != dstfix))
-        return -1;
-      sp->ttis[i].tt_gmtoff = -dstoffset;
-      sp->ttis[i].tt_abbrind = stdlen + 1;
-      sawdst = TRUE;
-    }
-    else
-    {
-      oldfix = stdfix;
-      stdfix =
-        sp->ttis[i].tt_gmtoff + stdoffset;
-      if (sawstd && (oldfix != stdfix))
-        return -1;
-      sp->ttis[i].tt_gmtoff = -stdoffset;
-      sp->ttis[i].tt_abbrind = 0;
-      sawstd = TRUE;
-    }
+        j = sp->types[i];
+        if (sp->ttis[j].tt_isdst)
+        {
+          theirdstoffset = -sp->ttis[j].tt_gmtoff;
+          break;
+        }
        }
        /*
-       ** Make sure we have both standard and summer time.
-       */
-      if (!sawdst || !sawstd)
-    return -1;
+      ** Initially we're assumed to be in standard time.
+      */
+      isdst = FALSE;
+      theiroffset = theirstdoffset;
        /*
-       ** Now correct the transition times by shifting
-       ** them by the difference between the real and
-       ** prototype offsets.  Note that this difference
-       ** can be different in standard and summer time;
-       ** the prototype probably has a 1-hour difference
-       ** between standard and summer time, but a different
-       ** difference can be specified in TZ.
-       */
-      isdst = FALSE; /* we start in standard time */
+      ** Now juggle transition times and types
+      ** tracking offsets as you do.
+      */
        for (i = 0; i < sp->timecnt; ++i)
        {
-    const struct ttinfo * ttisp;
-
-    /*
-     ** If summer time is in effect, and the
-     ** transition time was not specified as
-     ** standard time, add the summer time
-     ** offset to the transition time;
-     ** otherwise, add the standard time offset
-     ** to the transition time.
-     */
-    ttisp = &sp->ttis[sp->types[i]];
-    sp->ats[i] +=
-      (isdst && !ttisp->tt_ttisstd) ?
-        dstfix : stdfix;
-    isdst = ttisp->tt_isdst;
+        j = sp->types[i];
+        sp->types[i] = sp->ttis[j].tt_isdst;
+        if (sp->ttis[j].tt_ttisgmt)
+        {
+          /* No adjustment to transition time */
+        }
+        else
+        {
+          /*
+           ** If summer time is in effect, and the
+           ** transition time was not specified as
+           ** standard time, add the summer time
+           ** offset to the transition time;
+           ** otherwise, add the standard time
+           ** offset to the transition time.
+           */
+           /*
+            ** Transitions from DST to DDST
+            ** will effectively disappear since
+            ** POSIX provides for only one DST
+            ** offset.
+            */
+          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)
+          theirdstoffset = theiroffset;
+        else
+          theirstdoffset = theiroffset;
        }
+      /*
+      ** Finally, fill in ttis.
+      */
+      sp->ttis[0] = sp->ttis[1] = zttinfo;
+      sp->ttis[0].tt_gmtoff = -stdoffset;
+      sp->ttis[0].tt_isdst = FALSE;
+      sp->ttis[0].tt_abbrind = 0;
+      sp->ttis[1].tt_gmtoff = -dstoffset;
+      sp->ttis[1].tt_isdst = TRUE;
+      sp->ttis[1].tt_abbrind = stdlen + 1;
+      sp->typecnt = 2;
      }
    }
    else
    {
      dstlen = 0;
-    sp->typecnt = 1;        /* only standard time */
+    sp->typecnt = 1;             /* only standard time */
      sp->timecnt = 0;
      sp->ttis[0].tt_gmtoff = -stdoffset;
      sp->ttis[0].tt_isdst = 0;
      sp->ttis[0].tt_abbrind = 0;
    }
@@ -905,14 +1173,25 @@ tzparse(const char *name, struct state *
    }
    return 0;
  }

  static void
-gmtload(struct state * const sp)
+gmtload(struct state *const sp)
+{
+  if (tzload(gmt, sp, TRUE) != 0)
+    (void) tzparse(gmt, sp, TRUE);
+}
+
+void
+tzsetwall(void)
  {
-  if (tzload(GMT, sp) != 0)
-    (void) tzparse(GMT, sp, TRUE);
+  if (lcl_is_set == -1)
+    return;
+  lcl_is_set = -1;
+  if (tzload((char *) NULL, lclptr, TRUE) != 0)
+    gmtload(lclptr);
+  settzname();
  }

  void
  tzset(void)
  {
@@ -928,328 +1207,331 @@ tzset(void)
       were called, we are all done here.  */
    last_env_changed = __environ_changed;
    name = getenv("TZ");
    /* Use stricmp, since if TZ points to a file name, we need to be
       case-insensitive.  */
-  if (lcl_is_set > 0 && (name == NULL || stricmp(name, lcl_tzstr) == 0))
+  if (lcl_is_set > 0 && (name == NULL || stricmp(name, lcl_TZname) == 0))
      return;

    /* On to some *real* work... */
    if (name == NULL)
    {
      tzsetwall();
      lcl_is_set = 1;
      return;
    }
-  if (strlen(name) < sizeof(lcl_tzstr))
-  {
-    lcl_is_set = 1;
-    strcpy(lcl_tzstr, name);
-  }
-  else
-    lcl_is_set = 0;
-#ifdef ALL_STATE
-  if (lclptr == NULL)
-  {
-    lclptr = (struct state *) malloc(sizeof *lclptr);
-    if (lclptr == NULL)
-    {
-      settzname();        /* all we can do */
-      return;
-    }
-  }
-#endif /* defined ALL_STATE */
+  lcl_is_set = strlen(name) < sizeof lcl_TZname;
+  if (lcl_is_set)
+    strcpy(lcl_TZname, name);
+
    if (*name == '\0')
    {
      /*
       ** User wants it fast rather than right.
       */
-    lclptr->leapcnt = 0;    /* so, we're off a little */
+    lclptr->leapcnt = 0;       /* so, we're off a little */
      lclptr->timecnt = 0;
+    lclptr->ttis[0].tt_isdst = 0;
      lclptr->ttis[0].tt_gmtoff = 0;
      lclptr->ttis[0].tt_abbrind = 0;
-    (void) strcpy(lclptr->chars, GMT);
+    (void) strcpy(lclptr->chars, gmt);
    }
-  else if (tzload(name, lclptr) != 0)
+  else if (tzload(name, lclptr, TRUE) != 0)
      if (name[0] == ':' || tzparse(name, lclptr, FALSE) != 0)
        gmtload(lclptr);
    settzname();
  }

-void
-tzsetwall(void)
-{
-  if (lcl_is_set == -1)
-    return;
-  lcl_is_set = -1;
-#ifdef ALL_STATE
-  if (lclptr == NULL)
-  {
-    lclptr = (struct state *) malloc(sizeof *lclptr);
-    if (lclptr == NULL)
-    {
-      settzname();        /* all we can do */
-      return;
-    }
-  }
-#endif /* defined ALL_STATE */
-  if (tzload((char *) NULL, lclptr) != 0)
-    gmtload(lclptr);
-  settzname();
-}
-
  /*
  ** 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--
  ** but it *is* desirable.)
  **
  ** The unused offset argument is for the benefit of mktime variants.
  */

  /*ARGSUSED*/
-static void
-localsub(const time_t * const timep, const long offset, struct tm * const tmp)
+static struct tm *
+localsub(const time_t *const timep, const int_fast32_t offset, struct tm *const tmp)
  {
-  const struct state * sp;
-  const struct ttinfo * ttisp;
+  const struct state *sp;
+  const struct ttinfo *ttisp;
    int i;
+  struct tm *result;
    const time_t t = *timep;

-  tzset();
    sp = lclptr;
-#ifdef ALL_STATE
-  if (sp == NULL)
+  if ((sp->goback && t < sp->ats[0]) ||
+      (sp->goahead && t > sp->ats[sp->timecnt - 1]))
    {
-    gmtsub(timep, offset, tmp);
-    return;
+    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 = 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 -= icycles * YEARSPERREPEAT;
+      else
+        newy += icycles * YEARSPERREPEAT;
+      tmp->tm_year = newy;
+      if (tmp->tm_year != (int)newy)
+        return NULL;
+    }
+    return result;
    }
-#endif /* defined ALL_STATE */
    if (sp->timecnt == 0 || t < sp->ats[0])
-  {
-    i = 0;
-    while (sp->ttis[i].tt_isdst)
-      if (++i >= sp->typecnt)
-      {
-    i = 0;
-    break;
-      }
-  }
+    i = sp->defaulttype;
    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) >> 1;
+
+      if (t < sp->ats[mid])
+        hi = mid;
+      else
+        lo = mid + 1;
+    }
+    i = (int) sp->types[lo - 1];
    }
    ttisp = &sp->ttis[i];
    /*
     ** To get (wrong) behavior that's compatible with System V Release 2.0
     ** you'd replace the statement below with
     ** 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] = unconst(&sp->chars[ttisp->tt_abbrind], char *);
    tmp->tm_zone = unconst(&sp->chars[ttisp->tt_abbrind], char *);
+  return result;
  }

  struct tm *
-localtime_r( const time_t * __restrict__ timep, struct tm * __restrict__ tm)
+localtime(const time_t *const timep)
  {
+  static struct tm tm;

-  localsub(timep, 0L, tm);
-  return tm;
+  tzset();
+  return localtime_r(timep, &tm);
  }

  struct tm *
-localtime(const time_t * const timep)
+localtime_r( const time_t * __restrict__ timep, struct tm * __restrict__ tm)
  {
-  static struct tm tm;
-
-  return localtime_r(timep, &tm);
+  return localsub(timep, 0L, tm);;
  }

  /*
  ** gmtsub is to gmtime as localsub is to localtime.
  */

-static void
-gmtsub(const time_t * const timep, const long offset, struct tm * const tmp)
+static struct tm *
+gmtsub(const time_t *const timep, const int_fast32_t offset, struct tm *const tmp)
  {
+  register struct tm *result;
+
    if (!gmt_is_set)
    {
      gmt_is_set = TRUE;
-#ifdef ALL_STATE
-    gmtptr = (struct state *) malloc(sizeof *gmtptr);
-    if (gmtptr != NULL)
-#endif /* defined ALL_STATE */
-      gmtload(gmtptr);
+    gmtload(gmtptr);
    }
-  timesub(timep, offset, gmtptr, tmp);
+  result = timesub(timep, offset, gmtptr, tmp);
    /*
     ** Could get fancy here and deliver something such as
-   ** "GMT+xxxx" or "GMT-xxxx" if offset is non-zero,
+   ** "UTC+xxxx" or "UTC-xxxx" if offset is non-zero,
     ** but this is no time for a treasure hunt.
     */
    if (offset != 0)
-    tmp->tm_zone = WILDABBR;
+    tmp->tm_zone = wildabbr;
    else
-  {
-#ifdef ALL_STATE
-    if (gmtptr == NULL)
-      tmp->TM_ZONE = GMT;
-    else
-      tmp->TM_ZONE = gmtptr->chars;
-#endif /* defined ALL_STATE */
-#ifndef ALL_STATE
      tmp->tm_zone = gmtptr->chars;
-#endif /* State Farm */
-  }
+  return result;
  }

  struct tm *
-gmtime_r(const time_t * __restrict__ timep, struct tm * __restrict__ tm)
+gmtime(const time_t *const timep)
  {
+  static struct tm tm;

-  gmtsub(timep, 0L, tm);
-  return tm;
+  return gmtime_r(timep, &tm);
  }

  struct tm *
-gmtime(const time_t * const timep)
+gmtime_r(const time_t * __restrict__ timep, struct tm * __restrict__ tm)
  {
-  static struct tm tm;
-
-  return gmtime_r(timep, &tm);
+  return gmtsub(timep, 0L, tm);
  }

-/* Return the year which is DAYS away from the year Y0.  */
+/*
+** 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
-days_to_years(int y0, long *days)
+leaps_thru_end_of(register const int y)
  {
-  int y, dir, yleap;
-
-  y = y0;
-  dir = *days >= 0 ? 1 : -1;
-
-  /* We move by 400, 100, and 4 years at a time, to quickly reduce
-     DAYS to a reasonable value.  */
-  while (*days*dir > n_year_lengths[2])
-  {
-    y += dir*400;
-    *days -= dir*n_year_lengths[2];
-  }
-  while (*days*dir > n_year_lengths[1])
-  {
-    y += dir*100;
-    *days -= dir*n_year_lengths[1];
-  }
-  while (*days*dir > n_year_lengths[0])
-  {
-    y += dir*4;
-    *days -= dir*n_year_lengths[0];
-  }
-  if (dir == 1)
-    for ( ; ; )
-    {
-      yleap = isleap(y);
-      if (*days < (long) year_lengths[yleap])
-    break;
-      ++y;
-      *days = *days - (long) year_lengths[yleap];
-    }
-  else
-    do {
-    --y;
-    yleap = isleap(y);
-    *days = *days + (long) year_lengths[yleap];
-  } while (*days < 0);
-
-  return y;
+  return (y >= 0) ? (y / 4 - y / 100 + y / 400) : -(leaps_thru_end_of(-(y + 1)) + 1);
  }

-static void
-timesub(const time_t * const timep, const long offset, const struct state * const sp, struct tm * const tmp)
+static struct tm *
+timesub(const time_t *const timep, const int_fast32_t offset, register const struct state *const sp, register struct tm *const tmp)
  {
-  const struct lsinfo * lp;
-  long days;
-  long rem;
+  const struct lsinfo *lp;
+  time_t tdays;
+  int idays;     /* unsigned would be so 2003 */
+  int_fast64_t rem;
    int y;
-  int yleap;
-  const int * ip;
-  long corr;
+  const int *ip;
+  int_fast64_t corr;
    int hit;
    int i;

    corr = 0;
-  hit = FALSE;
-#ifdef ALL_STATE
-  i = (sp == NULL) ? 0 : sp->leapcnt;
-#endif /* defined ALL_STATE */
-#ifndef ALL_STATE
+  hit = 0;
    i = sp->leapcnt;
-#endif /* State Farm */
-  while (--i >= 0)
+  while (--i > -1)
    {
      lp = &sp->lsis[i];
      if (*timep >= lp->ls_trans)
      {
        if (*timep == lp->ls_trans)
-    hit = ((i == 0 && lp->ls_corr > 0) ||
-           lp->ls_corr > sp->lsis[i - 1].ls_corr);
+      {
+        hit = ((i == 0 && lp->ls_corr > 0) || lp->ls_corr > sp->lsis[i - 1].ls_corr);
+        if (hit)
+          while (i > 0 &&
+                 sp->lsis[i].ls_trans == sp->lsis[i - 1].ls_trans + 1 &&
+                 sp->lsis[i].ls_corr == sp->lsis[i - 1].ls_corr + 1)
+          {
+            ++hit;
+            --i;
+          }
+      }
        corr = lp->ls_corr;
        break;
      }
    }
-  days = *timep / SECSPERDAY;
-  rem = *timep % SECSPERDAY;
-#ifdef mc68k
-  if (*timep == 0x80000000)
+  y = EPOCH_YEAR;
+  tdays = *timep / SECSPERDAY;
+  rem = *timep - tdays * SECSPERDAY;
+  while (tdays < 0 || tdays >= (time_t)year_lengths[isleap(y)])
+  {
+    int newy;
+    register time_t tdelta;
+    register int idelta;
+    register int leapdays;
+
+    tdelta = tdays / DAYSPERLYEAR;
+    idelta = 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;
+  }
    {
-    /*
-     ** A 3B1 muffs the division on the most negative number.
-     */
-    days = -24855;
-    rem = -11648;
+    register int_fast32_t seconds;
+    register time_t half_second = 0.5;
+
+    seconds = tdays * SECSPERDAY + half_second;
+    tdays = seconds / SECSPERDAY;
+    rem += seconds - tdays * SECSPERDAY;
    }
-#endif /* mc68k */
-  rem += (offset - corr);
+  /*
+  ** Given the range, we can now fearlessly cast...
+  */
+  idays = tdays;
+  rem += offset - corr;
    while (rem < 0)
    {
      rem += SECSPERDAY;
-    --days;
+    --idays;
    }
    while (rem >= SECSPERDAY)
    {
      rem -= SECSPERDAY;
-    ++days;
+    ++idays;
    }
-  tmp->tm_hour = (int) (rem / SECSPERHOUR);
-  rem = rem % SECSPERHOUR;
-  tmp->tm_min = (int) (rem / SECSPERMIN);
-  tmp->tm_sec = (int) (rem % SECSPERMIN);
-  if (hit)
-    /*
-     ** A positive leap second requires a special
-     ** representation.  This uses "... ??:59:60".
-     */
-    ++(tmp->tm_sec);
-  tmp->tm_wday = (int) ((EPOCH_WDAY + days) % DAYSPERWEEK);
+  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;
-  y = days_to_years(EPOCH_YEAR, &days);
-  yleap = isleap(y);
-  tmp->tm_year = 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);
+  tmp->tm_hour = (int) (rem / SECSPERHOUR);
+  rem %= SECSPERHOUR;
+  tmp->tm_min = (int) (rem / SECSPERMIN);
+  /*
+  ** A positive leap second requires a special
+  ** representation. This uses "... ??:59:60" et seq.
+  */
+  tmp->tm_sec = (int) (rem % SECSPERMIN) + hit;
+  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;
    tmp->tm_gmtoff = offset;
+  return tmp;
  }

  /*
  ** A la X3J11
  */
@@ -1264,15 +1546,15 @@ asctime_r(const struct tm * __restrict__
      "Jan", "Feb", "Mar", "Apr", "May", "Jun",
      "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
    };

    (void) sprintf(result, "%.3s %.3s%3d %02d:%02d:%02d %d\n",
-         wday_name[timeptr->tm_wday],
-         mon_name[timeptr->tm_mon],
-         timeptr->tm_mday, timeptr->tm_hour,
-         timeptr->tm_min, timeptr->tm_sec,
-         TM_YEAR_BASE + timeptr->tm_year);
+                 wday_name[timeptr->tm_wday],
+                 mon_name[timeptr->tm_mon],
+                 timeptr->tm_mday, timeptr->tm_hour,
+                 timeptr->tm_min, timeptr->tm_sec,
+                 TM_YEAR_BASE + timeptr->tm_year);
    return result;
  }

  char *
  asctime(const struct tm *timeptr)
@@ -1289,50 +1571,82 @@ ctime_r(const time_t *timep, char *resul

    return asctime_r(localtime_r(timep, &tm), result);
  }

  char *
-ctime(const time_t * const timep)
+ctime(const time_t *const timep)
  {
    return asctime(localtime(timep));
  }

  /*
  ** 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. (mtxinu!kridle now).
-**    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).
+**      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. (mtxinu!kridle now).
+**      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).
  */

  #ifndef WRONG
-#define WRONG    (-1)
+#define WRONG   (-1)
  #endif /* !defined WRONG */

-static void
-normalize(int * const tensptr, int * const unitsptr, const int base)
+/*
+** Normalize logic courtesy Paul Eggert.
+*/
+
+static int
+increment_overflow(int *const ip, int j)
  {
-  if (*unitsptr >= base)
-  {
-    *tensptr += *unitsptr / base;
-    *unitsptr %= base;
-  }
-  else if (*unitsptr < 0)
-  {
-    --*tensptr;
-    *unitsptr += base;
-    if (*unitsptr < 0)
-    {
-      *tensptr -= 1 + (-*unitsptr) / base;
-      *unitsptr = base - (-*unitsptr) % base;
-    }
-  }
+  register int const i = *ip;
+
+  /*
+  ** If i >= 0 there can only be overflow if i + j > INT_MAX
+  ** or if j > INT_MAX - i; given i >= 0, INT_MAX - i cannot overflow.
+  ** If i < 0 there can only be overflow if i + j < INT_MIN
+  ** or if j < INT_MIN - i; given i < 0, INT_MIN - i cannot overflow.
+  */
+  if ((i >= 0) ? (j > INT_MAX - i) : (j < INT_MIN - i))
+    return TRUE;
+  *ip += j;
+  return FALSE;
  }

  static int
-tmcomp(const struct tm * const atmp, const struct tm * const btmp)
+increment_overflow32(int_fast32_t *const lp, int const m)
+{
+  register int_fast32_t const l = *lp;
+
+  if ((l >= 0) ? (m > INT_FAST32_MAX - l) : (m < INT_FAST32_MIN - l))
+    return TRUE;
+  *lp += m;
+  return FALSE;
+}
+
+static int
+normalize_overflow(int *const tensptr, int *const unitsptr, const int base)
+{
+  register int tensdelta;
+
+  tensdelta = (*unitsptr >= 0) ? (*unitsptr / base) : (-1 - (-1 - *unitsptr) / base);
+  *unitsptr -= tensdelta * base;
+  return increment_overflow(tensptr, tensdelta);
+}
+
+static int
+normalize_overflow32(int_fast32_t *const tensptr, int *const unitsptr, const int base)
+{
+  register int tensdelta;
+
+  tensdelta = (*unitsptr >= 0) ? (*unitsptr / base) : (-1 - (-1 - *unitsptr) / base);
+  *unitsptr -= tensdelta * base;
+  return increment_overflow32(tensptr, tensdelta);
+}
+
+static int
+tmcomp(const struct tm *const atmp, const struct tm *const btmp)
  {
    int result;

    if ((result = (atmp->tm_year - btmp->tm_year)) == 0 &&
        (result = (atmp->tm_mon - btmp->tm_mon)) == 0 &&
@@ -1341,220 +1655,283 @@ tmcomp(const struct tm * const atmp, con
        (result = (atmp->tm_min - btmp->tm_min)) == 0)
      result = atmp->tm_sec - btmp->tm_sec;
    return result;
  }

-static void
-tmnormalize(struct tm *tmp)
-{
-  if (tmp->tm_sec >= SECSPERMIN + 2 || tmp->tm_sec < 0)
-    normalize(&tmp->tm_min, &tmp->tm_sec, SECSPERMIN);
-  normalize(&tmp->tm_hour, &tmp->tm_min, MINSPERHOUR);
-  normalize(&tmp->tm_mday, &tmp->tm_hour, HOURSPERDAY);
-  normalize(&tmp->tm_year, &tmp->tm_mon, MONSPERYEAR);
-
-  /* If tm_mday is negative, or positive and too large, bring it back
-     to the reasonable range [1..366].  */
-  if (tmp->tm_mday <= 0 || tmp->tm_mday > DAYSPERLYEAR)
-  {
-    long days = tmp->tm_mday;
-    int yleap = isleap(tmp->tm_year + TM_YEAR_BASE);
-
-    while (tmp->tm_mon--)
-      days += mon_lengths[yleap][tmp->tm_mon];
-    tmp->tm_year =
-      days_to_years(tmp->tm_year + TM_YEAR_BASE, &days) - TM_YEAR_BASE;
-    tmp->tm_mday = days;
-    tmp->tm_mon = 0;
-  }
-
-  /* Now correct tm_mon and tm_mday so that they are within their
-     normal ranges [0..11] and [1..mon_length[tm_mon]], respectively.  */
-  for ( ; ; )
-  {
-    int i = mon_lengths[isleap(tmp->tm_year + TM_YEAR_BASE)][tmp->tm_mon];
-    if (tmp->tm_mday <= i)
-      break;
-    tmp->tm_mday -= i;
-    if (++tmp->tm_mon >= MONSPERYEAR)
-    {
-      tmp->tm_mon = 0;
-      ++tmp->tm_year;
-    }
-  }
-}
-
  static time_t
-time2(struct tm *tmp, void (*const funcp)(const time_t *const,const long,struct tm *), const long offset, int * const okayp)
+time2sub(struct tm *const tmp, struct tm *(*const funcp)(const time_t *, int_fast32_t, struct tm *), const int_fast32_t offset, int *const okayp, const int do_norm_secs)
  {
-  const struct state * sp;
-  int dir;
-  int bits;
-  int i, j ;
-  int saved_seconds;
+  register const struct state *sp;
+  register int dir;
+  register int i, j;
+  register int saved_seconds;
+  register int_fast32_t li;
+  register time_t lo;
+  register time_t hi;
+  int_fast32_t y;
    time_t newt;
    time_t t;
    struct tm yourtm, mytm;

    *okayp = FALSE;
-  tmnormalize(tmp);
    yourtm = *tmp;
-  saved_seconds = yourtm.tm_sec;
-  yourtm.tm_sec = 0;
+  if (do_norm_secs)
+  {
+    if (normalize_overflow(&yourtm.tm_min, &yourtm.tm_sec, SECSPERMIN))
+      return WRONG;
+  }
+  if (normalize_overflow(&yourtm.tm_hour, &yourtm.tm_min, MINSPERHOUR))
+    return WRONG;
+  if (normalize_overflow(&yourtm.tm_mday, &yourtm.tm_hour, HOURSPERDAY))
+    return WRONG;
+  y = yourtm.tm_year;
+  if (normalize_overflow32(&y, &yourtm.tm_mon, MONSPERYEAR))
+    return WRONG;
    /*
-   ** Calculate the number of magnitude bits in a time_t
-   ** (this works regardless of whether time_t is
-   ** signed or unsigned, though lint complains if unsigned).
-   */
-  for (bits = 0, t = 1; t > 0; ++bits, t <<= 1)
-    ;
+  ** Turn y into an actual year number for now.
+  ** It is converted back to an offset from TM_YEAR_BASE later.
+  */
+  if (increment_overflow32(&y, TM_YEAR_BASE))
+    return WRONG;
+  while (yourtm.tm_mday <= 0)
+  {
+    if (increment_overflow32(&y, -1))
+      return WRONG;
+    li = y + (1 < yourtm.tm_mon);
+    yourtm.tm_mday += year_lengths[isleap(li)];
+  }
+  while (yourtm.tm_mday > DAYSPERLYEAR)
+  {
+    li = y + (1 < yourtm.tm_mon);
+    yourtm.tm_mday -= year_lengths[isleap(li)];
+    if (increment_overflow32(&y, 1))
+      return WRONG;
+  }
+  for ( ; ; )
+  {
+    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_overflow32(&y, 1))
+        return WRONG;
+    }
+  }
+  if (increment_overflow32(&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 (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.
+    ** Set tm_sec to 59 instead.
+    ** This assumes that the minimum representable time is
+    ** not in the same minute that a leap second was deleted from,
+    ** which is a safer assumption than using 58 would be.
+    */
+    if (increment_overflow(&yourtm.tm_sec, 1 - SECSPERMIN))
+      return WRONG;
+    saved_seconds = yourtm.tm_sec;
+    yourtm.tm_sec = SECSPERMIN - 1;
+  }
+  else
+  {
+    saved_seconds = yourtm.tm_sec;
+    yourtm.tm_sec = 0;
+  }
    /*
-   ** If time_t is signed, then 0 is the median value,
-   ** if time_t is unsigned, then 1 << bits is median.
-   */
-  t = (time_t) 1 << bits;
+  ** Do a binary search (this works whatever time_t's type is).
+  */
+  if (!TYPE_SIGNED(time_t))
+  {
+    lo = 0;
+    hi = lo - 1;
+  }
+  else if (!TYPE_INTEGRAL(time_t))
+  {
+    if (sizeof(time_t) > sizeof(float))
+      hi = (time_t) DBL_MAX;
+    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)
-    return WRONG;
-      if (bits < 0)
-    --t;
-      else if (dir > 0)
-    t -= (time_t) 1 << bits;
-      else t += (time_t) 1 << bits;
+      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 (dir > 0)
+        hi = t;
+      else
+        lo = t;
        continue;
      }
      if (yourtm.tm_isdst < 0 || mytm.tm_isdst == yourtm.tm_isdst)
        break;
      /*
-     ** Right time, wrong type.
-     ** Hunt for right time, right type.
-     ** It's okay to guess wrong since the guess
-     ** gets checked.
-     */
-    sp = (const struct state *)
-      ((funcp == localsub) ? lclptr : gmtptr);
-#ifdef ALL_STATE
-    if (sp == NULL)
-      return WRONG;
-#endif /* defined ALL_STATE */
-    for (i = 0; i < sp->typecnt; ++i)
+    ** Right time, wrong type.
+    ** Hunt for right time, right type.
+    ** It's okay to guess wrong since the guess
+    ** gets checked.
+    */
+    sp = (const struct state *)((funcp == localsub) ? lclptr : gmtptr);
+    for (i = sp->typecnt - 1; i >= 0; --i)
      {
        if (sp->ttis[i].tt_isdst != yourtm.tm_isdst)
-    continue;
-      for (j = 0; j < sp->typecnt; ++j)
+        continue;
+      for (j = sp->typecnt - 1; j >= 0; --j)
        {
-    if (sp->ttis[j].tt_isdst == yourtm.tm_isdst)
-      continue;
-    newt = t + sp->ttis[j].tt_gmtoff -
-      sp->ttis[i].tt_gmtoff;
-    (*funcp)(&newt, offset, &mytm);
-    if (tmcomp(&mytm, &yourtm) != 0)
-      continue;
-    if (mytm.tm_isdst != yourtm.tm_isdst)
-      continue;
-    /*
-     ** We have a match.
-     */
-    t = newt;
-    goto label;
+        if (sp->ttis[j].tt_isdst == yourtm.tm_isdst)
+          continue;
+        newt = t + sp->ttis[j].tt_gmtoff - sp->ttis[i].tt_gmtoff;
+        if ((*funcp)(&newt, offset, &mytm) == NULL)
+          continue;
+        if (tmcomp(&mytm, &yourtm) != 0)
+          continue;
+        if (mytm.tm_isdst != yourtm.tm_isdst)
+          continue;
+        /*
+        ** We have a match.
+        */
+        t = newt;
+        goto label;
        }
      }
      return WRONG;
    }
- label:
-  t += saved_seconds;
-  (*funcp)(&t, offset, tmp);
-  *okayp = TRUE;
+label:
+  newt = t + saved_seconds;
+  if ((newt < t) != (saved_seconds < 0))
+    return WRONG;
+  t = newt;
+  if ((*funcp)(&t, offset, tmp))
+    *okayp = TRUE;
    return t;
  }

  static time_t
-time1(struct tm * const tmp, void (*const funcp)(const time_t * const, const long, struct tm *), const long offset)
+time2(struct tm *const tmp, struct tm *(*const funcp)(const time_t *, int_fast32_t, struct tm *), const int_fast32_t offset, int *const okayp)
  {
    time_t t;
-  const struct state * sp;
-  int samei, otheri;
+
+  /*
+  ** First try without normalization of seconds
+  ** (in case tm_sec contains a value associated with a leap second).
+  ** If that fails, try with normalization of seconds.
+  */
+  t = time2sub(tmp, funcp, offset, okayp, FALSE);
+  return *okayp ? t : time2sub(tmp, funcp, offset, okayp, TRUE);
+}
+
+static time_t
+time1(struct tm *const tmp, struct tm *(*const funcp)(const time_t *, int_fast32_t, struct tm *), const int_fast32_t offset)
+{
+  register time_t t;
+  register const struct state *sp;
+  register int samei, otheri;
+  register int sameind, otherind;
+  register int i;
+  register int nseen;
+  int seen[TZ_MAX_TYPES];
+  int types[TZ_MAX_TYPES];
    int okay;

+  if (tmp == NULL)
+  {
+    errno = EINVAL;
+    return WRONG;
+  }
    if (tmp->tm_isdst > 1)
      tmp->tm_isdst = 1;
    t = time2(tmp, funcp, offset, &okay);
    if (okay || tmp->tm_isdst < 0)
      return t;
    /*
-   ** We're supposed to assume that somebody took a time of one type
-   ** and did some math on it that yielded a "struct tm" that's bad.
-   ** We try to divine the type they started from and adjust to the
-   ** type they need.
-   */
-  sp = (const struct state *) ((funcp == localsub) ? lclptr : gmtptr);
-#ifdef ALL_STATE
-  if (sp == NULL)
-    return WRONG;
-#endif /* defined ALL_STATE */
-  for (samei = 0; samei < sp->typecnt; ++samei)
+  ** We're supposed to assume that somebody took a time of one type
+  ** and did some math on it that yielded a "struct tm" that's bad.
+  ** We try to divine the type they started from and adjust to the
+  ** type they need.
+  */
+  sp = (const struct state *) ((funcp == localsub) ?  lclptr : gmtptr);
+  for (i = 0; i < sp->typecnt; ++i)
+    seen[i] = FALSE;
+  nseen = 0;
+  for (i = sp->timecnt - 1; i >= 0; --i)
+    if (!seen[sp->types[i]])
+    {
+      seen[sp->types[i]] = TRUE;
+      types[nseen++] = sp->types[i];
+    }
+  for (sameind = 0; sameind < nseen; ++sameind)
    {
+    samei = types[sameind];
      if (sp->ttis[samei].tt_isdst != tmp->tm_isdst)
        continue;
-    for (otheri = 0; otheri < sp->typecnt; ++otheri)
+    for (otherind = 0; otherind < nseen; ++otherind)
      {
+      otheri = types[otherind];
        if (sp->ttis[otheri].tt_isdst == tmp->tm_isdst)
-    continue;
-      tmp->tm_sec += sp->ttis[otheri].tt_gmtoff -
-    sp->ttis[samei].tt_gmtoff;
+        continue;
+      tmp->tm_sec += sp->ttis[otheri].tt_gmtoff - sp->ttis[samei].tt_gmtoff;
        tmp->tm_isdst = !tmp->tm_isdst;
        t = time2(tmp, funcp, offset, &okay);
        if (okay)
-    return t;
-      tmp->tm_sec -= sp->ttis[otheri].tt_gmtoff -
-    sp->ttis[samei].tt_gmtoff;
+        return t;
+      tmp->tm_sec -= sp->ttis[otheri].tt_gmtoff - sp->ttis[samei].tt_gmtoff;
        tmp->tm_isdst = !tmp->tm_isdst;
      }
    }
    return WRONG;
  }

  time_t
  mktime(struct tm * tmp)
  {
-  struct tm save_tm = *tmp;
-  int rv = time1(tmp, localsub, 0L);
-  if (rv == -1)
-  {
-    /* Try again, off a few hours.  This may get us out of the DST
-       switch zone (which has two valid time_t's) and into a "normal"
-       range, and we'll compensate the return value afterwards. */
-    int delta = 12;
-    if (tmp->tm_hour > 12)
-      delta = -12;
-
-    tmp->tm_hour += delta;
-    rv = time1(tmp, localsub, 0L);
-    tmp->tm_hour -= delta;
-    if (rv != -1)
-      rv -= delta*60*60;
-    else
-    {
-      /* tmp might point to a time structure that's before 1/1/1970.
-     This can happen if tmp is a result of a call to localtime(0)
-     issued in a timezone with a negative offset, like PST8.
-     Adding the timezone offset will bring the time structure into
-     the valid range.  */
-      delta = 24 - tmp->tm_hour;
-      tmp->tm_hour += delta;
-      rv = time1(tmp, localsub, 0L);
-      tmp->tm_hour -= delta;
-      if (rv != -1)
-    rv -= delta*60*60;
-    }
-    if (rv == -1)
-      *tmp = save_tm;
-    else
-      tmnormalize(tmp);
-  }
-  return rv;
+  tzset();
+  return time1(tmp, localsub, 0L);
  }
diff -aprNU5 djgpp.orig/src/libc/ansi/time/posixrul.h djgpp/src/libc/ansi/time/posixrul.h
--- djgpp.orig/src/libc/ansi/time/posixrul.h    1995-08-27 04:52:08 +0100
+++ djgpp/src/libc/ansi/time/posixrul.h    2013-08-17 16:02:38 +0100
@@ -1,49 +1,44 @@
+/* Copyright (C) 2013 DJ Delorie, see COPYING.DJ for details */
  /* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */
  /* generated with bin2h from DJGPP/zoneinfo/posixrules */

  unsigned char _posixrules_data[] = {
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,
-0,1,16,0,0,0,2,0,0,0,8,0,151,254,240,1,135,225,224,2,119,224,240,3,112,254,96,4,96,253,112,5,80,
+84,90,105,102,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,4,0,0,0,0,0,
+0,0,235,0,0,0,4,0,0,0,16,158,166,30,112,159,186,235,96,160,134,0,112,161,154,205,96,162,101,226,112,163,131,
+233,224,164,106,174,112,165,53,167,96,166,83,202,240,167,21,137,96,168,51,172,240,168,254,165,224,170,19,142,240,170,222,135,
+224,171,243,112,240,172,190,105,224,173,211,82,240,174,158,75,224,175,179,52,240,176,126,45,224,177,156,81,112,178,103,74,96,
+179,124,51,112,180,71,44,96,181,92,21,112,182,39,14,96,183,59,247,112,184,6,240,96,185,27,217,112,185,230,210,96,187,
+4,245,240,187,198,180,96,188,228,215,240,189,175,208,224,190,196,185,240,191,143,178,224,192,164,155,240,193,111,148,224,194,132,
+125,240,195,79,118,224,196,100,95,240,197,47,88,224,198,77,124,112,199,15,58,224,200,45,94,112,200,248,87,96,202,13,64,
+112,202,216,57,96,203,136,240,112,210,35,244,112,210,96,251,224,211,117,228,240,212,64,221,224,213,85,198,240,214,32,191,224,
+215,53,168,240,216,0,161,224,217,21,138,240,217,224,131,224,218,254,167,112,219,192,101,224,220,222,137,112,221,169,130,96,222,
+190,107,112,223,137,100,96,224,158,77,112,225,105,70,96,226,126,47,112,227,73,40,96,228,94,17,112,229,87,46,224,230,71,
+45,240,231,55,16,224,232,39,15,240,233,22,242,224,234,6,241,240,234,246,212,224,235,230,211,240,236,214,182,224,237,198,181,
+240,238,191,211,96,239,175,210,112,240,159,181,96,241,143,180,112,242,127,151,96,243,111,150,112,244,95,121,96,245,79,120,112,
+246,63,91,96,247,47,90,112,248,40,119,224,249,15,60,112,250,8,89,224,250,248,88,240,251,232,59,224,252,216,58,240,253,
+200,29,224,254,184,28,240,255,167,255,224,0,151,254,240,1,135,225,224,2,119,224,240,3,112,254,96,4,96,253,112,5,80,
  224,96,6,64,223,112,7,48,194,96,7,141,25,112,9,16,164,96,9,173,148,240,10,240,134,96,11,224,133,112,12,217,162,
  224,13,192,103,112,14,185,132,224,15,169,131,240,16,153,102,224,17,137,101,240,18,121,72,224,19,105,71,240,20,89,42,224,
  21,73,41,240,22,57,12,224,23,41,11,240,24,34,41,96,25,8,237,240,26,2,11,96,26,242,10,112,27,225,237,96,28,
  209,236,112,29,193,207,96,30,177,206,112,31,161,177,96,32,118,0,240,33,129,147,96,34,85,226,240,35,106,175,224,36,53,
  196,240,37,74,145,224,38,21,166,240,39,42,115,224,39,254,195,112,41,10,85,224,41,222,165,112,42,234,55,224,43,190,135,
  112,44,211,84,96,45,158,105,112,46,179,54,96,47,126,75,112,48,147,24,96,49,103,103,240,50,114,250,96,51,71,73,240,
  52,82,220,96,53,39,43,240,54,50,190,96,55,7,13,240,56,27,218,224,56,230,239,240,57,251,188,224,58,198,209,240,59,
  219,158,224,60,175,238,112,61,187,128,224,62,143,208,112,63,155,98,224,64,111,178,112,65,132,127,96,66,79,148,112,67,100,
-97,96,68,47,118,112,69,68,67,96,70,15,88,112,71,36,37,96,71,248,116,240,73,4,7,96,73,216,86,240,74,227,233,
-96,75,184,56,240,76,205,5,224,77,152,26,240,78,172,231,224,79,119,252,240,80,140,201,224,81,97,25,112,82,108,171,224,
-83,64,251,112,84,76,141,224,85,32,221,112,86,44,111,224,87,0,191,112,88,21,140,96,88,224,161,112,89,245,110,96,90,
-192,131,112,91,213,80,96,92,169,159,240,93,181,50,96,94,137,129,240,95,149,20,96,96,105,99,240,97,126,48,224,98,73,
-69,240,99,94,18,224,100,41,39,240,101,61,244,224,102,18,68,112,103,29,214,224,103,242,38,112,104,253,184,224,105,210,8,
-112,106,221,154,224,107,177,234,112,108,198,183,96,109,145,204,112,110,166,153,96,111,113,174,112,112,134,123,96,113,90,202,240,
-114,102,93,96,115,58,172,240,116,70,63,96,117,26,142,240,118,47,91,224,118,250,112,240,120,15,61,224,120,218,82,240,121,
-239,31,224,122,186,52,240,123,207,1,224,124,163,81,112,125,174,227,224,126,131,51,112,127,142,197,224,128,99,21,112,129,119,
-226,96,130,66,247,112,131,87,196,96,132,34,217,112,133,55,166,96,134,11,245,240,135,23,136,96,135,235,215,240,136,247,106,
-96,137,203,185,240,138,215,76,96,139,171,155,240,140,192,104,224,141,139,125,240,142,160,74,224,143,107,95,240,144,128,44,224,
-145,84,124,112,146,96,14,224,147,52,94,112,148,63,240,224,149,20,64,112,150,41,13,96,150,244,34,112,152,8,239,96,152,
-212,4,112,153,232,209,96,154,189,32,240,155,200,179,96,156,157,2,240,157,168,149,96,158,124,228,240,159,136,119,96,160,92,
-198,240,161,113,147,224,162,60,168,240,163,81,117,224,164,28,138,240,165,49,87,224,166,5,167,112,167,17,57,224,167,229,137,
-112,168,241,27,224,169,197,107,112,170,218,56,96,171,165,77,112,172,186,26,96,173,133,47,112,174,153,252,96,175,101,17,112,
-176,121,222,96,177,78,45,240,178,89,192,96,179,46,15,240,180,57,162,96,181,13,241,240,182,34,190,224,182,237,211,240,184,
-2,160,224,184,205,181,240,185,226,130,224,186,182,210,112,187,194,100,224,188,150,180,112,189,162,70,224,190,118,150,112,191,130,
-40,224,192,86,120,112,193,107,69,96,194,54,90,112,195,75,39,96,196,22,60,112,197,43,9,96,197,255,88,240,199,10,235,
-96,199,223,58,240,200,234,205,96,201,191,28,240,202,211,233,224,203,158,254,240,204,179,203,224,205,126,224,240,206,147,173,224,
-207,103,253,112,208,115,143,224,209,71,223,112,210,83,113,224,211,39,193,112,212,51,83,224,213,7,163,112,214,28,112,96,214,
-231,133,112,215,252,82,96,216,199,103,112,217,220,52,96,218,176,131,240,219,188,22,96,220,144,101,240,221,155,248,96,222,112,
-71,240,223,133,20,224,224,80,41,240,225,100,246,224,226,48,11,240,227,68,216,224,228,15,237,240,229,36,186,224,229,249,10,
-112,231,4,156,224,231,216,236,112,232,228,126,224,233,184,206,112,234,205,155,96,235,152,176,112,236,173,125,96,237,120,146,112,
-238,141,95,96,239,97,174,240,240,109,65,96,241,65,144,240,242,77,35,96,243,33,114,240,244,45,5,96,245,1,84,240,246,
-22,33,224,246,225,54,240,247,246,3,224,248,193,24,240,249,213,229,224,250,160,250,240,251,181,199,224,252,138,23,112,253,149,
-169,224,254,105,249,112,255,117,139,224,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,
-1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,
+97,96,68,47,118,112,69,68,67,96,69,243,168,240,71,45,95,224,71,211,138,240,73,13,65,224,73,179,108,240,74,237,35,
+224,75,156,137,112,76,214,64,96,77,124,107,112,78,182,34,96,79,92,77,112,80,150,4,96,81,60,47,112,82,117,230,96,
+83,28,17,112,84,85,200,96,84,251,243,112,86,53,170,96,86,229,15,240,88,30,198,224,88,196,241,240,89,254,168,224,90,
+164,211,240,91,222,138,224,92,132,181,240,93,190,108,224,94,100,151,240,95,158,78,224,96,77,180,112,97,135,107,96,98,45,
+150,112,99,103,77,96,100,13,120,112,101,71,47,96,101,237,90,112,103,39,17,96,103,205,60,112,105,6,243,96,105,173,30,
+112,106,230,213,96,107,150,58,240,108,207,241,224,109,118,28,240,110,175,211,224,111,85,254,240,112,143,181,224,113,53,224,240,
+114,111,151,224,115,21,194,240,116,79,121,224,116,254,223,112,118,56,150,96,118,222,193,112,120,24,120,96,120,190,163,112,121,
+248,90,96,122,158,133,112,123,216,60,96,124,126,103,112,125,184,30,96,126,94,73,112,127,152,0,96,0,1,0,1,0,1,
  0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,
+1,0,1,0,1,0,1,0,1,2,3,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,
  1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,
  0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,
  1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,
  0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,
-1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,
-0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,255,255,199,192,1,0,255,255,185,176,0,4,69,68,84,
-0,69,83,84,0,0,0
-};
+1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,255,255,
+199,192,1,0,255,255,185,176,0,4,255,255,199,192,1,8,255,255,199,192,1,12,69,68,84,0,69,83,84,0,69,87,84,
+0,69,80,84,0,0,0,0,1,0,0,0,1,};
diff -aprNU5 djgpp.orig/tests/libc/ansi/time/makefile djgpp/tests/libc/ansi/time/makefile
--- djgpp.orig/tests/libc/ansi/time/makefile    2005-01-09 15:55:52 +0100
+++ djgpp/tests/libc/ansi/time/makefile    2013-08-17 16:02:38 +0100
@@ -2,9 +2,10 @@ TOP=../..

  SRC += ctime.c         # There's a warning when compiling this with gcc 2.953.
  SRC += mktime.c
  SRC += strftime.c
  SRC += tzinfo.c
+SRC += tzinfo2.c
  SRC += xstrftm.c    # There's a warning when compiling this with gcc 2.953.

  include $(TOP)/../makefile.inc

diff -aprNU5 djgpp.orig/tests/libc/ansi/time/tzinfo2.c djgpp/tests/libc/ansi/time/tzinfo2.c
--- djgpp.orig/tests/libc/ansi/time/tzinfo2.c    1970-01-01 01:00:00 +0100
+++ djgpp/tests/libc/ansi/time/tzinfo2.c    2013-08-17 15:57:12 +0100
@@ -0,0 +1,88 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <string.h>
+#include <libc/unconst.h>
+
+#define buflen 80
+
+void timetest(int *fail, time_t t, const char er[buflen])
+{
+  char or[buflen];
+
+  if (!strftime (or, buflen, "%Y-%m-%d %H:%M:%S %Z", localtime(&t)))
+  {
+    fprintf(stderr, "strftime failed   FAIL\n");
+    exit(-1);
+  }
+
+  printf("time_t %ld  expected %s\n", (long)t, er);
+  printf("                        got %s", or);
+  if (strcmp(er, or)) *fail = 1, printf("   FAIL");
+  printf ("\n");
+}
+
+int main (int argc, char **argv)
+{
+  int fail = 0;
+  static const char *env_string[] = {"TZ=:America/New_York", "TZ=:Europe/Berlin", "TZ=:America/Buenos_Aires"};
+  char *tz;
+
+  if (tz = unconst(env_string[0], char *), putenv(tz))
+  {
+    fprintf(stderr, "putenv failed   FAIL\n");
+    exit(-1);
+  }
+  tzset();
+
+  timetest(&fail, 1357016400, "2013-01-01 00:00:00 EST");
+  timetest(&fail, 1362898799, "2013-03-10 01:59:59 EST");
+  timetest(&fail, 1362898800, "2013-03-10 03:00:00 EDT");
+  timetest(&fail, 1372780800, "2013-07-02 12:00:00 EDT");
+  timetest(&fail, 1383454800, "2013-11-03 01:00:00 EDT");
+  timetest(&fail, 1383458400, "2013-11-03 01:00:00 EST");
+  timetest(&fail, 1388552399, "2013-12-31 23:59:59 EST");
+  printf("Test #1 %s\n", (fail ? "FAILED" : "passed"));
+
+
+  printf("\n\n\n");
+
+
+  if (tz = unconst(env_string[1], char *), putenv(tz))
+  {
+    fprintf(stderr, "putenv failed   FAIL\n");
+    exit(-1);
+  }
+  tzset();
+
+  timetest(&fail, 1356998461, "2013-01-01 01:01:01 CET");
+  timetest(&fail, 1359766922, "2013-02-02 02:02:02 CET");
+  timetest(&fail, 1370491566, "2013-06-06 06:06:06 CEST");
+  timetest(&fail, 1376701904, "2013-08-17 03:11:44 CEST");
+  timetest(&fail, 1379401749, "2013-09-17 09:09:09 CEST");
+  timetest(&fail, 1384164692, "2013-11-11 11:11:32 CET");
+  timetest(&fail, 1388530799, "2013-12-31 23:59:59 CET");
+  printf("Test #2 %s\n", (fail ? "FAILED" : "passed"));
+
+
+  printf("\n\n\n");
+
+
+  if (tz = unconst(env_string[2], char *), putenv(tz))
+  {
+    fprintf(stderr, "putenv failed   FAIL\n");
+    exit(-1);
+  }
+  tzset();
+
+  timetest(&fail, 1357012861, "2013-01-01 01:01:01 ART");
+  timetest(&fail, 1359781322, "2013-02-02 02:02:02 ART");
+  timetest(&fail, 1370509566, "2013-06-06 06:06:06 ART");
+  timetest(&fail, 1376738799, "2013-08-17 08:26:39 ART");
+  timetest(&fail, 1379417277, "2013-09-17 08:27:57 ART");
+  timetest(&fail, 1384179071, "2013-11-11 11:11:11 ART");
+  timetest(&fail, 1388545199, "2013-12-31 23:59:59 ART");
+  printf("Test #3 %s\n", (fail ? "FAILED" : "passed"));
+
+  return 0;
+}

Diffs against tz[code|data]2013d.tar.gz


2013-08-17  Juan Manuel Guerrero <juan DOT guerrero AT gmx DOT de>

     * djgpp/zoneinfo/src/date.c [OLD_TIME]:  Only if OLD_TIME defined
     include utmp.h.
     [__MSDOS__]:  For MSDOS do not declare and do not define oops().
     (main):  Cast variable to time_t.
     [TSP_SETDATE]:  Only if TSP_SETDATE defined include syslog.h,
     sys/socket.h, netinet/in.h, netdb.h and protocols/timed.h and
     define TSPTYPES.
     (reset) [__MSDOS__]:  MSDOS does not support TSP_SETDATE.
     Fix -Wunused-but-set-variable.
     (convert):  Cast variable to time_t.
     (nondigit):  Use ATTRIBUTE_PURE macro.
     (main):  Fix -Wunused-but-set-variable.


2013-08-16  Juan Manuel Guerrero <juan DOT guerrero AT gmx DOT de>

     * djgpp/zoneinfo/src/zic.c [__DJGPP__]:  Define ZIC_VERSION to 0.
     [IS_SLASH, IS_ABSOLUTE]:  If not defined define them.
     (dolink):  Use IS_ABSOLUTE for portable testing of absolute file
     names.  Replace '+' by '%' in file names or directory names.
     (itsdir) [D_OK]:  On MSDOS/WINDOWS use access() to check if it is
     a directory.
     (writezone):  Replace '+' by '%' in file names or directory names.
     Make only the first pass and do not print the newline-enclosed,
     POSIX-TZ-environment-variable-style string to create a version 0 file.
     (mkdirs):  Use HAS_DEVICE and IS_SLASH to handle directory craetiong
     in a portable way.


2013-08-14  Juan Manuel Guerrero <juan DOT guerrero AT gmx DOT de>

     * djgpp/zoneinfo/src/makefile:  Support building with gcc 3.4.4 and
     from gcc 4.0.0 up to gcc 4.8.3.
     Install formated man pages into /share/man/catN.

     * djgpp/zoneinfo/src/private.h [__MSDOS__]:  Define IS_SLASH(c),
     HAS_DEVICE, IS_ABSOLUTE and TZDIR macros.

     * djgpp/zoneinfo/src/localtime.c:  Define IS_SLASH and IS_ABSOLUTE
     for portable testing of absolute file names.
     [STD_INSPIRED]:  Provide function declarations.
     [!__DJGPP__]:  Use DJGPP's own libc implementations of localtime,
     localtime_r, gmtime, gmtime_r, ctime, ctime_r and mktime.
     (tzload):  Use IS_ABSOLUTE for portable testing of absolute file
     names.

     * djgpp/zoneinfo/src/strftime.c [!__DJGPP__]:  Use DJGPP's libc
     implementations of asctime and asctime_r.

     * djgpp/zoneinfo/src/asctime.c [!__DJGPP__]:  Use DJGPP's libc
     implementations of asctime and asctime_r.

     * djgpp/distrib/p/djtzn204/files:  Man pages will be stored in
     /share/man/catN.





diff -aprNU5 djgpp.orig/distrib/p/djtzn204/files djgpp/distrib/p/djtzn204/files
--- djgpp.orig/distrib/p/djtzn204/files    2013-01-31 22:35:24 +0000
+++ djgpp/distrib/p/djtzn204/files    2013-08-17 14:34:22 +0000
@@ -1,14 +1,14 @@
  etc/date.exe
  etc/tzselect
  etc/zdump.exe
  etc/zic.exe
-share/man/man1/date.1
-share/man/man3/newctime.3
-share/man/man3/newtzset.3
-share/man/man3/time2posix.3
-share/man/man5/tzfile.5
-share/man/man8/tzselect.8
-share/man/man8/zdump.8
-share/man/man8/zic.8
+share/man/cat1/date.1
+share/man/cat3/newctime.3
+share/man/cat3/newtzset.3
+share/man/cat3/time2posix.3
+share/man/cat5/tzfile.5
+share/man/cat8/tzselect.8
+share/man/cat8/zdump.8
+share/man/cat8/zic.8
  lib/libtz.a
  zoneinfo
diff -aprNU5 djgpp.orig/zoneinfo/src/asctime.c djgpp/zoneinfo/src/asctime.c
--- djgpp.orig/zoneinfo/src/asctime.c    2012-10-26 23:37:42 +0000
+++ djgpp/zoneinfo/src/asctime.c    2013-08-17 14:34:22 +0000
@@ -1,5 +1,9 @@
+#ifndef __DJGPP__
+/*  Use DJGPP's own implementation of asctime and asctime_r.  */
+
+
  /*
  ** This file is in the public domain, so clarified as of
  ** 1996-06-05 by Arthur David Olson.
  */

@@ -128,5 +132,6 @@ asctime_r(register const struct tm *time
  char *
  asctime(register const struct tm *timeptr)
  {
      return asctime_r(timeptr, buf_asctime);
  }
+#endif  /* !__DJGPP__ */
diff -aprNU5 djgpp.orig/zoneinfo/src/date.c djgpp/zoneinfo/src/date.c
--- djgpp.orig/zoneinfo/src/date.c    2013-05-28 03:26:18 +0000
+++ djgpp/zoneinfo/src/date.c    2013-08-17 14:34:22 +0000
@@ -28,11 +28,13 @@ static char sccsid[] = "@(#)date.c    4.23
  #include "private.h"
  #if HAVE_ADJTIME || HAVE_SETTIMEOFDAY
  #include "sys/time.h"    /* for struct timeval, struct timezone */
  #endif /* HAVE_ADJTIME || HAVE_SETTIMEOFDAY */
  #include "locale.h"
+#ifdef OLD_TIME
  #include "utmp.h"    /* for OLD_TIME (or its absence) */
+#endif
  #if HAVE_UTMPX_H
  #include "utmpx.h"
  #endif

  #ifndef OTIME_MSG
@@ -52,18 +54,18 @@ static char sccsid[] = "@(#)date.c    4.23

  #ifndef SECSPERMIN
  #define SECSPERMIN    60
  #endif /* !defined SECSPERMIN */

-extern double        atof();
+extern double        atof(const char *s);
  extern char **        environ;
-extern char *        getlogin();
-extern time_t        mktime();
+extern char *        getlogin(void);
+extern time_t        mktime(struct tm *tptr);
  extern char *        optarg;
  extern int        optind;
-extern char *        strchr();
-extern time_t        time();
+extern char *        strchr(const char *s, int c);
+extern time_t        time(time_t *t);
  extern char *        tzname[2];

  static int        retval = EXIT_SUCCESS;

  static void        checkfinal(const char *, int, time_t, time_t);
@@ -72,11 +74,13 @@ static void        display(const char *);
  static void        dogmt(void);
  static void        errensure(void);
  static void        iffy(time_t, time_t, const char *, const char *);
  int            main(int, char**);
  static const char *    nondigit(const char *);
+#ifndef __MSDOS__
  static void        oops(const char *);
+#endif  /* __MSDOS__ */
  static void        reset(time_t, int);
  static int        sametm(const struct tm *, const struct tm *);
  static void        timeout(FILE *, const char *, const struct tm *);
  static void        usage(void);
  static void        wildinput(const char *, const char *,
@@ -92,19 +96,23 @@ main(const int argc, char *argv[])
      register int        dousg;
      register int        aflag = 0;
      register int        dflag = 0;
      register int        nflag = 0;
      register int        tflag = 0;
+#if HAVE_SETTIMEOFDAY == 2
      register int        minuteswest;
      register int        dsttime;
+#endif /* HAVE_SETTIMEOFDAY == 2 */
      register double        adjust;
      time_t            now;
      time_t            t;

      INITIALIZE(dousg);
+#if HAVE_SETTIMEOFDAY == 2
      INITIALIZE(minuteswest);
      INITIALIZE(dsttime);
+#endif /* HAVE_SETTIMEOFDAY == 2 */
      INITIALIZE(adjust);
      INITIALIZE(t);
  #ifdef LC_ALL
      (void) setlocale(LC_ALL, "");
  #endif /* defined(LC_ALL) */
@@ -133,11 +141,13 @@ main(const int argc, char *argv[])
                      _("date: error: multiple -d's used"));
                  usage();
              }
              dflag = 1;
              cp = optarg;
+#if HAVE_SETTIMEOFDAY == 2
              dsttime = atoi(cp);
+#endif /* HAVE_SETTIMEOFDAY == 2 */
              if (*cp == '\0' || *nondigit(cp) != '\0')
                  wildinput(_("-t value"), optarg,
                      _("must be a non-negative number"));
              break;
          case 't':        /* minutes west of UTC */
@@ -146,11 +156,13 @@ main(const int argc, char *argv[])
                      _("date: error: multiple -t's used"));
                  usage();
              }
              tflag = 1;
              cp = optarg;
+#if HAVE_SETTIMEOFDAY == 2
              minuteswest = atoi(cp);
+#endif /* HAVE_SETTIMEOFDAY == 2 */
              if (*cp == '+' || *cp == '-')
                  ++cp;
              if (*cp == '\0' || *nondigit(cp) != '\0')
                  wildinput(_("-d value"), optarg,
                      _("must be a number"));
@@ -424,18 +436,20 @@ reset(const time_t newt, const int nflag
  #ifndef BSD4_4
  #define TIME_NAME    ""
  #endif /* !defined BSD4_4 */
  #endif /* !defined TIME_NAME */

+#ifdef TSP_SETDATE
  #include "syslog.h"
  #include "sys/socket.h"
  #include "netinet/in.h"
  #include "netdb.h"
  #define TSPTYPES
  #include "protocols/timed.h"
+#endif

-extern int        logwtmp();
+extern int        logwtmp(char *line, char *name, char *host);

  #if HAVE_SETTIMEOFDAY == 1
  #define settimeofday(t, tz) (settimeofday)(t)
  #endif /* HAVE_SETTIMEOFDAY == 1 */

@@ -448,18 +462,21 @@ static int netsettime(struct timeval);
  #endif /* !defined TSP_SETDATE */
  static void
  reset(const time_t newt, const int nflag)
  {
      register const char *    username;
+#ifndef __MSDOS__
      static struct timeval    tv;    /* static so tv_usec is 0 */
+#endif  /* __MSDOS__ */

  #ifdef EBUG
      return;
  #endif /* defined EBUG */
      username = getlogin();
      if (username == NULL || *username == '\0') /* single-user or no tty */
          username = "root";
+#ifndef __MSDOS__
      tv.tv_sec = newt;
  #ifdef TSP_SETDATE
      if (nflag || !netsettime(tv))
  #endif /* defined TSP_SETDATE */
      {
@@ -471,10 +488,11 @@ reset(const time_t newt, const int nflag
              logwtmp("{", TIME_NAME, "");    /* } */
              syslog(LOG_AUTH | LOG_NOTICE, _("date set by %s"),
                  username);
          } else    oops("settimeofday");
      }
+#endif  /* __MSDOS__ */
  }

  #endif /* !defined OLD_TIME */

  static void
@@ -509,10 +527,11 @@ usage(void)
  [-t min-west] [-a sss.fff] [[yyyy]mmddhhmm[yyyy][.ss]] [+format]\n"));
      errensure();
      exit(retval);
  }

+#ifndef __MSDOS__
  static void
  oops(const char *const string)
  {
      int        e = errno;

@@ -520,10 +539,11 @@ oops(const char *const string)
      errno = e;
      (void) perror(string);
      errensure();
      display(NULL);
  }
+#endif /* __MSDOS__ */

  static void
  display(const char *const format)
  {
      struct tm    tm;
@@ -541,11 +561,11 @@ display(const char *const format)
          errensure();
      }
      exit(retval);
  }

-extern size_t    strftime();
+extern size_t    strftime(char *s, size_t maxsize, const char *format, const struct tm *t);

  #define INCR    1024

  static void
  timeout(FILE *const fp, const char *const format, const struct tm *const tmp)
diff -aprNU5 djgpp.orig/zoneinfo/src/localtime.c djgpp/zoneinfo/src/localtime.c
--- djgpp.orig/zoneinfo/src/localtime.c    2013-08-10 21:33:40 +0000
+++ djgpp/zoneinfo/src/localtime.c    2013-08-17 14:34:22 +0000
@@ -27,10 +27,21 @@
  #ifndef TZ_ABBR_ERR_CHAR
  #define TZ_ABBR_ERR_CHAR    '_'
  #endif /* !defined TZ_ABBR_ERR_CHAR */

  /*
+** Portable testing for absolute file names.
+*/
+
+#ifndef IS_SLASH
+#define IS_SLASH(c)     ((c) == '/')
+#endif
+#ifndef IS_ABSOLUTE
+#define IS_ABSOLUTE(n)  (IS_SLASH((n)[0]))
+#endif
+
+/*
  ** SunOS 4.1.1 headers lack O_BINARY.
  */

  #ifdef O_BINARY
  #define OPEN_MODE    (O_RDONLY | O_BINARY)
@@ -155,10 +166,19 @@ static struct tm *    timesub(const time_t
  static int        tmcomp(const struct tm * atmp, const struct tm * btmp);
  static time_t        transtime(time_t janfirst, int year, const struct rule * rulep, int_fast32_t offset) ATTRIBUTE_PURE;
  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);
+#ifdef STD_INSPIRED
+static int_fast64_t    leapcorr(time_t *timep);
+time_t            time2posix(time_t t);
+time_t            posix2time(time_t t);
+struct tm *        offtime(const time_t *const timep, const int_fast32_t offset);
+time_t            timelocal(struct tm *const tmp);
+time_t            timegm(struct tm *const tmp);
+time_t            timeoff(struct tm *const tmp, const int_fast32_t offset);
+#endif /* defined STD_INSPIRED */

  #ifdef ALL_STATE
  static struct state *    lclptr;
  static struct state *    gmtptr;
  #endif /* defined ALL_STATE */
@@ -176,14 +196,17 @@ static struct state    gmtmem;

  static char        lcl_TZname[TZ_STRLEN_MAX + 1];
  static int        lcl_is_set;
  static int        gmt_is_set;

+#ifndef __DJGPP__
+/*  Use DJGPP's own definition of tzname.  */
  char *            tzname[2] = {
      wildabbr,
      wildabbr
  };
+#endif  /* !__DJGPP__ */

  /*
  ** Section 4.12.3 of X3.159-1989 requires that
  **    Except for the strftime function, these functions [asctime,
  **    ctime, gmtime, localtime] return values in one of two static
@@ -341,11 +364,11 @@ tzload(register const char *name, regist
          */
          char        fullname[FILENAME_MAX + 1];

          if (name[0] == ':')
              ++name;
-        doaccess = name[0] == '/';
+        doaccess = IS_ABSOLUTE(name);
          if (!doaccess) {
              if ((p = TZDIR) == NULL)
                  goto oops;
              if ((strlen(p) + strlen(name) + 1) >= sizeof fullname)
                  goto oops;
@@ -1320,10 +1343,12 @@ localsub(const time_t *const timep, cons
      tmp->TM_ZONE = &sp->chars[ttisp->tt_abbrind];
  #endif /* defined TM_ZONE */
      return result;
  }

+#ifndef __DJGPP__
+/*  Use DJGPP's own implementation of localtime and localtime_r. */
  struct tm *
  localtime(const time_t *const timep)
  {
      tzset();
      return localsub(timep, 0L, &tm);
@@ -1336,10 +1361,11 @@ localtime(const time_t *const timep)
  struct tm *
  localtime_r(const time_t *const timep, struct tm *tmp)
  {
      return localsub(timep, 0L, tmp);
  }
+#endif  /* !__DJGPP__ */

  /*
  ** gmtsub is to gmtime as localsub is to localtime.
  */

@@ -1377,10 +1403,12 @@ gmtsub(const time_t *const timep, const
      }
  #endif /* defined TM_ZONE */
      return result;
  }

+#ifndef __DJGPP__
+/*  Use DJGPP's own implementation of gmtime and gmtime_r.  */
  struct tm *
  gmtime(const time_t *const timep)
  {
      return gmtsub(timep, 0L, &tm);
  }
@@ -1392,10 +1420,11 @@ gmtime(const time_t *const timep)
  struct tm *
  gmtime_r(const time_t *const timep, struct tm *tmp)
  {
      return gmtsub(timep, 0L, tmp);
  }
+#endif  /* !__DJGPP__ */

  #ifdef STD_INSPIRED

  struct tm *
  offtime(const time_t *const timep, const int_fast32_t offset)
@@ -1548,10 +1577,12 @@ timesub(const time_t *const timep, const
      tmp->TM_GMTOFF = offset;
  #endif /* defined TM_GMTOFF */
      return tmp;
  }

+#ifndef __DJGPP__
+/*  Use DJGPP's own implementation of ctime and ctime_r.  */
  char *
  ctime(const time_t *const timep)
  {
  /*
  ** Section 4.12.3.2 of X3.159-1989 requires that
@@ -1567,10 +1598,11 @@ ctime_r(const time_t *const timep, char
  {
      struct tm    mytm;

      return asctime_r(localtime_r(timep, &mytm), buf);
  }
+#endif  /* !__DJGPP__ */

  /*
  ** 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.
@@ -1929,16 +1961,19 @@ time1(struct tm *const tmp,
          }
      }
      return WRONG;
  }

+#ifndef __DJGPP__
+/*  Use DJGPP's own implementation of mktime.  */
  time_t
  mktime(struct tm *const tmp)
  {
      tzset();
      return time1(tmp, localsub, 0L);
  }
+#endif  /* !__DJGPP__ */

  #ifdef STD_INSPIRED

  time_t
  timelocal(struct tm *const tmp)
diff -aprNU5 djgpp.orig/zoneinfo/src/makefile djgpp/zoneinfo/src/makefile
--- djgpp.orig/zoneinfo/src/makefile    2013-07-05 13:38:00 +0000
+++ djgpp/zoneinfo/src/makefile    2013-08-17 15:13:10 +0000
@@ -43,38 +43,56 @@ POSIXRULES=    America/New_York
  # Also see TZDEFRULESTRING below, which takes effect only
  # if the time zone files cannot be accessed.

  # Everything gets put in subdirectories of. . .

-TOPDIR=        /usr/local
+TOPDIR=        ../..

  # "Compiled" time zone information is placed in the "TZDIR" directory
  # (and subdirectories).
  # Use an absolute path name for TZDIR unless you're just testing the software.

-TZDIR=        $(TOPDIR)/etc/zoneinfo
+TZDIR=        $(TOPDIR)/zoneinfo

  # Types to try, as an alternative to time_t.  int64_t should be first.
  TIME_T_ALTERNATIVES= int64_t int32_t uint32_t uint64_t

  # The "tzselect", "zic", and "zdump" commands get installed in. . .

  ETCDIR=        $(TOPDIR)/etc

  # If you "make INSTALL", the "date" command gets installed in. . .

-BINDIR=        $(TOPDIR)/bin
+BINDIR=        $(TOPDIR)/etc

  # Manual pages go in subdirectories of. . .

-MANDIR=        $(TOPDIR)/man
+SHAREDIR=    $(TOPDIR)/share
+MANDIR=        $(SHAREDIR)/man

  # Library functions are put in an archive in LIBDIR.

  LIBDIR=        $(TOPDIR)/lib
  TZLIB=        $(LIBDIR)/libtz.a

+# This defines several variables that enable zoneinfo/src/* files to be
+# built both natively and with cross-tools on Unix.
+
+include $(TOPDIR)/src/makefile.def
+export CROSS_BUILD
+
+# If cross compiling the native and cross-compiler versions may not match.
+# Allow different flag settings accrording the compiler version.
+GCC_MAJOR := $(word 3, $(shell ../../src/misc.exe | $(GCC) -E -dD -x c - | egrep 'define\ *__GNUC__'))
+GCC_MINOR := $(word 3, $(shell ../../src/misc.exe | $(GCC) -E -dD -x c - | egrep 'define\ *__GNUC_MINOR__'))
+CROSS_GCC_MAJOR := $(word 3, $(shell ../../src/misc.exe | $(CROSS_GCC) -E -dD -x c - | egrep 'define\ *__GNUC__'))
+CROSS_GCC_MINOR := $(word 3, $(shell ../../src/misc.exe | $(CROSS_GCC) -E -dD -x c - | egrep 'define\ *__GNUC_MINOR__'))
+
+# A replacement for (possibly missing) Unix programs:
+
+UTIL=        $(TOPDIR)/src/misc.exe
+
  # If you always want time values interpreted as "seconds since the epoch
  # (not counting leap seconds)", use
  #    REDO=        posix_only
  # below.  If you always want right time values interpreted as "seconds since
  # the epoch" (counting leap seconds)", use
@@ -87,11 +105,11 @@ TZLIB=        $(LIBDIR)/libtz.a
  #    REDO=        right_posix
  # below.
  # POSIX mandates that leap seconds not be counted; for compatibility with it,
  # use either "posix_only" or "posix_right".

-REDO=        posix_right
+REDO=        posix_only

  # Since "." may not be in PATH...

  YEARISTYPE=    ./yearistype

@@ -129,22 +147,115 @@ LDLIBS=
  #    DST transitions if the time zone files cannot be accessed
  #  -DZIC_MAX_ABBR_LEN_WO_WARN=3
  #    (or some other number) to set the maximum time zone abbreviation length
  #    that zic will accept without a warning (the default is 6)
  #  $(GCC_DEBUG_FLAGS) if you are using GCC and want lots of checking
-GCC_DEBUG_FLAGS = -Dlint -g3 -O3 -fno-common -fstrict-aliasing \
+#GCC_DEBUG_FLAGS = -Dlint -g3 -O3 -fno-common -fstrict-aliasing \
+#    -Wall -Wextra \
+#    -Wbad-function-cast -Wcast-align -Wcast-qual \
+#    -Wformat=2 -Winit-self \
+#    -Wmissing-declarations -Wmissing-noreturn -Wmissing-prototypes \
+#    -Wnested-externs \
+#    -Wno-format-nonliteral -Wno-sign-compare -Wno-sign-conversion \
+#    -Wno-type-limits \
+#    -Wno-unused-parameter -Woverlength-strings -Wpointer-arith \
+#    -Wshadow -Wstrict-prototypes -Wsuggest-attribute=const \
+#    -Wsuggest-attribute=noreturn -Wsuggest-attribute=pure -Wtrampolines \
+#    -Wwrite-strings
+
+# Cross compiler debug flags.
+CROSS_GCC_DEBUG_FLAGS_FOR_ALL = -Dlint -g2 -fno-common -fstrict-aliasing \
      -Wall -Wextra \
      -Wbad-function-cast -Wcast-align -Wcast-qual \
      -Wformat=2 -Winit-self \
      -Wmissing-declarations -Wmissing-noreturn -Wmissing-prototypes \
-    -Wnested-externs \
-    -Wno-format-nonliteral -Wno-sign-compare -Wno-sign-conversion \
-    -Wno-type-limits \
-    -Wno-unused-parameter -Woverlength-strings -Wpointer-arith \
-    -Wshadow -Wstrict-prototypes -Wsuggest-attribute=const \
-    -Wsuggest-attribute=noreturn -Wsuggest-attribute=pure -Wtrampolines \
+    -Wnested-externs -Wno-format-nonliteral -Wno-sign-compare \
+    -Wno-unused-parameter  -Wpointer-arith -Wshadow -Wstrict-prototypes \
      -Wwrite-strings
+
+ifeq ($(CROSS_GCC_MAJOR),3)
+ifeq ($(CROSS_GCC_MINOR),4)
+CROSS_GCC_DEBUG_FLAGS = $(CROSS_GCC_DEBUG_FLAGS_FOR_ALL) -Wconversion -Wtraditional
+endif
+endif
+
+ifeq ($(CROSS_GCC_MAJOR),4)
+ ifeq ($(CROSS_GCC_MINOR),0)
+CROSS_GCC_DEBUG_FLAGS_SPECIAL =
+ else
+  ifeq ($(CROSS_GCC_MINOR),1)
+CROSS_GCC_DEBUG_FLAGS_SPECIAL =
+  else
+   ifeq ($(CROSS_GCC_MINOR),2)
+CROSS_GCC_DEBUG_FLAGS_SPECIAL = -Woverlength-strings
+   else
+    ifeq ($(CROSS_GCC_MINOR),3)
+CROSS_GCC_DEBUG_FLAGS_SPECIAL = -Woverlength-strings -Wno-sign-conversion -Wno-type-limits
+    else
+     ifeq ($(CROSS_GCC_MINOR),4)
+CROSS_GCC_DEBUG_FLAGS_SPECIAL = -Woverlength-strings -Wno-sign-conversion -Wno-type-limits
+     else
+      ifeq ($(CROSS_GCC_MINOR),5)
+CROSS_GCC_DEBUG_FLAGS_SPECIAL = -Woverlength-strings -Wno-sign-conversion -Wno-type-limits
+      else
+# gcc 4.6 and later works.
+CROSS_GCC_DEBUG_FLAGS_SPECIAL = -Woverlength-strings -Wno-sign-conversion -Wno-type-limits -Wsuggest-attribute=const -Wsuggest-attribute=noreturn -Wsuggest-attribute=pure -Wtrampolines
+      endif
+     endif
+    endif
+   endif
+  endif
+CROSS_GCC_DEBUG_FLAGS = $(CROSS_GCC_DEBUG_FLAGS_FOR_ALL) $(CROSS_GCC_DEBUG_FLAGS_SPECIAL)
+ endif
+endif
+
+# Native compiler debug flags.
+GCC_DEBUG_FLAGS_FOR_ALL = -Dlint -g2 -fno-common -fstrict-aliasing \
+    -Wall -Wextra \
+    -Wbad-function-cast -Wcast-align -Wcast-qual \
+    -Wformat=2 -Winit-self \
+    -Wmissing-declarations -Wmissing-noreturn -Wmissing-prototypes \
+    -Wnested-externs -Wno-format-nonliteral -Wno-sign-compare \
+    -Wno-unused-parameter  -Wpointer-arith -Wshadow -Wstrict-prototypes \
+    -Wwrite-strings
+
+ifeq ($(GCC_MAJOR),3)
+ifeq ($(GCC_MINOR),4)
+GCC_DEBUG_FLAGS = $(GCC_DEBUG_FLAGS_FOR_ALL) -Wconversion -Wtraditional
+endif
+endif
+
+ifeq ($(GCC_MAJOR),4)
+ ifeq ($(GCC_MINOR),0)
+GCC_DEBUG_FLAGS_SPECIAL =
+ else
+  ifeq ($(GCC_MINOR),1)
+GCC_DEBUG_FLAGS_SPECIAL =
+  else
+   ifeq ($(GCC_MINOR),2)
+GCC_DEBUG_FLAGS_SPECIAL = -Woverlength-strings
+   else
+    ifeq ($(GCC_MINOR),3)
+GCC_DEBUG_FLAGS_SPECIAL = -Woverlength-strings -Wno-sign-conversion -Wno-type-limits
+    else
+     ifeq ($(GCC_MINOR),4)
+GCC_DEBUG_FLAGS_SPECIAL = -Woverlength-strings -Wno-sign-conversion -Wno-type-limits
+     else
+      ifeq ($(GCC_MINOR),5)
+GCC_DEBUG_FLAGS_SPECIAL = -Woverlength-strings -Wno-sign-conversion -Wno-type-limits
+      else
+# gcc 4.6 and later works.
+GCC_DEBUG_FLAGS_SPECIAL = -Woverlength-strings -Wno-sign-conversion -Wno-type-limits -Wsuggest-attribute=const -Wsuggest-attribute=noreturn -Wsuggest-attribute=pure -Wtrampolines
+      endif
+     endif
+    endif
+   endif
+  endif
+GCC_DEBUG_FLAGS = $(GCC_DEBUG_FLAGS_FOR_ALL) $(GCC_DEBUG_FLAGS_SPECIAL)
+ endif
+endif
+
  #
  # If you want to use System V compatibility code, add
  #    -DUSG_COMPAT
  # to the end of the "CFLAGS=" line.  This arrange for "timezone" and "daylight"
  # variables to be kept up-to-date by the time conversion functions.  Neither
@@ -229,22 +340,41 @@ GCC_DEBUG_FLAGS = -Dlint -g3 -O3 -fno-co
  # to the end of the "CFLAGS=" line.  This causes "strftime" to always return
  # 53 as a week number (rather than 52 or 53) for those days in January that
  # before the first Monday in January when a "%V" format is used and January 1
  # falls on a Friday, Saturday, or Sunday.

-CFLAGS=
+# If cross compiling the native and cross-compiler versions may not match.
+# Allow different flag settings accrording the compiler version.
+# Flags for cross compiler
+CFLAGS=        -DHAVE_ADJTIME=0 -DHAVE_LONG_DOUBLE=1 -DHAVE_SETTIMEOFDAY=1 \
+        -DHAVE_STRERROR=1 -DHAVE_SYMLINK=0 -DHAVE_STDINT_H=1\
+        -DSTD_INSPIRED \
+        -DLOCALE_HOME=\"/dev/env/DJDIR~c:/djgpp~/share/locale\" \
+        $(CROSS_GCC_DEBUG_FLAGS) -O2
+
+# Flags for native compiler
+GCCFLAGS=    -DHAVE_ADJTIME=0 -DHAVE_LONG_DOUBLE=1 -DHAVE_SETTIMEOFDAY=1 \
+        -DHAVE_STRERROR=1 -DHAVE_SYMLINK=0 -DHAVE_STDINT_H=1 \
+        -DSTD_INSPIRED \
+        -DLOCALE_HOME=\"/dev/env/DJDIR~c:/djgpp~/share/locale\" \
+        $(GCC_DEBUG_FLAGS) -O2
+
+# Don't use -s here, since "gcc -s" on DJ's Irix machine dumps core
+# when invoked with -s.  To work around, we use strip explicitly.
+LFLAGS=

  # Linker flags.  Default to $(LFLAGS) for backwards compatibility
  # to tzcode2012h and earlier.

  LDFLAGS=    $(LFLAGS)

-zic=        ./zic
+EXEEXT=        .exe
+zic=        ./host-zic
  ZIC=        $(zic) $(ZFLAGS)

  # The name of a Posix-compliant `awk' on your system.
-AWK=        awk
+AWK=        gawk

  # The full path name of a Posix-compliant shell that supports the Korn shell's
  # 'select' statement, as an extension.  These days, Bash is the most popular.
  KSHELL=        /bin/bash

@@ -290,24 +420,24 @@ TARFLAGS=    `if tar $(GNUTARFLAGS) --versi
  # Flags to give 'gzip' when making a distribution.
  GZIPFLAGS=    -9n

  ###############################################################################

-cc=        cc
-CC=        $(cc) -DTZDIR=\"$(TZDIR)\"
+cc=        $(CROSS_GCC)
+CC=        $(cc) -DTZDIR=\"/dev/env/DJDIR~c:/djgpp~/zoneinfo\"

  TZCSRCS=    zic.c localtime.c asctime.c scheck.c ialloc.c
  TZCOBJS=    zic.o localtime.o asctime.o scheck.o ialloc.o
  TZDSRCS=    zdump.c localtime.c ialloc.c
  TZDOBJS=    zdump.o localtime.o ialloc.o
-DATESRCS=    date.c localtime.c strftime.c asctime.c
-DATEOBJS=    date.o localtime.o strftime.o asctime.o
+DATESRCS=    date.c localtime.c logwtmp.c strftime.c asctime.c
+DATEOBJS=    date.o localtime.o logwtmp.o strftime.o asctime.o
  LIBSRCS=    localtime.c asctime.c difftime.c
  LIBOBJS=    localtime.o asctime.o difftime.o
  HEADERS=    tzfile.h private.h
  NONLIBSRCS=    zic.c zdump.c scheck.c ialloc.c
-NEWUCBSRCS=    date.c strftime.c
+NEWUCBSRCS=    date.c logwtmp.c strftime.c
  SOURCES=    $(HEADERS) $(LIBSRCS) $(NONLIBSRCS) $(NEWUCBSRCS) tzselect.ksh
  MANS=        newctime.3 newstrftime.3 newtzset.3 time2posix.3 \
              tzfile.5 tzselect.8 zic.8 zdump.8
  COMMON=        Makefile
  DOCS=        README Theory $(MANS) date.1
@@ -328,59 +458,87 @@ ENCHILADA=    $(COMMON) $(DOCS) $(SOURCES)
  # And for the benefit of csh users on systems that assume the user
  # shell should be used to handle commands in Makefiles. . .

  SHELL=        /bin/sh

-all:        tzselect zic zdump $(LIBOBJS)
-
-ALL:        all date
+INSTALL:    ALL install date.1
+        -$(UTIL) mkdir $(TOPDIR)
+        -$(UTIL) mkdir $(BINDIR)
+        $(UTIL) cp date$(EXEEXT) $(BINDIR)/date$(EXEEXT)
+        -$(UTIL) mkdir $(SHAREDIR)
+        -$(UTIL) mkdir $(MANDIR)
+        -$(UTIL) mkdir $(MANDIR)/cat1
+        -$(UTIL) rm $(MANDIR)/cat1/date.1
+        groff -mman -Tascii date.1 > date.man
+        $(UTIL) cp date.man $(MANDIR)/cat1/date.1

  install:    all $(DATA) $(REDO) $(TZLIB) $(MANS) $(TABDATA)
          $(ZIC) -y $(YEARISTYPE) \
              -d $(TZDIR) -l $(LOCALTIME) -p $(POSIXRULES)
-        -rm -f $(TZDIR)/iso3166.tab $(TZDIR)/zone.tab
-        cp iso3166.tab zone.tab $(TZDIR)/.
-        -mkdir $(TOPDIR) $(ETCDIR)
-        cp tzselect zic zdump $(ETCDIR)/.
-        -mkdir $(TOPDIR) $(MANDIR) \
-            $(MANDIR)/man3 $(MANDIR)/man5 $(MANDIR)/man8
-        -rm -f $(MANDIR)/man3/newctime.3 \
-            $(MANDIR)/man3/newtzset.3 \
-            $(MANDIR)/man5/tzfile.5 \
-            $(MANDIR)/man8/tzselect.8 \
-            $(MANDIR)/man8/zdump.8 \
-            $(MANDIR)/man8/zic.8
-        cp newctime.3 newtzset.3 $(MANDIR)/man3/.
-        cp tzfile.5 $(MANDIR)/man5/.
-        cp tzselect.8 zdump.8 zic.8 $(MANDIR)/man8/.
+        -$(UTIL) rm -f $(TZDIR)/iso3166.tab $(TZDIR)/zone.tab
+        $(UTIL) cp iso3166.tab $(TZDIR)/iso3166.tab
+        $(UTIL) cp zone.tab $(TZDIR)/zone.tab
+        -$(UTIL) mkdir $(TOPDIR)
+        -$(UTIL) mkdir $(ETCDIR)
+        $(UTIL) cp zic$(EXEEXT) $(ETCDIR)/zic$(EXEEXT)
+        $(UTIL) cp zdump$(EXEEXT) $(ETCDIR)/zdump$(EXEEXT)
+        $(UTIL) cp tzselect $(ETCDIR)/tzselect
+        -$(UTIL) mkdir $(SHAREDIR)
+        -$(UTIL) mkdir $(MANDIR)
+        -$(UTIL) mkdir $(MANDIR)/cat3
+        -$(UTIL) mkdir $(MANDIR)/cat5
+        -$(UTIL) mkdir $(MANDIR)/cat8
+        -$(UTIL) rm -f $(MANDIR)/cat3/newctime.3 \
+            $(MANDIR)/cat3/newtzset.3 \
+            $(MANDIR)/cat5/tzfile.5 \
+            $(MANDIR)/cat8/tzselect.8 \
+            $(MANDIR)/cat8/zdump.8 \
+            $(MANDIR)/cat8/zic.8
+        groff -mman -Tascii newctime.3 > newctime.man
+        groff -mman -Tascii newtzset.3 > newtzset.man
+        groff -mman -Tascii time2posix.3 > time2posix.man
+        groff -mman -Tascii tzfile.5 > tzfile.man
+        groff -mman -Tascii tzselect.8 > tzselect.man
+        groff -mman -Tascii zdump.8 > zdump.man
+        groff -mman -Tascii zic.8 > zic.man
+        $(UTIL) cp newctime.man $(MANDIR)/cat3/newctime.3
+        $(UTIL) cp newtzset.man $(MANDIR)/cat3/newtzset.3
+        $(UTIL) cp time2posix.man $(MANDIR)/cat3/time2posix.3
+        $(UTIL) cp tzfile.man $(MANDIR)/cat5/tzfile.5
+        $(UTIL) cp tzselect.man $(MANDIR)/cat8/tzselect.8
+        $(UTIL) cp zdump.man $(MANDIR)/cat8/zdump.8
+        $(UTIL) cp zic.man $(MANDIR)/cat8/zic.8

-INSTALL:    ALL install date.1
-        -mkdir $(TOPDIR) $(BINDIR)
-        cp date $(BINDIR)/.
-        -mkdir $(TOPDIR) $(MANDIR) $(MANDIR)/man1
-        -rm -f $(MANDIR)/man1/date.1
-        cp date.1 $(MANDIR)/man1/.
+all:        tzselect host-zic zic$(EXEEXT) zdump$(EXEEXT) $(LIBOBJS)
+
+ALL:        all date$(EXEEXT)

  version.h:
          (echo 'static char const PKGVERSION[]="($(PACKAGE)) ";' && \
           echo 'static char const TZVERSION[]="$(VERSION)";' && \
           echo 'static char const REPORT_BUGS_TO[]="$(BUGEMAIL)";') >$@

-zdump:        $(TZDOBJS)
+zdump$(EXEEXT):    $(TZDOBJS)
          $(CC) -o $@ $(CFLAGS) $(LDFLAGS) $(TZDOBJS) $(LDLIBS)
+        $(CROSS_STRIP) $@

-zic:        $(TZCOBJS) yearistype
+host-zic:    $(TZCSRCS) yearistype version.h
+        $(GCC) -DTZDIR=\"/dev/env/DJDIR~c:/djgpp~/zoneinfo\" \
+        $(GCCFLAGS) $(LDFLAGS) $(TZCSRCS) $(LDLIBS) -o $@
+        $(STRIP) $@
+
+zic$(EXEEXT):    $(TZCOBJS) yearistype
          $(CC) -o $@ $(CFLAGS) $(LDFLAGS) $(TZCOBJS) $(LDLIBS)
+        $(CROSS_STRIP) $@

  yearistype:    yearistype.sh
-        cp yearistype.sh yearistype
-        chmod +x yearistype
+        $(UTIL) cp yearistype.sh yearistype

-posix_only:    zic $(TDATA)
+posix_only:    $(zic) $(TDATA)
          $(ZIC) -y $(YEARISTYPE) -d $(TZDIR) -L /dev/null $(TDATA)

-right_only:    zic leapseconds $(TDATA)
+right_only:    $(zic) leapseconds $(TDATA)
          $(ZIC) -y $(YEARISTYPE) -d $(TZDIR) -L leapseconds $(TDATA)

  # In earlier versions of this makefile, the other two directories were
  # subdirectories of $(TZDIR).  However, this led to configuration errors.
  # For example, with posix_right under the earlier scheme,
@@ -388,11 +546,11 @@ right_only:    zic leapseconds $(TDATA)
  # but gmtime without leap seconds, which led to problems with applications
  # like sendmail that subtract gmtime from localtime.
  # Therefore, the other two directories are now siblings of $(TZDIR).
  # You must replace all of $(TZDIR) to switch from not using leap seconds
  # to using them, or vice versa.
-other_two:    zic leapseconds $(TDATA)
+other_two:    $(zic) leapseconds $(TDATA)
          $(ZIC) -y $(YEARISTYPE) -d $(TZDIR)-posix -L /dev/null $(TDATA)
          $(ZIC) -y $(YEARISTYPE) \
              -d $(TZDIR)-leaps -L leapseconds $(TDATA)

  posix_right:    posix_only other_two
@@ -400,25 +558,30 @@ posix_right:    posix_only other_two
  right_posix:    right_only other_two

  zones:        $(REDO)

  $(TZLIB):    $(LIBOBJS)
-        -mkdir $(TOPDIR) $(LIBDIR)
-        ar ru $@ $(LIBOBJS)
-        if [ -x /usr/ucb/ranlib ] || [ -x /usr/bin/ranlib ]; \
-            then ranlib $@ ; fi
-
-date:        $(DATEOBJS)
-        $(CC) -o $@ $(CFLAGS) $(LDFLAGS) $(DATEOBJS) $(LDLIBS)
+        -$(UTIL) mkdir $(TOPDIR)
+        -$(UTIL) mkdir $(LIBDIR)
+        $(CROSS_AR) rus $@ $(LIBOBJS)
+
+# We use the system's logwtmp in preference to ours if available.
+
+date$(EXEEXT):    $(DATEOBJS)
+        $(CROSS_AR) rs logwtmpl.a logwtmp.o
+        $(CC) $(CFLAGS) date.o localtime.o asctime.o strftime.o \
+            $(LDLIBS) -lc logwtmpl.a -o $@
+        $(CROSS_STRIP) $@
+        $(UTIL) rm logwtmpl.a
+        $(CROSS_STRIP) $@

  tzselect:    tzselect.ksh
          sed \
-            -e 's|#!/bin/bash|#!$(KSHELL)|g' \
              -e 's|AWK=[^}]*|AWK=$(AWK)|g' \
              -e 's|\(PKGVERSION\)=.*|\1='\''($(PACKAGE)) '\''|' \
              -e 's|\(REPORT_BUGS_TO\)=.*|\1=$(BUGEMAIL)|' \
-            -e 's|TZDIR=[^}]*|TZDIR=$(TZDIR)|' \
+            -e 's|TZDIR=[^}]*|TZDIR=/dev/env/DJDIR/zoneinfo|' \
              -e 's|\(TZVERSION\)=.*|\1=$(VERSION)|' \
              <$? >$@
          chmod +x $@

  check:        check_character_set check_tables check_web
@@ -431,22 +594,22 @@ check_tables:    checktab.awk $(PRIMARY_YDA

  check_web:    $(WEB_PAGES)
          $(VALIDATE_ENV) $(VALIDATE) $(VALIDATE_FLAGS) $(WEB_PAGES)

  clean_misc:
-        rm -f core *.o *.out \
-          date tzselect version.h zdump zic yearistype
+        $(UTIL) rm core *.o *.out tzselect zdump$(EXEEXT) zic$(EXEEXT) \
+            yearistype date$(EXEEXT) logwtmpl* *.tar.gz host-zic *.exe *.man
  clean:        clean_misc
-        rm -f -r tzpublic
+        $(UTIL) rm -f -r tzpublic

  maintainer-clean: clean
          @echo 'This command is intended for maintainers to use; it'
          @echo 'deletes files that may need special tools to rebuild.'
          rm -f *.[1-8].txt *.asc *.tar.gz

  names:
-        @echo $(ENCHILADA)
+        @$(UTIL) echo $(ENCHILADA)

  public:        check check_public check_time_t_alternatives \
          set-timestamps tarballs signatures

  # Set the time stamps to those of the git repository, if available,
@@ -468,11 +631,11 @@ set-timestamps:
  # The zics below ensure that each data file can stand on its own.
  # We also do an all-files run to catch links to links.

  check_public:    $(ENCHILADA)
          make maintainer-clean
-        make "CFLAGS=$(GCC_DEBUG_FLAGS)"
+        make "CFLAGS=$(CROSS_GCC_DEBUG_FLAGS)"
          mkdir tzpublic
          for i in $(TDATA) ; do \
            $(zic) -v -d tzpublic $$i 2>&1 || exit; \
          done
          $(zic) -v -d tzpublic $(TDATA)
diff -aprNU5 djgpp.orig/zoneinfo/src/private.h djgpp/zoneinfo/src/private.h
--- djgpp.orig/zoneinfo/src/private.h    2013-05-28 03:26:18 +0000
+++ djgpp/zoneinfo/src/private.h    2013-08-17 14:34:22 +0000
@@ -347,10 +347,20 @@ const char *    scheck(const char * string,
  #ifndef GNUC_or_lint
  #define INITIALIZE(x)
  #endif /* !defined GNUC_or_lint */
  #endif /* !defined INITIALIZE */

+#ifdef __MSDOS__
+#define IS_SLASH(c)     ((c) == '/' || (c) == '\\')
+#define HAS_DEVICE(n)   ((n)[0] && (n)[1] == ':')
+#define IS_ABSOLUTE(n)  (IS_SLASH((n)[0]) || HAS_DEVICE(n))
+#undef  TZDIR
+#define TZDIR           (getenv("TZDIR") ? getenv("TZDIR") : "/dev/env/DJDIR/zoneinfo")
+#else /* !__MSDOS__ */
+#define HAS_DEVICE(n) 0
+#endif /* !__MSDOS__ */
+
  /*
  ** For the benefit of GNU folk...
  ** `_(MSGID)' uses the current locale's message library string for MSGID.
  ** The default is to use gettext if available, and use MSGID otherwise.
  */
diff -aprNU5 djgpp.orig/zoneinfo/src/strftime.c djgpp/zoneinfo/src/strftime.c
--- djgpp.orig/zoneinfo/src/strftime.c    2013-05-28 03:26:18 +0000
+++ djgpp/zoneinfo/src/strftime.c    2013-08-17 14:34:22 +0000
@@ -3,10 +3,14 @@
  ** appearing below.
  **
  ** This is ANSIish only when "multibyte character == plain character".
  */

+#ifndef __DJGPP__
+/*  Use DJGPP's own implementation of strftime.  */
+
+
  #include "private.h"

  /*
  ** Copyright (c) 1989 The Regents of the University of California.
  ** All rights reserved.
@@ -736,5 +740,6 @@ no_locale:
      localebuf = C_time_locale;
      locale_buf = NULL;
      return &localebuf;
  }
  #endif /* defined LOCALE_HOME */
+#endif /* !__DJGPP__ */
diff -aprNU5 djgpp.orig/zoneinfo/src/zic.c djgpp/zoneinfo/src/zic.c
--- djgpp.orig/zoneinfo/src/zic.c    2013-05-28 03:26:18 +0000
+++ djgpp/zoneinfo/src/zic.c    2013-08-17 14:34:22 +0000
@@ -5,12 +5,15 @@

  #include "version.h"
  #include "private.h"
  #include "locale.h"
  #include "tzfile.h"
-
+#ifdef __DJGPP__
+#define    ZIC_VERSION    '\0'
+#else
  #define    ZIC_VERSION    '2'
+#endif

  typedef int_fast64_t    zic_t;
  #define ZIC_MIN INT_FAST64_MIN
  #define ZIC_MAX INT_FAST64_MAX
  #define SCNdZIC SCNdFAST64
@@ -27,10 +30,21 @@ typedef int_fast64_t    zic_t;
  #else
  #define MKDIR_UMASK 0755
  #endif

  /*
+** Portable testing for absolute file names.
+*/
+
+#ifndef IS_SLASH
+#define IS_SLASH(c)     ((c) == '/')
+#endif
+#ifndef IS_ABSOLUTE
+#define IS_ABSOLUTE(n)  (IS_SLASH((n)[0]))
+#endif
+
+/*
  ** On some ancient hosts, predicates like `isspace(C)' are defined
  ** 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.
@@ -579,24 +593,37 @@ static void
  dolink(const char *const fromfield, const char *const tofield)
  {
      register char *    fromname;
      register char *    toname;

-    if (fromfield[0] == '/')
+    if (IS_ABSOLUTE(fromfield))
          fromname = ecpyalloc(fromfield);
      else {
          fromname = ecpyalloc(directory);
          fromname = ecatalloc(fromname, "/");
          fromname = ecatalloc(fromname, fromfield);
      }
-    if (tofield[0] == '/')
+    if (IS_ABSOLUTE(tofield))
          toname = ecpyalloc(tofield);
      else {
          toname = ecpyalloc(directory);
          toname = ecatalloc(toname, "/");
          toname = ecatalloc(toname, tofield);
      }
+    /* Some zone names use `+' as part of their names, but DOS
+       doesn't allow `+' in file names.  Replace with a `%'.  */
+    if (getenv ("COMSPEC") || getenv ("CROSS_BUILD"))
+    {
+        char *p;
+
+        for (p = fromname; *p; p++)
+            if (*p == '+')
+                *p = '%';
+        for (p = toname; *p; p++)
+            if (*p == '+')
+                *p = '%';
+    }
      /*
      ** We get to be careful here since
      ** there's a fair chance of root running us.
      */
      if (!itsdir(toname))
@@ -648,17 +675,24 @@ static const zic_t min_time = (zic_t) -1
  static const zic_t max_time = -1 - ((zic_t) -1 << (TIME_T_BITS_IN_FILE - 1));

  static int
  itsdir(const char *const name)
  {
-    register char *    myname;
      register int    accres;

+#ifdef D_OK
+    /* MS-DOS/MS-Windows normalize "foo/." to "foo" before testing,
+       so we think foo is a directory.  Use D_OK instead.  */
+    accres = access(name, D_OK);
+#else
+    register char *    myname;
+
      myname = ecpyalloc(name);
      myname = ecatalloc(myname, "/.");
      accres = access(myname, F_OK);
      free(myname);
+#endif
      return accres == 0;
  }

  /*
  ** Associate sets of rules with zones.
@@ -1473,10 +1507,24 @@ writezone(const char *const name, const
          ++leapi32;
      }
      fullname = erealloc(fullname,
                  strlen(directory) + 1 + strlen(name) + 1);
      (void) sprintf(fullname, "%s/%s", directory, name);
+    /* Some zone names use `+' as part of their names, but DOS
+       doesn't allow `+' in file names.  Replace with a `%'.  */
+    if (getenv ("COMSPEC") || getenv ("CROSS_BUILD"))
+    {
+        char new_name[FILENAME_MAX + 1], *p;
+
+        strcpy(new_name, name);
+        for (p = new_name; *p; p++)
+            if (*p == '+')
+                *p = '%';
+        (void) sprintf(fullname, "%s/%s", directory, new_name);
+    }
+    else
+        (void) sprintf(fullname, "%s/%s", directory, name);
      /*
      ** Remove old file, if any, to snap links.
      */
      if (!itsdir(fullname) && remove(fullname) != 0 && errno != ENOENT) {
          const char *e = strerror(errno);
@@ -1494,11 +1542,15 @@ writezone(const char *const name, const
              (void) fprintf(stderr, _("%s: Can't create %s: %s\n"),
                  progname, fullname, e);
              exit(EXIT_FAILURE);
          }
      }
+#if defined(ZIC_VERSION) && ZIC_VERSION == 2
      for (pass = 1; pass <= 2; ++pass) {
+#else  /* ZIC_VERSION == 0  */
+    for (pass = 1; pass < 2; ++pass) {
+#endif  /* ZIC_VERSION == 0  */
          register int    thistimei, thistimecnt;
          register int    thisleapi, thisleapcnt;
          register int    thistimelim, thisleaplim;
          int        writetype[TZ_MAX_TIMES];
          int        typemap[TZ_MAX_TYPES];
@@ -1704,11 +1756,13 @@ writezone(const char *const name, const
                  (void) putc(ttisstds[i], fp);
          for (i = 0; i < typecnt; ++i)
              if (writetype[i])
                  (void) putc(ttisgmts[i], fp);
      }
+#if defined(ZIC_VERSION) && ZIC_VERSION == 2
      (void) fprintf(fp, "\n%s\n", string);
+#endif  /* ZIC_VERSION */
      if (ferror(fp) || fclose(fp)) {
          (void) fprintf(stderr, _("%s: Error writing %s\n"),
              progname, fullname);
          exit(EXIT_FAILURE);
      }
@@ -2608,42 +2662,40 @@ mkdirs(char *argname)
      register char *    cp;

      if (argname == NULL || *argname == '\0')
          return 0;
      cp = name = ecpyalloc(argname);
-    while ((cp = strchr(cp + 1, '/')) != 0) {
-        *cp = '\0';
-#ifdef HAVE_DOS_FILE_NAMES
-        /*
-        ** DOS drive specifier?
-        */
-        if (isalpha((unsigned char) name[0]) &&
-            name[1] == ':' && name[2] == '\0') {
-                *cp = '/';
-                continue;
-        }
-#endif
-        if (!itsdir(name)) {
-            /*
-            ** It doesn't seem to exist, so we try to create it.
-            ** Creation may fail because of the directory being
-            ** created by some other multiprocessor, so we get
-            ** to do extra checking.
-            */
-            if (mkdir(name, MKDIR_UMASK) != 0) {
-                const char *e = strerror(errno);
-
-                if (errno != EEXIST || !itsdir(name)) {
-                    (void) fprintf(stderr,
-_("%s: Can't create directory %s: %s\n"),
-                        progname, name, e);
-                    free(name);
-                    return -1;
-                }
-            }
-        }
-        *cp = '/';
+    /*
+    ** Get past a DOS-style drive specifier, if any.
+    */
+    if (HAS_DEVICE(name))
+        cp += 2;
+    while (*cp++) {
+        if (IS_SLASH(*cp)) {
+            *cp = '\0';
+            if (!itsdir(name)) {
+                /*
+                ** It doesn't seem to exist, so we try to
+                ** create it.  Creation may fail because
+                ** of the directory being created by some
+                ** other multiprocessor, so we get to do
+                ** extra checking.
+                */
+                if (mkdir(name, MKDIR_UMASK) != 0) {
+                    const char *e = strerror(errno);
+
+                    if (errno != EEXIST || !itsdir(name)) {
+                        (void) fprintf(stderr,
+  _("%s: Can't create directory %s: %s\n"),
+                               progname, name, e);
+                        free(name);
+                        return -1;
+                    }
+                  }
+              }
+            *cp = '/';
+          }
      }
      free(name);
      return 0;
  }