Force a checkpoint in CREATE DATABASE before starting to copy the files,

[PostgreSQL.git] / src / timezone / localtime.c

/*
 * This file is in the public domain, so clarified as of
 * 1996-06-05 by Arthur David Olson.
 *
 * IDENTIFICATION
 *        $PostgreSQL$
 */

/*
 * Leap second handling from Bradley White.
 * POSIX-style TZ environment variable handling from Guy Harris.
 */

/* this file needs to build in both frontend and backend contexts */
#include "c.h"

#include <fcntl.h>

#include "private.h"
#include "pgtz.h"
#include "tzfile.h"


#ifndef WILDABBR
/*----------
 * 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.
 * 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).
 *----------
 */
#define WILDABBR        "   "
#endif   /* !defined WILDABBR */

static char wildabbr[] = WILDABBR;

static const char gmt[] = "GMT";

/*
 * 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.
 */
#define TZDEFRULESTRING ",M4.1.0,M10.5.0"

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 */
};

#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(const char *codep);
static pg_time_t detzcode64(const char *codep);
static int differ_by_repeat(pg_time_t t1, pg_time_t t0);
static const char *getzname(const char *strp);
static const char *getqzname(const char *strp, int delim);
static const char *getnum(const char *strp, int *nump, int min, int max);
static const char *getsecs(const char *strp, long *secsp);
static const char *getoffset(const char *strp, long *offsetp);
static const char *getrule(const char *strp, struct rule * rulep);
static void gmtload(struct state * sp);
static struct pg_tm *gmtsub(const pg_time_t *timep, long offset, 
                                                        struct pg_tm *tmp);
static struct pg_tm *localsub(const pg_time_t *timep, long offset, 
                                                           struct pg_tm *tmp, const pg_tz *tz);
static int increment_overflow(int *number, int delta);
static pg_time_t transtime(pg_time_t janfirst, int year,
                  const struct rule *rulep, long offset);
static int typesequiv(const struct state *sp, int a, int b);
static struct pg_tm *timesub(const pg_time_t *timep, long offset,
                                                         const struct state *sp, struct pg_tm *tmp);

/* GMT timezone */
static struct state gmtmem;

#define gmtptr          (&gmtmem)


static int      gmt_is_set = 0;

/*
 * 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
 *      objects: a broken-down time structure and an array of char.
 * Thanks to Paul Eggert for noting this.
 */

static struct pg_tm tm;


