/src/ntp-dev/libntp/ntp_calendar.c

Source (jump to first uncovered line)
/*
 * ntp_calendar.c - calendar and helper functions
 *
 * Written by Juergen Perlinger (perlinger@ntp.org) for the NTP project.
 * The contents of 'html/copyright.html' apply.
 *
 * --------------------------------------------------------------------
 * Some notes on the implementation:
 *
 * Calendar algorithms thrive on the division operation, which is one of
 * the slowest numerical operations in any CPU. What saves us here from
 * abysmal performance is the fact that all divisions are divisions by
 * constant numbers, and most compilers can do this by a multiplication
 * operation.  But this might not work when using the div/ldiv/lldiv
 * function family, because many compilers are not able to do inline
 * expansion of the code with following optimisation for the
 * constant-divider case.
 *
 * Also div/ldiv/lldiv are defined in terms of int/long/longlong, which
 * are inherently target dependent. Nothing that could not be cured with
 * autoconf, but still a mess...
 *
 * Furthermore, we need floor division in many places. C either leaves
 * the division behaviour undefined (< C99) or demands truncation to
 * zero (>= C99), so additional steps are required to make sure the
 * algorithms work. The {l,ll}div function family is requested to
 * truncate towards zero, which is also the wrong direction for our
 * purpose.
 *
 * For all this, all divisions by constant are coded manually, even when
 * there is a joined div/mod operation: The optimiser should sort that
 * out, if possible. Most of the calculations are done with unsigned
 * types, explicitely using two's complement arithmetics where
 * necessary. This minimises the dependecies to compiler and target,
 * while still giving reasonable to good performance.
 *
 * The implementation uses a few tricks that exploit properties of the
 * two's complement: Floor division on negative dividents can be
 * executed by using the one's complement of the divident. One's
 * complement can be easily created using XOR and a mask.
 *
 * Finally, check for overflow conditions is minimal. There are only two
 * calculation steps in the whole calendar that suffer from an internal
 * overflow, and these conditions are checked: errno is set to EDOM and
 * the results are clamped/saturated in this case.  All other functions
 * do not suffer from internal overflow and simply return the result
 * truncated to 32 bits.
 *
 * This is a sacrifice made for execution speed.  Since a 32-bit day
 * counter covers +/- 5,879,610 years and the clamp limits the effective
 * range to +/-2.9 million years, this should not pose a problem here.
 *
 */

#include <config.h>
#include <sys/types.h>

#include "ntp_types.h"
#include "ntp_calendar.h"
#include "ntp_stdlib.h"
#include "ntp_fp.h"
#include "ntp_unixtime.h"

/* For now, let's take the conservative approach: if the target property
 * macros are not defined, check a few well-known compiler/architecture
 * settings. Default is to assume that the representation of signed
 * integers is unknown and shift-arithmetic-right is not available.
 */
#ifndef TARGET_HAS_2CPL
# if defined(__GNUC__)
#  if defined(__i386__) || defined(__x86_64__) || defined(__arm__)
#   define TARGET_HAS_2CPL 1
#  else
#   define TARGET_HAS_2CPL 0
#  endif
# elif defined(_MSC_VER)
#  if defined(_M_IX86) || defined(_M_X64) || defined(_M_ARM)
#   define TARGET_HAS_2CPL 1
#  else
#   define TARGET_HAS_2CPL 0
#  endif
# else
#  define TARGET_HAS_2CPL 0
# endif
#endif

#ifndef TARGET_HAS_SAR
# define TARGET_HAS_SAR 0
#endif

/*
 *---------------------------------------------------------------------
 * replacing the 'time()' function
 *---------------------------------------------------------------------
 */

static systime_func_ptr systime_func = &time;
static inline time_t now(void);


systime_func_ptr
ntpcal_set_timefunc(
  systime_func_ptr nfunc
  )
{
  systime_func_ptr res;

  res = systime_func;
  if (NULL == nfunc)
    nfunc = &time;
  systime_func = nfunc;

  return res;
}


static inline time_t
now(void)
{
  return (*systime_func)(NULL);
}

/*
 *---------------------------------------------------------------------
 * Get sign extension mask and unsigned 2cpl rep for a signed integer
 *---------------------------------------------------------------------
 */

static inline uint32_t
int32_sflag(
  const int32_t v)
{
#   if TARGET_HAS_2CPL && TARGET_HAS_SAR && SIZEOF_INT >= 4

  /* Let's assume that shift is the fastest way to get the sign
   * extension of of a signed integer. This might not always be
   * true, though -- On 8bit CPUs or machines without barrel
   * shifter this will kill the performance. So we make sure
   * we do this only if 'int' has at least 4 bytes.
   */
  return (uint32_t)(v >> 31);
  
#   else

  /* This should be a rather generic approach for getting a sign
   * extension mask...
   */
  return UINT32_C(0) - (uint32_t)(v < 0);
  
#   endif
}

static inline uint32_t
int32_to_uint32_2cpl(
  const int32_t v)
{
  uint32_t vu;
  
#   if TARGET_HAS_2CPL

  /* Just copy through the 32 bits from the signed value if we're
   * on a two's complement target.
   */
  vu = (uint32_t)v;
  
#   else

  /* Convert from signed int to unsigned int two's complement. Do
   * not make any assumptions about the representation of signed
   * integers, but make sure signed integer overflow cannot happen
   * here. A compiler on a two's complement target *might* find
   * out that this is just a complicated cast (as above), but your
   * mileage might vary.
   */
  if (v < 0)
    vu = ~(uint32_t)(-(v + 1));
  else
    vu = (uint32_t)v;
  
#   endif
  
  return vu;
}

static inline int32_t
uint32_2cpl_to_int32(
  const uint32_t vu)
{
  int32_t v;
  
#   if TARGET_HAS_2CPL

  /* Just copy through the 32 bits from the unsigned value if
   * we're on a two's complement target.
   */
  v = (int32_t)vu;

#   else

  /* Convert to signed integer, making sure signed integer
   * overflow cannot happen. Again, the optimiser might or might
   * not find out that this is just a copy of 32 bits on a target
   * with two's complement representation for signed integers.
   */
  if (vu > INT32_MAX)
    v = -(int32_t)(~vu) - 1;
  else
    v = (int32_t)vu;
  
#   endif
  
  return v;
}

/* Some of the calculations need to multiply the input by 4 before doing
 * a division. This can cause overflow and strange results. Therefore we
 * clamp / saturate the input operand. And since we do the calculations
 * in unsigned int with an extra sign flag/mask, we only loose one bit
 * of the input value range.
 */
static inline uint32_t
uint32_saturate(
  uint32_t vu,
  uint32_t mu)
{
  static const uint32_t limit = UINT32_MAX/4u;
  if ((mu ^ vu) > limit) {
    vu    = mu ^ limit;
    errno = EDOM;
  }
  return vu;
}

/*
 *---------------------------------------------------------------------
 * Convert between 'time_t' and 'vint64'
 *---------------------------------------------------------------------
 */
