1
0
mirror of https://git.FreeBSD.org/src.git synced 2024-12-06 09:17:25 +00:00
freebsd/contrib/ntp/libntp/vint64ops.c
Cy Schubert 2b15cb3d09 MFV ntp 4.2.8p1 (r258945, r275970, r276091, r276092, r276093, r278284)
Thanks to roberto for providing pointers to wedge this into HEAD.

Approved by:	roberto
2015-03-30 13:30:15 +00:00

285 lines
5.1 KiB
C

/*
* vint64ops.c - operations on 'vint64' values
*
* Written by Juergen Perlinger (perlinger@ntp.org) for the NTP project.
* The contents of 'html/copyright.html' apply.
* ----------------------------------------------------------------------
* This is an attempt to get the vint64 calculations stuff centralised.
*/
#include <config.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <errno.h>
#include "ntp_types.h"
#include "ntp_fp.h"
#include "vint64ops.h"
/* ---------------------------------------------------------------------
* GCC is rather sticky with its 'const' attribute. We have to do it more
* explicit than with a cast if we want to get rid of a CONST qualifier.
* Greetings from the PASCAL world, where casting was only possible via
* untagged unions...
*/
static inline void*
noconst(
const void* ptr
)
{
union {
const void * cp;
void * vp;
} tmp;
tmp.cp = ptr;
return tmp.vp;
}
/* -------------------------------------------------------------------------*/
vint64
strtouv64(
const char * begp,
char ** endp,
int base
)
{
vint64 res;
u_char digit;
int sig, num;
const u_char *src;
num = sig = 0;
src = (const u_char*)begp;
while (isspace(*src))
src++;
if (*src == '-') {
src++;
sig = 1;
} else if (*src == '+') {
src++;
}
if (base == 0) {
base = 10;
if (*src == '0') {
base = 8;
if (toupper(*++src) == 'X') {
src++;
base = 16;
}
}
} else if (base == 16) { /* remove optional leading '0x' or '0X' */
if (src[0] == '0' && toupper(src[1]) == 'X')
src += 2;
} else if (base <= 2 || base > 36) {
memset(&res, 0xFF, sizeof(res));
errno = ERANGE;
return res;
}
memset(&res, 0, sizeof(res));
while (*src) {
if (isdigit(*src))
digit = *src - '0';
else if (isupper(*src))
digit = *src - 'A' + 10;
else if (islower(*src))
digit = *src - 'a' + 10;
else
break;
if (digit >= base)
break;
num = 1;
#if defined(HAVE_INT64)
res.Q_s = res.Q_s * base + digit;
#else
/* res *= base, using 16x16->32 bit
* multiplication. Slow but portable.
*/
{
uint32_t accu;
accu = (uint32_t)res.W_s.ll * base;
res.W_s.ll = (uint16_t)accu;
accu = (accu >> 16)
+ (uint32_t)res.W_s.lh * base;
res.W_s.lh = (uint16_t)accu;
/* the upper bits can be done in one step: */
res.D_s.hi = res.D_s.hi * base + (accu >> 16);
}
M_ADD(res.D_s.hi, res.D_s.lo, 0, digit);
#endif
src++;
}
if (!num)
errno = EINVAL;
if (endp)
*endp = (char*)noconst(src);
if (sig)
M_NEG(res.D_s.hi, res.D_s.lo);
return res;
}
/* -------------------------------------------------------------------------*/
int
icmpv64(
const vint64 * lhs,
const vint64 * rhs
)
{
int res;
#if defined(HAVE_INT64)
res = (lhs->q_s > rhs->q_s)
- (lhs->q_s < rhs->q_s);
#else
res = (lhs->d_s.hi > rhs->d_s.hi)
- (lhs->d_s.hi < rhs->d_s.hi);
if ( ! res )
res = (lhs->D_s.lo > rhs->D_s.lo)
- (lhs->D_s.lo < rhs->D_s.lo);
#endif
return res;
}
/* -------------------------------------------------------------------------*/
int
ucmpv64(
const vint64 * lhs,
const vint64 * rhs
)
{
int res;
#if defined(HAVE_INT64)
res = (lhs->Q_s > rhs->Q_s)
- (lhs->Q_s < rhs->Q_s);
#else
res = (lhs->D_s.hi > rhs->D_s.hi)
- (lhs->D_s.hi < rhs->D_s.hi);
if ( ! res )
res = (lhs->D_s.lo > rhs->D_s.lo)
- (lhs->D_s.lo < rhs->D_s.lo);
#endif
return res;
}
/* -------------------------------------------------------------------------*/
vint64
addv64(
const vint64 *lhs,
const vint64 *rhs
)
{
vint64 res;
#if defined(HAVE_INT64)
res.Q_s = lhs->Q_s + rhs->Q_s;
#else
res = *lhs;
M_ADD(res.D_s.hi, res.D_s.lo, rhs->D_s.hi, rhs->D_s.lo);
#endif
return res;
}
/* -------------------------------------------------------------------------*/
vint64
subv64(
const vint64 *lhs,
const vint64 *rhs
)
{
vint64 res;
#if defined(HAVE_INT64)
res.Q_s = lhs->Q_s - rhs->Q_s;
#else
res = *lhs;
M_SUB(res.D_s.hi, res.D_s.lo, rhs->D_s.hi, rhs->D_s.lo);
#endif
return res;
}
/* -------------------------------------------------------------------------*/
vint64
addv64i32(
const vint64 * lhs,
int32_t rhs
)
{
vint64 res;
res = *lhs;
#if defined(HAVE_INT64)
res.q_s += rhs;
#else
M_ADD(res.D_s.hi, res.D_s.lo, -(rhs < 0), rhs);
#endif
return res;
}
/* -------------------------------------------------------------------------*/
vint64
subv64i32(
const vint64 * lhs,
int32_t rhs
)
{
vint64 res;
res = *lhs;
#if defined(HAVE_INT64)
res.q_s -= rhs;
#else
M_SUB(res.D_s.hi, res.D_s.lo, -(rhs < 0), rhs);
#endif
return res;
}
/* -------------------------------------------------------------------------*/
vint64
addv64u32(
const vint64 * lhs,
uint32_t rhs
)
{
vint64 res;
res = *lhs;
#if defined(HAVE_INT64)
res.Q_s += rhs;
#else
M_ADD(res.D_s.hi, res.D_s.lo, 0, rhs);
#endif
return res;
}
/* -------------------------------------------------------------------------*/
vint64
subv64u32(
const vint64 * lhs,
uint32_t rhs
)
{
vint64 res;
res = *lhs;
#if defined(HAVE_INT64)
res.Q_s -= rhs;
#else
M_SUB(res.D_s.hi, res.D_s.lo, 0, rhs);
#endif
return res;
}