static long
detzcode(const char *codep)
{
        long            result;
        int                     i;

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

static pg_time_t
detzcode64(const char *codep)
{
        pg_time_t result;
        int    i;

        result = (codep[0] & 0x80) ?  (~(int64) 0) : 0;
        for (i = 0; i < 8; ++i)
                result = result * 256 + (codep[i] & 0xff);
        return result;
}

static int
differ_by_repeat(pg_time_t t1, pg_time_t t0)
{
        if (TYPE_INTEGRAL(pg_time_t) &&
                TYPE_BIT(pg_time_t) - TYPE_SIGNED(pg_time_t) < SECSPERREPEAT_BITS)
                return 0;
        return t1 - t0 == SECSPERREPEAT;
}

int
tzload(const char *name, char *canonname, struct state * sp, int doextend)
{
        const char *p;
        int                     i;
        int                     fid;
        int                     stored;
        int                     nread;
        union
        {
                struct tzhead tzhead;
                char            buf[2 * sizeof(struct tzhead) +
                                                2 * sizeof *sp +
                                                4 * TZ_MAX_TIMES];
        } u;

        if (name == NULL && (name = TZDEFAULT) == NULL)
                return -1;
        if (name[0] == ':')
                ++name;
        fid = pg_open_tzfile(name, canonname);
        if (fid < 0)
                return -1;
        nread = read(fid, u.buf, sizeof u.buf);
        if (close(fid) != 0 || nread <= 0)
                return -1;
        for (stored = 4; stored <= 8; stored *= 2)
        {
                int                     ttisstdcnt;
                int                     ttisgmtcnt;

                ttisstdcnt = (int) detzcode(u.tzhead.tzh_ttisstdcnt);
                ttisgmtcnt = (int) detzcode(u.tzhead.tzh_ttisgmtcnt);
                sp->leapcnt = (int) detzcode(u.tzhead.tzh_leapcnt);
                sp->timecnt = (int) detzcode(u.tzhead.tzh_timecnt);
                sp->typecnt = (int) detzcode(u.tzhead.tzh_typecnt);
                sp->charcnt = (int) detzcode(u.tzhead.tzh_charcnt);
                p = u.tzhead.tzh_charcnt + sizeof u.tzhead.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) ||
                        (ttisgmtcnt != sp->typecnt && ttisgmtcnt != 0))
                        return -1;
                if (nread - (p - u.buf) <
                        sp->timecnt * stored + /* ats */
                        sp->timecnt +           /* types */
                        sp->typecnt * 6 +               /* ttinfos */
                        sp->charcnt +           /* chars */
                        sp->leapcnt * (stored + 4) +            /* lsinfos */
                        ttisstdcnt +            /* ttisstds */
                        ttisgmtcnt)                     /* ttisgmts */
                        return -1;
                for (i = 0; i < sp->timecnt; ++i)
                {
                        sp->ats[i] = (stored == 4) ? detzcode(p) : detzcode64(p);
                        p += stored;
                }
                for (i = 0; i < sp->timecnt; ++i)
                {
                        sp->types[i] = (unsigned char) *p++;
                        if (sp->types[i] >= sp->typecnt)
                                return -1;
                }
                for (i = 0; i < sp->typecnt; ++i)
                {
                        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)
                                return -1;
                }
                for (i = 0; i < sp->charcnt; ++i)
                        sp->chars[i] = *p++;
                sp->chars[i] = '\0';    /* ensure '\0' at end */
                for (i = 0; i < sp->leapcnt; ++i)
                {
                        struct lsinfo *lsisp;

                        lsisp = &sp->lsis[i];
                        lsisp->ls_trans = (stored == 4) ? detzcode(p) : detzcode64(p);
                        p += stored;
                        lsisp->ls_corr = detzcode(p);
                        p += 4;
                }
                for (i = 0; i < sp->typecnt; ++i)
                {
                        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;
                        }
                }
                for (i = 0; i < sp->typecnt; ++i)
                {
                        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 - 2; ++i)
                        if (sp->ats[i] > sp->ats[i + 1])
                        {
                                ++i;
                                if (TYPE_SIGNED(pg_time_t))
                                {
                                        /*
                                         * Ignore the end (easy).
                                         */
                                        sp->timecnt = i;
                                }
                                else
                                {
                                        /*
                                         * Ignore the beginning (harder).
                                         */
                                        int j;
                                        
                                        for (j = 0; j + i < sp->timecnt; ++j)
                                        {
                                                sp->ats[j] = sp->ats[j + i];
                                                sp->types[j] = sp->types[j + i];
                                        }
                                        sp->timecnt = j;
                                }
                                break;
                        }
                /*
                 * If this is an old file, we're done.
                 */
                if (u.tzhead.tzh_version[0] == '\0')
                        break;
                nread -= p - u.buf;
                for (i = 0; i < nread; ++i)
                        u.buf[i] = p[i];
                /*
                 * If this is a narrow integer time_t system, we're done.
                 */
                if (stored >= (int) sizeof(pg_time_t) && TYPE_INTEGRAL(pg_time_t))
                        break;
        }
        if (doextend && nread > 2 &&
                u.buf[0] == '\n' && u.buf[nread - 1] == '\n' &&
                sp->typecnt + 2 <= TZ_MAX_TYPES)
        {
                struct state    ts;
                int    result;
 
                u.buf[nread - 1] = '\0';
                result = tzparse(&u.buf[1], &ts, FALSE);
                if (result == 0 && ts.typecnt == 2 &&
                        sp->charcnt + ts.charcnt <= TZ_MAX_CHARS)
                {
                        for (i = 0; i < 2; ++i)
                                ts.ttis[i].tt_abbrind +=
                                        sp->charcnt;
                        for (i = 0; i < ts.charcnt; ++i)
                                sp->chars[sp->charcnt++] =
                                        ts.chars[i];
                        i = 0;
                        while (i < ts.timecnt &&
                                   ts.ats[i] <=
                                   sp->ats[sp->timecnt - 1])
                                ++i;
                        while (i < ts.timecnt &&
                                   sp->timecnt < TZ_MAX_TIMES)
                        {
                                sp->ats[sp->timecnt] =
                                        ts.ats[i];
                                sp->types[sp->timecnt] =
                                        sp->typecnt +
                                        ts.types[i];
                                ++sp->timecnt;
                                ++i;
                        }
                        sp->ttis[sp->typecnt++] = ts.ttis[0];
                        sp->ttis[sp->typecnt++] = ts.ttis[1];
                }
        }
        i = 2 * YEARSPERREPEAT;
        sp->goback = sp->goahead = sp->timecnt > i;
        sp->goback = sp->goback &&
                typesequiv(sp, sp->types[i], sp->types[0]) &&
                differ_by_repeat(sp->ats[i], sp->ats[0]);
        sp->goahead = sp->goahead &&
                typesequiv(sp, sp->types[sp->timecnt - 1],
                                   sp->types[sp->timecnt - 1 - i]) &&
                differ_by_repeat(sp->ats[sp->timecnt - 1],
                                                 sp->ats[sp->timecnt - 1 - i]);
        return 0;
}