vint64
time_to_vint64(
  const time_t * ptt
  )
{
  vint64 res;
  time_t tt;

  tt = *ptt;

#   if SIZEOF_TIME_T <= 4

  res.D_s.hi = 0;
  if (tt < 0) {
    res.D_s.lo = (uint32_t)-tt;
    M_NEG(res.D_s.hi, res.D_s.lo);
  } else {
    res.D_s.lo = (uint32_t)tt;
  }

#   elif defined(HAVE_INT64)

  res.q_s = tt;

#   else
  /*
   * shifting negative signed quantities is compiler-dependent, so
   * we better avoid it and do it all manually. And shifting more
   * than the width of a quantity is undefined. Also a don't do!
   */
  if (tt < 0) {
    tt = -tt;
    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 = (uint32_t)tt;
    res.D_s.hi = (uint32_t)(tt >> 32);
  }

#   endif

  return res;
}


time_t
vint64_to_time(
  const vint64 *tv
  )
{
  time_t res;

#   if SIZEOF_TIME_T <= 4

  res = (time_t)tv->D_s.lo;

#   elif defined(HAVE_INT64)

  res = (time_t)tv->q_s;

#   else

  res = ((time_t)tv->d_s.hi << 32) | tv->D_s.lo;

#   endif

  return res;
}

/*
 *---------------------------------------------------------------------
 * Get the build date & time
 *---------------------------------------------------------------------
 */
int
ntpcal_get_build_date(
  struct calendar * jd
  )
{
  /* The C standard tells us the format of '__DATE__':
   *
   * __DATE__ The date of translation of the preprocessing
   * translation unit: a character string literal of the form "Mmm
   * dd yyyy", where the names of the months are the same as those
   * generated by the asctime function, and the first character of
   * dd is a space character if the value is less than 10. If the
   * date of translation is not available, an
   * implementation-defined valid date shall be supplied.
   *
   * __TIME__ The time of translation of the preprocessing
   * translation unit: a character string literal of the form
   * "hh:mm:ss" as in the time generated by the asctime
   * function. If the time of translation is not available, an
   * implementation-defined valid time shall be supplied.
   *
   * Note that MSVC declares DATE and TIME to be in the local time
   * zone, while neither the C standard nor the GCC docs make any
   * statement about this. As a result, we may be +/-12hrs off
   * UTC.  But for practical purposes, this should not be a
   * problem.
   *
   */
#   ifdef MKREPRO_DATE
  static const char build[] = MKREPRO_TIME "/" MKREPRO_DATE;
#   else
  static const char build[] = __TIME__ "/" __DATE__;
#   endif
  static const char mlist[] = "JanFebMarAprMayJunJulAugSepOctNovDec";

  char      monstr[4];
  const char *    cp;
  unsigned short    hour, minute, second, day, year;
  /* Note: The above quantities are used for sscanf 'hu' format,
   * so using 'uint16_t' is contra-indicated!
   */

#   ifdef DEBUG
  static int        ignore  = 0;
#   endif

  ZERO(*jd);
  jd->year     = 1970;
  jd->month    = 1;
  jd->monthday = 1;

#   ifdef DEBUG
  /* check environment if build date should be ignored */
  if (0 == ignore) {
      const char * envstr;
      envstr = getenv("NTPD_IGNORE_BUILD_DATE");
      ignore = 1 + (envstr && (!*envstr || !strcasecmp(envstr, "yes")));
  }
  if (ignore > 1)
      return FALSE;
#   endif

  if (6 == sscanf(build, "%hu:%hu:%hu/%3s %hu %hu",
      &hour, &minute, &second, monstr, &day, &year)) {
    cp = strstr(mlist, monstr);
    if (NULL != cp) {
      jd->year     = year;
      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;
    }
  }

  return FALSE;
}


/*
 *---------------------------------------------------------------------
 * basic calendar stuff
 *---------------------------------------------------------------------
 */

/* month table for a year starting with March,1st */
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 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 -*- */
  { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
};

/*
 * Some notes on the terminology:
 *
 * We use the proleptic Gregorian calendar, which is the Gregorian
 * calendar extended in both directions ad infinitum. This totally
 * disregards the fact that this calendar was invented in 1582, and
 * was adopted at various dates over the world; sometimes even after
 * the start of the NTP epoch.
 *
 * Normally date parts are given as current cycles, while time parts
 * are given as elapsed cycles:
 *
 * 1970-01-01/03:04:05 means 'IN the 1970st. year, IN the first month,
 * ON the first day, with 3hrs, 4minutes and 5 seconds elapsed.
 *
 * The basic calculations for this calendar implementation deal with
 * ELAPSED date units, which is the number of full years, full months
 * and full days before a date: 1970-01-01 would be (1969, 0, 0) in
 * that notation.
 *
 * To ease the numeric computations, month and day values outside the
 * normal range are acceptable: 2001-03-00 will be treated as the day
 * before 2001-03-01, 2000-13-32 will give the same result as
 * 2001-02-01 and so on.
 *
 * 'rd' or 'RD' is used as an abbreviation for the latin 'rata die'
 * (day number).  This is the number of days elapsed since 0000-12-31
 * in the proleptic Gregorian calendar. The begin of the Christian Era
 * (0001-01-01) is RD(1).
 */

/*
 * ====================================================================
 *
 * General algorithmic stuff
 *
 * ====================================================================
 */

/*
 *---------------------------------------------------------------------
 * Do a periodic extension of 'value' around 'pivot' with a period of
 * 'cycle'.
 *
 * The result 'res' is a number that holds to the following properties:
 *
 *   1)  res MOD cycle == value MOD cycle
 *   2)  pivot <= res < pivot + cycle
 *   (replace </<= with >/>= for negative cycles)
 *
 * where 'MOD' denotes the modulo operator for FLOOR DIVISION, which
 * is not the same as the '%' operator in C: C requires division to be
 * a truncated division, where remainder and dividend have the same
 * sign if the remainder is not zero, whereas floor division requires
 * divider and modulus to have the same sign for a non-zero modulus.
 *
 * This function has some useful applications:
 *
 * + let Y be a calendar year and V a truncated 2-digit year: then
 *  periodic_extend(Y-50, V, 100)
 *   is the closest expansion of the truncated year with respect to
 *   the full year, that is a 4-digit year with a difference of less
 *   than 50 years to the year Y. ("century unfolding")
 *
 * + let T be a UN*X time stamp and V be seconds-of-day: then
 *  perodic_extend(T-43200, V, 86400)
 *   is a time stamp that has the same seconds-of-day as the input
 *   value, with an absolute difference to T of <= 12hrs.  ("day
 *   unfolding")
 *
 * + Wherever you have a truncated periodic value and a non-truncated
 *   base value and you want to match them somehow...
 *
 * Basically, the function delivers 'pivot + (value - pivot) % cycle',
 * but the implementation takes some pains to avoid internal signed
 * integer overflows in the '(value - pivot) % cycle' part and adheres
 * to the floor division convention.
 *
 * If 64bit scalars where available on all intended platforms, writing a
 * version that uses 64 bit ops would be easy; writing a general
 * division routine for 64bit ops on a platform that can only do
 * 32/16bit divisions and is still performant is a bit more
 * difficult. Since most usecases can be coded in a way that does only
 * require the 32-bit version a 64bit version is NOT provided here.
 *---------------------------------------------------------------------
 */
