generic-library/bionic
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

am 4ab29a3e: Merge "Update tzcode to 2013i"

Browse Source 
* commit '4ab29a3e4a797cff05a3a1a6fea3db5a800ac5ba':
  Update tzcode to 2013i
This commit is contained in:
Calin Juravle 2014-03-11 18:17:09 +00:00 committed by Android Git Automerger
commit 9a539ec998
3 changed files with 98 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

189
libc/tzcode/localtime.c
View File

@ -147,7 +147,7 @@ struct rule {
static int __bionic_open_tzdata(const char*, int*); static int __bionic_open_tzdata(const char*, int*);
static int_fast32_t detzcode(const char * codep); static int_fast32_t detzcode(const char * codep);
static time_t detzcode64(const char * codep); static int_fast64_t detzcode64(const char * codep);
static int differ_by_repeat(time_t t1, time_t t0); static int differ_by_repeat(time_t t1, time_t t0);
static const char * getzname(const char * strp) ATTRIBUTE_PURE; static const char * getzname(const char * strp) ATTRIBUTE_PURE;
static const char * getqzname(const char * strp, const int delim) static const char * getqzname(const char * strp, const int delim)
@ -165,6 +165,7 @@ static struct tm * localsub(const time_t * timep, int_fast32_t offset,
static int increment_overflow(int * number, int delta); static int increment_overflow(int * number, int delta);
static int leaps_thru_end_of(int y) ATTRIBUTE_PURE; static int leaps_thru_end_of(int y) ATTRIBUTE_PURE;
static int increment_overflow32(int_fast32_t * number, int delta); static int increment_overflow32(int_fast32_t * number, int delta);
static int increment_overflow_time(time_t *t, int_fast32_t delta);
static int normalize_overflow32(int_fast32_t * tensptr, static int normalize_overflow32(int_fast32_t * tensptr,
int * unitsptr, int base); int * unitsptr, int base);
static int normalize_overflow(int * tensptr, int * unitsptr, static int normalize_overflow(int * tensptr, int * unitsptr,
@ -186,8 +187,8 @@ static struct tm * timesub(const time_t * timep, int_fast32_t offset,
const struct state * sp, struct tm * tmp); const struct state * sp, struct tm * tmp);
static int tmcomp(const struct tm * atmp, static int tmcomp(const struct tm * atmp,
const struct tm * btmp); const struct tm * btmp);
static time_t transtime(time_t janfirst, int year, static int_fast32_t transtime(int year, const struct rule * rulep,
const struct rule * rulep, int_fast32_t offset) int_fast32_t offset)
ATTRIBUTE_PURE; ATTRIBUTE_PURE;
static int typesequiv(const struct state * sp, int a, int b); static int typesequiv(const struct state * sp, int a, int b);
static int tzload(const char * name, struct state * sp, static int tzload(const char * name, struct state * sp,
@ -251,15 +252,15 @@ detzcode(const char *const codep)
return result; return result;
} }
static time_t static int_fast64_t
detzcode64(const char *const codep) detzcode64(const char *const codep)
{ {
register time_t result; register int_fast64_t result;
register int i; register int i;
result = (codep[0] & 0x80) ? (~(int_fast64_t) 0) : 0; result = (codep[0] & 0x80) ? -1 : 0;
for (i = 0; i < 8; ++i) for (i = 0; i < 8; ++i)
result = result * 256 + (codep[i] & 0xff); result = (result << 8) | (codep[i] & 0xff);
return result; return result;
} }
@ -379,6 +380,7 @@ tzload(register const char* name, register struct state* const sp,
for (stored = 4; stored <= 8; stored *= 2) { for (stored = 4; stored <= 8; stored *= 2) {
int ttisstdcnt; int ttisstdcnt;
int ttisgmtcnt; int ttisgmtcnt;
int timecnt;
ttisstdcnt = (int) detzcode(up->tzhead.tzh_ttisstdcnt); ttisstdcnt = (int) detzcode(up->tzhead.tzh_ttisstdcnt);
ttisgmtcnt = (int) detzcode(up->tzhead.tzh_ttisgmtcnt); ttisgmtcnt = (int) detzcode(up->tzhead.tzh_ttisgmtcnt);
@ -403,16 +405,37 @@ tzload(register const char* name, register struct state* const sp,
ttisstdcnt + /* ttisstds */ ttisstdcnt + /* ttisstds */
ttisgmtcnt) /* ttisgmts */ ttisgmtcnt) /* ttisgmts */
goto oops; goto oops;
timecnt = 0;
for (i = 0; i < sp->timecnt; ++i) { for (i = 0; i < sp->timecnt; ++i) {
sp->ats[i] = (stored == 4) ? int_fast64_t at
detzcode(p) : detzcode64(p); = stored == 4 ? detzcode(p) : detzcode64(p);
sp->types[i] = ((TYPE_SIGNED(time_t)
? time_t_min <= at
: 0 <= at)
&& at <= time_t_max);
if (sp->types[i]) {
if (i && !timecnt && at != time_t_min) {
/*
** Keep the earlier record, but tweak
** it so that it starts with the
** minimum time_t value.
*/
sp->types[i - 1] = 1;
sp->ats[timecnt++] = time_t_min;
}
sp->ats[timecnt++] = at;
}
p += stored; p += stored;
} }
timecnt = 0;
for (i = 0; i < sp->timecnt; ++i) { for (i = 0; i < sp->timecnt; ++i) {
sp->types[i] = (unsigned char) *p++; unsigned char typ = *p++;
if (sp->types[i] >= sp->typecnt) if (sp->typecnt <= typ)
goto oops; goto oops;
if (sp->types[i])
sp->types[timecnt++] = typ;
} }
sp->timecnt = timecnt;
for (i = 0; i < sp->typecnt; ++i) { for (i = 0; i < sp->typecnt; ++i) {
register struct ttinfo * ttisp; register struct ttinfo * ttisp;
@ -467,44 +490,6 @@ tzload(register const char* name, register struct state* const sp,
} }
} }
/* /*
** 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] >
((stored == 4) ? INT32_MAX : INT64_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;
}
/*
** If this is an old file, we're done. ** If this is an old file, we're done.
*/ */
if (up->tzhead.tzh_version[0] == '\0') if (up->tzhead.tzh_version[0] == '\0')
@ -513,9 +498,9 @@ tzload(register const char* name, register struct state* const sp,
for (i = 0; i < nread; ++i) for (i = 0; i < nread; ++i)
up->buf[i] = p[i]; up->buf[i] = p[i];
/* /*
** If this is a narrow time_t system, we're done. ** If this is a signed narrow time_t system, we're done.
*/ */
if (stored >= (int) sizeof(time_t)) if (TYPE_SIGNED(time_t) && stored >= (int) sizeof(time_t))
break; break;
} }
if (doextend && nread > 2 && if (doextend && nread > 2 &&
@ -829,17 +814,16 @@ getrule(const char * strp, register struct rule * const rulep)
} }
/* /*
** Given the Epoch-relative time of January 1, 00:00:00 UTC, in a year, the ** Given a year, a rule, and the offset from UT at the time that rule takes
** year, a rule, and the offset from UT at the time that rule takes effect, ** effect, calculate the year-relative time that rule takes effect.
** calculate the Epoch-relative time that rule takes effect.
*/ */
static time_t static int_fast32_t
transtime(const time_t janfirst, const int year, transtime(const int year, register const struct rule *const rulep,
register const struct rule *const rulep, const int_fast32_t offset) const int_fast32_t offset)
{ {
register int leapyear; register int leapyear;
register time_t value; register int_fast32_t value;
register int i; register int i;
int d, m1, yy0, yy1, yy2, dow; int d, m1, yy0, yy1, yy2, dow;
@ -855,7 +839,7 @@ transtime(const time_t janfirst, const int year,
** add SECSPERDAY times the day number-1 to the time of ** add SECSPERDAY times the day number-1 to the time of
** January 1, midnight, to get the day. ** January 1, midnight, to get the day.
*/ */
value = janfirst + (rulep->r_day - 1) * SECSPERDAY; value = (rulep->r_day - 1) * SECSPERDAY;
if (leapyear && rulep->r_day >= 60) if (leapyear && rulep->r_day >= 60)
value += SECSPERDAY; value += SECSPERDAY;
break; break;
@ -866,16 +850,13 @@ transtime(const time_t janfirst, const int year,
** Just add SECSPERDAY times the day number to the time of ** Just add SECSPERDAY times the day number to the time of
** January 1, midnight, to get the day. ** January 1, midnight, to get the day.
*/ */
value = janfirst + rulep->r_day * SECSPERDAY; value = rulep->r_day * SECSPERDAY;
break; break;
case MONTH_NTH_DAY_OF_WEEK: case MONTH_NTH_DAY_OF_WEEK:
/* /*
** Mm.n.d - nth "dth day" of month m. ** 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 ** Use Zeller's Congruence to get day-of-week of first day of
@ -908,13 +889,15 @@ transtime(const time_t janfirst, const int year,
/* /*
** "d" is the day-of-month (zero-origin) of the day we want. ** "d" is the day-of-month (zero-origin) of the day we want.
*/ */
value += d * SECSPERDAY; value = d * SECSPERDAY;
for (i = 0; i < rulep->r_mon - 1; ++i)
value += mon_lengths[leapyear][i] * SECSPERDAY;
break; break;
} }
/* /*
** "value" is the Epoch-relative time of 00:00:00 UT on the day in ** "value" is the year-relative time of 00:00:00 UT on the day in
** question. To get the Epoch-relative time of the specified local ** question. To get the year-relative time of the specified local
** time on that day, add the transition time and the current offset ** time on that day, add the transition time and the current offset
** from UT. ** from UT.
*/ */
@ -936,8 +919,6 @@ tzparse(const char * name, register struct state * const sp,
size_t dstlen; size_t dstlen;
int_fast32_t stdoffset; int_fast32_t stdoffset;
int_fast32_t dstoffset; int_fast32_t dstoffset;
register time_t * atp;
register unsigned char * typep;
register char * cp; register char * cp;
register int load_result; register int load_result;
static struct ttinfo zttinfo; static struct ttinfo zttinfo;
@ -997,9 +978,8 @@ tzparse(const char * name, register struct state * const sp,
struct rule end; struct rule end;
register int year; register int year;
register int yearlim; register int yearlim;
register time_t janfirst; register int timecnt;
time_t starttime; time_t janfirst;
time_t endtime;
++name; ++name;
if ((name = getrule(name, &start)) == NULL) if ((name = getrule(name, &start)) == NULL)
@ -1021,45 +1001,46 @@ tzparse(const char * name, register struct state * const sp,
sp->ttis[1].tt_gmtoff = -stdoffset; sp->ttis[1].tt_gmtoff = -stdoffset;
sp->ttis[1].tt_isdst = 0; sp->ttis[1].tt_isdst = 0;
sp->ttis[1].tt_abbrind = 0; sp->ttis[1].tt_abbrind = 0;
atp = sp->ats; timecnt = 0;
typep = sp->types;
janfirst = 0; janfirst = 0;
yearlim = EPOCH_YEAR + YEARSPERREPEAT; yearlim = EPOCH_YEAR + YEARSPERREPEAT;
for (year = EPOCH_YEAR; year < yearlim; year++) { for (year = EPOCH_YEAR; year < yearlim; year++) {
int_fast32_t yearsecs; int_fast32_t
starttime = transtime(year, &start, stdoffset),
starttime = transtime(janfirst, year, &start, endtime = transtime(year, &end, dstoffset);
stdoffset); int_fast32_t
endtime = transtime(janfirst, year, &end,
dstoffset);
yearsecs = (year_lengths[isleap(year)] yearsecs = (year_lengths[isleap(year)]
* SECSPERDAY); * SECSPERDAY);
if (starttime > endtime int reversed = endtime < starttime;
if (reversed) {
int_fast32_t swap = starttime;
starttime = endtime;
endtime = swap;
}
if (reversed
|| (starttime < endtime || (starttime < endtime
&& (endtime - starttime && (endtime - starttime
< (yearsecs < (yearsecs
+ (stdoffset - dstoffset))))) { + (stdoffset - dstoffset))))) {
if (&sp->ats[TZ_MAX_TIMES - 2] < atp) if (TZ_MAX_TIMES - 2 < timecnt)
break; break;
yearlim = year + YEARSPERREPEAT + 1; yearlim = year + YEARSPERREPEAT + 1;
if (starttime > endtime) { sp->ats[timecnt] = janfirst;
*atp++ = endtime; if (increment_overflow_time
*typep++ = 1; /* DST ends */ (&sp->ats[timecnt], starttime))
*atp++ = starttime; break;
*typep++ = 0; /* DST begins */ sp->types[timecnt++] = reversed;
} else { sp->ats[timecnt] = janfirst;
*atp++ = starttime; if (increment_overflow_time
*typep++ = 0; /* DST begins */ (&sp->ats[timecnt], endtime))
*atp++ = endtime; break;
*typep++ = 1; /* DST ends */ sp->types[timecnt++] = !reversed;
} }
} if (increment_overflow_time(&janfirst, yearsecs))
if (time_t_max - janfirst < yearsecs)
break; break;
janfirst += yearsecs;
} }
sp->timecnt = atp - sp->ats; sp->timecnt = timecnt;
if (!sp->timecnt) if (!timecnt)
sp->typecnt = 1; /* Perpetual DST. */ sp->typecnt = 1; /* Perpetual DST. */
} else { } else {
register int_fast32_t theirstdoffset; register int_fast32_t theirstdoffset;
@ -1655,6 +1636,22 @@ increment_overflow32(int_fast32_t *const lp, int const m)
return FALSE; return FALSE;
} }
static int
increment_overflow_time(time_t *tp, int_fast32_t j)
{
/*
** This is like
** 'if (! (time_t_min <= *tp + j && *tp + j <= time_t_max)) ...',
** except that it does the right thing even if *tp + j would overflow.
*/
if (! (j < 0
? (TYPE_SIGNED(time_t) ? time_t_min - j <= *tp : -1 - j < *tp)
: *tp <= time_t_max - j))
return TRUE;
*tp += j;
return FALSE;
}
static int static int
normalize_overflow(int *const tensptr, int *const unitsptr, const int base) normalize_overflow(int *const tensptr, int *const unitsptr, const int base)
{ {

4
libc/tzcode/private.h
View File

@ -34,6 +34,10 @@
#define HAVE_INCOMPATIBLE_CTIME_R 0 #define HAVE_INCOMPATIBLE_CTIME_R 0
#endif /* !defined INCOMPATIBLE_CTIME_R */ #endif /* !defined INCOMPATIBLE_CTIME_R */
#ifndef HAVE_LINK
#define HAVE_LINK 1
#endif /* !defined HAVE_LINK */
#ifndef HAVE_SETTIMEOFDAY #ifndef HAVE_SETTIMEOFDAY
#define HAVE_SETTIMEOFDAY 3 #define HAVE_SETTIMEOFDAY 3
#endif /* !defined HAVE_SETTIMEOFDAY */ #endif /* !defined HAVE_SETTIMEOFDAY */

10
libc/tzcode/tzfile.h
View File

@ -101,16 +101,8 @@ struct tzhead {
#endif /* !defined TZ_MAX_TIMES */ #endif /* !defined TZ_MAX_TIMES */
#ifndef TZ_MAX_TYPES #ifndef TZ_MAX_TYPES
#ifndef NOSOLAR /* This must be at least 17 for Europe/Samara and Europe/Vilnius. */
#define TZ_MAX_TYPES 256 /* Limited by what (unsigned char)'s can hold */ #define TZ_MAX_TYPES 256 /* Limited by what (unsigned char)'s can hold */
#endif /* !defined NOSOLAR */
#ifdef NOSOLAR
/*
** Must be at least 14 for Europe/Riga as of Jan 12 1995,
** as noted by Earl Chew.
*/
#define TZ_MAX_TYPES 20 /* Maximum number of local time types */
#endif /* !defined NOSOLAR */
#endif /* !defined TZ_MAX_TYPES */ #endif /* !defined TZ_MAX_TYPES */
#ifndef TZ_MAX_CHARS #ifndef TZ_MAX_CHARS