#include <sys/param.h>
#include <fcntl.h>
#include <time.h>
#include <tzfile.h>
#include <string.h>
#include <ctype.h>
#include <stdio.h>
#include <unistd.h>
#ifdef __STDC__
#include <stdlib.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
#else
#define P(s) ()
typedef char * genericptr_t;
typedef unsigned alloc_size_t;
typedef int qsort_size_t;
typedef int fread_size_t;
typedef int fwrite_size_t;
extern char * calloc();
extern char * malloc();
extern char * realloc();
extern char * getenv();
#endif
extern time_t time();
#define ACCESS_MODE O_RDONLY
#define OPEN_MODE O_RDONLY
#ifndef WILDABBR
#define WILDABBR " "
#endif
#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif
static const char GMT[] = "GMT";
struct ttinfo {
long tt_gmtoff;
int tt_isdst;
int tt_abbrind;
int tt_ttisstd;
};
struct lsinfo {
time_t ls_trans;
long ls_corr;
};
struct state {
int leapcnt;
int timecnt;
int typecnt;
int charcnt;
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];
struct lsinfo lsis[TZ_MAX_LEAPS];
};
struct rule {
int r_type;
int r_day;
int r_week;
int r_mon;
long r_time;
};
#define JULIAN_DAY 0
#define DAY_OF_YEAR 1
#define MONTH_NTH_DAY_OF_WEEK 2
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)(),
long offset));
static time_t time2 P((struct tm *tmp, void (* funcp)(),
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 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
#ifndef ALL_STATE
static struct state lclmem;
static struct state gmtmem;
#define lclptr (&lclmem)
#define gmtptr (&gmtmem)
#endif
static int lcl_is_set;
static int gmt_is_set;
char * tzname[2] = {
WILDABBR,
WILDABBR
};
#ifdef USG_COMPAT
time_t timezone = 0;
int daylight = 0;
#endif
#ifdef ALTZONE
time_t altzone = 0;
#endif
static long
detzcode(codep)
const char * const codep;
{
register long result;
register int i;
result = 0;
for (i = 0; i < 4; ++i)
result = (result << 8) | (codep[i] & 0xff);
return result;
}
static void
settzname()
{
register const struct state * const sp = lclptr;
register int i;
tzname[0] = WILDABBR;
tzname[1] = WILDABBR;
#ifdef USG_COMPAT
daylight = 0;
timezone = 0;
#endif
#ifdef ALTZONE
altzone = 0;
#endif
#ifdef ALL_STATE
if (sp == NULL) {
tzname[0] = tzname[1] = GMT;
return;
}
#endif
for (i = 0; i < sp->typecnt; ++i) {
register const struct ttinfo * const ttisp = &sp->ttis[i];
tzname[ttisp->tt_isdst] =
(char *) &sp->chars[ttisp->tt_abbrind];
#ifdef USG_COMPAT
if (ttisp->tt_isdst)
daylight = 1;
if (i == 0 || !ttisp->tt_isdst)
timezone = -(ttisp->tt_gmtoff);
#endif
#ifdef ALTZONE
if (i == 0 || ttisp->tt_isdst)
altzone = -(ttisp->tt_gmtoff);
#endif
}
for (i = 0; i < sp->timecnt; ++i) {
register const struct ttinfo * const ttisp =
&sp->ttis[sp->types[i]];
tzname[ttisp->tt_isdst] =
(char *) &sp->chars[ttisp->tt_abbrind];
}
}
static int
tzload(name, sp)
register const char * name;
register struct state * const sp;
{
register const char * p;
register int i;
register int fid;
if (name == NULL && (name = TZDEFAULT) == NULL)
return -1;
{
char fullname[FILENAME_MAX + 1];
if (name[0] == ':')
++name;
if (name[0] != '/') {
if ((p = TZDIR) == NULL)
return -1;
if ((strlen(p) + strlen(name) + 1) >= sizeof fullname)
return -1;
(void) strcpy(fullname, p);
(void) strcat(fullname, "/");
(void) strcat(fullname, name);
name = fullname;
}
if ((fid = open(name, OPEN_MODE)) == -1)
return -1;
}
{
register const struct tzhead * tzhp;
char buf[sizeof *sp + sizeof *tzhp];
int ttisstdcnt;
i = read(fid, buf, sizeof buf);
if (close(fid) != 0 || i < sizeof *tzhp)
return -1;
tzhp = (struct tzhead *) buf;
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))
return -1;
if (i < sizeof *tzhp +
sp->timecnt * (4 + sizeof (char)) +
sp->typecnt * (4 + 2 * sizeof (char)) +
sp->charcnt * sizeof (char) +
sp->leapcnt * 2 * 4 +
ttisstdcnt * sizeof (char))
return -1;
p = buf + sizeof *tzhp;
for (i = 0; i < sp->timecnt; ++i) {
sp->ats[i] = detzcode(p);
p += 4;
}
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) {
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)
return -1;
}
for (i = 0; i < sp->charcnt; ++i)
sp->chars[i] = *p++;
sp->chars[i] = '\0';
for (i = 0; i < sp->leapcnt; ++i) {
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) {
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;
}
}
}
return 0;
}
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
};
static const char *
getzname(strp)
register const char * strp;
{
register char c;
while ((c = *strp) != '\0' && !isdigit(c) && c != ',' && c != '-' &&
c != '+')
++strp;
return strp;
}
static const char *
getnum(strp, nump, min, max)
register const char * strp;
int * const nump;
const int min;
const int max;
{
register char c;
register int num;
if (strp == NULL || !isdigit(*strp))
return NULL;
num = 0;
while ((c = *strp) != '\0' && isdigit(c)) {
num = num * 10 + (c - '0');
if (num > max)
return NULL;
++strp;
}
if (num < min)
return NULL;
*nump = num;
return strp;
}
static const char *
getsecs(strp, secsp)
register const char * strp;
long * const secsp;
{
int num;
strp = getnum(strp, &num, 0, HOURSPERDAY);
if (strp == NULL)
return NULL;
*secsp = num * 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);
if (strp == NULL)
return NULL;
*secsp += num;
}
}
return strp;
}
static const char *
getoffset(strp, offsetp)
register const char * strp;
long * const offsetp;
{
register int neg;
if (*strp == '-') {
neg = 1;
++strp;
} else if (isdigit(*strp) || *strp++ == '+')
neg = 0;
else return NULL;
strp = getsecs(strp, offsetp);
if (strp == NULL)
return NULL;
if (neg)
*offsetp = -*offsetp;
return strp;
}
static const char *
getrule(strp, rulep)
const char * strp;
register struct rule * const rulep;
{
if (*strp == 'J') {
rulep->r_type = JULIAN_DAY;
++strp;
strp = getnum(strp, &rulep->r_day, 1, DAYSPERNYEAR);
} else if (*strp == 'M') {
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 (isdigit(*strp)) {
rulep->r_type = DAY_OF_YEAR;
strp = getnum(strp, &rulep->r_day, 0, DAYSPERLYEAR - 1);
} else return NULL;
if (strp == NULL)
return NULL;
if (*strp == '/') {
++strp;
strp = getsecs(strp, &rulep->r_time);
} else rulep->r_time = 2 * SECSPERHOUR;
return strp;
}
static time_t
transtime(janfirst, year, rulep, offset)
const time_t janfirst;
const int year;
register const struct rule * const rulep;
const long offset;
{
register int leapyear;
register time_t value;
register int i;
int d, m1, yy0, yy1, yy2, dow;
leapyear = isleap(year);
switch (rulep->r_type) {
case JULIAN_DAY:
value = janfirst + (rulep->r_day - 1) * SECSPERDAY;
if (leapyear && rulep->r_day >= 60)
value += SECSPERDAY;
break;
case DAY_OF_YEAR:
value = janfirst + rulep->r_day * SECSPERDAY;
break;
case MONTH_NTH_DAY_OF_WEEK:
value = janfirst;
for (i = 0; i < rulep->r_mon - 1; ++i)
value += mon_lengths[leapyear][i] * SECSPERDAY;
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;
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;
}
value += d * SECSPERDAY;
break;
}
return value + rulep->r_time + offset;
}
static int
tzparse(name, sp, lastditch)
const char * name;
register struct state * const sp;
const int lastditch;
{
const char * stdname;
const char * dstname;
int stdlen;
int dstlen;
long stdoffset;
long dstoffset;
register time_t * atp;
register unsigned char * typep;
register char * cp;
register int load_result;
stdname = name;
if (lastditch) {
stdlen = strlen(name);
name += stdlen;
if (stdlen >= sizeof sp->chars)
stdlen = (sizeof sp->chars) - 1;
} else {
name = getzname(name);
stdlen = name - stdname;
if (stdlen < 3)
return -1;
}
if (*name == '\0')
return -1;
else {
name = getoffset(name, &stdoffset);
if (name == NULL)
return -1;
}
load_result = tzload(TZDEFRULES, sp);
if (load_result != 0)
sp->leapcnt = 0;
if (*name != '\0') {
dstname = name;
name = getzname(name);
dstlen = name - dstname;
if (dstlen < 3)
return -1;
if (*name != '\0' && *name != ',' && *name != ';') {
name = getoffset(name, &dstoffset);
if (name == NULL)
return -1;
} else dstoffset = stdoffset - SECSPERHOUR;
if (*name == ',' || *name == ';') {
struct rule start;
struct rule end;
register int year;
register time_t janfirst;
time_t starttime;
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;
sp->timecnt = 2 * (2037 - EPOCH_YEAR + 1);
if (sp->timecnt > TZ_MAX_TIMES)
return -1;
sp->ttis[0].tt_gmtoff = -dstoffset;
sp->ttis[0].tt_isdst = 1;
sp->ttis[0].tt_abbrind = stdlen + 1;
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) {
starttime = transtime(janfirst, year, &start,
stdoffset);
endtime = transtime(janfirst, year, &end,
dstoffset);
if (starttime > endtime) {
*atp++ = endtime;
*typep++ = 1;
*atp++ = starttime;
*typep++ = 0;
} else {
*atp++ = starttime;
*typep++ = 0;
*atp++ = endtime;
*typep++ = 1;
}
janfirst +=
year_lengths[isleap(year)] * SECSPERDAY;
}
} else {
int sawstd;
int sawdst;
long stdfix;
long dstfix;
long oldfix;
int isdst;
register int i;
if (*name != '\0')
return -1;
if (load_result != 0)
return -1;
sawstd = FALSE;
sawdst = FALSE;
stdfix = 0;
dstfix = 0;
for (i = 0; i < sp->typecnt; ++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;
}
}
if (!sawdst || !sawstd)
return -1;
isdst = FALSE;
for (i = 0; i < sp->timecnt; ++i) {
register const struct ttinfo * ttisp;
ttisp = &sp->ttis[sp->types[i]];
sp->ats[i] +=
(isdst && !ttisp->tt_ttisstd) ?
dstfix : stdfix;
isdst = ttisp->tt_isdst;
}
}
} else {
dstlen = 0;
sp->typecnt = 1;
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 (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(sp)
struct state * const sp;
{
if (tzload(GMT, sp) != 0)
(void) tzparse(GMT, sp, TRUE);
}
void
tzset()
{
register const char * name;
void tzsetwall();
name = getenv("TZ");
if (name == NULL) {
tzsetwall();
return;
}
lcl_is_set = TRUE;
#ifdef ALL_STATE
if (lclptr == NULL) {
lclptr = (struct state *) malloc(sizeof *lclptr);
if (lclptr == NULL) {
settzname();
return;
}
}
#endif
if (*name == '\0') {
lclptr->leapcnt = 0;
lclptr->timecnt = 0;
lclptr->ttis[0].tt_gmtoff = 0;
lclptr->ttis[0].tt_abbrind = 0;
(void) strcpy(lclptr->chars, GMT);
} else if (tzload(name, lclptr) != 0)
if (name[0] == ':' || tzparse(name, lclptr, FALSE) != 0)
(void) gmtload(lclptr);
settzname();
}
void
tzsetwall()
{
lcl_is_set = TRUE;
#ifdef ALL_STATE
if (lclptr == NULL) {
lclptr = (struct state *) malloc(sizeof *lclptr);
if (lclptr == NULL) {
settzname();
return;
}
}
#endif
if (tzload((char *) NULL, lclptr) != 0)
gmtload(lclptr);
settzname();
}
static void
localsub(timep, offset, tmp)
const time_t * const timep;
const long offset;
struct tm * const tmp;
{
register struct state * sp;
register const struct ttinfo * ttisp;
register int i;
const time_t t = *timep;
if (!lcl_is_set)
tzset();
sp = lclptr;
#ifdef ALL_STATE
if (sp == NULL) {
gmtsub(timep, offset, tmp);
return;
}
#endif
if (sp->timecnt == 0 || t < sp->ats[0]) {
i = 0;
while (sp->ttis[i].tt_isdst)
if (++i >= sp->typecnt) {
i = 0;
break;
}
} else {
for (i = 1; i < sp->timecnt; ++i)
if (t < sp->ats[i])
break;
i = sp->types[i - 1];
}
ttisp = &sp->ttis[i];
timesub(&t, ttisp->tt_gmtoff, sp, tmp);
tmp->tm_isdst = ttisp->tt_isdst;
tzname[tmp->tm_isdst] = (char *) &sp->chars[ttisp->tt_abbrind];
tmp->tm_zone = &sp->chars[ttisp->tt_abbrind];
}
struct tm *
localtime(timep)
const time_t * const timep;
{
static struct tm tm;
localsub(timep, 0L, &tm);
return &tm;
}
static void
gmtsub(timep, offset, tmp)
const time_t * const timep;
const long offset;
struct tm * const tmp;
{
if (!gmt_is_set) {
gmt_is_set = TRUE;
#ifdef ALL_STATE
gmtptr = (struct state *) malloc(sizeof *gmtptr);
if (gmtptr != NULL)
#endif
gmtload(gmtptr);
}
timesub(timep, offset, gmtptr, tmp);
if (offset != 0)
tmp->tm_zone = WILDABBR;
else {
#ifdef ALL_STATE
if (gmtptr == NULL)
tmp->TM_ZONE = GMT;
else tmp->TM_ZONE = gmtptr->chars;
#endif
#ifndef ALL_STATE
tmp->tm_zone = gmtptr->chars;
#endif
}
}
struct tm *
gmtime(timep)
const time_t * const timep;
{
static struct tm tm;
gmtsub(timep, 0L, &tm);
return &tm;
}
static void
timesub(timep, offset, sp, tmp)
const time_t * const timep;
const long offset;
register const struct state * const sp;
register struct tm * const tmp;
{
register const struct lsinfo * lp;
register long days;
register long rem;
register int y;
register int yleap;
register const int * ip;
register long corr;
register int hit;
register int i;
corr = 0;
hit = FALSE;
#ifdef ALL_STATE
i = (sp == NULL) ? 0 : sp->leapcnt;
#endif
#ifndef ALL_STATE
i = sp->leapcnt;
#endif
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);
corr = lp->ls_corr;
break;
}
}
days = *timep / SECSPERDAY;
rem = *timep % SECSPERDAY;
#ifdef mc68k
if (*timep == 0x80000000) {
days = -24855;
rem = -11648;
}
#endif
rem += (offset - corr);
while (rem < 0) {
rem += SECSPERDAY;
--days;
}
while (rem >= SECSPERDAY) {
rem -= SECSPERDAY;
++days;
}
tmp->tm_hour = (int) (rem / SECSPERHOUR);
rem = rem % SECSPERHOUR;
tmp->tm_min = (int) (rem / SECSPERMIN);
tmp->tm_sec = (int) (rem % SECSPERMIN);
if (hit)
++(tmp->tm_sec);
tmp->tm_wday = (int) ((EPOCH_WDAY + days) % DAYSPERWEEK);
if (tmp->tm_wday < 0)
tmp->tm_wday += DAYSPERWEEK;
y = EPOCH_YEAR;
if (days >= 0)
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);
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_isdst = 0;
tmp->tm_gmtoff = offset;
}
char *
asctime(timeptr)
register const struct tm * timeptr;
{
static const char wday_name[DAYSPERWEEK][3] = {
"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
};
static const char mon_name[MONSPERYEAR][3] = {
"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};
static char result[26];
(void) sprintf(result, "%.3s %.3s%3d %02.2d:%02.2d:%02.2d %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);
return result;
}
char *
ctime(timep)
const time_t * const timep;
{
return asctime(localtime(timep));
}
#ifndef WRONG
#define WRONG (-1)
#endif
static void
normalize(tensptr, unitsptr, base)
int * const tensptr;
int * const unitsptr;
const int base;
{
if (*unitsptr >= base) {
*tensptr += *unitsptr / base;
*unitsptr %= base;
} else if (*unitsptr < 0) {
*tensptr -= 1 + (-(*unitsptr + 1)) / base;
*unitsptr = base - 1 - (-(*unitsptr + 1)) % base;
}
}
static int
tmcomp(atmp, btmp)
register const struct tm * const atmp;
register const struct tm * const btmp;
{
register int result;
if ((result = (atmp->tm_year - btmp->tm_year)) == 0 &&
(result = (atmp->tm_mon - btmp->tm_mon)) == 0 &&
(result = (atmp->tm_mday - btmp->tm_mday)) == 0 &&
(result = (atmp->tm_hour - btmp->tm_hour)) == 0 &&
(result = (atmp->tm_min - btmp->tm_min)) == 0)
result = atmp->tm_sec - btmp->tm_sec;
return result;
}
static time_t
time2(tmp, funcp, offset, okayp)
struct tm * const tmp;
void (* const funcp)();
const long offset;
int * const okayp;
{
register const struct state * sp;
register int dir;
register int bits;
register int i, j ;
register int saved_seconds;
time_t newt;
time_t t;
struct tm yourtm, mytm;
*okayp = FALSE;
yourtm = *tmp;
if (yourtm.tm_sec >= SECSPERMIN + 2 || yourtm.tm_sec < 0)
normalize(&yourtm.tm_min, &yourtm.tm_sec, SECSPERMIN);
normalize(&yourtm.tm_hour, &yourtm.tm_min, MINSPERHOUR);
normalize(&yourtm.tm_mday, &yourtm.tm_hour, HOURSPERDAY);
normalize(&yourtm.tm_year, &yourtm.tm_mon, MONSPERYEAR);
while (yourtm.tm_mday <= 0) {
--yourtm.tm_year;
yourtm.tm_mday +=
year_lengths[isleap(yourtm.tm_year + TM_YEAR_BASE)];
}
while (yourtm.tm_mday > DAYSPERLYEAR) {
yourtm.tm_mday -=
year_lengths[isleap(yourtm.tm_year + TM_YEAR_BASE)];
++yourtm.tm_year;
}
for ( ; ; ) {
i = mon_lengths[isleap(yourtm.tm_year +
TM_YEAR_BASE)][yourtm.tm_mon];
if (yourtm.tm_mday <= i)
break;
yourtm.tm_mday -= i;
if (++yourtm.tm_mon >= MONSPERYEAR) {
yourtm.tm_mon = 0;
++yourtm.tm_year;
}
}
saved_seconds = yourtm.tm_sec;
yourtm.tm_sec = 0;
for (bits = 0, t = 1; t > 0; ++bits, t <<= 1)
;
t = (t < 0) ? 0 : ((time_t) 1 << bits);
for ( ; ; ) {
(*funcp)(&t, offset, &mytm);
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;
continue;
}
if (yourtm.tm_isdst < 0 || mytm.tm_isdst == yourtm.tm_isdst)
break;
sp = (const struct state *)
((funcp == localsub) ? lclptr : gmtptr);
#ifdef ALL_STATE
if (sp == NULL)
return WRONG;
#endif
for (i = 0; i < sp->typecnt; ++i) {
if (sp->ttis[i].tt_isdst != yourtm.tm_isdst)
continue;
for (j = 0; j < sp->typecnt; ++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;
t = newt;
goto label;
}
}
return WRONG;
}
label:
t += saved_seconds;
(*funcp)(&t, offset, tmp);
*okayp = TRUE;
return t;
}
static time_t
time1(tmp, funcp, offset)
struct tm * const tmp;
void (* const funcp)();
const long offset;
{
register time_t t;
register const struct state * sp;
register int samei, otheri;
int okay;
if (tmp->tm_isdst > 1)
tmp->tm_isdst = 1;
t = time2(tmp, funcp, offset, &okay);
if (okay || tmp->tm_isdst < 0)
return t;
sp = (const struct state *) ((funcp == localsub) ? lclptr : gmtptr);
#ifdef ALL_STATE
if (sp == NULL)
return WRONG;
#endif
for (samei = 0; samei < sp->typecnt; ++samei) {
if (sp->ttis[samei].tt_isdst != tmp->tm_isdst)
continue;
for (otheri = 0; otheri < sp->typecnt; ++otheri) {
if (sp->ttis[otheri].tt_isdst == tmp->tm_isdst)
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;
tmp->tm_isdst = !tmp->tm_isdst;
}
}
return WRONG;
}
time_t
mktime(tmp)
struct tm * const tmp;
{
return time1(tmp, localsub, 0L);
}