int32_t
ntpcal_periodic_extend(
  int32_t pivot,
  int32_t value,
  int32_t cycle
  )
{
  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) {
    cycle = - cycle;
    neg ^= 1;
    cpl ^= 1;
  }
  /* guard against div by zero or one */
  if (cycle > 1) {
    /*
     * Get absolute difference as unsigned quantity and
     * the complement flag. This is done by always
     * subtracting the smaller value from the bigger
     * one.
     */
    if (value >= pivot) {
      diff = int32_to_uint32_2cpl(value)
           - int32_to_uint32_2cpl(pivot);
    } else {
      diff = int32_to_uint32_2cpl(pivot)
           - int32_to_uint32_2cpl(value);
      cpl ^= 1;
    }
    diff %= (uint32_t)cycle;
    if (diff) {
      if (cpl)
        diff = (uint32_t)cycle - diff;
      if (neg)
        diff = ~diff + 1;
      pivot += uint32_2cpl_to_int32(diff);
    }
  }
  return pivot;
}

/*---------------------------------------------------------------------
 * Note to the casual reader
 *
 * In the next two functions you will find (or would have found...)
 * the expression
 *
 *   res.Q_s -= 0x80000000;
 *
 * There was some ruckus about a possible programming error due to
 * integer overflow and sign propagation.
 *
 * This assumption is based on a lack of understanding of the C
 * standard. (Though this is admittedly not one of the most 'natural'
 * aspects of the 'C' language and easily to get wrong.)
 *
 * see 
 *  http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf
 *  "ISO/IEC 9899:201x Committee Draft — April 12, 2011"
 *  6.4.4.1 Integer constants, clause 5
 *
 * why there is no sign extension/overflow problem here.
 *
 * But to ease the minds of the doubtful, I added back the 'u' qualifiers
 * that somehow got lost over the last years. 
 */


/*
 *---------------------------------------------------------------------
 * Convert a timestamp in NTP scale to a 64bit seconds value in the UN*X
 * scale with proper epoch unfolding around a given pivot or the current
 * system time. This function happily accepts negative pivot values as
 * timestamps befor 1970-01-01, so be aware of possible trouble on
 * platforms with 32bit 'time_t'!
 *
 * This is also a periodic extension, but since the cycle is 2^32 and
 * the shift is 2^31, we can do some *very* fast math without explicit
 * divisions.
 *---------------------------------------------------------------------
 */
vint64
ntpcal_ntp_to_time(
  uint32_t  ntp,
  const time_t *  pivot
  )
{
  vint64 res;

#   if defined(HAVE_INT64)

  res.q_s = (pivot != NULL)
          ? *pivot
          : now();
  res.Q_s -= 0x80000000u;   /* unshift of half range */
  ntp -= (uint32_t)JAN_1970; /* warp into UN*X domain */
  ntp -= res.D_s.lo;    /* cycle difference  */
  res.Q_s += (uint64_t)ntp; /* get expanded time   */

#   else /* no 64bit scalars */

  time_t tmp;

  tmp = (pivot != NULL)
      ? *pivot
      : now();
  res = time_to_vint64(&tmp);
  M_SUB(res.D_s.hi, res.D_s.lo, 0, 0x80000000u);
  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);

#   endif /* no 64bit scalars */

  return res;
}

/*
 *---------------------------------------------------------------------
 * Convert a timestamp in NTP scale to a 64bit seconds value in the NTP
 * scale with proper epoch unfolding around a given pivot or the current
 * system time.
 *
 * Note: The pivot must be given in the UN*X time domain!
 *
 * This is also a periodic extension, but since the cycle is 2^32 and
 * the shift is 2^31, we can do some *very* fast math without explicit
 * divisions.
 *---------------------------------------------------------------------
 */
vint64
ntpcal_ntp_to_ntp(
  uint32_t      ntp,
  const time_t *pivot
  )
{
  vint64 res;

#   if defined(HAVE_INT64)

  res.q_s = (pivot)
          ? *pivot
          : now();
  res.Q_s -= 0x80000000u;   /* unshift of half range */
  res.Q_s += (uint32_t)JAN_1970; /* warp into NTP domain  */
  ntp -= res.D_s.lo;    /* cycle difference  */
  res.Q_s += (uint64_t)ntp; /* get expanded time   */

#   else /* no 64bit scalars */

  time_t tmp;

  tmp = (pivot)
      ? *pivot
      : 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, (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);

#   endif /* no 64bit scalars */

  return res;
}


/*
 * ====================================================================
 *
 * Splitting values to composite entities
 *
 * ====================================================================
 */

/*
 *---------------------------------------------------------------------
 * Split a 64bit seconds value into elapsed days in 'res.hi' and
 * elapsed seconds since midnight in 'res.lo' using explicit floor
 * division. This function happily accepts negative time values as
 * timestamps before the respective epoch start.
 *---------------------------------------------------------------------
 */
ntpcal_split
ntpcal_daysplit(
  const vint64 *ts
  )
{
  ntpcal_split res;
  uint32_t Q;

#   if defined(HAVE_INT64)
  
  /* Manual floor division by SECSPERDAY. This uses the one's
   * complement trick, too, but without an extra flag value: The
   * flag would be 64bit, and that's a bit of overkill on a 32bit
   * target that has to use a register pair for a 64bit number.
   */
  if (ts->q_s < 0)
    Q = ~(uint32_t)(~ts->Q_s / SECSPERDAY);
  else
    Q = (uint32_t)(ts->Q_s / SECSPERDAY);

#   else

  uint32_t ah, al, sflag, A;

  /* get operand into ah/al (either ts or ts' one's complement,
   * for later floor division)
   */
  sflag = int32_sflag(ts->d_s.hi);
  ah = sflag ^ ts->D_s.hi;
  al = sflag ^ ts->D_s.lo;

  /* Since 86400 == 128*675 we can drop the least 7 bits and
   * divide by 675 instead of 86400. Then the maximum remainder
   * after each devision step is 674, and we need 10 bits for
   * that. So in the next step we can shift in 22 bits from the
   * numerator.
   *
   * Therefore we load the accu with the top 13 bits (51..63) in
   * the first shot. We don't have to remember the quotient -- it
   * would be shifted out anyway.
   */
  A = ah >> 19;
  if (A >= 675)
    A = (A % 675u);

  /* Now assemble the remainder with bits 29..50 from the
   * numerator and divide. This creates the upper ten bits of the
   * quotient. (Well, the top 22 bits of a 44bit result. But that
   * will be truncated to 32 bits anyway.)
   */
  A = (A << 19) | (ah & 0x0007FFFFu);
  A = (A <<  3) | (al >> 29);
  Q = A / 675u;
  A = A % 675u;

  /* Now assemble the remainder with bits 7..28 from the numerator
   * and do a final division step.
   */
  A = (A << 22) | ((al >> 7) & 0x003FFFFFu);
  Q = (Q << 22) | (A / 675u);

  /* The last 7 bits get simply dropped, as they have no affect on
   * the quotient when dividing by 86400.
   */

  /* apply sign correction and calculate the true floor
   * remainder.
   */
  Q ^= sflag;
  
#   endif
  
  res.hi = uint32_2cpl_to_int32(Q);
  res.lo = ts->D_s.lo - Q * SECSPERDAY;

  return res;
}

