/*
*---------------------------------------------------------------------
* 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 {
char *
mfptoa(
u_long fpi,
u_long fpf,
int ndec
)
{
int isneg;
if (M_ISNEG(fpi, fpf)) {
isneg = 1;
M_NEG(fpi, fpf);
} else
isneg = 0;
return dolfptoa(fpi, fpf, isneg, ndec, 0);
}
int
atolfp(
const char *str,
l_fp *lfp
)
{
register const char *cp;
register u_long dec_i;
register u_long dec_f;
char *ind;
int ndec;
int isneg;
static const char *digits = "0123456789";
NTP_REQUIRE(str != NULL);
isneg = 0;
dec_i = dec_f = 0;
ndec = 0;
cp = str;
/*
* We understand numbers of the form:
*
* [spaces][-|+][digits][.][digits][spaces|\n|\0]
*/
while (isspace((unsigned char)*cp))
cp++;
if (*cp == '-') {
cp++;
isneg = 1;
}
if (*cp == '+')
cp++;
if (*cp != '.' && !isdigit((unsigned char)*cp))
return 0;
while (*cp != '\0' && (ind = strchr(digits, *cp)) != NULL) {
dec_i = (dec_i << 3) + (dec_i << 1); /* multiply by 10 */
dec_i += (ind - digits);
cp++;
}
if (*cp != '\0' && !isspace((unsigned char)*cp)) {
if (*cp++ != '.')
return 0;
while (ndec < 9 && *cp != '\0'
&& (ind = strchr(digits, *cp)) != NULL) {
ndec++;
dec_f = (dec_f << 3) + (dec_f << 1); /* *10 */
dec_f += (ind - digits);
cp++;
}
while (isdigit((unsigned char)*cp))
cp++;
if (*cp != '\0' && !isspace((unsigned char)*cp))
return 0;
}
if (ndec > 0) {
register u_long tmp;
register u_long bit;
register u_long ten_fact;
ten_fact = ten_to_the_n[ndec];
tmp = 0;
bit = 0x80000000;
while (bit != 0) {
dec_f <<= 1;
if (dec_f >= ten_fact) {
tmp |= bit;
dec_f -= ten_fact;
}
bit >>= 1;
}
if ((dec_f << 1) > ten_fact)
tmp++;
dec_f = tmp;
}
if (isneg)
M_NEG(dec_i, dec_f);
lfp->l_ui = dec_i;
lfp->l_uf = dec_f;
return 1;
}
void
mfp_mul(
int32 *o_i,
u_int32 *o_f,
int32 a_i,
u_int32 a_f,
int32 b_i,
u_int32 b_f
)
{
int32 i, j;
u_int32 f;
u_long a[4]; /* operand a */
u_long b[4]; /* operand b */
u_long c[5]; /* result c - 5 items for performance - see below */
u_long carry;
int neg = 0;
if (a_i < 0) /* examine sign situation */
{
neg = 1;
M_NEG(a_i, a_f);
}
if (b_i < 0) /* examine sign situation */
{
neg = !neg;
M_NEG(b_i, b_f);
}
a[0] = a_f & LOW_MASK; /* prepare a operand */
a[1] = (a_f & HIGH_MASK) >> (FRACTION_PREC/2);
a[2] = a_i & LOW_MASK;
a[3] = (a_i & HIGH_MASK) >> (FRACTION_PREC/2);
b[0] = b_f & LOW_MASK; /* prepare b operand */
b[1] = (b_f & HIGH_MASK) >> (FRACTION_PREC/2);
b[2] = b_i & LOW_MASK;
b[3] = (b_i & HIGH_MASK) >> (FRACTION_PREC/2);
c[0] = c[1] = c[2] = c[3] = c[4] = 0;
for (i = 0; i < 4; i++) /* we do assume 32 * 32 = 64 bit multiplication */
for (j = 0; j < 4; j++)
{
u_long result_low, result_high;
int low_index = (i+j)/2; /* formal [0..3] - index for low long word */
int mid_index = 1+low_index; /* formal [1..4]! - index for high long word
will generate unecessary add of 0 to c[4]
but save 15 'if (result_high) expressions' */
int high_index = 1+mid_index; /* formal [2..5]! - index for high word overflow
- only assigned on overflow (limits range to 2..3) */
result_low = (u_long)a[i] * (u_long)b[j]; /* partial product */
if ((i+j) & 1) /* splits across two result registers */
{
result_high = result_low >> (FRACTION_PREC/2);
result_low <<= FRACTION_PREC/2;
carry = (unsigned)1<<(FRACTION_PREC/2);
}
else
{ /* stays in a result register - except for overflows */
