518 lines
11 KiB
C
518 lines
11 KiB
C
/*
|
|
* misc - data and miscellaneous routines
|
|
*/
|
|
/* $Id$ */
|
|
|
|
#include <ctype.h>
|
|
#include <time.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "loc_time.h"
|
|
|
|
#define RULE_LEN 120
|
|
#define TZ_LEN 10
|
|
|
|
/* Make sure that the strings do not end up in ROM.
|
|
* These strings probably contain the wrong value, and we cannot obtain the
|
|
* right value from the system. TZ is the only help.
|
|
*/
|
|
static char ntstr[TZ_LEN + 1] = "GMT"; /* string for normal time */
|
|
static char dststr[TZ_LEN + 1] = "GDT"; /* string for daylight saving */
|
|
|
|
long _timezone = 0;
|
|
long _dst_off = 60 * 60;
|
|
int _daylight = 0;
|
|
char* _tzname[2] = { ntstr, dststr };
|
|
|
|
char* tzname[2] = { ntstr, dststr };
|
|
|
|
static struct dsttype
|
|
{
|
|
char ds_type; /* Unknown, Julian, Zero-based or M */
|
|
int ds_date[3]; /* months, weeks, days */
|
|
long ds_sec; /* usually 02:00:00 */
|
|
} dststart = { 'U', { 0, 0, 0 }, 2 * 60 * 60 }, dstend = { 'U', { 0, 0, 0 }, 2 * 60 * 60 };
|
|
|
|
const char* _days[] = {
|
|
"Sunday", "Monday", "Tuesday", "Wednesday",
|
|
"Thursday", "Friday", "Saturday"
|
|
};
|
|
|
|
const char* _months[] = {
|
|
"January", "February", "March",
|
|
"April", "May", "June",
|
|
"July", "August", "September",
|
|
"October", "November", "December"
|
|
};
|
|
|
|
const int _ytab[2][12] = {
|
|
{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
|
|
{ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
|
|
};
|
|
|
|
#if !defined(_POSIX_SOURCE) && !defined(__USG)
|
|
#define USE_TABLE 1
|
|
#endif
|
|
|
|
#if USE_TABLE
|
|
static int usetable = 1;
|
|
|
|
typedef struct table
|
|
{
|
|
const char* tz_name;
|
|
const int daylight;
|
|
const long zoneoffset;
|
|
} TABLE;
|
|
|
|
#define HOUR(x) ((x)*60 * 60)
|
|
|
|
static TABLE TimezoneTable[] = {
|
|
{ "GMT", 0, HOUR(0) }, /* Greenwich Mean */
|
|
{ "BST", 60 * 60, HOUR(0) }, /* British Summer */
|
|
{ "WAT", 0, HOUR(1) }, /* West Africa */
|
|
{ "AT", 0, HOUR(2) }, /* Azores */
|
|
{ "BST", 0, HOUR(3) }, /* Brazil Standard */
|
|
{ "NFT", 0, HOUR(3.5) }, /* Newfoundland */
|
|
{ "NDT", 60 * 60, HOUR(3.5) }, /* Newfoundland Daylight */
|
|
{ "AST", 0, HOUR(4) }, /* Atlantic Standard */
|
|
{ "ADT", 60 * 60, HOUR(4) }, /* Atlantic Daylight */
|
|
{ "EST", 0, HOUR(5) }, /* Eastern Standard */
|
|
{ "EDT", 60 * 60, HOUR(5) }, /* Eastern Daylight */
|
|
{ "CST", 0, HOUR(6) }, /* Central Standard */
|
|
{ "CDT", 60 * 60, HOUR(6) }, /* Central Daylight */
|
|
{ "MST", 0, HOUR(7) }, /* Mountain Standard */
|
|
{ "MDT", 60 * 60, HOUR(7) }, /* Mountain Daylight */
|
|
{ "PST", 0, HOUR(8) }, /* Pacific Standard */
|
|
{ "PDT", 60 * 60, HOUR(8) }, /* Pacific Daylight */
|
|
{ "YST", 0, HOUR(9) }, /* Yukon Standard */
|
|
{ "YDT", 60 * 60, HOUR(9) }, /* Yukon Daylight */
|
|
{ "HST", 0, HOUR(10) }, /* Hawaii Standard */
|
|
{ "HDT", 60 * 60, HOUR(10) }, /* Hawaii Daylight */
|
|
{ "NT", 0, HOUR(11) }, /* Nome */
|
|
{ "IDLW", 0, HOUR(12) }, /* International Date Line West */
|
|
{ "MET", 0, -HOUR(1) }, /* Middle European */
|
|
{ "MDT", 60 * 60, -HOUR(1) }, /* Middle European Summer */
|
|
{ "EET", 0, -HOUR(2) }, /* Eastern Europe, USSR Zone 1 */
|
|
{ "BT", 0, -HOUR(3) }, /* Baghdad, USSR Zone 2 */
|
|
{ "IT", 0, -HOUR(3.5) }, /* Iran */
|
|
{ "ZP4", 0, -HOUR(4) }, /* USSR Zone 3 */
|
|
{ "ZP5", 0, -HOUR(5) }, /* USSR Zone 4 */
|
|
{ "IST", 0, -HOUR(5.5) }, /* Indian Standard */
|
|
{ "ZP6", 0, -HOUR(6) }, /* USSR Zone 5 */
|
|
{ "NST", 0, -HOUR(6.5) }, /* North Sumatra */
|
|
{ "SST", 0, -HOUR(7) }, /* South Sumatra, USSR Zone 6 */
|
|
{ "WAST", 0, -HOUR(7) }, /* West Australian Standard */
|
|
{ "WADT", 60 * 60, -HOUR(7) }, /* West Australian Daylight */
|
|
{ "JT", 0, -HOUR(7.5) }, /* Java (3pm in Cronusland!) */
|
|
{ "CCT", 0, -HOUR(8) }, /* China Coast, USSR Zone 7 */
|
|
{ "JST", 0, -HOUR(9) }, /* Japan Standard, USSR Zone 8 */
|
|
{ "CAST", 0, -HOUR(9.5) }, /* Central Australian Standard */
|
|
{ "CADT", 60 * 60, -HOUR(9.5) }, /* Central Australian Daylight */
|
|
{ "EAST", 0, -HOUR(10) }, /* Eastern Australian Standard */
|
|
{ "EADT", 60 * 60, -HOUR(10) }, /* Eastern Australian Daylight */
|
|
{ "NZT", 0, -HOUR(12) }, /* New Zealand */
|
|
{ "NZDT", 60 * 60, -HOUR(12) }, /* New Zealand Daylight */
|
|
{ NULL, 0, 0 }
|
|
};
|
|
|
|
/*
|
|
* The function ZoneFromTable() searches the table for the current
|
|
* timezone. It saves the last one found in ntstr or dststr, depending on
|
|
* wheter the name is for daylight-saving-time or not.
|
|
* Both ntstr and dststr are TZ_LEN + 1 chars.
|
|
*/
|
|
static void
|
|
ZoneFromTable(long timezone)
|
|
{
|
|
register TABLE* tptr = TimezoneTable;
|
|
|
|
while (tptr->tz_name != NULL)
|
|
{
|
|
if (tptr->zoneoffset == timezone)
|
|
{
|
|
if (tptr->daylight == 0)
|
|
{
|
|
strncpy(ntstr, tptr->tz_name, TZ_LEN);
|
|
ntstr[TZ_LEN] = '\0';
|
|
}
|
|
else
|
|
{
|
|
strncpy(dststr, tptr->tz_name, TZ_LEN);
|
|
dststr[TZ_LEN] = '\0';
|
|
}
|
|
}
|
|
tptr++;
|
|
}
|
|
}
|
|
#endif /* USE_TABLE */
|
|
|
|
static const char*
|
|
parseZoneName(register char* buf, register const char* p)
|
|
{
|
|
register int n = 0;
|
|
|
|
if (*p == ':')
|
|
return NULL;
|
|
while (*p && !isdigit(*p) && *p != ',' && *p != '-' && *p != '+')
|
|
{
|
|
if (n < TZ_LEN)
|
|
*buf++ = *p;
|
|
p++;
|
|
n++;
|
|
}
|
|
if (n < 3)
|
|
return NULL; /* error */
|
|
*buf = '\0';
|
|
return p;
|
|
}
|
|
|
|
static const char*
|
|
parseTime(register long* tm, const char* p, register struct dsttype* dst)
|
|
{
|
|
register int n = 0;
|
|
register const char* q = p;
|
|
char ds_type = (dst ? dst->ds_type : '\0');
|
|
|
|
if (dst)
|
|
dst->ds_type = 'U';
|
|
|
|
*tm = 0;
|
|
while (*p >= '0' && *p <= '9')
|
|
{
|
|
n = 10 * n + (*p++ - '0');
|
|
}
|
|
if (q == p)
|
|
return NULL; /* "The hour shall be required" */
|
|
if (n < 0 || n >= 24)
|
|
return NULL;
|
|
*tm = n * 60 * 60;
|
|
if (*p == ':')
|
|
{
|
|
p++;
|
|
n = 0;
|
|
while (*p >= '0' && *p <= '9')
|
|
{
|
|
n = 10 * n + (*p++ - '0');
|
|
}
|
|
if (q == p)
|
|
return NULL; /* format error */
|
|
if (n < 0 || n >= 60)
|
|
return NULL;
|
|
*tm += n * 60;
|
|
if (*p == ':')
|
|
{
|
|
p++;
|
|
n = 0;
|
|
while (*p >= '0' && *p <= '9')
|
|
{
|
|
n = 10 * n + (*p++ - '0');
|
|
}
|
|
if (q == p)
|
|
return NULL; /* format error */
|
|
if (n < 0 || n >= 60)
|
|
return NULL;
|
|
*tm += n;
|
|
}
|
|
}
|
|
if (dst)
|
|
{
|
|
dst->ds_type = ds_type;
|
|
dst->ds_sec = *tm;
|
|
}
|
|
return p;
|
|
}
|
|
|
|
static const char*
|
|
parseDate(register char* buf, register const char* p, struct dsttype* dstinfo)
|
|
{
|
|
register const char* q;
|
|
register int n = 0;
|
|
int cnt = 0;
|
|
const int bnds[3][2] = { { 1, 12 },
|
|
{ 1, 5 },
|
|
{ 0, 6 } };
|
|
char ds_type;
|
|
|
|
if (*p != 'M')
|
|
{
|
|
if (*p == 'J')
|
|
{
|
|
*buf++ = *p++;
|
|
ds_type = 'J';
|
|
}
|
|
else
|
|
ds_type = 'Z';
|
|
q = p;
|
|
while (*p >= '0' && *p <= '9')
|
|
{
|
|
n = 10 * n + (*p - '0');
|
|
*buf++ = *p++;
|
|
}
|
|
if (q == p)
|
|
return NULL; /* format error */
|
|
if (n < (ds_type == 'J') || n > 365)
|
|
return NULL;
|
|
dstinfo->ds_type = ds_type;
|
|
dstinfo->ds_date[0] = n;
|
|
return p;
|
|
}
|
|
ds_type = 'M';
|
|
do
|
|
{
|
|
*buf++ = *p++;
|
|
q = p;
|
|
n = 0;
|
|
while (*p >= '0' && *p <= '9')
|
|
{
|
|
n = 10 * n + (*p - '0');
|
|
*buf++ = *p++;
|
|
}
|
|
if (q == p)
|
|
return NULL; /* format error */
|
|
if (n < bnds[cnt][0] || n > bnds[cnt][1])
|
|
return NULL;
|
|
dstinfo->ds_date[cnt] = n;
|
|
cnt++;
|
|
} while (cnt < 3 && *p == '.');
|
|
if (cnt != 3)
|
|
return NULL;
|
|
*buf = '\0';
|
|
dstinfo->ds_type = ds_type;
|
|
return p;
|
|
}
|
|
|
|
static const char*
|
|
parseRule(register char* buf, register const char* p)
|
|
{
|
|
long tim;
|
|
register const char* q;
|
|
|
|
if (!(p = parseDate(buf, p, &dststart)))
|
|
return NULL;
|
|
buf += strlen(buf);
|
|
if (*p == '/')
|
|
{
|
|
q = ++p;
|
|
if (!(p = parseTime(&tim, p, &dststart)))
|
|
return NULL;
|
|
while (p != q)
|
|
*buf++ = *q++;
|
|
}
|
|
if (*p != ',')
|
|
return NULL;
|
|
p++;
|
|
if (!(p = parseDate(buf, p, &dstend)))
|
|
return NULL;
|
|
buf += strlen(buf);
|
|
if (*p == '/')
|
|
{
|
|
q = ++p;
|
|
if (!(p = parseTime(&tim, p, &dstend)))
|
|
return NULL;
|
|
while (*buf++ = *q++)
|
|
;
|
|
}
|
|
if (*p)
|
|
return NULL;
|
|
return p;
|
|
}
|
|
|
|
/* The following routine parses timezone information in POSIX-format. For
|
|
* the requirements, see IEEE Std 1003.1-1988 section 8.1.1.
|
|
* The function returns as soon as it spots an error.
|
|
*/
|
|
static void
|
|
parseTZ(const char* p)
|
|
{
|
|
long tz, dst = 60 * 60, sign = 1;
|
|
static char lastTZ[2 * RULE_LEN];
|
|
static char buffer[RULE_LEN];
|
|
|
|
if (!p)
|
|
return;
|
|
|
|
#if USE_TABLE
|
|
usetable = 0;
|
|
#endif
|
|
if (*p == ':')
|
|
{
|
|
/*
|
|
* According to POSIX, this is implementation defined.
|
|
* Since it depends on the particular operating system, we
|
|
* can do nothing.
|
|
*/
|
|
return;
|
|
}
|
|
|
|
if (!strcmp(lastTZ, p))
|
|
return; /* nothing changed */
|
|
|
|
*_tzname[0] = '\0';
|
|
*_tzname[1] = '\0';
|
|
dststart.ds_type = 'U';
|
|
dststart.ds_sec = 2 * 60 * 60;
|
|
dstend.ds_type = 'U';
|
|
dstend.ds_sec = 2 * 60 * 60;
|
|
|
|
if (strlen(p) > 2 * RULE_LEN)
|
|
return;
|
|
strcpy(lastTZ, p);
|
|
|
|
if (!(p = parseZoneName(buffer, p)))
|
|
return;
|
|
|
|
if (*p == '-')
|
|
{
|
|
sign = -1;
|
|
p++;
|
|
}
|
|
else if (*p == '+')
|
|
p++;
|
|
|
|
if (!(p = parseTime(&tz, p, NULL)))
|
|
return;
|
|
tz *= sign;
|
|
_timezone = tz;
|
|
strncpy(_tzname[0], buffer, TZ_LEN);
|
|
|
|
if (!(_daylight = (*p != '\0')))
|
|
return;
|
|
|
|
buffer[0] = '\0';
|
|
if (!(p = parseZoneName(buffer, p)))
|
|
return;
|
|
strncpy(_tzname[1], buffer, TZ_LEN);
|
|
|
|
buffer[0] = '\0';
|
|
if (*p && (*p != ','))
|
|
if (!(p = parseTime(&dst, p, NULL)))
|
|
return;
|
|
_dst_off = dst; /* dst was initialized to 1 hour */
|
|
if (*p)
|
|
{
|
|
if (*p != ',')
|
|
return;
|
|
p++;
|
|
if (strlen(p) > RULE_LEN)
|
|
return;
|
|
if (!(p = parseRule(buffer, p)))
|
|
return;
|
|
}
|
|
}
|
|
|
|
void _tzset(void)
|
|
{
|
|
parseTZ(getenv("TZ")); /* should go inside #if */
|
|
|
|
tzname[0] = _tzname[0];
|
|
tzname[1] = _tzname[1];
|
|
}
|
|
|
|
static int
|
|
last_sunday(register int day, register struct tm* timep)
|
|
{
|
|
int first = FIRSTSUNDAY(timep);
|
|
|
|
if (day >= 58 && LEAPYEAR(YEAR0 + timep->tm_year))
|
|
day++;
|
|
if (day < first)
|
|
return first;
|
|
return day - (day - first) % 7;
|
|
}
|
|
|
|
static int
|
|
date_of(register struct dsttype* dst, struct tm* timep)
|
|
{
|
|
int leap = LEAPYEAR(YEAR0 + timep->tm_year);
|
|
int firstday, tmpday;
|
|
register int day, month;
|
|
|
|
if (dst->ds_type != 'M')
|
|
{
|
|
return dst->ds_date[0] - (dst->ds_type == 'J'
|
|
&& leap
|
|
&& dst->ds_date[0] < 58);
|
|
}
|
|
day = 0;
|
|
month = 1;
|
|
while (month < dst->ds_date[0])
|
|
{
|
|
day += _ytab[leap][month - 1];
|
|
month++;
|
|
}
|
|
firstday = (day + FIRSTDAYOF(timep)) % 7;
|
|
tmpday = day;
|
|
day += (dst->ds_date[2] - firstday + 7) % 7
|
|
+ 7 * (dst->ds_date[1] - 1);
|
|
if (day >= tmpday + _ytab[leap][month])
|
|
day -= 7;
|
|
return day;
|
|
}
|
|
|
|
/*
|
|
* The default dst transitions are those for Western Europe (except Great
|
|
* Britain).
|
|
*/
|
|
unsigned
|
|
_dstget(register struct tm* timep)
|
|
{
|
|
int begindst, enddst;
|
|
register struct dsttype *dsts = &dststart, *dste = &dstend;
|
|
int do_dst = 0;
|
|
|
|
if (_daylight == -1)
|
|
_tzset();
|
|
|
|
timep->tm_isdst = _daylight;
|
|
if (!_daylight)
|
|
return 0;
|
|
|
|
if (dsts->ds_type != 'U')
|
|
begindst = date_of(dsts, timep);
|
|
else
|
|
begindst = last_sunday(89, timep); /* last Sun before Apr */
|
|
if (dste->ds_type != 'U')
|
|
enddst = date_of(dste, timep);
|
|
else
|
|
enddst = last_sunday(272, timep); /* last Sun in Sep */
|
|
|
|
/* assume begindst != enddst (otherwise it would be no use) */
|
|
if (begindst < enddst)
|
|
{ /* northern hemisphere */
|
|
if (timep->tm_yday > begindst && timep->tm_yday < enddst)
|
|
do_dst = 1;
|
|
}
|
|
else
|
|
{ /* southern hemisphere */
|
|
if (timep->tm_yday > begindst || timep->tm_yday < enddst)
|
|
do_dst = 1;
|
|
}
|
|
|
|
if (!do_dst
|
|
&& (timep->tm_yday == begindst || timep->tm_yday == enddst))
|
|
{
|
|
long dsttranssec; /* transition when day is this old */
|
|
long cursec;
|
|
|
|
if (timep->tm_yday == begindst)
|
|
dsttranssec = dsts->ds_sec;
|
|
else
|
|
dsttranssec = dste->ds_sec;
|
|
cursec = ((timep->tm_hour * 60) + timep->tm_min) * 60L
|
|
+ timep->tm_sec;
|
|
|
|
if ((timep->tm_yday == begindst && cursec >= dsttranssec)
|
|
|| (timep->tm_yday == enddst && cursec < dsttranssec))
|
|
do_dst = 1;
|
|
}
|
|
#if USE_TABLE
|
|
if (usetable)
|
|
ZoneFromTable(_timezone);
|
|
#endif
|
|
if (do_dst)
|
|
return _dst_off;
|
|
timep->tm_isdst = 0;
|
|
return 0;
|
|
}
|