/*
 *---------------------------------------------------------------------
 * Split a 32bit seconds value into h/m/s and excessive days.  This
 * function happily accepts negative time values as timestamps before
 * midnight.
 *---------------------------------------------------------------------
 */
static int32_t
priv_timesplit(
  int32_t split[3],
  int32_t ts
  )
{
  /* Do 3 chained floor divisions by positive constants, using the
   * one's complement trick and factoring out the intermediate XOR
   * ops to reduce the number of operations.
   */
  uint32_t us, um, uh, ud, sflag;

  sflag = int32_sflag(ts);
  us    = int32_to_uint32_2cpl(ts);

  um = (sflag ^ us) / SECSPERMIN;
  uh = um / MINSPERHR;
  ud = uh / HRSPERDAY;

  um ^= sflag;
  uh ^= sflag;
  ud ^= sflag;

  split[0] = (int32_t)(uh - ud * HRSPERDAY );
  split[1] = (int32_t)(um - uh * MINSPERHR );
  split[2] = (int32_t)(us - um * SECSPERMIN);
  
  return uint32_2cpl_to_int32(ud);
}

/*
 *---------------------------------------------------------------------
 * Given the number of elapsed days in the calendar era, split this
 * number into the number of elapsed years in 'res.hi' and the number
 * of elapsed days of that year in 'res.lo'.
 *
 * if 'isleapyear' is not NULL, it will receive an integer that is 0 for
 * regular years and a non-zero value for leap years.
 *---------------------------------------------------------------------
 */
ntpcal_split
ntpcal_split_eradays(
  int32_t days,
  int  *isleapyear
  )
{
  /* Use the fast cyclesplit algorithm here, to calculate the
   * centuries and years in a century with one division each. This
   * reduces the number of division operations to two, but is
   * susceptible to internal range overflow. We make sure the
   * input operands are in the safe range; this still gives us
   * approx +/-2.9 million years.
   */
  ntpcal_split res;
  int32_t  n100, n001; /* calendar year cycles */
  uint32_t uday, Q, sflag;

  /* split off centuries first */
  sflag = int32_sflag(days);
  uday  = uint32_saturate(int32_to_uint32_2cpl(days), sflag);
  uday  = (4u * uday) | 3u;
  Q    = sflag ^ ((sflag ^ uday) / GREGORIAN_CYCLE_DAYS);
  uday = uday - Q * GREGORIAN_CYCLE_DAYS;
  n100 = uint32_2cpl_to_int32(Q);
  
  /* Split off years in century -- days >= 0 here, and we're far
   * away from integer overflow trouble now. */
  uday |= 3;
  n001 = uday / GREGORIAN_NORMAL_LEAP_CYCLE_DAYS;
  uday = uday % GREGORIAN_NORMAL_LEAP_CYCLE_DAYS;

  /* Assemble the year and day in year */
  res.hi = n100 * 100 + n001;
  res.lo = uday / 4u;

  /* Eventually set the leap year flag. Note: 0 <= n001 <= 99 and
   * Q is still the two's complement representation of the
   * centuries: The modulo 4 ops can be done with masking here.
   * We also shift the year and the century by one, so the tests
   * can be done against zero instead of 3.
   */
  if (isleapyear)
    *isleapyear = !((n001+1) & 3)
        && ((n001 != 99) || !((Q+1) & 3));
  
  return res;
}

/*
 *---------------------------------------------------------------------
 * Given a number of elapsed days in a year and a leap year indicator,
 * split the number of elapsed days into the number of elapsed months in
 * 'res.hi' and the number of elapsed days of that month in 'res.lo'.
 *
 * This function will fail and return {-1,-1} if the number of elapsed
 * days is not in the valid range!
 *---------------------------------------------------------------------
 */
ntpcal_split
ntpcal_split_yeardays(
  int32_t eyd,
  int     isleapyear
  )
{
  ntpcal_split    res;
  const uint16_t *lt; /* month length table */

  /* check leap year flag and select proper table */
  lt = real_month_table[(isleapyear != 0)];
  if (0 <= eyd && eyd < lt[12]) {
    /* get zero-based month by approximation & correction step */
    res.hi = eyd >> 5;     /* approx month; might be 1 too low */
    if (lt[res.hi + 1] <= eyd) /* fixup approximative month value  */
      res.hi += 1;
    res.lo = eyd - lt[res.hi];
  } else {
    res.lo = res.hi = -1;
  }

  return res;
}

/*
 *---------------------------------------------------------------------
 * Convert a RD into the date part of a 'struct calendar'.
 *---------------------------------------------------------------------
 */
int
ntpcal_rd_to_date(
  struct calendar *jd,
  int32_t    rd
  )
{
  ntpcal_split split;
  int      leapy;
  u_int      ymask;

  /* Get day-of-week first. Since rd is signed, the remainder can
   * be in the range [-6..+6], but the assignment to an unsigned
   * variable maps the negative values to positive values >=7.
   * This makes the sign correction look strange, but adding 7
   * causes the needed wrap-around into the desired value range of
   * zero to six, both inclusive.
   */
  jd->weekday = rd % DAYSPERWEEK;
  if (jd->weekday >= DAYSPERWEEK) /* weekday is unsigned! */
    jd->weekday += DAYSPERWEEK;

  split = ntpcal_split_eradays(rd - 1, &leapy);
  /* Get year and day-of-year, with overflow check. If any of the
   * upper 16 bits is set after shifting to unity-based years, we
   * will have an overflow when converting to an unsigned 16bit
   * year. Shifting to the right is OK here, since it does not
   * matter if the shift is logic or arithmetic.
   */
  split.hi += 1;
  ymask = 0u - ((split.hi >> 16) == 0);
  jd->year = (uint16_t)(split.hi & ymask);
  jd->yearday = (uint16_t)split.lo + 1;

  /* convert to month and mday */
  split = ntpcal_split_yeardays(split.lo, leapy);
  jd->month    = (uint8_t)split.hi + 1;
  jd->monthday = (uint8_t)split.lo + 1;

  return ymask ? leapy : -1;
}

/*
 *---------------------------------------------------------------------
 * Convert a RD into the date part of a 'struct tm'.
 *---------------------------------------------------------------------
 */
int
ntpcal_rd_to_tm(
  struct tm  *utm,
  int32_t     rd
  )
{
  ntpcal_split split;
  int      leapy;

  /* get day-of-week first */
  utm->tm_wday = rd % DAYSPERWEEK;
  if (utm->tm_wday < 0)
    utm->tm_wday += DAYSPERWEEK;

  /* get year and day-of-year */
  split = ntpcal_split_eradays(rd - 1, &leapy);
  utm->tm_year = split.hi - 1899;
  utm->tm_yday = split.lo;  /* 0-based */

  /* convert to month and mday */
  split = ntpcal_split_yeardays(split.lo, leapy);
  utm->tm_mon  = split.hi;  /* 0-based */
  utm->tm_mday = split.lo + 1;  /* 1-based */

  return leapy;
}