static int
typesequiv(const struct state *sp, int a, int b)
{
        int    result;

        if (sp == NULL ||
                a < 0 || a >= sp->typecnt ||
                b < 0 || b >= sp->typecnt)
                result = FALSE;
        else
        {
                const struct ttinfo *ap = &sp->ttis[a];
                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}
};

static const int year_lengths[2] = {
        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
 * character.
 */
static const char *
getzname(const char *strp)
{
        char            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, int delim)
{
        int    c;

        while ((c = *strp) != '\0' && c != delim)
                ++strp;
        return strp;
}

/*
 * Given a pointer into a time zone string, extract a number from that string.
 * Check that the number is within a specified range; if it is not, return
 * NULL.
 * Otherwise, return a pointer to the first character not part of the number.
 */
static const char *
getnum(const char *strp, int *nump, int min, int max)
{
        char            c;
        int                     num;

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

/*
 * Given a pointer into a time zone string, extract a number of seconds,
 * in hh[:mm[:ss]] form, from the string.
 * If any error occurs, return NULL.
 * Otherwise, return a pointer to the first character not part of the number
 * of seconds.
 */
static const char *
getsecs(const char *strp, long *secsp)
{
        int                     num;

        /*
         * `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 * (long) SECSPERHOUR;
        if (*strp == ':')
        {
                ++strp;
                strp = getnum(strp, &num, 0, MINSPERHOUR - 1);
                if (strp == NULL)
                        return NULL;
                *secsp += num * SECSPERMIN;
                if (*strp == ':')
                {
                        ++strp;
                        /* `SECSPERMIN' allows for leap seconds. */
                        strp = getnum(strp, &num, 0, SECSPERMIN);
                        if (strp == NULL)
                                return NULL;
                        *secsp += num;
                }
        }
        return strp;
}

/*
 * Given a pointer into a time zone string, extract an offset, in
 * [+-]hh[:mm[:ss]] form, from the string.
 * 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 *offsetp)
{
        int                     neg = 0;

        if (*strp == '-')
        {
                neg = 1;
                ++strp;
        }
        else if (*strp == '+')
                ++strp;
        strp = getsecs(strp, offsetp);
        if (strp == NULL)
                return NULL;                    /* illegal time */
        if (neg)
                *offsetp = -*offsetp;
        return strp;
}

/*
 * Given a pointer into a time zone string, extract a rule in the form
 * date[/time]. See POSIX section 8 for the format of "date" and "time".
 * 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 * rulep)
{
        if (*strp == 'J')
        {
                /*
                 * Julian day.
                 */
                rulep->r_type = JULIAN_DAY;
                ++strp;
                strp = getnum(strp, &rulep->r_day, 1, DAYSPERNYEAR);
        }
        else if (*strp == 'M')
        {
                /*
                 * Month, week, day.
                 */
                rulep->r_type = MONTH_NTH_DAY_OF_WEEK;
                ++strp;
                strp = getnum(strp, &rulep->r_mon, 1, MONSPERYEAR);
                if (strp == NULL)
                        return NULL;
                if (*strp++ != '.')
                        return NULL;
                strp = getnum(strp, &rulep->r_week, 1, 5);
                if (strp == NULL)
                        return NULL;
                if (*strp++ != '.')
                        return NULL;
                strp = getnum(strp, &rulep->r_day, 0, DAYSPERWEEK - 1);
        }
        else if (is_digit(*strp))
        {
                /*
                 * Day of year.
                 */
                rulep->r_type = DAY_OF_YEAR;
                strp = getnum(strp, &rulep->r_day, 0, DAYSPERLYEAR - 1);
        }
        else
                return NULL;                    /* invalid format */
        if (strp == NULL)
                return NULL;
        if (*strp == '/')
        {
                /*
                 * Time specified.
                 */
                ++strp;
                strp = getsecs(strp, &rulep->r_time);
        }
        else
                rulep->r_time = 2 * SECSPERHOUR;                /* default = 2:00:00 */
        return strp;
}

