libroot: Replace the old localtime fallback backend with musl code.
This allows for the deletion of quite a lot of ugly C89 code.
This commit is contained in:
Augustin Cavalier
parent
16c85099f9
commit
a8e2f08853
@ -10,6 +10,10 @@ for architectureObject in [ MultiArchSubDirSetup ] {
|
||||
local architecture = $(TARGET_PACKAGING_ARCH) ;
|
||||
|
||||
MergeObject <$(architecture)>posix_musl_time.o :
|
||||
__month_to_secs.c
|
||||
__secs_to_tm.c
|
||||
__tm_to_secs.c
|
||||
__year_to_secs.c
|
||||
asctime.c
|
||||
asctime_r.c
|
||||
difftime.c
|
||||
|
||||
10
src/system/libroot/posix/musl/time/__month_to_secs.c
Normal file
10
src/system/libroot/posix/musl/time/__month_to_secs.c
Normal file
@ -0,0 +1,10 @@
|
||||
int __month_to_secs(int month, int is_leap)
|
||||
{
|
||||
static const int secs_through_month[] = {
|
||||
0, 31*86400, 59*86400, 90*86400,
|
||||
120*86400, 151*86400, 181*86400, 212*86400,
|
||||
243*86400, 273*86400, 304*86400, 334*86400 };
|
||||
int t = secs_through_month[month];
|
||||
if (is_leap && month >= 2) t+=86400;
|
||||
return t;
|
||||
}
|
||||
82
src/system/libroot/posix/musl/time/__secs_to_tm.c
Normal file
82
src/system/libroot/posix/musl/time/__secs_to_tm.c
Normal file
@ -0,0 +1,82 @@
|
||||
#include "time_impl.h"
|
||||
#include <limits.h>
|
||||
|
||||
/* 2000-03-01 (mod 400 year, immediately after feb29 */
|
||||
#define LEAPOCH (946684800LL + 86400*(31+29))
|
||||
|
||||
#define DAYS_PER_400Y (365*400 + 97)
|
||||
#define DAYS_PER_100Y (365*100 + 24)
|
||||
#define DAYS_PER_4Y (365*4 + 1)
|
||||
|
||||
int __secs_to_tm(long long t, struct tm *tm)
|
||||
{
|
||||
long long days, secs, years;
|
||||
int remdays, remsecs, remyears;
|
||||
int qc_cycles, c_cycles, q_cycles;
|
||||
int months;
|
||||
int wday, yday, leap;
|
||||
static const char days_in_month[] = {31,30,31,30,31,31,30,31,30,31,31,29};
|
||||
|
||||
/* Reject time_t values whose year would overflow int */
|
||||
if (t < INT_MIN * 31622400LL || t > INT_MAX * 31622400LL)
|
||||
return -1;
|
||||
|
||||
secs = t - LEAPOCH;
|
||||
days = secs / 86400;
|
||||
remsecs = secs % 86400;
|
||||
if (remsecs < 0) {
|
||||
remsecs += 86400;
|
||||
days--;
|
||||
}
|
||||
|
||||
wday = (3+days)%7;
|
||||
if (wday < 0) wday += 7;
|
||||
|
||||
qc_cycles = days / DAYS_PER_400Y;
|
||||
remdays = days % DAYS_PER_400Y;
|
||||
if (remdays < 0) {
|
||||
remdays += DAYS_PER_400Y;
|
||||
qc_cycles--;
|
||||
}
|
||||
|
||||
c_cycles = remdays / DAYS_PER_100Y;
|
||||
if (c_cycles == 4) c_cycles--;
|
||||
remdays -= c_cycles * DAYS_PER_100Y;
|
||||
|
||||
q_cycles = remdays / DAYS_PER_4Y;
|
||||
if (q_cycles == 25) q_cycles--;
|
||||
remdays -= q_cycles * DAYS_PER_4Y;
|
||||
|
||||
remyears = remdays / 365;
|
||||
if (remyears == 4) remyears--;
|
||||
remdays -= remyears * 365;
|
||||
|
||||
leap = !remyears && (q_cycles || !c_cycles);
|
||||
yday = remdays + 31 + 28 + leap;
|
||||
if (yday >= 365+leap) yday -= 365+leap;
|
||||
|
||||
years = remyears + 4*q_cycles + 100*c_cycles + 400LL*qc_cycles;
|
||||
|
||||
for (months=0; days_in_month[months] <= remdays; months++)
|
||||
remdays -= days_in_month[months];
|
||||
|
||||
if (months >= 10) {
|
||||
months -= 12;
|
||||
years++;
|
||||
}
|
||||
|
||||
if (years+100 > INT_MAX || years+100 < INT_MIN)
|
||||
return -1;
|
||||
|
||||
tm->tm_year = years + 100;
|
||||
tm->tm_mon = months + 2;
|
||||
tm->tm_mday = remdays + 1;
|
||||
tm->tm_wday = wday;
|
||||
tm->tm_yday = yday;
|
||||
|
||||
tm->tm_hour = remsecs / 3600;
|
||||
tm->tm_min = remsecs / 60 % 60;
|
||||
tm->tm_sec = remsecs % 60;
|
||||
|
||||
return 0;
|
||||
}
|
||||
24
src/system/libroot/posix/musl/time/__tm_to_secs.c
Normal file
24
src/system/libroot/posix/musl/time/__tm_to_secs.c
Normal file
@ -0,0 +1,24 @@
|
||||
#include "time_impl.h"
|
||||
|
||||
long long __tm_to_secs(const struct tm *tm)
|
||||
{
|
||||
int is_leap;
|
||||
long long year = tm->tm_year;
|
||||
int month = tm->tm_mon;
|
||||
if (month >= 12 || month < 0) {
|
||||
int adj = month / 12;
|
||||
month %= 12;
|
||||
if (month < 0) {
|
||||
adj--;
|
||||
month += 12;
|
||||
}
|
||||
year += adj;
|
||||
}
|
||||
long long t = __year_to_secs(year, &is_leap);
|
||||
t += __month_to_secs(month, is_leap);
|
||||
t += 86400LL * (tm->tm_mday-1);
|
||||
t += 3600LL * tm->tm_hour;
|
||||
t += 60LL * tm->tm_min;
|
||||
t += tm->tm_sec;
|
||||
return t;
|
||||
}
|
||||
47
src/system/libroot/posix/musl/time/__year_to_secs.c
Normal file
47
src/system/libroot/posix/musl/time/__year_to_secs.c
Normal file
@ -0,0 +1,47 @@
|
||||
long long __year_to_secs(long long year, int *is_leap)
|
||||
{
|
||||
if (year-2ULL <= 136) {
|
||||
int y = year;
|
||||
int leaps = (y-68)>>2;
|
||||
if (!((y-68)&3)) {
|
||||
leaps--;
|
||||
if (is_leap) *is_leap = 1;
|
||||
} else if (is_leap) *is_leap = 0;
|
||||
return 31536000*(y-70) + 86400*leaps;
|
||||
}
|
||||
|
||||
int cycles, centuries, leaps, rem;
|
||||
|
||||
if (!is_leap) is_leap = &(int){0};
|
||||
cycles = (year-100) / 400;
|
||||
rem = (year-100) % 400;
|
||||
if (rem < 0) {
|
||||
cycles--;
|
||||
rem += 400;
|
||||
}
|
||||
if (!rem) {
|
||||
*is_leap = 1;
|
||||
centuries = 0;
|
||||
leaps = 0;
|
||||
} else {
|
||||
if (rem >= 200) {
|
||||
if (rem >= 300) centuries = 3, rem -= 300;
|
||||
else centuries = 2, rem -= 200;
|
||||
} else {
|
||||
if (rem >= 100) centuries = 1, rem -= 100;
|
||||
else centuries = 0;
|
||||
}
|
||||
if (!rem) {
|
||||
*is_leap = 0;
|
||||
leaps = 0;
|
||||
} else {
|
||||
leaps = rem / 4U;
|
||||
rem %= 4U;
|
||||
*is_leap = !rem;
|
||||
}
|
||||
}
|
||||
|
||||
leaps += 97*cycles + 24*centuries - *is_leap;
|
||||
|
||||
return (year-100) * 31536000LL + leaps * 86400LL + 946684800 + 86400;
|
||||
}
|
||||
@ -5,6 +5,10 @@
|
||||
#define restrict
|
||||
#endif
|
||||
|
||||
hidden int __month_to_secs(int, int);
|
||||
hidden long long __year_to_secs(long long, int *);
|
||||
hidden long long __tm_to_secs(const struct tm *);
|
||||
hidden int __secs_to_tm(long long, struct tm *);
|
||||
hidden size_t __strftime_l(char *restrict s, size_t n, const char *restrict f, const struct tm *restrict tm, locale_t loc);
|
||||
hidden const char *__strftime_fmt_1(char (*)[100], size_t *, int, const struct tm *, locale_t, int);
|
||||
|
||||
|
||||
@ -1,12 +1,3 @@
|
||||
time_t timegm(struct tm *tm);
|
||||
|
||||
static inline time_t
|
||||
__tm_to_secs(const struct tm *tm)
|
||||
{
|
||||
struct tm tmp = *tm;
|
||||
return timegm(&tmp);
|
||||
}
|
||||
|
||||
static inline const char*
|
||||
__tm_to_tzname(const struct tm *tm)
|
||||
{
|
||||
|
||||
@ -1,15 +1,12 @@
|
||||
SubDir HAIKU_TOP src system libroot posix time ;
|
||||
|
||||
# for localtime.c strftime.c
|
||||
SubDirCcFlags -DNOID -DUSG_COMPAT -DTM_GMTOFF=tm_gmtoff -DTM_ZONE=tm_zone
|
||||
-DPCTS=1 -DSTD_INSPIRED ;
|
||||
|
||||
UsePrivateHeaders
|
||||
libroot
|
||||
[ FDirName libroot locale ]
|
||||
[ FDirName libroot time ]
|
||||
shared
|
||||
;
|
||||
SubDirSysHdrs [ FDirName $(SUBDIR) .. musl include ] ;
|
||||
|
||||
local architectureObject ;
|
||||
for architectureObject in [ MultiArchSubDirSetup ] {
|
||||
@ -22,8 +19,8 @@ for architectureObject in [ MultiArchSubDirSetup ] {
|
||||
clock.cpp
|
||||
clock_support.cpp
|
||||
ctime.c
|
||||
localtime_fading_out.c
|
||||
localtime.cpp
|
||||
localtime_fallback.c
|
||||
nanosleep.c
|
||||
stime.c
|
||||
time.c
|
||||
@ -32,67 +29,3 @@ for architectureObject in [ MultiArchSubDirSetup ] {
|
||||
;
|
||||
}
|
||||
}
|
||||
|
||||
# Explanations of flags:
|
||||
#
|
||||
# If you want to use System V compatibility code, add
|
||||
# -DUSG_COMPAT
|
||||
# to the end of the "CFLAGS=" line. This arrange for "timezone" and "daylight"
|
||||
# variables to be kept up-to-date by the time conversion functions. Neither
|
||||
# "timezone" nor "daylight" is described in X3J11's work.
|
||||
#
|
||||
# If your system has a "GMT offset" field in its "struct tm"s
|
||||
# (or if you decide to add such a field in your system's "time.h" file),
|
||||
# add the name to a define such as
|
||||
# -DTM_GMTOFF=tm_gmtoff
|
||||
# or
|
||||
# -DTM_GMTOFF=_tm_gmtoff
|
||||
# to the end of the "CFLAGS=" line.
|
||||
# Neither tm_gmtoff nor _tm_gmtoff is described in X3J11's work;
|
||||
# in its work, use of "tm_gmtoff" is described as non-conforming.
|
||||
# Both Linux and BSD have done the equivalent of defining TM_GMTOFF in
|
||||
# their recent releases.
|
||||
#
|
||||
# If your system has a "zone abbreviation" field in its "struct tm"s
|
||||
# (or if you decide to add such a field in your system's "time.h" file),
|
||||
# add the name to a define such as
|
||||
# -DTM_ZONE=tm_zone
|
||||
# or
|
||||
# -DTM_ZONE=_tm_zone
|
||||
# to the end of the "CFLAGS=" line.
|
||||
# Neither tm_zone nor _tm_zone is described in X3J11's work;
|
||||
# in its work, use of "tm_zone" is described as non-conforming.
|
||||
# Both UCB and Sun have done the equivalent of defining TM_ZONE in
|
||||
# their recent releases.
|
||||
#
|
||||
# If you want functions that were inspired by early versions of X3J11's work,
|
||||
# add
|
||||
# -DSTD_INSPIRED
|
||||
# to the end of the "CFLAGS=" line. This arranges for the functions
|
||||
# "tzsetwall", "offtime", "timelocal", "timegm", "timeoff",
|
||||
# "posix2time", and "time2posix" to be added to the time conversion library.
|
||||
# "tzsetwall" is like "tzset" except that it arranges for local wall clock
|
||||
# time (rather than the time specified in the TZ environment variable)
|
||||
# to be used.
|
||||
# "offtime" is like "gmtime" except that it accepts a second (long) argument
|
||||
# that gives an offset to add to the time_t when converting it.
|
||||
# "timelocal" is equivalent to "mktime".
|
||||
# "timegm" is like "timelocal" except that it turns a struct tm into
|
||||
# a time_t using UTC (rather than local time as "timelocal" does).
|
||||
# "timeoff" is like "timegm" except that it accepts a second (long) argument
|
||||
# that gives an offset to use when converting to a time_t.
|
||||
# "posix2time" and "time2posix" are described in an included manual page.
|
||||
# X3J11's work does not describe any of these functions.
|
||||
# Sun has provided "tzsetwall", "timelocal", and "timegm" in SunOS 4.0.
|
||||
# These functions may well disappear in future releases of the time
|
||||
# conversion package.
|
||||
#
|
||||
# If you want Source Code Control System ID's left out of object modules, add
|
||||
# -DNOID
|
||||
# to the end of the "CFLAGS=" line.
|
||||
#
|
||||
# NIST-PCTS:151-2, Version 1.4, (1993-12-03) is a test suite put
|
||||
# out by the National Institute of Standards and Technology
|
||||
# which claims to test C and Posix conformance. If you want to pass PCTS, add
|
||||
# -DPCTS
|
||||
# to the end of the "CFLAGS=" line.
|
||||
|
||||
@ -34,7 +34,7 @@ int daylight = 0;
|
||||
|
||||
|
||||
// These three functions are used as a fallback when the locale backend could not
|
||||
// be loaded. They are implemented in localtime_fading_out.c.
|
||||
// be loaded, or for the POSIX locale. They are implemented in localtime_fallback.c.
|
||||
extern "C" struct tm* __gmtime_r_fallback(const time_t* timep, struct tm* tmp);
|
||||
extern "C" time_t __mktime_fallback(struct tm* tmp);
|
||||
extern "C" time_t __timegm_fallback(struct tm* tmp);
|
||||
|
||||
@ -1,839 +0,0 @@
|
||||
/*
|
||||
** This file is in the public domain, so clarified as of
|
||||
** 1996-06-05 by Arthur David Olson.
|
||||
*/
|
||||
|
||||
#ifndef lint
|
||||
#ifndef NOID
|
||||
static char elsieid[] = "@(#)localtime.c 8.5";
|
||||
#endif /* !defined NOID */
|
||||
#endif /* !defined lint */
|
||||
|
||||
/*
|
||||
** Leap second handling from Bradley White.
|
||||
** POSIX-style TZ environment variable handling from Guy Harris.
|
||||
*/
|
||||
|
||||
/*LINTLIBRARY*/
|
||||
|
||||
#include "private.h"
|
||||
#include "tzfile.h"
|
||||
#include "fcntl.h"
|
||||
#include "float.h" /* for FLT_MAX and DBL_MAX */
|
||||
|
||||
#ifndef TZ_ABBR_MAX_LEN
|
||||
#define TZ_ABBR_MAX_LEN 16
|
||||
#endif /* !defined TZ_ABBR_MAX_LEN */
|
||||
|
||||
#ifndef TZ_ABBR_CHAR_SET
|
||||
#define TZ_ABBR_CHAR_SET \
|
||||
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 :+-._"
|
||||
#endif /* !defined TZ_ABBR_CHAR_SET */
|
||||
|
||||
#ifndef TZ_ABBR_ERR_CHAR
|
||||
#define TZ_ABBR_ERR_CHAR '_'
|
||||
#endif /* !defined TZ_ABBR_ERR_CHAR */
|
||||
|
||||
/*
|
||||
** SunOS 4.1.1 headers lack O_BINARY.
|
||||
*/
|
||||
|
||||
#ifdef O_BINARY
|
||||
#define OPEN_MODE (O_RDONLY | O_BINARY)
|
||||
#endif /* defined O_BINARY */
|
||||
#ifndef O_BINARY
|
||||
#define OPEN_MODE O_RDONLY
|
||||
#endif /* !defined O_BINARY */
|
||||
|
||||
#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.
|
||||
*/
|
||||
#ifndef TZDEFRULESTRING
|
||||
#define TZDEFRULESTRING ",M4.1.0,M10.5.0"
|
||||
#endif /* !defined TZDEFDST */
|
||||
|
||||
struct ttinfo { /* time type information */
|
||||
long tt_gmtoff; /* UTC offset in seconds */
|
||||
int tt_isdst; /* used to set tm_isdst */
|
||||
int tt_abbrind; /* abbreviation list index */
|
||||
int tt_ttisstd; /* TRUE if transition is std time */
|
||||
int tt_ttisgmt; /* TRUE if transition is UTC */
|
||||
};
|
||||
|
||||
struct lsinfo { /* leap second information */
|
||||
time_t ls_trans; /* transition time */
|
||||
long ls_corr; /* correction to apply */
|
||||
};
|
||||
|
||||
#define BIGGEST(a, b) (((a) > (b)) ? (a) : (b))
|
||||
|
||||
#ifdef TZNAME_MAX
|
||||
#define MY_TZNAME_MAX TZNAME_MAX
|
||||
#endif /* defined TZNAME_MAX */
|
||||
#ifndef TZNAME_MAX
|
||||
#define MY_TZNAME_MAX 255
|
||||
#endif /* !defined TZNAME_MAX */
|
||||
|
||||
struct state {
|
||||
int leapcnt;
|
||||
int timecnt;
|
||||
int typecnt;
|
||||
int charcnt;
|
||||
int goback;
|
||||
int goahead;
|
||||
time_t ats[TZ_MAX_TIMES];
|
||||
unsigned char types[TZ_MAX_TIMES];
|
||||
struct ttinfo ttis[TZ_MAX_TYPES];
|
||||
char chars[BIGGEST(BIGGEST(TZ_MAX_CHARS + 1, sizeof gmt),
|
||||
(2 * (MY_TZNAME_MAX + 1)))];
|
||||
struct lsinfo lsis[TZ_MAX_LEAPS];
|
||||
};
|
||||
|
||||
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 struct tm * gmtsub P((const time_t * timep, long offset,
|
||||
struct tm * tmp));
|
||||
static struct tm * localsub P((const time_t * timep, long offset,
|
||||
struct tm * tmp));
|
||||
static int increment_overflow P((int * number, int delta));
|
||||
static int leaps_thru_end_of P((int y));
|
||||
static int long_increment_overflow P((long * number, int delta));
|
||||
static int long_normalize_overflow P((long * tensptr,
|
||||
int * unitsptr, int base));
|
||||
static int normalize_overflow P((int * tensptr, int * unitsptr,
|
||||
int base));
|
||||
static time_t time1 P((struct tm * tmp,
|
||||
struct tm * (*funcp) P((const time_t *,
|
||||
long, struct tm *)),
|
||||
long offset));
|
||||
static time_t time2 P((struct tm *tmp,
|
||||
struct tm * (*funcp) P((const time_t *,
|
||||
long, struct tm*)),
|
||||
long offset, int * okayp));
|
||||
static time_t time2sub P((struct tm *tmp,
|
||||
struct tm * (*funcp) P((const time_t *,
|
||||
long, struct tm*)),
|
||||
long offset, int * okayp, int do_norm_secs));
|
||||
static struct tm * 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));
|
||||
|
||||
/*
|
||||
** Other prototypes.
|
||||
*/
|
||||
struct tm* __gmtime_r_fallback(const time_t* timep, struct tm* tmp);
|
||||
time_t __mktime_fallback(struct tm* tmp);
|
||||
time_t __timegm_fallback(struct tm* const tmp);
|
||||
|
||||
static struct state lclmem;
|
||||
static struct state gmtmem;
|
||||
#define lclptr (&lclmem)
|
||||
#define gmtptr (&gmtmem)
|
||||
|
||||
static int gmt_is_set;
|
||||
|
||||
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
|
||||
};
|
||||
|
||||
/*
|
||||
** The easy way to behave "as if no library function calls" localtime
|
||||
** is to not call it--so we drop its guts into "localsub", which can be
|
||||
** freely called. (And no, the PANS doesn't require the above behavior--
|
||||
** but it *is* desirable.)
|
||||
**
|
||||
** The unused offset argument is for the benefit of mktime variants.
|
||||
*/
|
||||
|
||||
/*ARGSUSED*/
|
||||
static struct tm *
|
||||
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;
|
||||
register struct tm * result;
|
||||
const time_t t = *timep;
|
||||
|
||||
sp = lclptr;
|
||||
if ((sp->goback && t < sp->ats[0]) ||
|
||||
(sp->goahead && t > sp->ats[sp->timecnt - 1])) {
|
||||
time_t newt = t;
|
||||
register time_t seconds;
|
||||
register time_t tcycles;
|
||||
register int_fast64_t icycles;
|
||||
|
||||
if (t < sp->ats[0])
|
||||
seconds = sp->ats[0] - t;
|
||||
else seconds = t - sp->ats[sp->timecnt - 1];
|
||||
--seconds;
|
||||
tcycles = seconds / YEARSPERREPEAT / AVGSECSPERYEAR;
|
||||
++tcycles;
|
||||
icycles = tcycles;
|
||||
if (tcycles - icycles >= 1 || icycles - tcycles >= 1)
|
||||
return NULL;
|
||||
seconds = icycles;
|
||||
seconds *= YEARSPERREPEAT;
|
||||
seconds *= AVGSECSPERYEAR;
|
||||
if (t < sp->ats[0])
|
||||
newt += seconds;
|
||||
else newt -= seconds;
|
||||
if (newt < sp->ats[0] ||
|
||||
newt > sp->ats[sp->timecnt - 1])
|
||||
return NULL; /* "cannot happen" */
|
||||
result = localsub(&newt, offset, tmp);
|
||||
if (result == tmp) {
|
||||
register time_t newy;
|
||||
|
||||
newy = tmp->tm_year;
|
||||
if (t < sp->ats[0])
|
||||
newy -= icycles * YEARSPERREPEAT;
|
||||
else newy += icycles * YEARSPERREPEAT;
|
||||
tmp->tm_year = newy;
|
||||
if (tmp->tm_year != 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 {
|
||||
register int lo = 1;
|
||||
register int hi = sp->timecnt;
|
||||
|
||||
while (lo < hi) {
|
||||
register int mid = (lo + hi) >> 1;
|
||||
|
||||
if (t < sp->ats[mid])
|
||||
hi = mid;
|
||||
else lo = mid + 1;
|
||||
}
|
||||
i = (int) sp->types[lo - 1];
|
||||
}
|
||||
ttisp = &sp->ttis[i];
|
||||
/*
|
||||
** To get (wrong) behavior that's compatible with System V Release 2.0
|
||||
** you'd replace the statement below with
|
||||
** t += ttisp->tt_gmtoff;
|
||||
** timesub(&t, 0L, sp, tmp);
|
||||
*/
|
||||
result = timesub(&t, ttisp->tt_gmtoff, sp, tmp);
|
||||
tmp->tm_isdst = ttisp->tt_isdst;
|
||||
tzname[tmp->tm_isdst] = &sp->chars[ttisp->tt_abbrind];
|
||||
#ifdef TM_ZONE
|
||||
tmp->TM_ZONE = &sp->chars[ttisp->tt_abbrind];
|
||||
#endif /* defined TM_ZONE */
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** gmtsub is to gmtime as localsub is to localtime.
|
||||
*/
|
||||
|
||||
static struct tm *
|
||||
gmtsub(timep, offset, tmp)
|
||||
const time_t * const timep;
|
||||
const long offset;
|
||||
struct tm * const tmp;
|
||||
{
|
||||
register struct tm * result;
|
||||
|
||||
if (!gmt_is_set)
|
||||
gmt_is_set = TRUE;
|
||||
result = timesub(timep, offset, gmtptr, tmp);
|
||||
#ifdef TM_ZONE
|
||||
/*
|
||||
** 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;
|
||||
#endif /* defined TM_ZONE */
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
|
||||
// used in Haiku as fallback when the locale backend could not be loaded
|
||||
struct tm*
|
||||
__gmtime_r_fallback(const time_t* timep, struct tm* tmp)
|
||||
{
|
||||
return gmtsub(timep, 0L, tmp);
|
||||
}
|
||||
|
||||
/*
|
||||
** 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(y)
|
||||
register const int y;
|
||||
{
|
||||
return (y >= 0) ? (y / 4 - y / 100 + y / 400) :
|
||||
-(leaps_thru_end_of(-(y + 1)) + 1);
|
||||
}
|
||||
|
||||
static struct tm *
|
||||
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 time_t tdays;
|
||||
register int idays; /* unsigned would be so 2003 */
|
||||
register long rem;
|
||||
int y;
|
||||
register const int * ip;
|
||||
register long corr;
|
||||
register int hit;
|
||||
register 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;
|
||||
register time_t tdelta;
|
||||
register int idelta;
|
||||
register int leapdays;
|
||||
|
||||
tdelta = tdays / DAYSPERLYEAR;
|
||||
idelta = tdelta;
|
||||
if (tdelta - idelta >= 1 || idelta - tdelta >= 1)
|
||||
return NULL;
|
||||
if (idelta == 0)
|
||||
idelta = (tdays < 0) ? -1 : 1;
|
||||
newy = y;
|
||||
if (increment_overflow(&newy, idelta))
|
||||
return NULL;
|
||||
leapdays = leaps_thru_end_of(newy - 1) -
|
||||
leaps_thru_end_of(y - 1);
|
||||
tdays -= ((time_t) newy - y) * DAYSPERNYEAR;
|
||||
tdays -= leapdays;
|
||||
y = newy;
|
||||
}
|
||||
{
|
||||
register 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;
|
||||
#ifdef TM_GMTOFF
|
||||
tmp->TM_GMTOFF = offset;
|
||||
#endif /* defined TM_GMTOFF */
|
||||
return tmp;
|
||||
}
|
||||
|
||||
/*
|
||||
** Adapted from code provided by Robert Elz, who writes:
|
||||
** The "best" way to do mktime I think is based on an idea of Bob
|
||||
** Kridle's (so its said...) from a long time ago.
|
||||
** It does a binary search of the time_t space. Since time_t's are
|
||||
** just 32 bits, its a max of 32 iterations (even at 64 bits it
|
||||
** would still be very reasonable).
|
||||
*/
|
||||
|
||||
#ifndef WRONG
|
||||
#define WRONG (-1)
|
||||
#endif /* !defined WRONG */
|
||||
|
||||
/*
|
||||
** Simplified normalize logic courtesy Paul Eggert.
|
||||
*/
|
||||
|
||||
static int
|
||||
increment_overflow(number, delta)
|
||||
int * number;
|
||||
int delta;
|
||||
{
|
||||
int number0;
|
||||
|
||||
number0 = *number;
|
||||
*number += delta;
|
||||
return (*number < number0) != (delta < 0);
|
||||
}
|
||||
|
||||
static int
|
||||
long_increment_overflow(number, delta)
|
||||
long * number;
|
||||
int delta;
|
||||
{
|
||||
long number0;
|
||||
|
||||
number0 = *number;
|
||||
*number += delta;
|
||||
return (*number < number0) != (delta < 0);
|
||||
}
|
||||
|
||||
static int
|
||||
normalize_overflow(tensptr, unitsptr, base)
|
||||
int * const tensptr;
|
||||
int * const unitsptr;
|
||||
const int base;
|
||||
{
|
||||
register int tensdelta;
|
||||
|
||||
tensdelta = (*unitsptr >= 0) ?
|
||||
(*unitsptr / base) :
|
||||
(-1 - (-1 - *unitsptr) / base);
|
||||
*unitsptr -= tensdelta * base;
|
||||
return increment_overflow(tensptr, tensdelta);
|
||||
}
|
||||
|
||||
static int
|
||||
long_normalize_overflow(tensptr, unitsptr, base)
|
||||
long * const tensptr;
|
||||
int * const unitsptr;
|
||||
const int base;
|
||||
{
|
||||
register int tensdelta;
|
||||
|
||||
tensdelta = (*unitsptr >= 0) ?
|
||||
(*unitsptr / base) :
|
||||
(-1 - (-1 - *unitsptr) / base);
|
||||
*unitsptr -= tensdelta * base;
|
||||
return long_increment_overflow(tensptr, tensdelta);
|
||||
}
|
||||
|
||||
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
|
||||
time2sub(tmp, funcp, offset, okayp, do_norm_secs)
|
||||
struct tm * const tmp;
|
||||
struct tm * (* const funcp) P((const time_t*, long, struct tm*));
|
||||
const long offset;
|
||||
int * const okayp;
|
||||
const int do_norm_secs;
|
||||
{
|
||||
register const struct state * sp;
|
||||
register int dir;
|
||||
register int i, j;
|
||||
register int saved_seconds;
|
||||
register long li;
|
||||
register time_t lo;
|
||||
register time_t hi;
|
||||
long y;
|
||||
time_t newt;
|
||||
time_t t;
|
||||
struct tm yourtm, mytm;
|
||||
|
||||
*okayp = FALSE;
|
||||
yourtm = *tmp;
|
||||
if (do_norm_secs) {
|
||||
if (normalize_overflow(&yourtm.tm_min, &yourtm.tm_sec,
|
||||
SECSPERMIN))
|
||||
return WRONG;
|
||||
}
|
||||
if (normalize_overflow(&yourtm.tm_hour, &yourtm.tm_min, MINSPERHOUR))
|
||||
return WRONG;
|
||||
if (normalize_overflow(&yourtm.tm_mday, &yourtm.tm_hour, HOURSPERDAY))
|
||||
return WRONG;
|
||||
y = yourtm.tm_year;
|
||||
if (long_normalize_overflow(&y, &yourtm.tm_mon, MONSPERYEAR))
|
||||
return WRONG;
|
||||
/*
|
||||
** Turn y into an actual year number for now.
|
||||
** It is converted back to an offset from TM_YEAR_BASE later.
|
||||
*/
|
||||
if (long_increment_overflow(&y, TM_YEAR_BASE))
|
||||
return WRONG;
|
||||
while (yourtm.tm_mday <= 0) {
|
||||
if (long_increment_overflow(&y, -1))
|
||||
return WRONG;
|
||||
li = y + (1 < yourtm.tm_mon);
|
||||
yourtm.tm_mday += year_lengths[isleap(li)];
|
||||
}
|
||||
while (yourtm.tm_mday > DAYSPERLYEAR) {
|
||||
li = y + (1 < yourtm.tm_mon);
|
||||
yourtm.tm_mday -= year_lengths[isleap(li)];
|
||||
if (long_increment_overflow(&y, 1))
|
||||
return WRONG;
|
||||
}
|
||||
for ( ; ; ) {
|
||||
i = mon_lengths[isleap(y)][yourtm.tm_mon];
|
||||
if (yourtm.tm_mday <= i)
|
||||
break;
|
||||
yourtm.tm_mday -= i;
|
||||
if (++yourtm.tm_mon >= MONSPERYEAR) {
|
||||
yourtm.tm_mon = 0;
|
||||
if (long_increment_overflow(&y, 1))
|
||||
return WRONG;
|
||||
}
|
||||
}
|
||||
if (long_increment_overflow(&y, -TM_YEAR_BASE))
|
||||
return WRONG;
|
||||
yourtm.tm_year = y;
|
||||
if (yourtm.tm_year != y)
|
||||
return WRONG;
|
||||
if (yourtm.tm_sec >= 0 && yourtm.tm_sec < SECSPERMIN)
|
||||
saved_seconds = 0;
|
||||
else if (y + TM_YEAR_BASE < EPOCH_YEAR) {
|
||||
/*
|
||||
** We can't set tm_sec to 0, because that might push the
|
||||
** time below the minimum representable time.
|
||||
** Set tm_sec to 59 instead.
|
||||
** This assumes that the minimum representable time is
|
||||
** not in the same minute that a leap second was deleted from,
|
||||
** which is a safer assumption than using 58 would be.
|
||||
*/
|
||||
if (increment_overflow(&yourtm.tm_sec, 1 - SECSPERMIN))
|
||||
return WRONG;
|
||||
saved_seconds = yourtm.tm_sec;
|
||||
yourtm.tm_sec = SECSPERMIN - 1;
|
||||
} else {
|
||||
saved_seconds = yourtm.tm_sec;
|
||||
yourtm.tm_sec = 0;
|
||||
}
|
||||
/*
|
||||
** Do a binary search (this works whatever time_t's type is).
|
||||
*/
|
||||
if (!TYPE_SIGNED(time_t)) {
|
||||
lo = 0;
|
||||
hi = lo - 1;
|
||||
} else if (!TYPE_INTEGRAL(time_t)) {
|
||||
if (sizeof(time_t) > sizeof(float))
|
||||
hi = (time_t) DBL_MAX;
|
||||
else hi = (time_t) FLT_MAX;
|
||||
lo = -hi;
|
||||
} else {
|
||||
lo = 1;
|
||||
for (i = 0; i < (int) TYPE_BIT(time_t) - 1; ++i)
|
||||
lo *= 2;
|
||||
hi = -(lo + 1);
|
||||
}
|
||||
for ( ; ; ) {
|
||||
t = lo / 2 + hi / 2;
|
||||
if (t < lo)
|
||||
t = lo;
|
||||
else if (t > hi)
|
||||
t = hi;
|
||||
if ((*funcp)(&t, offset, &mytm) == NULL) {
|
||||
/*
|
||||
** Assume that t is too extreme to be represented in
|
||||
** a struct tm; arrange things so that it is less
|
||||
** extreme on the next pass.
|
||||
*/
|
||||
dir = (t > 0) ? 1 : -1;
|
||||
} else dir = tmcomp(&mytm, &yourtm);
|
||||
if (dir != 0) {
|
||||
if (t == lo) {
|
||||
++t;
|
||||
if (t <= lo)
|
||||
return WRONG;
|
||||
++lo;
|
||||
} else if (t == hi) {
|
||||
--t;
|
||||
if (t >= hi)
|
||||
return WRONG;
|
||||
--hi;
|
||||
}
|
||||
if (lo > hi)
|
||||
return WRONG;
|
||||
if (dir > 0)
|
||||
hi = t;
|
||||
else lo = t;
|
||||
continue;
|
||||
}
|
||||
if (yourtm.tm_isdst < 0 || mytm.tm_isdst == yourtm.tm_isdst)
|
||||
break;
|
||||
/*
|
||||
** Right time, wrong type.
|
||||
** Hunt for right time, right type.
|
||||
** It's okay to guess wrong since the guess
|
||||
** gets checked.
|
||||
*/
|
||||
/*
|
||||
** The (void *) casts are the benefit of SunOS 3.3 on Sun 2's.
|
||||
*/
|
||||
sp = (const struct state *)
|
||||
(((void *) funcp == (void *) localsub) ?
|
||||
lclptr : gmtptr);
|
||||
for (i = sp->typecnt - 1; i >= 0; --i) {
|
||||
if (sp->ttis[i].tt_isdst != yourtm.tm_isdst)
|
||||
continue;
|
||||
for (j = sp->typecnt - 1; j >= 0; --j) {
|
||||
if (sp->ttis[j].tt_isdst == yourtm.tm_isdst)
|
||||
continue;
|
||||
newt = t + sp->ttis[j].tt_gmtoff -
|
||||
sp->ttis[i].tt_gmtoff;
|
||||
if ((*funcp)(&newt, offset, &mytm) == NULL)
|
||||
continue;
|
||||
if (tmcomp(&mytm, &yourtm) != 0)
|
||||
continue;
|
||||
if (mytm.tm_isdst != yourtm.tm_isdst)
|
||||
continue;
|
||||
/*
|
||||
** We have a match.
|
||||
*/
|
||||
t = newt;
|
||||
goto label;
|
||||
}
|
||||
}
|
||||
return WRONG;
|
||||
}
|
||||
label:
|
||||
newt = t + saved_seconds;
|
||||
if ((newt < t) != (saved_seconds < 0))
|
||||
return WRONG;
|
||||
t = newt;
|
||||
if ((*funcp)(&t, offset, tmp))
|
||||
*okayp = TRUE;
|
||||
return t;
|
||||
}
|
||||
|
||||
static time_t
|
||||
time2(tmp, funcp, offset, okayp)
|
||||
struct tm * const tmp;
|
||||
struct tm * (* const funcp) P((const time_t*, long, struct tm*));
|
||||
const long offset;
|
||||
int * const okayp;
|
||||
{
|
||||
time_t t;
|
||||
|
||||
/*
|
||||
** First try without normalization of seconds
|
||||
** (in case tm_sec contains a value associated with a leap second).
|
||||
** If that fails, try with normalization of seconds.
|
||||
*/
|
||||
t = time2sub(tmp, funcp, offset, okayp, FALSE);
|
||||
return *okayp ? t : time2sub(tmp, funcp, offset, okayp, TRUE);
|
||||
}
|
||||
|
||||
static time_t
|
||||
time1(tmp, funcp, offset)
|
||||
struct tm * const tmp;
|
||||
struct tm * (* const funcp) P((const time_t *, long, struct tm *));
|
||||
const long offset;
|
||||
{
|
||||
register time_t t;
|
||||
register const struct state * sp;
|
||||
register int samei, otheri;
|
||||
register int sameind, otherind;
|
||||
register int i;
|
||||
register int nseen;
|
||||
int seen[TZ_MAX_TYPES];
|
||||
int types[TZ_MAX_TYPES];
|
||||
int okay;
|
||||
|
||||
if (tmp->tm_isdst > 1)
|
||||
tmp->tm_isdst = 1;
|
||||
t = time2(tmp, funcp, offset, &okay);
|
||||
/*
|
||||
** PCTS code courtesy Grant Sullivan.
|
||||
*/
|
||||
if (okay)
|
||||
return t;
|
||||
if (tmp->tm_isdst < 0)
|
||||
tmp->tm_isdst = 0; /* reset to std and try again */
|
||||
/*
|
||||
** We're supposed to assume that somebody took a time of one type
|
||||
** and did some math on it that yielded a "struct tm" that's bad.
|
||||
** We try to divine the type they started from and adjust to the
|
||||
** type they need.
|
||||
*/
|
||||
/*
|
||||
** The (void *) casts are the benefit of SunOS 3.3 on Sun 2's.
|
||||
*/
|
||||
sp = (const struct state *) (((void *) funcp == (void *) localsub) ?
|
||||
lclptr : gmtptr);
|
||||
for (i = 0; i < sp->typecnt; ++i)
|
||||
seen[i] = FALSE;
|
||||
nseen = 0;
|
||||
for (i = sp->timecnt - 1; i >= 0; --i)
|
||||
if (!seen[sp->types[i]]) {
|
||||
seen[sp->types[i]] = TRUE;
|
||||
types[nseen++] = sp->types[i];
|
||||
}
|
||||
for (sameind = 0; sameind < nseen; ++sameind) {
|
||||
samei = types[sameind];
|
||||
if (sp->ttis[samei].tt_isdst != tmp->tm_isdst)
|
||||
continue;
|
||||
for (otherind = 0; otherind < nseen; ++otherind) {
|
||||
otheri = types[otherind];
|
||||
if (sp->ttis[otheri].tt_isdst == tmp->tm_isdst)
|
||||
continue;
|
||||
tmp->tm_sec += sp->ttis[otheri].tt_gmtoff -
|
||||
sp->ttis[samei].tt_gmtoff;
|
||||
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;
|
||||
}
|
||||
|
||||
|
||||
// used in Haiku as fallback when the locale backend could not be loaded
|
||||
time_t
|
||||
__mktime_fallback(struct tm* tmp)
|
||||
{
|
||||
return time1(tmp, localsub, 0L);
|
||||
}
|
||||
|
||||
|
||||
time_t
|
||||
__timegm_fallback(struct tm* const tmp)
|
||||
{
|
||||
tmp->tm_isdst = 0;
|
||||
return time1(tmp, gmtsub, 0L);
|
||||
}
|
||||
81
src/system/libroot/posix/time/localtime_fallback.c
Normal file
81
src/system/libroot/posix/time/localtime_fallback.c
Normal file
@ -0,0 +1,81 @@
|
||||
/* The following methods were adapted from musl.
|
||||
* See musl/COPYRIGHT for license information. */
|
||||
|
||||
#include <errno.h>
|
||||
|
||||
#include "../musl/time/time_impl.h"
|
||||
|
||||
|
||||
static long __timezone = 0;
|
||||
static int dst_off = 0;
|
||||
const char __utc[] = "UTC";
|
||||
static const char *__tzname[2] = { __utc, __utc };
|
||||
|
||||
|
||||
static void
|
||||
__secs_to_zone(long long t, int local, int *isdst, int *offset, long *oppoff, const char **zonename)
|
||||
{
|
||||
*isdst = 0;
|
||||
*offset = -__timezone;
|
||||
if (oppoff) *oppoff = -dst_off;
|
||||
*zonename = __tzname[0];
|
||||
}
|
||||
|
||||
|
||||
struct tm *
|
||||
__gmtime_r_fallback(const time_t *restrict t, struct tm *restrict tm)
|
||||
{
|
||||
if (__secs_to_tm(*t, tm) < 0) {
|
||||
errno = EOVERFLOW;
|
||||
return 0;
|
||||
}
|
||||
tm->tm_isdst = 0;
|
||||
tm->__tm_gmtoff = 0;
|
||||
tm->__tm_zone = __utc;
|
||||
return tm;
|
||||
}
|
||||
|
||||
|
||||
time_t
|
||||
__mktime_fallback(struct tm *tm)
|
||||
{
|
||||
struct tm new;
|
||||
long opp;
|
||||
long long t = __tm_to_secs(tm);
|
||||
|
||||
__secs_to_zone(t, 1, &new.tm_isdst, &new.__tm_gmtoff, &opp, &new.__tm_zone);
|
||||
|
||||
if (tm->tm_isdst>=0 && new.tm_isdst!=tm->tm_isdst)
|
||||
t -= opp - new.__tm_gmtoff;
|
||||
|
||||
t -= new.__tm_gmtoff;
|
||||
if ((time_t)t != t) goto error;
|
||||
|
||||
__secs_to_zone(t, 0, &new.tm_isdst, &new.__tm_gmtoff, &opp, &new.__tm_zone);
|
||||
|
||||
if (__secs_to_tm(t + new.__tm_gmtoff, &new) < 0) goto error;
|
||||
|
||||
*tm = new;
|
||||
return t;
|
||||
|
||||
error:
|
||||
errno = EOVERFLOW;
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
time_t
|
||||
__timegm_fallback(struct tm *tm)
|
||||
{
|
||||
struct tm new;
|
||||
long long t = __tm_to_secs(tm);
|
||||
if (__secs_to_tm(t, &new) < 0) {
|
||||
errno = EOVERFLOW;
|
||||
return -1;
|
||||
}
|
||||
*tm = new;
|
||||
tm->tm_isdst = 0;
|
||||
tm->__tm_gmtoff = 0;
|
||||
tm->__tm_zone = __utc;
|
||||
return t;
|
||||
}
|
||||
@ -1,366 +0,0 @@
|
||||
#ifndef PRIVATE_H
|
||||
|
||||
#define PRIVATE_H
|
||||
|
||||
/*
|
||||
** This file is in the public domain, so clarified as of
|
||||
** 1996-06-05 by Arthur David Olson.
|
||||
*/
|
||||
|
||||
/*
|
||||
** This header is for use ONLY with the time conversion code.
|
||||
** There is no guarantee that it will remain unchanged,
|
||||
** or that it will remain at all.
|
||||
** Do NOT copy it to any system include directory.
|
||||
** Thank you!
|
||||
*/
|
||||
|
||||
/*
|
||||
** ID
|
||||
*/
|
||||
|
||||
#ifndef lint
|
||||
#ifndef NOID
|
||||
static char privatehid[] = "@(#)private.h 8.2";
|
||||
#endif /* !defined NOID */
|
||||
#endif /* !defined lint */
|
||||
|
||||
#define GRANDPARENTED "Local time zone must be set--see zic manual page"
|
||||
|
||||
/*
|
||||
** Defaults for preprocessor symbols.
|
||||
** You can override these in your C compiler options, e.g. `-DHAVE_ADJTIME=0'.
|
||||
*/
|
||||
|
||||
#ifndef HAVE_ADJTIME
|
||||
#define HAVE_ADJTIME 1
|
||||
#endif /* !defined HAVE_ADJTIME */
|
||||
|
||||
#ifndef HAVE_GETTEXT
|
||||
#define HAVE_GETTEXT 0
|
||||
#endif /* !defined HAVE_GETTEXT */
|
||||
|
||||
#ifndef HAVE_INCOMPATIBLE_CTIME_R
|
||||
#define HAVE_INCOMPATIBLE_CTIME_R 0
|
||||
#endif /* !defined INCOMPATIBLE_CTIME_R */
|
||||
|
||||
#ifndef HAVE_SETTIMEOFDAY
|
||||
#define HAVE_SETTIMEOFDAY 3
|
||||
#endif /* !defined HAVE_SETTIMEOFDAY */
|
||||
|
||||
#ifndef HAVE_STRERROR
|
||||
#define HAVE_STRERROR 1
|
||||
#endif /* !defined HAVE_STRERROR */
|
||||
|
||||
#ifndef HAVE_SYMLINK
|
||||
#define HAVE_SYMLINK 1
|
||||
#endif /* !defined HAVE_SYMLINK */
|
||||
|
||||
#ifndef HAVE_SYS_STAT_H
|
||||
#define HAVE_SYS_STAT_H 1
|
||||
#endif /* !defined HAVE_SYS_STAT_H */
|
||||
|
||||
#ifndef HAVE_SYS_WAIT_H
|
||||
#define HAVE_SYS_WAIT_H 1
|
||||
#endif /* !defined HAVE_SYS_WAIT_H */
|
||||
|
||||
#ifndef HAVE_UNISTD_H
|
||||
#define HAVE_UNISTD_H 1
|
||||
#endif /* !defined HAVE_UNISTD_H */
|
||||
|
||||
#ifndef HAVE_UTMPX_H
|
||||
#define HAVE_UTMPX_H 0
|
||||
#endif /* !defined HAVE_UTMPX_H */
|
||||
|
||||
#ifndef LOCALE_HOME
|
||||
#define LOCALE_HOME "/usr/lib/locale"
|
||||
#endif /* !defined LOCALE_HOME */
|
||||
|
||||
#if HAVE_INCOMPATIBLE_CTIME_R
|
||||
#define asctime_r _incompatible_asctime_r
|
||||
#define ctime_r _incompatible_ctime_r
|
||||
#endif /* HAVE_INCOMPATIBLE_CTIME_R */
|
||||
|
||||
/*
|
||||
** Nested includes
|
||||
*/
|
||||
|
||||
#include "sys/types.h" /* for time_t */
|
||||
#include "stdio.h"
|
||||
#include "errno.h"
|
||||
#include "string.h"
|
||||
#include "limits.h" /* for CHAR_BIT et al. */
|
||||
#include "time.h"
|
||||
#include "stdlib.h"
|
||||
|
||||
#if HAVE_GETTEXT
|
||||
#include "libintl.h"
|
||||
#endif /* HAVE_GETTEXT */
|
||||
|
||||
#if HAVE_SYS_WAIT_H
|
||||
#include <sys/wait.h> /* for WIFEXITED and WEXITSTATUS */
|
||||
#endif /* HAVE_SYS_WAIT_H */
|
||||
|
||||
#ifndef WIFEXITED
|
||||
#define WIFEXITED(status) (((status) & 0xff) == 0)
|
||||
#endif /* !defined WIFEXITED */
|
||||
#ifndef WEXITSTATUS
|
||||
#define WEXITSTATUS(status) (((status) >> 8) & 0xff)
|
||||
#endif /* !defined WEXITSTATUS */
|
||||
|
||||
#if HAVE_UNISTD_H
|
||||
#include "unistd.h" /* for F_OK and R_OK */
|
||||
#endif /* HAVE_UNISTD_H */
|
||||
|
||||
#if !HAVE_UNISTD_H
|
||||
#ifndef F_OK
|
||||
#define F_OK 0
|
||||
#endif /* !defined F_OK */
|
||||
#ifndef R_OK
|
||||
#define R_OK 4
|
||||
#endif /* !defined R_OK */
|
||||
#endif /* !HAVE_UNISTD_H */
|
||||
|
||||
/* Unlike <ctype.h>'s isdigit, this also works if c < 0 | c > UCHAR_MAX. */
|
||||
#define is_digit(c) ((unsigned)(c) - '0' <= 9)
|
||||
|
||||
/*
|
||||
** Define HAVE_STDINT_H's default value here, rather than at the
|
||||
** start, since __GLIBC__'s value depends on previously-included
|
||||
** files.
|
||||
** (glibc 2.1 and later have stdint.h, even with pre-C99 compilers.)
|
||||
*/
|
||||
#ifndef HAVE_STDINT_H
|
||||
#define HAVE_STDINT_H 1
|
||||
#endif /* !defined HAVE_STDINT_H */
|
||||
|
||||
#if HAVE_STDINT_H
|
||||
#include "stdint.h"
|
||||
#endif /* !HAVE_STDINT_H */
|
||||
|
||||
#ifndef INT_FAST64_MAX
|
||||
/* Pre-C99 GCC compilers define __LONG_LONG_MAX__ instead of LLONG_MAX. */
|
||||
#if defined LLONG_MAX || defined __LONG_LONG_MAX__
|
||||
typedef long long int_fast64_t;
|
||||
#else /* ! (defined LLONG_MAX || defined __LONG_LONG_MAX__) */
|
||||
#if (LONG_MAX >> 31) < 0xffffffff
|
||||
Please use a compiler that supports a 64-bit integer type (or wider);
|
||||
you may need to compile with "-DHAVE_STDINT_H".
|
||||
#endif /* (LONG_MAX >> 31) < 0xffffffff */
|
||||
typedef long int_fast64_t;
|
||||
#endif /* ! (defined LLONG_MAX || defined __LONG_LONG_MAX__) */
|
||||
#endif /* !defined INT_FAST64_MAX */
|
||||
|
||||
#ifndef INT32_MAX
|
||||
#define INT32_MAX 0x7fffffff
|
||||
#endif /* !defined INT32_MAX */
|
||||
#ifndef INT32_MIN
|
||||
#define INT32_MIN (-1 - INT32_MAX)
|
||||
#endif /* !defined INT32_MIN */
|
||||
|
||||
/*
|
||||
** Workarounds for compilers/systems.
|
||||
*/
|
||||
|
||||
/*
|
||||
** If your compiler lacks prototypes, "#define P(x) ()".
|
||||
*/
|
||||
|
||||
#ifndef P
|
||||
#define P(x) x
|
||||
#endif /* !defined P */
|
||||
|
||||
/*
|
||||
** SunOS 4.1.1 headers lack EXIT_SUCCESS.
|
||||
*/
|
||||
|
||||
#ifndef EXIT_SUCCESS
|
||||
#define EXIT_SUCCESS 0
|
||||
#endif /* !defined EXIT_SUCCESS */
|
||||
|
||||
/*
|
||||
** SunOS 4.1.1 headers lack EXIT_FAILURE.
|
||||
*/
|
||||
|
||||
#ifndef EXIT_FAILURE
|
||||
#define EXIT_FAILURE 1
|
||||
#endif /* !defined EXIT_FAILURE */
|
||||
|
||||
/*
|
||||
** SunOS 4.1.1 headers lack FILENAME_MAX.
|
||||
*/
|
||||
|
||||
#ifndef FILENAME_MAX
|
||||
|
||||
#ifndef MAXPATHLEN
|
||||
#ifdef unix
|
||||
#include "sys/param.h"
|
||||
#endif /* defined unix */
|
||||
#endif /* !defined MAXPATHLEN */
|
||||
|
||||
#ifdef MAXPATHLEN
|
||||
#define FILENAME_MAX MAXPATHLEN
|
||||
#endif /* defined MAXPATHLEN */
|
||||
#ifndef MAXPATHLEN
|
||||
#define FILENAME_MAX 1024 /* Pure guesswork */
|
||||
#endif /* !defined MAXPATHLEN */
|
||||
|
||||
#endif /* !defined FILENAME_MAX */
|
||||
|
||||
/*
|
||||
** SunOS 4.1.1 libraries lack remove.
|
||||
*/
|
||||
|
||||
#ifndef remove
|
||||
extern int unlink P((const char * filename));
|
||||
#define remove unlink
|
||||
#endif /* !defined remove */
|
||||
|
||||
/*
|
||||
** Some ancient errno.h implementations don't declare errno.
|
||||
** But some newer errno.h implementations define it as a macro.
|
||||
** Fix the former without affecting the latter.
|
||||
*/
|
||||
|
||||
#ifndef errno
|
||||
extern int errno;
|
||||
#endif /* !defined errno */
|
||||
|
||||
/*
|
||||
** Some time.h implementations don't declare asctime_r.
|
||||
** Others might define it as a macro.
|
||||
** Fix the former without affecting the latter.
|
||||
*/
|
||||
|
||||
#ifndef asctime_r
|
||||
extern char * asctime_r();
|
||||
#endif
|
||||
|
||||
/*
|
||||
** Private function declarations.
|
||||
*/
|
||||
|
||||
char * icalloc P((int nelem, int elsize));
|
||||
char * icatalloc P((char * old, const char * new));
|
||||
char * icpyalloc P((const char * string));
|
||||
char * imalloc P((int n));
|
||||
void * irealloc P((void * pointer, int size));
|
||||
void icfree P((char * pointer));
|
||||
void ifree P((char * pointer));
|
||||
const char * scheck P((const char * string, const char * format));
|
||||
|
||||
/*
|
||||
** Finally, some convenience items.
|
||||
*/
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE 1
|
||||
#endif /* !defined TRUE */
|
||||
|
||||
#ifndef FALSE
|
||||
#define FALSE 0
|
||||
#endif /* !defined FALSE */
|
||||
|
||||
#ifndef TYPE_BIT
|
||||
#define TYPE_BIT(type) (sizeof (type) * CHAR_BIT)
|
||||
#endif /* !defined TYPE_BIT */
|
||||
|
||||
#ifndef TYPE_SIGNED
|
||||
#define TYPE_SIGNED(type) (((type) -1) < 0)
|
||||
#endif /* !defined TYPE_SIGNED */
|
||||
|
||||
/*
|
||||
** Since the definition of TYPE_INTEGRAL contains floating point numbers,
|
||||
** it cannot be used in preprocessor directives.
|
||||
*/
|
||||
|
||||
#ifndef TYPE_INTEGRAL
|
||||
#define TYPE_INTEGRAL(type) (((type) 0.5) != 0.5)
|
||||
#endif /* !defined TYPE_INTEGRAL */
|
||||
|
||||
#ifndef INT_STRLEN_MAXIMUM
|
||||
/*
|
||||
** 302 / 1000 is log10(2.0) rounded up.
|
||||
** Subtract one for the sign bit if the type is signed;
|
||||
** add one for integer division truncation;
|
||||
** add one more for a minus sign if the type is signed.
|
||||
*/
|
||||
#define INT_STRLEN_MAXIMUM(type) \
|
||||
((TYPE_BIT(type) - TYPE_SIGNED(type)) * 302 / 1000 + \
|
||||
1 + TYPE_SIGNED(type))
|
||||
#endif /* !defined INT_STRLEN_MAXIMUM */
|
||||
|
||||
/*
|
||||
** INITIALIZE(x)
|
||||
*/
|
||||
|
||||
#ifndef GNUC_or_lint
|
||||
#ifdef lint
|
||||
#define GNUC_or_lint
|
||||
#endif /* defined lint */
|
||||
#ifndef lint
|
||||
#ifdef __GNUC__
|
||||
#define GNUC_or_lint
|
||||
#endif /* defined __GNUC__ */
|
||||
#endif /* !defined lint */
|
||||
#endif /* !defined GNUC_or_lint */
|
||||
|
||||
#ifndef INITIALIZE
|
||||
#ifdef GNUC_or_lint
|
||||
#define INITIALIZE(x) ((x) = 0)
|
||||
#endif /* defined GNUC_or_lint */
|
||||
#ifndef GNUC_or_lint
|
||||
#define INITIALIZE(x)
|
||||
#endif /* !defined GNUC_or_lint */
|
||||
#endif /* !defined INITIALIZE */
|
||||
|
||||
/*
|
||||
** For the benefit of GNU folk...
|
||||
** `_(MSGID)' uses the current locale's message library string for MSGID.
|
||||
** The default is to use gettext if available, and use MSGID otherwise.
|
||||
*/
|
||||
|
||||
#ifndef _
|
||||
#if HAVE_GETTEXT
|
||||
#define _(msgid) gettext(msgid)
|
||||
#else /* !HAVE_GETTEXT */
|
||||
#define _(msgid) msgid
|
||||
#endif /* !HAVE_GETTEXT */
|
||||
#endif /* !defined _ */
|
||||
|
||||
#ifndef TZ_DOMAIN
|
||||
#define TZ_DOMAIN "tz"
|
||||
#endif /* !defined TZ_DOMAIN */
|
||||
|
||||
#if HAVE_INCOMPATIBLE_CTIME_R
|
||||
#undef asctime_r
|
||||
#undef ctime_r
|
||||
char *asctime_r P((struct tm const *, char *));
|
||||
char *ctime_r P((time_t const *, char *));
|
||||
#endif /* HAVE_INCOMPATIBLE_CTIME_R */
|
||||
|
||||
#ifndef YEARSPERREPEAT
|
||||
#define YEARSPERREPEAT 400 /* years before a Gregorian repeat */
|
||||
#endif /* !defined YEARSPERREPEAT */
|
||||
|
||||
/*
|
||||
** The Gregorian year averages 365.2425 days, which is 31556952 seconds.
|
||||
*/
|
||||
|
||||
#ifndef AVGSECSPERYEAR
|
||||
#define AVGSECSPERYEAR 31556952L
|
||||
#endif /* !defined AVGSECSPERYEAR */
|
||||
|
||||
#ifndef SECSPERREPEAT
|
||||
#define SECSPERREPEAT ((int_fast64_t) YEARSPERREPEAT * (int_fast64_t) AVGSECSPERYEAR)
|
||||
#endif /* !defined SECSPERREPEAT */
|
||||
|
||||
#ifndef SECSPERREPEAT_BITS
|
||||
#define SECSPERREPEAT_BITS 34 /* ceil(log2(SECSPERREPEAT)) */
|
||||
#endif /* !defined SECSPERREPEAT_BITS */
|
||||
|
||||
/*
|
||||
** UNIX was a registered trademark of The Open Group in 2003.
|
||||
*/
|
||||
|
||||
#endif /* !defined PRIVATE_H */
|
||||
@ -1,180 +0,0 @@
|
||||
#ifndef TZFILE_H
|
||||
|
||||
#define TZFILE_H
|
||||
|
||||
/*
|
||||
** This file is in the public domain, so clarified as of
|
||||
** 1996-06-05 by Arthur David Olson.
|
||||
*/
|
||||
|
||||
/*
|
||||
** This header is for use ONLY with the time conversion code.
|
||||
** There is no guarantee that it will remain unchanged,
|
||||
** or that it will remain at all.
|
||||
** Do NOT copy it to any system include directory.
|
||||
** Thank you!
|
||||
*/
|
||||
|
||||
/*
|
||||
** ID
|
||||
*/
|
||||
|
||||
#ifndef lint
|
||||
#ifndef NOID
|
||||
static char tzfilehid[] = "@(#)tzfile.h 8.1";
|
||||
#endif /* !defined NOID */
|
||||
#endif /* !defined lint */
|
||||
|
||||
/*
|
||||
** Information about time zone files.
|
||||
*/
|
||||
|
||||
#ifndef TZDIR
|
||||
#define TZDIR "/usr/local/etc/zoneinfo" /* Time zone object file directory */
|
||||
#endif /* !defined TZDIR */
|
||||
|
||||
#ifndef TZDEFAULT
|
||||
#define TZDEFAULT "localtime"
|
||||
#endif /* !defined TZDEFAULT */
|
||||
|
||||
#ifndef TZDEFRULES
|
||||
#define TZDEFRULES "posixrules"
|
||||
#endif /* !defined TZDEFRULES */
|
||||
|
||||
/*
|
||||
** Each file begins with. . .
|
||||
*/
|
||||
|
||||
#define TZ_MAGIC "TZif"
|
||||
|
||||
struct tzhead {
|
||||
char tzh_magic[4]; /* TZ_MAGIC */
|
||||
char tzh_version[1]; /* '\0' or '2' as of 2005 */
|
||||
char tzh_reserved[15]; /* reserved--must be zero */
|
||||
char tzh_ttisgmtcnt[4]; /* coded number of trans. time flags */
|
||||
char tzh_ttisstdcnt[4]; /* coded number of trans. time flags */
|
||||
char tzh_leapcnt[4]; /* coded number of leap seconds */
|
||||
char tzh_timecnt[4]; /* coded number of transition times */
|
||||
char tzh_typecnt[4]; /* coded number of local time types */
|
||||
char tzh_charcnt[4]; /* coded number of abbr. chars */
|
||||
};
|
||||
|
||||
/*
|
||||
** . . .followed by. . .
|
||||
**
|
||||
** tzh_timecnt (char [4])s coded transition times a la time(2)
|
||||
** tzh_timecnt (unsigned char)s types of local time starting at above
|
||||
** tzh_typecnt repetitions of
|
||||
** one (char [4]) coded UTC offset in seconds
|
||||
** one (unsigned char) used to set tm_isdst
|
||||
** one (unsigned char) that's an abbreviation list index
|
||||
** tzh_charcnt (char)s '\0'-terminated zone abbreviations
|
||||
** tzh_leapcnt repetitions of
|
||||
** one (char [4]) coded leap second transition times
|
||||
** one (char [4]) total correction after above
|
||||
** tzh_ttisstdcnt (char)s indexed by type; if TRUE, transition
|
||||
** time is standard time, if FALSE,
|
||||
** transition time is wall clock time
|
||||
** if absent, transition times are
|
||||
** assumed to be wall clock time
|
||||
** tzh_ttisgmtcnt (char)s indexed by type; if TRUE, transition
|
||||
** time is UTC, if FALSE,
|
||||
** transition time is local time
|
||||
** if absent, transition times are
|
||||
** assumed to be local time
|
||||
*/
|
||||
|
||||
/*
|
||||
** If tzh_version is '2' or greater, the above is followed by a second instance
|
||||
** of tzhead and a second instance of the data in which each coded transition
|
||||
** time uses 8 rather than 4 chars,
|
||||
** then a POSIX-TZ-environment-variable-style string for use in handling
|
||||
** instants after the last transition time stored in the file
|
||||
** (with nothing between the newlines if there is no POSIX representation for
|
||||
** such instants).
|
||||
*/
|
||||
|
||||
/*
|
||||
** In the current implementation, "tzset()" refuses to deal with files that
|
||||
** exceed any of the limits below.
|
||||
*/
|
||||
|
||||
#ifndef TZ_MAX_TIMES
|
||||
#define TZ_MAX_TIMES 1200
|
||||
#endif /* !defined TZ_MAX_TIMES */
|
||||
|
||||
#ifndef TZ_MAX_TYPES
|
||||
#ifndef NOSOLAR
|
||||
#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 */
|
||||
|
||||
#ifndef TZ_MAX_CHARS
|
||||
#define TZ_MAX_CHARS 50 /* Maximum number of abbreviation characters */
|
||||
/* (limited by what unsigned chars can hold) */
|
||||
#endif /* !defined TZ_MAX_CHARS */
|
||||
|
||||
#ifndef TZ_MAX_LEAPS
|
||||
#define TZ_MAX_LEAPS 50 /* Maximum number of leap second corrections */
|
||||
#endif /* !defined TZ_MAX_LEAPS */
|
||||
|
||||
#define SECSPERMIN 60
|
||||
#define MINSPERHOUR 60
|
||||
#define HOURSPERDAY 24
|
||||
#define DAYSPERWEEK 7
|
||||
#define DAYSPERNYEAR 365
|
||||
#define DAYSPERLYEAR 366
|
||||
#define SECSPERHOUR (SECSPERMIN * MINSPERHOUR)
|
||||
#define SECSPERDAY ((long) SECSPERHOUR * HOURSPERDAY)
|
||||
#define MONSPERYEAR 12
|
||||
|
||||
#define TM_SUNDAY 0
|
||||
#define TM_MONDAY 1
|
||||
#define TM_TUESDAY 2
|
||||
#define TM_WEDNESDAY 3
|
||||
#define TM_THURSDAY 4
|
||||
#define TM_FRIDAY 5
|
||||
#define TM_SATURDAY 6
|
||||
|
||||
#define TM_JANUARY 0
|
||||
#define TM_FEBRUARY 1
|
||||
#define TM_MARCH 2
|
||||
#define TM_APRIL 3
|
||||
#define TM_MAY 4
|
||||
#define TM_JUNE 5
|
||||
#define TM_JULY 6
|
||||
#define TM_AUGUST 7
|
||||
#define TM_SEPTEMBER 8
|
||||
#define TM_OCTOBER 9
|
||||
#define TM_NOVEMBER 10
|
||||
#define TM_DECEMBER 11
|
||||
|
||||
#define TM_YEAR_BASE 1900
|
||||
|
||||
#define EPOCH_YEAR 1970
|
||||
#define EPOCH_WDAY TM_THURSDAY
|
||||
|
||||
#define isleap(y) (((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0))
|
||||
|
||||
/*
|
||||
** Since everything in isleap is modulo 400 (or a factor of 400), we know that
|
||||
** isleap(y) == isleap(y % 400)
|
||||
** and so
|
||||
** isleap(a + b) == isleap((a + b) % 400)
|
||||
** or
|
||||
** isleap(a + b) == isleap(a % 400 + b % 400)
|
||||
** This is true even if % means modulo rather than Fortran remainder
|
||||
** (which is allowed by C89 but not C99).
|
||||
** We use this to avoid addition overflow problems.
|
||||
*/
|
||||
|
||||
#define isleap_sum(a, b) isleap((a) % 400 + (b) % 400)
|
||||
|
||||
#endif /* !defined TZFILE_H */
|
||||
Loading…
Reference in New Issue
Block a user