/*
 *---------------------------------------------------------------------
 * Take a value of seconds since midnight and split it into hhmmss in a
 * 'struct calendar'.
 *---------------------------------------------------------------------
 */
int32_t
ntpcal_daysec_to_date(
  struct calendar *jd,
  int32_t   sec
  )
{
  int32_t days;
  int   ts[3];

  days = priv_timesplit(ts, sec);
  jd->hour   = (uint8_t)ts[0];
  jd->minute = (uint8_t)ts[1];
  jd->second = (uint8_t)ts[2];

  return days;
}

/*
 *---------------------------------------------------------------------
 * Take a value of seconds since midnight and split it into hhmmss in a
 * 'struct tm'.
 *---------------------------------------------------------------------
 */
int32_t
ntpcal_daysec_to_tm(
  struct tm *utm,
  int32_t    sec
  )
{
  int32_t days;
  int32_t ts[3];

  days = priv_timesplit(ts, sec);
  utm->tm_hour = ts[0];
  utm->tm_min  = ts[1];
  utm->tm_sec  = ts[2];

  return days;
}

/*
 *---------------------------------------------------------------------
 * take a split representation for day/second-of-day and day offset
 * and convert it to a 'struct calendar'. The seconds will be normalised
 * into the range of a day, and the day will be adjusted accordingly.
 *
 * returns >0 if the result is in a leap year, 0 if in a regular
 * year and <0 if the result did not fit into the calendar struct.
 *---------------------------------------------------------------------
 */
int
ntpcal_daysplit_to_date(
  struct calendar    *jd,
  const ntpcal_split *ds,
  int32_t       dof
  )
{
  dof += ntpcal_daysec_to_date(jd, ds->lo);
  return ntpcal_rd_to_date(jd, ds->hi + dof);
}

/*
 *---------------------------------------------------------------------
 * take a split representation for day/second-of-day and day offset
 * and convert it to a 'struct tm'. The seconds will be normalised
 * into the range of a day, and the day will be adjusted accordingly.
 *
 * returns 1 if the result is in a leap year and zero if in a regular
 * year.
 *---------------------------------------------------------------------
 */
int
ntpcal_daysplit_to_tm(
  struct tm    *utm,
  const ntpcal_split *ds ,
  int32_t       dof
  )
{
  dof += ntpcal_daysec_to_tm(utm, ds->lo);

  return ntpcal_rd_to_tm(utm, ds->hi + dof);
}

/*
 *---------------------------------------------------------------------
 * Take a UN*X time and convert to a calendar structure.
 *---------------------------------------------------------------------
 */
int
ntpcal_time_to_date(
  struct calendar *jd,
  const vint64  *ts
  )
{
  ntpcal_split ds;

  ds = ntpcal_daysplit(ts);
  ds.hi += ntpcal_daysec_to_date(jd, ds.lo);
  ds.hi += DAY_UNIX_STARTS;

  return ntpcal_rd_to_date(jd, ds.hi);
}


/*
 * ====================================================================
 *
 * merging composite entities
 *
 * ====================================================================
 */

/*
 *---------------------------------------------------------------------
 * Merge a number of days and a number of seconds into seconds,
 * expressed in 64 bits to avoid overflow.
 *---------------------------------------------------------------------
 */
vint64
ntpcal_dayjoin(
  int32_t days,
  int32_t secs
  )
{
  vint64 res;

#   if defined(HAVE_INT64)

  res.q_s  = days;
  res.q_s *= SECSPERDAY;
  res.q_s += secs;

#   else

  uint32_t p1, p2;
  int  isneg;

  /*
   * res = days *86400 + secs, using manual 16/32 bit
   * multiplications and shifts.
   */
  isneg = (days < 0);
  if (isneg)
    days = -days;

  /* assemble days * 675 */
  res.D_s.lo = (days & 0xFFFF) * 675u;
  res.D_s.hi = 0;
  p1 = (days >> 16) * 675u;
  p2 = p1 >> 16;
  p1 = p1 << 16;
  M_ADD(res.D_s.hi, res.D_s.lo, p2, p1);

  /* mul by 128, using shift */
  res.D_s.hi = (res.D_s.hi << 7) | (res.D_s.lo >> 25);
  res.D_s.lo = (res.D_s.lo << 7);

  /* fix sign */
  if (isneg)
    M_NEG(res.D_s.hi, res.D_s.lo);

  /* properly add seconds */
  p2 = 0;
  if (secs < 0) {
    p1 = (uint32_t)-secs;
    M_NEG(p2, p1);
  } else {
    p1 = (uint32_t)secs;
  }
  M_ADD(res.D_s.hi, res.D_s.lo, p2, p1);

#   endif

  return res;
}

/*
 *---------------------------------------------------------------------
 * get leap years since epoch in elapsed years
 *---------------------------------------------------------------------
 */
int32_t
ntpcal_leapyears_in_years(
  int32_t years
  )
{
  /* We use the in-out-in algorithm here, using the one's
   * complement division trick for negative numbers. The chained
   * division sequence by 4/25/4 gives the compiler the chance to
   * get away with only one true division and doing shifts otherwise.
   */

  uint32_t sflag, sum, uyear;

  sflag = int32_sflag(years);
  uyear = int32_to_uint32_2cpl(years);
  uyear ^= sflag;

  sum  = (uyear /=  4u);  /*   4yr rule --> IN  */
  sum -= (uyear /= 25u);  /* 100yr rule --> OUT */
  sum += (uyear /=  4u);  /* 400yr rule --> IN  */

  /* Thanks to the alternation of IN/OUT/IN we can do the sum
   * directly and have a single one's complement operation
   * here. (Only if the years are negative, of course.) Otherwise
   * the one's complement would have to be done when
   * adding/subtracting the terms.
   */
  return uint32_2cpl_to_int32(sflag ^ sum);
}

/*
 *---------------------------------------------------------------------
 * Convert elapsed years in Era into elapsed days in Era.
 *---------------------------------------------------------------------
 */
int32_t
ntpcal_days_in_years(
  int32_t years
  )
{
  return years * DAYSPERYEAR + ntpcal_leapyears_in_years(years);
}

/*
 *---------------------------------------------------------------------
 * Convert a number of elapsed month in a year into elapsed days in year.
 *
 * The month will be normalized, and 'res.hi' will contain the
 * excessive years that must be considered when converting the years,
 * while 'res.lo' will contain the number of elapsed days since start
 * of the year.
 *
 * This code uses the shifted-month-approach to convert month to days,
 * because then there is no need to have explicit leap year
 * information.  The slight disadvantage is that for most month values
 * the result is a negative value, and the year excess is one; the
 * conversion is then simply based on the start of the following year.
 *---------------------------------------------------------------------
 */
