struct calendar {
uint16_t year; /* year (A.D.) */
uint16_t yearday; /* day of year, 1 = January 1 */
- uint8_t month; /* month, 1 = January */
- uint8_t monthday; /* day of month */
- uint8_t hour; /* hour of day, midnight = 0 */
- uint8_t minute; /* minute of hour */
- uint8_t second; /* second of minute */
- uint8_t weekday; /* 0..7, 0=Sunday */
+ uint8_t month; /* month, 1 = January */
+ uint8_t monthday; /* day of month */
+ uint8_t hour; /* hour of day, midnight = 0 */
+ uint8_t minute; /* minute of hour */
+ uint8_t second; /* second of minute */
+ uint8_t weekday; /* 0..7, 0=Sunday */
};
/* ISO week calendar date */
struct isodate {
- uint16_t year; /* year (A.D.) */
- uint8_t week; /* 1..53, week in year */
- uint8_t weekday; /* 1..7, 1=Monday */
- uint8_t hour; /* hour of day, midnight = 0 */
- uint8_t minute; /* minute of hour */
- uint8_t second; /* second of minute */
+ uint16_t year; /* year (A.D.) */
+ uint8_t week; /* 1..53, week in year */
+ uint8_t weekday; /* 1..7, 1=Monday */
+ uint8_t hour; /* hour of day, midnight = 0 */
+ uint8_t minute; /* minute of hour */
+ uint8_t second; /* second of minute */
};
/* general split representation */
typedef struct {
- int32 hi;
- int32 lo;
+ int32_t hi;
+ int32_t lo;
} ntpcal_split;
typedef time_t (*systime_func_ptr)(time_t*);
extern const char * const months[12];
extern const char * const daynames[7];
-extern void caljulian (u_int32, struct calendar *);
-extern u_int32 caltontp (const struct calendar *);
+extern void caljulian (uint32_t, struct calendar *);
+extern uint32_t caltontp (const struct calendar *);
/*
* Convert between 'time_t' and 'vint64'
* current system time.
*/
extern vint64
-ntpcal_ntp_to_time(u_int32 ntp, const time_t *pivot);
+ntpcal_ntp_to_time(uint32_t ntp, const time_t *pivot);
/*
* Convert a timestamp in NTP scale to a 64bit seconds value in the NTP
* Note: The pivot must be given in UN*X time scale!
*/
extern vint64
-ntpcal_ntp_to_ntp(u_int32 ntp, const time_t *pivot);
+ntpcal_ntp_to_ntp(uint32_t ntp, const time_t *pivot);
/*
* Split a time stamp in seconds into elapsed days and elapsed seconds
* expressed in 64 bits to avoid overflow.
*/
extern vint64
-ntpcal_dayjoin(int32 days, int32 seconds);
+ntpcal_dayjoin(int32_t days, int32_t seconds);
/*
* Convert elapsed years in Era into elapsed days in Era.
*/
-extern int32
-ntpcal_days_in_years(int32 years);
+extern int32_t
+ntpcal_days_in_years(int32_t years);
/*
* Convert a number of elapsed month in a year into elapsed days
* excess! But then, we need no leap year flag, either...)
*/
extern ntpcal_split
-ntpcal_days_in_months(int32 mons);
+ntpcal_days_in_months(int32_t months);
/*
* Convert ELAPSED years/months/days of gregorian calendar to elapsed
* days in Gregorian epoch. No range checks done here!
*/
-extern int32
-ntpcal_edate_to_eradays(int32 years, int32 mons, int32 mdays);
+extern int32_t
+ntpcal_edate_to_eradays(int32_t years, int32_t months, int32_t mdays);
/*
* Convert a time spec to seconds. No range checks done here!
*/
-extern int32
-ntpcal_etime_to_seconds(int32 hours, int32 minutes, int32 seconds);
+extern int32_t
+ntpcal_etime_to_seconds(int32_t hours, int32_t minutes, int32_t seconds);
/*
* Convert ELAPSED years/months/days of gregorian calendar to elapsed
* Note: This will give the true difference to the start of the given year,
* even if months & days are off-scale.
*/
-extern int32
-ntpcal_edate_to_yeardays(int32 years, int32 mons, int32 mdays);
+extern int32_t
+ntpcal_edate_to_yeardays(int32_t years, int32_t months, int32_t mdays);
/*
* Convert the date part of a 'struct tm' (that is, year, month,
* day-of-month) into the RataDie of that day.
*/
-extern int32
+extern int32_t
ntpcal_tm_to_rd(const struct tm *utm);
/*
* Convert the date part of a 'struct calendar' (that is, year, month,
* day-of-month) into the RataDie of that day.
*/
-extern int32
+extern int32_t
ntpcal_date_to_rd(const struct calendar *jt);
/*
* for regular years and a non-zero value for leap years.
*/
extern ntpcal_split
-ntpcal_split_eradays(int32 days, int *isleapyear);
+ntpcal_split_eradays(int32_t days, int/*BOOL*/ *isleapyear);
/*
* Given a number of elapsed days in a year and a leap year indicator,
* 'res.rem'.
*/
extern ntpcal_split
-ntpcal_split_yeardays(int32 eyd, int isleapyear);
+ntpcal_split_yeardays(int32_t eyd, int/*BOOL*/ isleapyear);
/*
* Convert a RataDie number into the date part of a 'struct
* calendar'. Return 0 if the year is regular year, !0 if the year is
* a leap year.
*/
-extern int
-ntpcal_rd_to_date(struct calendar *jt, int32 rd);
+extern int/*BOOL*/
+ntpcal_rd_to_date(struct calendar *jt, int32_t rd);
/*
* Convert a RataDie number into the date part of a 'struct
* tm'. Return 0 if the year is regular year, !0 if the year is a leap
* year.
*/
-extern int
-ntpcal_rd_to_tm(struct tm *utm, int32 rd);
+extern int/*BOOL*/
+ntpcal_rd_to_tm(struct tm *utm, int32_t rd);
/*
* Take a value of seconds since midnight and split it into hhmmss in
* a 'struct calendar'. Return excessive days.
*/
-extern int32
-ntpcal_daysec_to_date(struct calendar *jt, int32 secs);
+extern int32_t
+ntpcal_daysec_to_date(struct calendar *jt, int32_t secs);
/*
* Take the time part of a 'struct calendar' and return the seconds
* since midnight.
*/
-extern int32
+extern int32_t
ntpcal_date_to_daysec(const struct calendar*);
/*
* Take a value of seconds since midnight and split it into hhmmss in
* a 'struct tm'. Return excessive days.
*/
-extern int32
-ntpcal_daysec_to_tm(struct tm *utm, int32 secs);
+extern int32_t
+ntpcal_daysec_to_tm(struct tm *utm, int32_t secs);
-extern int32
+extern int32_t
ntpcal_tm_to_daysec(const struct tm *utm);
/*
* convert a year number to rata die of year start
*/
-extern int32
-ntpcal_year_to_ystart(int32 year);
+extern int32_t
+ntpcal_year_to_ystart(int32_t year);
/*
* For a given RataDie, get the RataDie of the associated year start,
* that is, the RataDie of the last January,1st on or before that day.
*/
-extern int32
-ntpcal_rd_to_ystart(int32 rd);
+extern int32_t
+ntpcal_rd_to_ystart(int32_t rd);
/*
* convert a RataDie to the RataDie of start of the calendar month.
*/
-extern int32
-ntpcal_rd_to_mstart(int32 year);
+extern int32_t
+ntpcal_rd_to_mstart(int32_t year);
extern int
ntpcal_daysplit_to_date(struct calendar *jt, const ntpcal_split *ds,
- int32 dof);
+ int32_t dof);
extern int
ntpcal_daysplit_to_tm(struct tm *utm, const ntpcal_split *ds,
- int32 dof);
+ int32_t dof);
extern int
ntpcal_time_to_date(struct calendar *jd, const vint64 *ts);
-extern int32
-ntpcal_periodic_extend(int32 pivot, int32 value, int32 cycle);
+extern int32_t
+ntpcal_periodic_extend(int32_t pivot, int32_t value, int32_t cycle);
extern int
-ntpcal_ntp_to_date(struct calendar *jd, u_int32 ntp, const time_t *pivot);
+ntpcal_ntp_to_date(struct calendar *jd, uint32_t ntp, const time_t *pivot);
-extern u_int32
+extern uint32_t
ntpcal_date_to_ntp(const struct calendar *jd);
extern time_t
/*
* ISO week-calendar conversions
*/
-extern int32
-isocal_weeks_in_years(int32 years);
+extern int32_t
+isocal_weeks_in_years(int32_t years);
extern ntpcal_split
-isocal_split_eraweeks(int32 weeks);
+isocal_split_eraweeks(int32_t weeks);
extern int
-isocal_ntp_to_date(struct isodate *id, u_int32 ntp, const time_t *pivot);
+isocal_ntp_to_date(struct isodate *id, uint32_t ntp, const time_t *pivot);
-extern u_int32
+extern uint32_t
isocal_date_to_ntp(const struct isodate *id);
* greater-or equal, closest, less-or-equal or less-than the given RDN
* and denotes the given day-of-week
*/
-extern int32
-ntpcal_weekday_gt(int32 rdn, int32 dow);
+extern int32_t
+ntpcal_weekday_gt(int32_t rdn, int32_t dow);
-extern int32
-ntpcal_weekday_ge(int32 rdn, int32 dow);
+extern int32_t
+ntpcal_weekday_ge(int32_t rdn, int32_t dow);
-extern int32
-ntpcal_weekday_close(int32 rdn, int32 dow);
+extern int32_t
+ntpcal_weekday_close(int32_t rdn, int32_t dow);
-extern int32
-ntpcal_weekday_le(int32 rdn, int32 dow);
+extern int32_t
+ntpcal_weekday_le(int32_t rdn, int32_t dow);
-extern int32
-ntpcal_weekday_lt(int32 rdn, int32 dow);
+extern int32_t
+ntpcal_weekday_lt(int32_t rdn, int32_t dow);
/*
* Additional support stuff for Ed Rheingold's calendrical calculations
void
caljulian(
- u_int32 ntp,
+ uint32_t ntp,
struct calendar * jt
)
{
* than 68 years off from the current time...
*/
-u_int32
+uint32_t
caltontp(
const struct calendar *jt
)
{
- int32 eraday; /* CE Rata Die number */
- vint64 ntptime; /* resulting NTP time */
+ int32_t eraday; /* CE Rata Die number */
+ vint64 ntptime;/* resulting NTP time */
NTP_INSIST(jt != NULL);
res.D_s.hi = 0;
if (tt < 0) {
- res.D_s.lo = (u_int32)-tt;
+ res.D_s.lo = (uint32_t)-tt;
M_NEG(res.D_s.hi, res.D_s.lo);
} else {
- res.D_s.lo = (u_int32)tt;
+ res.D_s.lo = (uint32_t)tt;
}
#elif defined(HAVE_INT64)
*/
if (tt < 0) {
tt = -tt;
- res.D_s.lo = (u_int32)tt;
- res.D_s.hi = (u_int32)(tt >> 32);
+ res.D_s.lo = (uint32_t)tt;
+ res.D_s.hi = (uint32_t)(tt >> 32);
M_NEG(res.D_s.hi, res.D_s.lo);
} else {
- res.D_s.lo = (u_int32)tt;
- res.D_s.hi = (u_int32)(tt >> 32);
+ res.D_s.lo = (uint32_t)tt;
+ res.D_s.hi = (uint32_t)(tt >> 32);
}
#endif
static const char mlist[] = "JanFebMarAprMayJunJulAugSepOctNovDec";
char monstr[4];
const char * cp;
- u_short hour, minute, second, month, day, year;
+ unsigned short hour, minute, second, day, year;
+ /* Note: The above quantities are used for sscanf 'hu' format,
+ * so using 'uint16_t' is contra-indicated!
+ */
ZERO(*jd);
jd->year = 1970;
&hour, &minute, &second, monstr, &day, &year)) {
cp = strstr(mlist, monstr);
if (NULL != cp) {
- month = (u_short)(cp - mlist) / 3 + 1;
jd->year = year;
- jd->month = (u_char)month;
- jd->monthday = (u_char)day;
- jd->hour = (u_char)hour;
- jd->minute = (u_char)minute;
- jd->second = (u_char)second;
+ jd->month = (uint8_t)((cp - mlist) / 3 + 1);
+ jd->monthday = (uint8_t)day;
+ jd->hour = (uint8_t)hour;
+ jd->minute = (uint8_t)minute;
+ jd->second = (uint8_t)second;
return TRUE;
}
*/
/* month table for a year starting with March,1st */
-static const u_short shift_month_table[13] = {
+static const uint16_t shift_month_table[13] = {
0, 31, 61, 92, 122, 153, 184, 214, 245, 275, 306, 337, 366
};
/* month tables for years starting with January,1st; regular & leap */
-static const u_short real_month_table[2][13] = {
+static const uint16_t real_month_table[2][13] = {
/* -*- table for regular years -*- */
{ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
/* -*- table for leap years -*- */
* are inherently target dependent. Nothing that could not be cured with
* autoconf, but still a mess...
*
- * Furhermore, we need floor division while C demands truncation to
+ * Furthermore, we need floor division while C demands truncation to
* zero, so additional steps are required to make sure the algorithms
* work.
*
* there is a joined div/mod operation: The optimiser should sort that
* out, if possible.
*
- * Furthermore, the functions do not check for overflow conditions. This
+ * Finally, the functions do not check for overflow conditions. This
* is a sacrifice made for execution speed; since a 32-bit day counter
* covers +/- 5,879,610 years, this should not pose a problem here.
*/
* require the 32-bit version a 64bit version is NOT provided here.
* ---------------------------------------------------------------------
*/
-int32
+int32_t
ntpcal_periodic_extend(
- int32 pivot,
- int32 value,
- int32 cycle
+ int32_t pivot,
+ int32_t value,
+ int32_t cycle
)
{
- u_int32 diff;
- char cpl = 0; /* modulo complement flag */
- char neg = 0; /* sign change flag */
+ uint32_t diff;
+ char cpl = 0; /* modulo complement flag */
+ char neg = 0; /* sign change flag */
/* make the cycle positive and adjust the flags */
if (cycle < 0) {
* complement machine!
*/
if (value >= pivot) {
- diff = (u_int32)value - (u_int32)pivot;
+ diff = (uint32_t)value - (uint32_t)pivot;
} else {
- diff = (u_int32)pivot - (u_int32)value;
+ diff = (uint32_t)pivot - (uint32_t)value;
cpl ^= 1;
}
- diff %= (u_int32)cycle;
+ diff %= (uint32_t)cycle;
if (diff) {
if (cpl)
diff = cycle - diff;
*/
vint64
ntpcal_ntp_to_time(
- u_int32 ntp,
+ uint32_t ntp,
const time_t * pivot
)
{
? *pivot
: now();
res.Q_s -= 0x80000000; /* unshift of half range */
- ntp -= (u_int32)JAN_1970; /* warp into UN*X domain */
+ ntp -= (uint32_t)JAN_1970; /* warp into UN*X domain */
ntp -= res.D_s.lo; /* cycle difference */
- res.Q_s += (u_int64)ntp; /* get expanded time */
+ res.Q_s += (uint64_t)ntp; /* get expanded time */
#else /* no 64bit scalars */
: now();
res = time_to_vint64(&tmp);
M_SUB(res.D_s.hi, res.D_s.lo, 0, 0x80000000);
- ntp -= (u_int32)JAN_1970; /* warp into UN*X domain */
+ ntp -= (uint32_t)JAN_1970; /* warp into UN*X domain */
ntp -= res.D_s.lo; /* cycle difference */
M_ADD(res.D_s.hi, res.D_s.lo, 0, ntp);
*/
vint64
ntpcal_ntp_to_ntp(
- u_int32 ntp,
+ uint32_t ntp,
const time_t *pivot
)
{
? *pivot
: now();
res.Q_s -= 0x80000000; /* unshift of half range */
- res.Q_s += (u_int32)JAN_1970; /* warp into NTP domain */
+ res.Q_s += (uint32_t)JAN_1970; /* warp into NTP domain */
ntp -= res.D_s.lo; /* cycle difference */
- res.Q_s += (u_int64)ntp; /* get expanded time */
+ res.Q_s += (uint64_t)ntp; /* get expanded time */
#else /* no 64bit scalars */
: now();
res = time_to_vint64(&tmp);
M_SUB(res.D_s.hi, res.D_s.lo, 0, 0x80000000u);
- M_ADD(res.D_s.hi, res.D_s.lo, 0, (u_int32)JAN_1970);/*into NTP */
+ M_ADD(res.D_s.hi, res.D_s.lo, 0, (uint32_t)JAN_1970);/*into NTP */
ntp -= res.D_s.lo; /* cycle difference */
M_ADD(res.D_s.hi, res.D_s.lo, 0, ntp);
#ifdef HAVE_INT64
/* manual floor division by SECSPERDAY */
- res.hi = (int32)(ts->q_s / SECSPERDAY);
- res.lo = (int32)(ts->q_s % SECSPERDAY);
+ res.hi = (int32_t)(ts->q_s / SECSPERDAY);
+ res.lo = (int32_t)(ts->q_s % SECSPERDAY);
if (res.lo < 0) {
res.hi -= 1;
res.lo += SECSPERDAY;
* Luckily SECSPERDAY is 86400 is 675*128, so we do the division
* using chained 32/16 bit divisions and shifts.
*/
- vint64 op;
- u_int32 q, r, a;
- int isneg;
+ vint64 op;
+ uint32_t q, r, a;
+ int isneg;
memcpy(&op, ts, sizeof(op));
/* fix sign */
/* now do a mnual division, trying to remove as many ops as
* possible -- division is always slow! An since we do not have
- * the advantage of a specic 64/32 bit or even a specific 32/16
- * bit division op but must use the general 32/32bit division
- * even if we *know* the divider fits into unsigned 16 bits the
+ * the advantage of a specific 64/32 bit or even a specific 32/16
+ * bit division op, but must use the general 32/32bit division
+ * even if we *know* the divider fits into unsigned 16 bits, the
* exra code pathes should pay off.
*/
a = op.D_s.hi;
* midnight.
* -------------------------------------------------------------------
*/
-static int32
+static int32_t
priv_timesplit(
- int split[3],
- int32 ts
+ int32_t split[3],
+ int32_t ts
)
{
- int32 days = 0;
+ int32_t days = 0;
/* make sure we have a positive offset into a day */
if (ts < 0 || ts >= SECSPERDAY) {
}
/* get secs, mins, hours */
- split[2] = (u_char)(ts % SECSPERMIN);
+ split[2] = (uint8_t)(ts % SECSPERMIN);
ts /= SECSPERMIN;
- split[1] = (u_char)(ts % MINSPERHR);
- split[0] = (u_char)(ts / MINSPERHR);
+ split[1] = (uint8_t)(ts % MINSPERHR);
+ split[0] = (uint8_t)(ts / MINSPERHR);
return days;
}
*/
ntpcal_split
ntpcal_split_eradays(
- int32 days,
+ int32_t days,
int *isleapyear
)
{
ntpcal_split res;
- int32 n400, n100, n004, n001, yday; /* calendar year cycles */
+ int32_t n400, n100, n004, n001, yday; /* calendar year cycles */
/*
* Split off calendar cycles, using floor division in the first
*/
ntpcal_split
ntpcal_split_yeardays(
- int32 eyd,
- int isleapyear
+ int32_t eyd,
+ int isleapyear
)
{
- ntpcal_split res;
- const u_short *lt; /* month length table */
+ ntpcal_split res;
+ const uint16_t *lt; /* month length table */
/* check leap year flag and select proper table */
lt = real_month_table[(isleapyear != 0)];
int
ntpcal_rd_to_date(
struct calendar *jd,
- int32 rd
+ int32_t rd
)
{
ntpcal_split split;
split = ntpcal_split_eradays(rd - 1, &leaps);
retv = leaps;
/* get year and day-of-year */
- jd->year = (u_short)split.hi + 1;
+ jd->year = (uint16_t)split.hi + 1;
if (jd->year != split.hi + 1) {
jd->year = 0;
retv = -1; /* bletch. overflow trouble. */
}
- jd->yearday = (u_short)split.lo + 1;
+ jd->yearday = (uint16_t)split.lo + 1;
/* convert to month and mday */
split = ntpcal_split_yeardays(split.lo, leaps);
- jd->month = (u_char)split.hi + 1;
- jd->monthday = (u_char)split.lo + 1;
+ jd->month = (uint8_t)split.hi + 1;
+ jd->monthday = (uint8_t)split.lo + 1;
return retv ? retv : leaps;
}
int
ntpcal_rd_to_tm(
struct tm *utm,
- int32 rd
+ int32_t rd
)
{
ntpcal_split split;
* 'struct calendar'.
*---------------------------------------------------------------------
*/
-int32
+int32_t
ntpcal_daysec_to_date(
struct calendar *jd,
- int32 sec
+ int32_t sec
)
{
- int32 days;
+ int32_t days;
int ts[3];
days = priv_timesplit(ts, sec);
- jd->hour = (u_char)ts[0];
- jd->minute = (u_char)ts[1];
- jd->second = (u_char)ts[2];
+ jd->hour = (uint8_t)ts[0];
+ jd->minute = (uint8_t)ts[1];
+ jd->second = (uint8_t)ts[2];
return days;
}
* 'struct tm'.
*---------------------------------------------------------------------
*/
-int32
+int32_t
ntpcal_daysec_to_tm(
struct tm *utm,
- int32 sec
+ int32_t sec
)
{
- int32 days;
- int ts[3];
+ int32_t days;
+ int32_t ts[3];
days = priv_timesplit(ts, sec);
utm->tm_hour = ts[0];
ntpcal_daysplit_to_date(
struct calendar *jd,
const ntpcal_split *ds,
- int32 dof
+ int32_t dof
)
{
dof += ntpcal_daysec_to_date(jd, ds->lo);
ntpcal_daysplit_to_tm(
struct tm *utm,
const ntpcal_split *ds ,
- int32 dof
+ int32_t dof
)
{
dof += ntpcal_daysec_to_tm(utm, ds->lo);
*/
vint64
ntpcal_dayjoin(
- int32 days,
- int32 secs
+ int32_t days,
+ int32_t secs
)
{
vint64 res;
#else
- u_int32 p1, p2;
- int isneg;
+ uint32_t p1, p2;
+ int isneg;
/*
* res = days *86400 + secs, using manual 16/32 bit
/* properly add seconds */
p2 = 0;
if (secs < 0) {
- p1 = (u_int32)-secs;
+ p1 = (uint32_t)-secs;
M_NEG(p2, p1);
} else {
- p1 = (u_int32)secs;
+ p1 = (uint32_t)secs;
}
M_ADD(res.D_s.hi, res.D_s.lo, p2, p1);
* can be regular truncated divisions.
*---------------------------------------------------------------------
*/
-int32
+int32_t
ntpcal_days_in_years(
- int32 years
+ int32_t years
)
{
- int32 cycle; /* full gregorian cycle */
+ int32_t cycle; /* full gregorian cycle */
/* split off full calendar cycles, using floor division */
cycle = years / 400;
*/
ntpcal_split
ntpcal_days_in_months(
- int32 m
+ int32_t m
)
{
ntpcal_split res;
* zero.
*---------------------------------------------------------------------
*/
-int32
+int32_t
ntpcal_edate_to_eradays(
- int32 years,
- int32 mons,
- int32 mdays
+ int32_t years,
+ int32_t mons,
+ int32_t mdays
)
{
ntpcal_split tmp;
- int32 res;
+ int32_t res;
if (mons) {
tmp = ntpcal_days_in_months(mons);
* even if months & days are off-scale.
*---------------------------------------------------------------------
*/
-int32
+int32_t
ntpcal_edate_to_yeardays(
- int32 years,
- int32 mons,
- int32 mdays
+ int32_t years,
+ int32_t mons,
+ int32_t mdays
)
{
ntpcal_split tmp;
* single leapsecond.
*---------------------------------------------------------------------
*/
-int32
+int32_t
ntpcal_etime_to_seconds(
- int32 hours,
- int32 minutes,
- int32 seconds
+ int32_t hours,
+ int32_t minutes,
+ int32_t seconds
)
{
- int32 res;
+ int32_t res;
res = (hours * MINSPERHR + minutes) * SECSPERMIN + seconds;
* day-of-month) into the RD of that day.
*---------------------------------------------------------------------
*/
-int32
+int32_t
ntpcal_tm_to_rd(
const struct tm *utm
)
* day-of-month) into the RD of that day.
*---------------------------------------------------------------------
*/
-int32
+int32_t
ntpcal_date_to_rd(
const struct calendar *jd
)
{
- return ntpcal_edate_to_eradays((int32)jd->year - 1,
- (int32)jd->month - 1,
- (int32)jd->monthday - 1) + 1;
+ return ntpcal_edate_to_eradays((int32_t)jd->year - 1,
+ (int32_t)jd->month - 1,
+ (int32_t)jd->monthday - 1) + 1;
}
/*
* convert a year number to rata die of year start
*---------------------------------------------------------------------
*/
-int32
+int32_t
ntpcal_year_to_ystart(
- int32 year
+ int32_t year
)
{
return ntpcal_days_in_years(year - 1) + 1;
* that is, the RD of the last January,1st on or before that day.
*---------------------------------------------------------------------
*/
-int32
+int32_t
ntpcal_rd_to_ystart(
- int32 rd
+ int32_t rd
)
{
/*
* For a given RD, get the RD of the associated month start.
*---------------------------------------------------------------------
*/
-int32
+int32_t
ntpcal_rd_to_mstart(
- int32 rd
+ int32_t rd
)
{
ntpcal_split split;
* take a 'struct calendar' and get the seconds-of-day from it.
*---------------------------------------------------------------------
*/
-int32
+int32_t
ntpcal_date_to_daysec(
const struct calendar *jd
)
* take a 'struct tm' and get the seconds-of-day from it.
*---------------------------------------------------------------------
*/
-int32
+int32_t
ntpcal_tm_to_daysec(
const struct tm *utm
)
const struct calendar *jd
)
{
- vint64 join;
- int32 days, secs;
+ vint64 join;
+ int32_t days, secs;
days = ntpcal_date_to_rd(jd) - DAY_UNIX_STARTS;
secs = ntpcal_date_to_daysec(jd);
/*
* ==================================================================
*
- * extended and uncecked variants of caljulian/caltontp
+ * extended and unchecked variants of caljulian/caltontp
*
* ==================================================================
*/
int
ntpcal_ntp_to_date(
struct calendar *jd,
- u_int32 ntp,
+ uint32_t ntp,
const time_t *piv
)
{
}
-u_int32
+uint32_t
ntpcal_date_to_ntp(
const struct calendar *jd
)
* greater-or equal, closest, less-or-equal or less-than the given RDN
* and denotes the given day-of-week
*/
-int32
+int32_t
ntpcal_weekday_gt(
- int32 rdn,
- int32 dow
+ int32_t rdn,
+ int32_t dow
)
{
return ntpcal_periodic_extend(rdn+1, dow, 7);
}
-int32
+int32_t
ntpcal_weekday_ge(
- int32 rdn,
- int32 dow
+ int32_t rdn,
+ int32_t dow
)
{
return ntpcal_periodic_extend(rdn, dow, 7);
}
-int32
+int32_t
ntpcal_weekday_close(
- int32 rdn,
- int32 dow
+ int32_t rdn,
+ int32_t dow
)
{
return ntpcal_periodic_extend(rdn-3, dow, 7);
}
-int32
+int32_t
ntpcal_weekday_le(
- int32 rdn,
- int32 dow
+ int32_t rdn,
+ int32_t dow
)
{
return ntpcal_periodic_extend(rdn, dow, -7);
}
-int32
+int32_t
ntpcal_weekday_lt(
- int32 rdn,
- int32 dow
+ int32_t rdn,
+ int32_t dow
)
{
return ntpcal_periodic_extend(rdn-1, dow, -7);
* christian era, return the number of elapsed weeks corresponding to
* the number of years.
*/
-int32
+int32_t
isocal_weeks_in_years(
- int32 years
+ int32_t years
)
{
/*
* use: w = (y * 53431 + b[c]) / 1024 as interpolation
*/
- static const int32 bctab[4] = { 449, 157, 889, 597 };
- int32 cycle; /* full gregorian cycle */
- int32 cents; /* full centuries */
- int32 weeks; /* accumulated weeks */
+ static const int32_t bctab[4] = { 449, 157, 889, 597 };
+ int32_t cycle; /* full gregorian cycle */
+ int32_t cents; /* full centuries */
+ int32_t weeks; /* accumulated weeks */
/* split off full calendar cycles, using floor division */
cycle = years / 400;
*/
ntpcal_split
isocal_split_eraweeks(
- int32 weeks
+ int32_t weeks
)
{
/*
* use: y = (w * 157 + b[c]) / 8192 as interpolation
*/
- static const int32 bctab[4] = { 85, 131, 17, 62 };
+ static const int32_t bctab[4] = { 85, 131, 17, 62 };
ntpcal_split res;
- int32 cents;
+ int32_t cents;
/*
* split off 400-year cycles, using the fact that a 400-year
int
isocal_ntp_to_date(
struct isodate *id,
- u_int32 ntp,
+ uint32_t ntp,
const time_t *piv
)
{
vint64 vl;
ntpcal_split ds;
- int ts[3];
+ int32_t ts[3];
/*
* Unfold ntp time around current time into NTP domain. Split
/* split time part */
ds.hi += priv_timesplit(ts, ds.lo);
- id->hour = (u_char)ts[0];
- id->minute = (u_char)ts[1];
- id->second = (u_char)ts[2];
+ id->hour = (uint8_t)ts[0];
+ id->minute = (uint8_t)ts[1];
+ id->second = (uint8_t)ts[2];
/* split date part */
ds.lo = ds.hi + DAY_NTP_STARTS - 1; /* elapsed era days */
ds.hi -= 1;
ds.lo += 7;
}
- id->weekday = (u_char)ds.lo + 1; /* weekday result */
+ id->weekday = (uint8_t)ds.lo + 1; /* weekday result */
ds = isocal_split_eraweeks(ds.hi); /* elapsed years&week*/
- id->year = (u_short)ds.hi + 1; /* shift to current */
- id->week = (u_char)ds.lo + 1;
+ id->year = (uint16_t)ds.hi + 1; /* shift to current */
+ id->week = (uint8_t )ds.lo + 1;
return (ds.hi >= 0 && ds.hi < 0xFFFFU);
}
* Convert a ISO date spec into a second in the NTP time scale,
* properly truncated to 32 bit.
*/
-u_int32
+uint32_t
isocal_date_to_ntp(
const struct isodate *id
)
{
- int32 weeks, days, secs;
+ int32_t weeks, days, secs;
- weeks = isocal_weeks_in_years((int32)id->year - 1)
- + (int32)id->week - 1;
- days = weeks * 7 + (int32)id->weekday;
+ weeks = isocal_weeks_in_years((int32_t)id->year - 1)
+ + (int32_t)id->week - 1;
+ days = weeks * 7 + (int32_t)id->weekday;
/* days is RDN of ISO date now */
secs = ntpcal_etime_to_seconds(id->hour, id->minute, id->second);
#if defined(_MSC_VER)
# define MISSING_INTTYPES_H 1 /* not provided by VS2012 and earlier */
# define MISSING_STDBOOL_H 1 /* not provided by VS2012 and earlier */
-# if _MSC_VER < 1600
-# define MISSING_STDINT_H 1 /* not provided before VS2010 */
-# endif
#else
/* add defines for non-MS compilers here, if required */
#endif
#if !defined(MISSING_INTTYPES_H)
# define HAVE_INTTYPES_H 1
-# include <inttypes.h>
#elif !defined(MISSING_STDINT_H)
# define HAVE_STDINT_H 1
-# include <stdint.h>
#elif !defined(ADDED_EXACT_SIZE_INTEGERS)
# define ADDED_EXACT_SIZE_INTEGERS 1
typedef __int8 int8_t;
--- /dev/null
+/*
+ * stdint_msvc.h - C99 integer types for older Visual C compilers
+ *
+ * Written by Juergen Perlinger (perlinger@ntp.org) for the NTP project.
+ * The contents of 'html/copyright.html' apply.
+ *
+ * ----------------------------------------------------------------------
+ *
+ * Fairly straight forward implementation of the C99 standard integer
+ * types.
+ */
+
+#ifndef __STDINT_INCLUDED
+#define __STDINT_INCLUDED
+
+#if !defined(_MSC_VER) || _MSC_VER >= 1600
+# error Use only with MSVC6 - MSVC9
+#endif
+
+#include <crtdefs.h>
+#include <limits.h>
+
+/* ---------------------------------------------------------------------
+ * We declare the min/max values, using the MSVC syntax for literals of
+ * a given bit width.
+ */
+
+#define _VC_SI_LIT(lit,wbit) (lit ## i ## wbit)
+#define _VC_UI_LIT(lit,wbit) (lit ## ui ## wbit)
+
+/* ---------------------------------------------------------------------
+ * Exact width integer types
+ */
+typedef __int8 int8_t;
+typedef __int16 int16_t;
+typedef __int32 int32_t;
+typedef __int64 int64_t;
+
+typedef unsigned __int8 uint8_t;
+typedef unsigned __int16 uint16_t;
+typedef unsigned __int32 uint32_t;
+typedef unsigned __int64 uint64_t;
+
+#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS)
+# define INT8_MIN _I8_MIN
+# define INT8_MAX _I8_MAX
+# define UINT8_MAX _UI8_MAX
+# define INT16_MIN _I16_MIN
+# define INT16_MAX _I16_MAX
+# define UINT16_MAX _UI16_MAX
+# define INT32_MIN _I32_MIN
+# define INT32_MAX _I32_MAX
+# define UINT32_MAX _UI32_MAX
+# define INT64_MIN _I64_MIN
+# define INT64_MAX _I64_MAX
+# define UINT64_MAX _UI64_MAX
+#endif
+
+/* ---------------------------------------------------------------------
+ * Least-size integers
+ *
+ * These are mapped to exact size.
+ */
+typedef __int8 int_least8_t;
+typedef __int16 int_least16_t;
+typedef __int32 int_least32_t;
+typedef __int64 int_least64_t;
+
+typedef unsigned __int8 uint_least8_t;
+typedef unsigned __int16 uint_least16_t;
+typedef unsigned __int32 uint_least32_t;
+typedef unsigned __int64 uint_least64_t;
+
+#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS)
+#define INT_LEAST8_MIN _I8_MIN
+#define INT_LEAST8_MAX _I8_MAX
+#define UINT_LEAST8_MAX _UI8_MAX
+#define INT_LEAST16_MIN _I16_MIN
+#define INT_LEAST16_MAX _I16_MAX
+#define UINT_LEAST16_MAX _UI16_MAX
+#define INT_LEAST32_MIN _I32_MIN
+#define INT_LEAST32_MAX _I32_MAX
+#define UINT_LEAST32_MAX _UI32_MAX
+#define INT_LEAST64_MIN _I64_MIN
+#define INT_LEAST64_MAX _I64_MAX
+#define UINT_LEAST64_MAX _UI64_MAX
+#endif
+
+/* ---------------------------------------------------------------------
+ * least-size, fastest integer
+ *
+ * The 'FAST' types are all 32 bits, except the 64 bit quantity; as the
+ * natural register width is 32 bits, quantities of that size are fastest
+ * to operate on naturally. (This even holds for the x86_64; MSVC uses
+ * the 'llp64' model.
+ */
+typedef __int32 int_fast8_t;
+typedef __int32 int_fast16_t;
+typedef __int32 int_fast32_t;
+typedef __int64 int_fast64_t;
+
+typedef unsigned __int32 uint_fast8_t;
+typedef unsigned __int32 uint_fast16_t;
+typedef unsigned __int32 uint_fast32_t;
+typedef unsigned __int64 uint_fast64_t;
+
+#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS)
+#define INT_FAST8_MIN _I32_MIN
+#define INT_FAST8_MAX _I32_MAX
+#define UINT_FAST8_MAX _UI32_MAX
+#define INT_FAST16_MIN _I32_MIN
+#define INT_FAST16_MAX _I32_MAX
+#define UINT_FAST16_MAX _UI32_MAX
+#define INT_FAST32_MIN _I32_MIN
+#define INT_FAST32_MAX _I32_MAX
+#define UINT_FAST32_MAX _UI32_MAX
+#define INT_FAST64_MIN _I64_MIN
+#define INT_FAST64_MAX _I64_MAX
+#define UINT_FAST64_MAX _UI64_MAX
+#endif
+
+/* ---------------------------------------------------------------------
+ * The (u)intptr_t, ptrdiff_t and size_t definitions depend on the
+ * target: 32bit for x86, and 64bit for x64, aka amd64. Well, we
+ * have to bite the bullet.
+ */
+
+/* ------------------------------------------------------------------ */
+# if defined(_WIN64) || defined(WIN64)
+/* ------------------------------------------------------------------ */
+
+# ifndef _INTPTR_T_DEFINED
+# define _INTPTR_T_DEFINED
+ typedef __int64 intptr_t;
+# endif
+
+# ifndef _UINTPTR_T_DEFINED
+# define _UINTPTR_T_DEFINED
+ typedef unsigned __int64 uintptr_t;
+# endif
+
+# ifndef _PTRDIFF_T_DEFINED
+# define _PTRDIFF_T_DEFINED
+ typedef __int64 ptrdiff_t;
+# endif
+
+# if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS)
+# ifndef INTPTR_MIN
+# define INTPTR_MIN _I64_MIN
+# endif
+# ifndef INTPTR_MAX
+# define INTPTR_MAX _I64_MAX
+# endif
+# ifndef UINTPTR_MAX
+# define UINTPTR_MAX _UI64_MAX
+# endif
+# ifndef PTRDIFF_MIN
+# define PTRDIFF_MIN _I64_MIN
+# endif
+# ifndef PTRDIFF_MAX
+# define PTRDIFF_MAX _I64_MAX
+# endif
+# endif
+
+/* ------------------------------------------------------------------ */
+#else /* 32 bit target assumed here! */
+/* ------------------------------------------------------------------ */
+
+# ifndef _INTPTR_T_DEFINED
+# define _INTPTR_T_DEFINED
+ typedef __int32 intptr_t;
+# endif
+
+# ifndef _UINTPTR_T_DEFINED
+# define _UINTPTR_T_DEFINED
+ typedef unsigned __int32 uintptr_t;
+# endif
+
+# ifndef _PTRDIFF_T_DEFINED
+# define _PTRDIFF_T_DEFINED
+ typedef __int64 ptrdiff_t;
+# endif
+
+# if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS)
+# ifndef INTPTR_MIN
+# define INTPTR_MIN _I32_MIN
+# endif
+# ifndef INTPTR_MAX
+# define INTPTR_MAX _I32_MAX
+# endif
+# ifndef UINTPTR_MAX
+# define UINTPTR_MAX _UI32_MAX
+# endif
+# ifndef PTRDIFF_MIN
+# define PTRDIFF_MIN _I32_MIN
+# endif
+# ifndef PTRDIFF_MAX
+# define PTRDIFF_MAX _I32_MAX
+# endif
+# endif
+#endif /* platform dependent stuff */
+
+
+/* ---------------------------------------------------------------------
+ * max integer is 64-bit integer
+ */
+typedef __int64 intmax_t;
+typedef unsigned __int64 uintmax_t;
+
+#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS)
+# define INTMAX_MIN _I64_MIN
+# define INTMAX_MAX _I64_MAX
+# define UINTMAX_MAX _UI64_MAX
+#endif
+
+/* ---------------------------------------------------------------------
+ * limit for size_t (older MSVC versions lack that one)
+ */
+#if _MSC_VER <=1200
+# if defined(_WIN64) || defined(WIN64)
+# define SIZE_MAX _UI64_MAX
+#else
+# define SIZE_MAX _UI32_MAX
+# endif
+#endif
+
+/* ---------------------------------------------------------------------
+ * construct numerical literals with precise size
+ */
+#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS)
+# define INT8_C(lit) _VC_SI_LIT(lit,8)
+# define UINT8_C(lit) _VC_UI_LIT(lit,8)
+# define INT16_C(lit) _VC_SI_LIT(lit,16)
+# define UINT16_C(lit) _VC_UI_LIT(lit,16)
+# define INT32_C(lit) _VC_SI_LIT(lit,32)
+# define UINT32_C(lit) _VC_UI_LIT(lit,32)
+# define INT64_C(lit) _VC_SI_LIT(lit,64)
+# define UINT64_C(lit) _VC_UI_LIT(lit,64)
+# define INTMAX_C(lit) _VC_SI_LIT(lit,64)
+# define UINTMAX_C(lit) _VC_UI_LIT(lit,64)
+#endif
+
+#endif
+/**** EOF ****/
projects / thirdparty / ntp.git / commitdiff