/*
 * 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 pg_time_t
transtime(pg_time_t janfirst, int year,
                  const struct rule * rulep, long offset)
{
        int                     leapyear;
        pg_time_t       value = 0;
        int                     i,
                                d,
                                m1,
                                yy0,
                                yy1,
                                yy2,
                                dow;

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

                case JULIAN_DAY:

                        /*
                         * Jn - Julian day, 1 == January 1, 60 == March 1 even in leap
                         * years. In non-leap years, or if the day number is 59 or less,
                         * just add SECSPERDAY times the day number-1 to the time of
                         * January 1, midnight, to get the day.
                         */
                        value = janfirst + (rulep->r_day - 1) * SECSPERDAY;
                        if (leapyear && rulep->r_day >= 60)
                                value += SECSPERDAY;
                        break;

                case DAY_OF_YEAR:

                        /*
                         * n - day of year. Just add SECSPERDAY times the day number to
                         * the time of January 1, midnight, to get the day.
                         */
                        value = janfirst + rulep->r_day * SECSPERDAY;
                        break;

                case MONTH_NTH_DAY_OF_WEEK:

                        /*
                         * Mm.n.d - nth "dth day" of month m.
                         */
                        value = janfirst;
                        for (i = 0; i < rulep->r_mon - 1; ++i)
                                value += mon_lengths[leapyear][i] * SECSPERDAY;

                        /*
                         * Use Zeller's Congruence to get day-of-week of first day of
                         * month.
                         */
                        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;
                        if (dow < 0)
                                dow += DAYSPERWEEK;

                        /*
                         * "dow" is the day-of-week of the first day of the month. Get the
                         * day-of-month (zero-origin) of the first "dow" day of the month.
                         */
                        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;
                                d += DAYSPERWEEK;
                        }

                        /*
                         * "d" is the day-of-month (zero-origin) of the day we want.
                         */
                        value += d * SECSPERDAY;
                        break;
        }

        /*
         * "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 UTC.
         */
        return value + rulep->r_time + offset;
}

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