ntpcal_split
ntpcal_days_in_months(
  int32_t m
  )
{
  ntpcal_split res;

  /* Add ten months and correct if needed. (It likely is...) */
  res.lo  = m + 10;
  res.hi  = (res.lo >= 12);
  if (res.hi)
    res.lo -= 12;

  /* if still out of range, normalise by floor division ... */
  if (res.lo < 0 || res.lo >= 12) {
    uint32_t mu, Q, sflag;
    sflag = int32_sflag(res.lo);
    mu    = int32_to_uint32_2cpl(res.lo);
    Q     = sflag ^ ((sflag ^ mu) / 12u);
    res.hi += uint32_2cpl_to_int32(Q);
    res.lo  = mu - Q * 12u;
  }
  
  /* get cummulated days in year with unshift */
  res.lo = shift_month_table[res.lo] - 306;

  return res;
}

/*
 *---------------------------------------------------------------------
 * Convert ELAPSED years/months/days of gregorian calendar to elapsed
 * days in Gregorian epoch.
 *
 * If you want to convert years and days-of-year, just give a month of
 * zero.
 *---------------------------------------------------------------------
 */
int32_t
ntpcal_edate_to_eradays(
  int32_t years,
  int32_t mons,
  int32_t mdays
  )
{
  ntpcal_split tmp;
  int32_t      res;

  if (mons) {
    tmp = ntpcal_days_in_months(mons);
    res = ntpcal_days_in_years(years + tmp.hi) + tmp.lo;
  } else
    res = ntpcal_days_in_years(years);
  res += mdays;

  return res;
}

/*
 *---------------------------------------------------------------------
 * Convert ELAPSED years/months/days of gregorian calendar to elapsed
 * days in year.
 *
 * Note: This will give the true difference to the start of the given
 * year, even if months & days are off-scale.
 *---------------------------------------------------------------------
 */
int32_t
ntpcal_edate_to_yeardays(
  int32_t years,
  int32_t mons,
  int32_t mdays
  )
{
  ntpcal_split tmp;

  if (0 <= mons && mons < 12) {
    years += 1;
    mdays += real_month_table[is_leapyear(years)][mons];
  } else {
    tmp = ntpcal_days_in_months(mons);
    mdays += tmp.lo
           + ntpcal_days_in_years(years + tmp.hi)
           - ntpcal_days_in_years(years);
  }

  return mdays;
}

/*
 *---------------------------------------------------------------------
 * Convert elapsed days and the hour/minute/second information into
 * total seconds.
 *
 * If 'isvalid' is not NULL, do a range check on the time specification
 * and tell if the time input is in the normal range, permitting for a
 * single leapsecond.
 *---------------------------------------------------------------------
 */
int32_t
ntpcal_etime_to_seconds(
  int32_t hours,
  int32_t minutes,
  int32_t seconds
  )
{
  int32_t res;

  res = (hours * MINSPERHR + minutes) * SECSPERMIN + seconds;

  return res;
}

/*
 *---------------------------------------------------------------------
 * Convert the date part of a 'struct tm' (that is, year, month,
 * day-of-month) into the RD of that day.
 *---------------------------------------------------------------------
 */
int32_t
ntpcal_tm_to_rd(
  const struct tm *utm
  )
{
  return ntpcal_edate_to_eradays(utm->tm_year + 1899,
               utm->tm_mon,
               utm->tm_mday - 1) + 1;
}

/*
 *---------------------------------------------------------------------
 * Convert the date part of a 'struct calendar' (that is, year, month,
 * day-of-month) into the RD of that day.
 *---------------------------------------------------------------------
 */
