/*
* dolfptoa - do the grunge work of converting an l_fp number to decimal
*/
#include <config.h>
#include <stdio.h>
#include "ntp_fp.h"
#include "lib_strbuf.h"
#include "ntp_string.h"
#include "ntp_stdlib.h"
char *
dolfptoa(
u_int32 fpi,
u_int32 fpv,
int neg,
short ndec,
int msec
)
{
u_char *cp, *cpend, *cpdec;
int dec;
u_char cbuf[24];
char *buf, *bp;
/*
* Get a string buffer before starting
*/
LIB_GETBUF(buf);
/*
* Zero the character buffer
*/
ZERO(cbuf);
/*
* Work on the integral part. This should work reasonable on
* all machines with 32 bit arithmetic. Please note that 32 bits
* can *always* be represented with at most 10 decimal digits,
* including a possible rounding from the fractional part.
*/
cp = cpend = cpdec = &cbuf[10];
for (dec = (int)(cp - cbuf); dec > 0 && fpi != 0; dec--) {
/* can add another digit */
u_int32 digit;
digit = fpi;
fpi /= 10U;
digit -= (fpi << 3) + (fpi << 1); /* i*10 */
*--cp = (u_char)digit;
}
/*
* Done that, now deal with the problem of the fraction. First
* determine the number of decimal places.
*/
dec = ndec;
if (dec < 0)
dec = 0;
if (msec) {
dec += 3;
cpdec += 3;
}
if ((size_t)dec > sizeof(cbuf) - (cpend - cbuf))
dec = (int)(sizeof(cbuf) - (cpend - cbuf));
/*
* If there's a fraction to deal with, do so.
*/
for (/*NOP*/; dec > 0 && fpv != 0; dec--) {
u_int32 digit, tmph, tmpl;
/*
* The scheme here is to multiply the fraction
* (0.1234...) by ten. This moves a junk of BCD into
* the units part. record that and iterate.
* multiply by shift/add in two dwords.
*/
digit = 0;
M_LSHIFT(digit, fpv);
tmph = digit;
tmpl = fpv;
M_LSHIFT(digit, fpv);
M_LSHIFT(digit, fpv);
M_ADD(digit, fpv, tmph, tmpl);
*cpend++ = (u_char)digit;
}
/* decide whether to round or simply extend by zeros */
if (dec > 0) {
/* only '0' digits left -- just reposition end */
cpend += dec;
} else {
/* some bits remain in 'fpv'; do round */
u_char *tp = cpend;
int carry = ((fpv & 0x80000000) != 0);
for (dec = (int)(tp - cbuf); carry && dec > 0; dec--) {
*--tp += 1;
if (*tp == 10)
*tp = 0;
else
carry = FALSE;
}
if (tp < cp) /* rounding from 999 to 1000 or similiar? */
cp = tp;
}
/*
* We've now got the fraction in cbuf[], with cp pointing at
* the first character, cpend pointing past the last, and
* cpdec pointing at the first character past the decimal.
* Remove leading zeros, then format the number into the
* buffer.
*/
while (cp < cpdec && *cp == 0)
cp++;
if (cp >= cpdec)
cp = cpdec - 1;
bp = buf;
if (neg)
*bp++ = '-';
while (cp < cpend) {
if (cp == cpdec)
*bp++ = '.';
*bp++ = (char)(*cp++) + '0';
}
*bp = '\0';
/*
* Done!
*/
return buf;
}
char *
mfptoa(
u_int32 fpi,
u_int32 fpf,
short ndec
)
{
int isneg;
isneg = M_ISNEG(fpi);
if (isneg) {
M_NEG(fpi, fpf);
}
return dolfptoa(fpi, fpf, isneg, ndec, FALSE);
}
char *
mfptoms(
u_int32 fpi,
u_int32 fpf,
short ndec
)
{
int isneg;
isneg = M_ISNEG(fpi);
if (isneg) {
M_NEG(fpi, fpf);
}
return dolfptoa(fpi, fpf, isneg, ndec, TRUE);
}