int
tzparse(const char *name, struct state * sp, int lastditch)
{
        const char *stdname;
        const char *dstname = NULL;
        size_t          stdlen;
        size_t          dstlen;
        long            stdoffset;
        long            dstoffset;
        pg_time_t  *atp;
        unsigned char *typep;
        char       *cp;
        int                     load_result;

        stdname = name;
        if (lastditch)
        {
                stdlen = strlen(name);  /* length of standard zone name */
                name += stdlen;
                if (stdlen >= sizeof sp->chars)
                        stdlen = (sizeof sp->chars) - 1;
                stdoffset = 0;

                /*
                 * Unlike the original zic library, do NOT invoke tzload() here; we
                 * can't assume pg_open_tzfile() is sane yet, and we don't care about
                 * leap seconds anyway.
                 */
                load_result = -1;
        }
        else
        {
                if (*name == '<')
                {
                        name++;
                        stdname = name;
                        name = getqzname(name, '>');
                        if (*name != '>')
                                return (-1);
                        stdlen = name - stdname;
                        name++;
                }
                else
                {
                        name = getzname(name);
                        stdlen = name - stdname;
                }
                if (*name == '\0')
                        return -1;
                name = getoffset(name, &stdoffset);
                if (name == NULL)
                        return -1;
                load_result = tzload(TZDEFRULES, NULL, sp, FALSE);
        }
        if (load_result != 0)
                sp->leapcnt = 0;                /* so, we're off a little */
        if (*name != '\0')
        {
                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;
                }
                else
                        dstoffset = stdoffset - SECSPERHOUR;
                if (*name == '\0' && load_result != 0)
                        name = TZDEFRULESTRING;
                if (*name == ',' || *name == ';')
                {
                        struct rule start;
                        struct rule end;
                        int                     year;
                        pg_time_t       janfirst;
                        pg_time_t       starttime;
                        pg_time_t       endtime;

                        ++name;
                        if ((name = getrule(name, &start)) == NULL)
                                return -1;
                        if (*name++ != ',')
                                return -1;
                        if ((name = getrule(name, &end)) == NULL)
                                return -1;
                        if (*name != '\0')
                                return -1;
                        sp->typecnt = 2;        /* standard time and DST */

                        /*
                         * Two transitions per year, from EPOCH_YEAR forward.
                         */
                        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;
                        sp->timecnt = 0;
                        for (year = EPOCH_YEAR;
                                 sp->timecnt + 2 <= TZ_MAX_TIMES;
                                 ++year)
                        {
                                pg_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
                {
                        long            theirstdoffset;
                        long            theirdstoffset;
                        long            theiroffset;
                        int                     isdst;
                        int                     i;
                        int                     j;

                        if (*name != '\0')
                                return -1;

                        /*
                         * 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)
                        {
                                j = sp->types[i];
                                if (sp->ttis[j].tt_isdst)
                                {
                                        theirdstoffset =
                                                -sp->ttis[j].tt_gmtoff;
                                        break;
                                }
                        }

                        /*
                         * Initially we're assumed to be in standard time.
                         */
                        isdst = FALSE;
                        theiroffset = theirstdoffset;

                        /*
                         * Now juggle transition times and types tracking offsets as you
                         * do.
                         */
                        for (i = 0; i < sp->timecnt; ++i)
                        {
                                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. ttisstd and ttisgmt need not be handled.
                         */
                        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->timecnt = 0;
                sp->ttis[0].tt_gmtoff = -stdoffset;
                sp->ttis[0].tt_isdst = 0;
                sp->ttis[0].tt_abbrind = 0;
        }
        sp->charcnt = stdlen + 1;
        if (dstlen != 0)
                sp->charcnt += dstlen + 1;
        if ((size_t) sp->charcnt > sizeof sp->chars)
                return -1;
        cp = sp->chars;
        (void) strncpy(cp, stdname, stdlen);
        cp += stdlen;
        *cp++ = '\0';
        if (dstlen != 0)
        {
                (void) strncpy(cp, dstname, dstlen);
                *(cp + dstlen) = '\0';
        }
        return 0;
}

static void
gmtload(struct state * sp)
{
        if (tzload(gmt, NULL, sp, TRUE) != 0)
                (void) tzparse(gmt, sp, TRUE);
}


/*
 * 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.
 */
static struct pg_tm *
localsub(const pg_time_t *timep, long offset,
                 struct pg_tm *tmp, const pg_tz *tz)
{
        const struct state *sp;
        const struct ttinfo *ttisp;
        int                     i;
        struct pg_tm *result;
        const pg_time_t t = *timep;

        sp = &tz->state;
        if ((sp->goback && t < sp->ats[0]) ||
                (sp->goahead && t > sp->ats[sp->timecnt - 1]))
        {
                pg_time_t       newt = t;
                pg_time_t       seconds;
                pg_time_t       tcycles;
                int64           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, tz);
                if (result == tmp)
                {
                        pg_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 != newy)
                                return NULL;
                }
                return result;
        }
        if (sp->timecnt == 0 || t < sp->ats[0])
        {
                i = 0;
                while (sp->ttis[i].tt_isdst)
                        if (++i >= sp->typecnt)
                        {
                                i = 0;
                                break;
                        }
        }
        else
        {
                int    lo = 1;
                int    hi = sp->timecnt;
 
                while (lo < hi)
                {
                        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];

        result = timesub(&t, ttisp->tt_gmtoff, sp, tmp);
        tmp->tm_isdst = ttisp->tt_isdst;
        tmp->tm_zone = &sp->chars[ttisp->tt_abbrind];
        return result;
}


struct pg_tm *
pg_localtime(const pg_time_t *timep, const pg_tz *tz)
{
        return localsub(timep, 0L, &tm, tz);
}


/*
 * gmtsub is to gmtime as localsub is to localtime.
 */
static struct pg_tm *
gmtsub(const pg_time_t *timep, long offset, struct pg_tm *tmp)
{
        struct pg_tm *result;

        if (!gmt_is_set)
        {
                gmt_is_set = TRUE;
                gmtload(gmtptr);
        }
        result = timesub(timep, offset, gmtptr, tmp);

        /*
         * Could get fancy here and deliver something such as "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;
        else
                tmp->tm_zone = gmtptr->chars;

        return result;
}

struct pg_tm *
pg_gmtime(const pg_time_t *timep)
{
        return gmtsub(timep, 0L, &tm);
}

/*
 * Return the number of leap years through the end of the given year
 * where, to make the math easy, the answer for year zero is defined as zero.
 */
static int
leaps_thru_end_of(const int y)
{
        return (y >= 0) ? (y / 4 - y / 100 + y / 400) :
                -(leaps_thru_end_of(-(y + 1)) + 1);
}


static struct pg_tm *
timesub(const pg_time_t *timep, long offset,
                const struct state *sp, struct pg_tm *tmp)
{
        const struct lsinfo *lp;
        pg_time_t       tdays;
        int                     idays;  /* unsigned would be so 2003 */
        long            rem;
        int                     y;
        const int  *ip;
        long            corr;
        int                     hit;
        int                     i;

        corr = 0;
        hit = 0;
        i = sp->leapcnt;
        while (--i >= 0)
        {
                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);
                                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;
                }
        }
        y = EPOCH_YEAR;
        tdays = *timep / SECSPERDAY;
        rem = *timep - tdays * SECSPERDAY;
        while (tdays < 0 || tdays >= year_lengths[isleap(y)])
        {
                int             newy;
                pg_time_t       tdelta;
                int             idelta;
                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 -= ((pg_time_t) newy - y) * DAYSPERNYEAR;
                tdays -= leapdays;
                y = newy;
        }
        {
                long   seconds;
 
                seconds = tdays * SECSPERDAY + 0.5;
                tdays = seconds / SECSPERDAY;
                rem += seconds - tdays * SECSPERDAY;
        }
        /*
         * Given the range, we can now fearlessly cast...
         */
        idays = tdays;
        rem += offset - corr;
        while (rem < 0)
        {
                rem += SECSPERDAY;
                --idays;
        }
        while (rem >= SECSPERDAY)
        {
                rem -= SECSPERDAY;
                ++idays;
        }
        while (idays < 0)
        {
                if (increment_overflow(&y, -1))
                        return NULL;
                idays += year_lengths[isleap(y)];
        }
        while (idays >= year_lengths[isleap(y)])
        {
                idays -= year_lengths[isleap(y)];
                if (increment_overflow(&y, 1))
                        return NULL;
        }
        tmp->tm_year = y;
        if (increment_overflow(&tmp->tm_year, -TM_YEAR_BASE))
                return NULL;
        tmp->tm_yday = idays;
        /*
         * The "extra" mods below avoid overflow problems.
         */
        tmp->tm_wday = EPOCH_WDAY +
                ((y - EPOCH_YEAR) % DAYSPERWEEK) *
                (DAYSPERNYEAR % DAYSPERWEEK) +
                leaps_thru_end_of(y - 1) -
                leaps_thru_end_of(EPOCH_YEAR - 1) +
                idays;
        tmp->tm_wday %= DAYSPERWEEK;
        if (tmp->tm_wday < 0)
                tmp->tm_wday += DAYSPERWEEK;
        tmp->tm_hour = (int) (rem / SECSPERHOUR);
        rem %= 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;
}

/*
 * Simplified normalize logic courtesy Paul Eggert.
 */

static int
increment_overflow(int *number, int delta)
{
        int     number0;

        number0 = *number;
        *number += delta;
        return (*number < number0) != (delta < 0);
}

/*
 * Find the next DST transition time at or after the given time
 *
 * *timep is the input value, the other parameters are output values.
 *
 * When the function result is 1, *boundary is set to the time_t
 * representation of the next DST transition time at or after *timep,
 * *before_gmtoff and *before_isdst are set to the GMT offset and isdst
 * state prevailing just before that boundary, and *after_gmtoff and
 * *after_isdst are set to the state prevailing just after that boundary.
 *
 * When the function result is 0, there is no known DST transition at or
 * after *timep, but *before_gmtoff and *before_isdst indicate the GMT
 * offset and isdst state prevailing at *timep.  (This would occur in
 * DST-less time zones, for example.)
 *
 * A function result of -1 indicates failure (this case does not actually
 * occur in our current implementation).
 */
int
pg_next_dst_boundary(const pg_time_t *timep,
                                         long int *before_gmtoff,
                                         int *before_isdst,
                                         pg_time_t *boundary,
                                         long int *after_gmtoff,
                                         int *after_isdst,
                                         const pg_tz *tz)
{
        const struct state *sp;
        const struct ttinfo *ttisp;
        int                     i;
        int                     j;
        const pg_time_t t = *timep;

        sp = &tz->state;
        if (sp->timecnt == 0)
        {
                /* non-DST zone, use lowest-numbered standard type */
                i = 0;
                while (sp->ttis[i].tt_isdst)
                        if (++i >= sp->typecnt)
                        {
                                i = 0;
                                break;
                        }
                ttisp = &sp->ttis[i];
                *before_gmtoff = ttisp->tt_gmtoff;
                *before_isdst = ttisp->tt_isdst;
                return 0;
        }
        if ((sp->goback && t < sp->ats[0]) ||
                (sp->goahead && t > sp->ats[sp->timecnt - 1]))
        {
                /* For values outside the transition table, extrapolate */
                pg_time_t       newt = t;
                pg_time_t       seconds;
                pg_time_t       tcycles;
                int64           icycles;
                int                     result;
                
                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 -1;
                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 -1;    /* "cannot happen" */

                result = pg_next_dst_boundary(&newt, before_gmtoff,
                                                                          before_isdst,
                                                                          boundary,
                                                                          after_gmtoff,
                                                                          after_isdst,
                                                                          tz);
                if (t < sp->ats[0])
                        *boundary -= seconds;
                else
                        *boundary += seconds;
                return result;
        }

        if (t > sp->ats[sp->timecnt - 1])
        {
                /* No known transition >= t, so use last known segment's type */
                i = sp->types[sp->timecnt - 1];
                ttisp = &sp->ttis[i];
                *before_gmtoff = ttisp->tt_gmtoff;
                *before_isdst = ttisp->tt_isdst;
                return 0;
        }
        if (t <= sp->ats[0])
        {
                /* For "before", use lowest-numbered standard type */
                i = 0;
                while (sp->ttis[i].tt_isdst)
                        if (++i >= sp->typecnt)
                        {
                                i = 0;
                                break;
                        }
                ttisp = &sp->ttis[i];
                *before_gmtoff = ttisp->tt_gmtoff;
                *before_isdst = ttisp->tt_isdst;
                *boundary = sp->ats[0];
                /* And for "after", use the first segment's type */
                i = sp->types[0];
                ttisp = &sp->ttis[i];
                *after_gmtoff = ttisp->tt_gmtoff;
                *after_isdst = ttisp->tt_isdst;
                return 1;
        }
        /* Else search to find the containing segment */
        {
                int    lo = 1;
                int    hi = sp->timecnt;
 
                while (lo < hi)
                {
                        int    mid = (lo + hi) >> 1;
 
                        if (t < sp->ats[mid])
                                hi = mid;
                        else    lo = mid + 1;
                }
                i = lo;
        }
        j = sp->types[i - 1];
        ttisp = &sp->ttis[j];
        *before_gmtoff = ttisp->tt_gmtoff;
        *before_isdst = ttisp->tt_isdst;
        *boundary = sp->ats[i];
        j = sp->types[i];
        ttisp = &sp->ttis[j];
        *after_gmtoff = ttisp->tt_gmtoff;
        *after_isdst = ttisp->tt_isdst;
        return 1;
}

/*
 * If the given timezone uses only one GMT offset, store that offset
 * into *gmtoff and return TRUE, else return FALSE.
 */
bool
pg_get_timezone_offset(const pg_tz *tz, long int *gmtoff)
{
        /*
         * The zone could have more than one ttinfo, if it's historically used
         * more than one abbreviation.  We return TRUE as long as they all have
         * the same gmtoff.
         */
        const struct state *sp;
        int                     i;

        sp = &tz->state;
        for (i = 1; i < sp->typecnt; i++)
        {
                if (sp->ttis[i].tt_gmtoff != sp->ttis[0].tt_gmtoff)
                        return false;
        }
        *gmtoff = sp->ttis[0].tt_gmtoff;
        return true;
}

/*
 * Return the name of the current timezone
 */
const char *
pg_get_timezone_name(pg_tz *tz)
{
        if (tz)
                return tz->TZname;
        return NULL;
}