int32_t
ntpcal_date_to_rd(
  const struct calendar *jd
  )
{
  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_t
ntpcal_year_to_ystart(
  int32_t year
  )
{
  return ntpcal_days_in_years(year - 1) + 1;
}

/*
 *---------------------------------------------------------------------
 * For a given RD, get the RD of the associated year start,
 * that is, the RD of the last January,1st on or before that day.
 *---------------------------------------------------------------------
 */
int32_t
ntpcal_rd_to_ystart(
  int32_t rd
  )
{
  /*
   * Rather simple exercise: split the day number into elapsed
   * years and elapsed days, then remove the elapsed days from the
   * input value. Nice'n sweet...
   */
  return rd - ntpcal_split_eradays(rd - 1, NULL).lo;
}

/*
 *---------------------------------------------------------------------
 * For a given RD, get the RD of the associated month start.
 *---------------------------------------------------------------------
 */
int32_t
ntpcal_rd_to_mstart(
  int32_t rd
  )
{
  ntpcal_split split;
  int      leaps;

  split = ntpcal_split_eradays(rd - 1, &leaps);
  split = ntpcal_split_yeardays(split.lo, leaps);

  return rd - split.lo;
}

/*
 *---------------------------------------------------------------------
 * take a 'struct calendar' and get the seconds-of-day from it.
 *---------------------------------------------------------------------
 */
int32_t
ntpcal_date_to_daysec(
  const struct calendar *jd
  )
{
  return ntpcal_etime_to_seconds(jd->hour, jd->minute,
               jd->second);
}

/*
 *---------------------------------------------------------------------
 * take a 'struct tm' and get the seconds-of-day from it.
 *---------------------------------------------------------------------
 */
int32_t
ntpcal_tm_to_daysec(
  const struct tm *utm
  )
{
  return ntpcal_etime_to_seconds(utm->tm_hour, utm->tm_min,
               utm->tm_sec);
}

/*
 *---------------------------------------------------------------------
 * take a 'struct calendar' and convert it to a 'time_t'
 *---------------------------------------------------------------------
 */
time_t
ntpcal_date_to_time(
  const struct calendar *jd
  )
{
  vint64  join;
  int32_t days, secs;

  days = ntpcal_date_to_rd(jd) - DAY_UNIX_STARTS;
  secs = ntpcal_date_to_daysec(jd);
  join = ntpcal_dayjoin(days, secs);

  return vint64_to_time(&join);
}


/*
 * ====================================================================
 *
 * extended and unchecked variants of caljulian/caltontp
 *
 * ====================================================================
 */
int
ntpcal_ntp64_to_date(
  struct calendar *jd,
  const vint64    *ntp
  )
{
  ntpcal_split ds;

  ds = ntpcal_daysplit(ntp);
  ds.hi += ntpcal_daysec_to_date(jd, ds.lo);

  return ntpcal_rd_to_date(jd, ds.hi + DAY_NTP_STARTS);
}

int
ntpcal_ntp_to_date(
  struct calendar *jd,
  uint32_t   ntp,
  const time_t  *piv
  )
{
  vint64  ntp64;

  /*
   * Unfold ntp time around current time into NTP domain. Split
   * into days and seconds, shift days into CE domain and
   * process the parts.
   */
  ntp64 = ntpcal_ntp_to_ntp(ntp, piv);
  return ntpcal_ntp64_to_date(jd, &ntp64);
}


vint64
ntpcal_date_to_ntp64(
  const struct calendar *jd
  )
{
  /*
   * Convert date to NTP. Ignore yearday, use d/m/y only.
   */
  return ntpcal_dayjoin(ntpcal_date_to_rd(jd) - DAY_NTP_STARTS,
            ntpcal_date_to_daysec(jd));
}


uint32_t
ntpcal_date_to_ntp(
  const struct calendar *jd
  )
{
  /*
   * Get lower half of 64-bit NTP timestamp from date/time.
   */
  return ntpcal_date_to_ntp64(jd).d_s.lo;
}



/*
 * ====================================================================
 *
 * day-of-week calculations
 *
 * ====================================================================
 */
/*
 * Given a RataDie and a day-of-week, calculate a RDN that is reater-than,
 * greater-or equal, closest, less-or-equal or less-than the given RDN
 * and denotes the given day-of-week
 */
int32_t
ntpcal_weekday_gt(
  int32_t rdn,
  int32_t dow
  )
{
  return ntpcal_periodic_extend(rdn+1, dow, 7);
}

int32_t
ntpcal_weekday_ge(
  int32_t rdn,
  int32_t dow
  )
{
  return ntpcal_periodic_extend(rdn, dow, 7);
}

int32_t
ntpcal_weekday_close(
  int32_t rdn,
  int32_t dow
  )
{
  return ntpcal_periodic_extend(rdn-3, dow, 7);
}

int32_t
ntpcal_weekday_le(
  int32_t rdn,
  int32_t dow
  )
{
  return ntpcal_periodic_extend(rdn, dow, -7);
}

int32_t
ntpcal_weekday_lt(
  int32_t rdn,
  int32_t dow
  )
{
  return ntpcal_periodic_extend(rdn-1, dow, -7);
}

/*
 * ====================================================================
 *
 * ISO week-calendar conversions
 *
 * The ISO8601 calendar defines a calendar of years, weeks and weekdays.
 * It is related to the Gregorian calendar, and a ISO year starts at the
 * Monday closest to Jan,1st of the corresponding Gregorian year.  A ISO
 * calendar year has always 52 or 53 weeks, and like the Grogrian
 * calendar the ISO8601 calendar repeats itself every 400 years, or
 * 146097 days, or 20871 weeks.
 *
 * While it is possible to write ISO calendar functions based on the
 * Gregorian calendar functions, the following implementation takes a
 * different approach, based directly on years and weeks.
 *
 * Analysis of the tabulated data shows that it is not possible to
 * interpolate from years to weeks over a full 400 year range; cyclic
 * shifts over 400 years do not provide a solution here. But it *is*
 * possible to interpolate over every single century of the 400-year
 * cycle. (The centennial leap year rule seems to be the culprit here.)
 *
 * It can be shown that a conversion from years to weeks can be done
 * using a linear transformation of the form
 *
 *   w = floor( y * a + b )
 *
 * where the slope a must hold to
 *
 *  52.1780821918 <= a < 52.1791044776
 *
 * and b must be chosen according to the selected slope and the number
 * of the century in a 400-year period.
 *
 * The inverse calculation can also be done in this way. Careful scaling
 * provides an unlimited set of integer coefficients a,k,b that enable
 * us to write the calulation in the form
 *
 *   w = (y * a  + b ) / k
 *   y = (w * a' + b') / k'
 *
 * In this implementation the values of k and k' are chosen to be
 * smallest possible powers of two, so the division can be implemented
 * as shifts if the optimiser chooses to do so.
 *
 * ====================================================================
 */

/*
 * Given a number of elapsed (ISO-)years since the begin of the
 * christian era, return the number of elapsed weeks corresponding to
 * the number of years.
 */
int32_t
isocal_weeks_in_years(
  int32_t years
  )
{ 
  /*
   * use: w = (y * 53431 + b[c]) / 1024 as interpolation
   */
  static const uint16_t bctab[4] = { 157, 449, 597, 889 };

  int32_t  cs, cw;
  uint32_t cc, ci, yu, sflag;

  sflag = int32_sflag(years);
  yu    = int32_to_uint32_2cpl(years);
  
  /* split off centuries, using floor division */
  cc  = sflag ^ ((sflag ^ yu) / 100u);
  yu -= cc * 100u;

  /* calculate century cycles shift and cycle index:
   * Assuming a century is 5217 weeks, we have to add a cycle
   * shift that is 3 for every 4 centuries, because 3 of the four
   * centuries have 5218 weeks. So '(cc*3 + 1) / 4' is the actual
   * correction, and the second century is the defective one.
   *
   * Needs floor division by 4, which is done with masking and
   * shifting.
   */
  ci = cc * 3u + 1;
  cs = uint32_2cpl_to_int32(sflag ^ ((sflag ^ ci) / 4u));
  ci = ci % 4u;
  
  /* Get weeks in century. Can use plain division here as all ops
   * are >= 0,  and let the compiler sort out the possible
   * optimisations.
   */
  cw = (yu * 53431u + bctab[ci]) / 1024u;

  return uint32_2cpl_to_int32(cc) * 5217 + cs + cw;
}

/*
 * Given a number of elapsed weeks since the begin of the christian
 * era, split this number into the number of elapsed years in res.hi
 * and the excessive number of weeks in res.lo. (That is, res.lo is
 * the number of elapsed weeks in the remaining partial year.)
 */
ntpcal_split
isocal_split_eraweeks(
  int32_t weeks
  )
{
  /*
   * use: y = (w * 157 + b[c]) / 8192 as interpolation
   */

  static const uint16_t bctab[4] = { 85, 130, 17, 62 };

  ntpcal_split res;
  int32_t  cc, ci;
  uint32_t sw, cy, Q, sflag;

  /* Use two fast cycle-split divisions here. This is again
   * susceptible to internal overflow, so we check the range. This
   * still permits more than +/-20 million years, so this is
   * likely a pure academical problem.
   *
   * We want to execute '(weeks * 4 + 2) /% 20871' under floor
   * division rules in the first step.
   */
  sflag = int32_sflag(weeks);
  sw  = uint32_saturate(int32_to_uint32_2cpl(weeks), sflag);
  sw  = 4u * sw + 2;
  Q   = sflag ^ ((sflag ^ sw) / GREGORIAN_CYCLE_WEEKS);
  sw -= Q * GREGORIAN_CYCLE_WEEKS;
  ci  = Q % 4u;
  cc  = uint32_2cpl_to_int32(Q);

  /* Split off years; sw >= 0 here! The scaled weeks in the years
   * are scaled up by 157 afterwards.
   */ 
  sw  = (sw / 4u) * 157u + bctab[ci];
  cy  = sw / 8192u; /* ws >> 13 , let the compiler sort it out */
  sw  = sw % 8192u; /* ws & 8191, let the compiler sort it out */

  /* assemble elapsed years and downscale the elapsed weeks in
   * the year.
   */
  res.hi = 100*cc + cy;
  res.lo = sw / 157u;

  return res;
}

/*
 * Given a second in the NTP time scale and a pivot, expand the NTP
 * time stamp around the pivot and convert into an ISO calendar time
 * stamp.
 */
int
isocal_ntp64_to_date(
  struct isodate *id,
  const vint64   *ntp
  )
{
  ntpcal_split ds;
  int32_t      ts[3];
  uint32_t     uw, ud, sflag;

  /*
   * Split NTP time into days and seconds, shift days into CE
   * domain and process the parts.
   */
  ds = ntpcal_daysplit(ntp);

  /* split time part */
  ds.hi += priv_timesplit(ts, ds.lo);
  id->hour   = (uint8_t)ts[0];
  id->minute = (uint8_t)ts[1];
  id->second = (uint8_t)ts[2];

  /* split days into days and weeks, using floor division in unsigned */
  ds.hi += DAY_NTP_STARTS - 1; /* shift from NTP to RDN */
  sflag = int32_sflag(ds.hi);
  ud  = int32_to_uint32_2cpl(ds.hi);
  uw  = sflag ^ ((sflag ^ ud) / DAYSPERWEEK);
  ud -= uw * DAYSPERWEEK;
  ds.hi = uint32_2cpl_to_int32(uw);
  ds.lo = ud;

  id->weekday = (uint8_t)ds.lo + 1; /* weekday result    */

  /* get year and week in year */
  ds = isocal_split_eraweeks(ds.hi);  /* elapsed years&week*/
  id->year = (uint16_t)ds.hi + 1;   /* shift to current  */
  id->week = (uint8_t )ds.lo + 1;

  return (ds.hi >= 0 && ds.hi < 0x0000FFFF);
}

int
isocal_ntp_to_date(
  struct isodate *id,
  uint32_t  ntp,
  const time_t   *piv
  )
{
  vint64  ntp64;

  /*
   * Unfold ntp time around current time into NTP domain, then
   * convert the full time stamp.
   */
  ntp64 = ntpcal_ntp_to_ntp(ntp, piv);
  return isocal_ntp64_to_date(id, &ntp64);
}

/*
 * Convert a ISO date spec into a second in the NTP time scale,
 * properly truncated to 32 bit.
 */
vint64
isocal_date_to_ntp64(
  const struct isodate *id
  )
{
  int32_t weeks, days, secs;

  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);

  return ntpcal_dayjoin(days - DAY_NTP_STARTS, secs);
}

