/* *--------------------------------------------------------------------- * 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 */