uint32_t
isocal_date_to_ntp(
  const struct isodate *id
  )
{
  /*
   * Get lower half of 64-bit NTP timestamp from date/time.
   */
  return isocal_date_to_ntp64(id).d_s.lo;
}

/*
 * ====================================================================
 * 'basedate' support functions
 * ====================================================================
 */

static int32_t s_baseday = NTP_TO_UNIX_DAYS;
static int32_t s_gpsweek = 0;

int32_t
basedate_eval_buildstamp(void)
{
  struct calendar jd;
  int32_t   ed;
  
  if (!ntpcal_get_build_date(&jd))
    return NTP_TO_UNIX_DAYS;

  /* The time zone of the build stamp is unspecified; we remove
   * one day to provide a certain slack. And in case somebody
   * fiddled with the system clock, we make sure we do not go
   * before the UNIX epoch (1970-01-01). It's probably not possible
   * to do this to the clock on most systems, but there are other
   * ways to tweak the build stamp.
   */
  jd.monthday -= 1;
  ed = ntpcal_date_to_rd(&jd) - DAY_NTP_STARTS;
  return (ed < NTP_TO_UNIX_DAYS) ? NTP_TO_UNIX_DAYS : ed;
}

int32_t
basedate_eval_string(
  const char * str
  )
{
  u_short y,m,d;
  u_long  ned;
  int rc, nc;
  size_t  sl;

  sl = strlen(str); 
  rc = sscanf(str, "%4hu-%2hu-%2hu%n", &y, &m, &d, &nc);
  if (rc == 3 && (size_t)nc == sl) {
    if (m >= 1 && m <= 12 && d >= 1 && d <= 31)
      return ntpcal_edate_to_eradays(y-1, m-1, d)
          - DAY_NTP_STARTS;
    goto buildstamp;
  }

  rc = sscanf(str, "%lu%n", &ned, &nc);
  if (rc == 1 && (size_t)nc == sl) {
    if (ned <= INT32_MAX)
      return (int32_t)ned;
    goto buildstamp;
  }

  buildstamp:
  msyslog(LOG_WARNING,
    "basedate string \"%s\" invalid, build date substituted!",
    str);
  return basedate_eval_buildstamp();
}

uint32_t
basedate_get_day(void)
{
  return s_baseday;
}

int32_t
basedate_set_day(
  int32_t day
  )
{
  struct calendar jd;
  int32_t   retv;

  /* set NTP base date for NTP era unfolding */
  if (day < NTP_TO_UNIX_DAYS) {
    msyslog(LOG_WARNING,
      "baseday_set_day: invalid day (%lu), UNIX epoch substituted",
      (unsigned long)day);
    day = NTP_TO_UNIX_DAYS;
  }
  retv = s_baseday; 
  s_baseday = day;
  ntpcal_rd_to_date(&jd, day + DAY_NTP_STARTS);
  msyslog(LOG_INFO, "basedate set to %04hu-%02hu-%02hu",
    jd.year, (u_short)jd.month, (u_short)jd.monthday);

  /* set GPS base week for GPS week unfolding */
  day = ntpcal_weekday_ge(day + DAY_NTP_STARTS, CAL_SUNDAY)
      - DAY_NTP_STARTS;
  if (day < NTP_TO_GPS_DAYS)
      day = NTP_TO_GPS_DAYS;
  s_gpsweek = (day - NTP_TO_GPS_DAYS) / DAYSPERWEEK;
  ntpcal_rd_to_date(&jd, day + DAY_NTP_STARTS);
  msyslog(LOG_INFO, "gps base set to %04hu-%02hu-%02hu (week %d)",
    jd.year, (u_short)jd.month, (u_short)jd.monthday, s_gpsweek);
  
  return retv;
}

time_t
basedate_get_eracenter(void)
{
  time_t retv;
  retv  = (time_t)(s_baseday - NTP_TO_UNIX_DAYS);
  retv *= SECSPERDAY;
  retv += (UINT32_C(1) << 31);
  return retv;
}

time_t
basedate_get_erabase(void)
{
  time_t retv;
  retv  = (time_t)(s_baseday - NTP_TO_UNIX_DAYS);
  retv *= SECSPERDAY;
  return retv;
}

uint32_t
basedate_get_gpsweek(void)
{
    return s_gpsweek;
}

uint32_t
basedate_expand_gpsweek(
    unsigned short weekno
    )
{
    /* We do a fast modulus expansion here. Since all quantities are
     * unsigned and we cannot go before the start of the GPS epoch
     * anyway, and since the truncated GPS week number is 10 bit, the
     * expansion becomes a simple sub/and/add sequence.
     */
    #if GPSWEEKS != 1024
    # error GPSWEEKS defined wrong -- should be 1024!
    #endif
    
    uint32_t diff;
    diff = ((uint32_t)weekno - s_gpsweek) & (GPSWEEKS - 1);
    return s_gpsweek + diff;
}

/* -*-EOF-*- */

Coverage Report

Created: 2023-05-19 06:16