float
disrf(int stream, int *retval)
{
int expon;
unsigned uexpon;
int locret;
int negate;
/* following were static vars, so initializing them to defaults */
unsigned ndigs=0; /* 3 vars now stack variables for threads */
unsigned nskips=0;
double dval=0.0;
assert(retval != NULL);
assert(stream >= 0);
assert(dis_getc != NULL);
assert(dis_gets != NULL);
assert(disr_skip != NULL);
assert(disr_commit != NULL);
dval = 0.0;
if ((locret = disrd_(stream, 1, &ndigs, &nskips, &dval, 0)) == DIS_SUCCESS) {
locret = disrsi_(stream, &negate, &uexpon, 1, 0);
if (locret == DIS_SUCCESS) {
expon = negate ? nskips - uexpon : nskips + uexpon;
if (expon + (int)ndigs > FLT_MAX_10_EXP) {
if (expon + (int)ndigs > FLT_MAX_10_EXP + 1) {
dval = dval < 0.0 ?
-HUGE_VAL : HUGE_VAL;
locret = DIS_OVERFLOW;
} else {
dval *= disp10d_(expon - 1);
if (dval > FLT_MAX / 10.0) {
dval = dval < 0.0 ?
-HUGE_VAL : HUGE_VAL;
locret = DIS_OVERFLOW;
} else
dval *= 10.0;
}
} else {
if (expon < DBL_MIN_10_EXP) {
dval *= disp10d_(expon + (int)ndigs);
dval /= disp10d_((int)ndigs);
} else
dval *= disp10d_(expon);
}
}
}
if ((*disr_commit)(stream, locret == DIS_SUCCESS) < 0)
locret = DIS_NOCOMMIT;
*retval = locret;
return (dval);
}
/**
* @brief
* Converts <value> into a Data-is-Strings floating point number and sends
* it to <stream>.
*
* @param[in] stream socket fd
* @param[in] value value to be converted
*
* @return int
* @retval DIS_SUCCESS success
* @retval error code error
*
*/
int
diswf(int stream, double value)
{
int c;
int expon;
unsigned ndigs;
int negate;
int retval;
unsigned pow2;
char *cp;
char *ocp;
double dval;
assert(stream >= 0);
assert(dis_puts != NULL);
assert(disw_commit != NULL);
/* Make zero a special case. If we don't it will blow exponent */
/* calculation. */
if (value == 0.0) {
retval = (*dis_puts)(stream, "+0+0", 4) != 4 ?
DIS_PROTO : DIS_SUCCESS;
return (((*disw_commit)(stream, retval == DIS_SUCCESS) < 0) ?
DIS_NOCOMMIT : retval);
}
/* Extract the sign from the coefficient. */
dval = (negate = value < 0.0) ? -value : value;
/* Detect and complain about the infinite form. */
if (dval > FLT_MAX)
return (DIS_HUGEVAL);
/* Compute the integer part of the log to the base 10 of dval. As a */
/* byproduct, reduce the range of dval to the half-open interval, */
/* [1, 10). */
/* dis_dmx10 would be initialized by prior call to dis_init_tables */
expon = 0;
pow2 = dis_dmx10 + 1;
if (dval < 1.0) {
do {
if (dval < dis_dn10[--pow2]) {
dval *= dis_dp10[pow2];
expon += 1 << pow2;
}
} while (pow2);
dval *= 10.0;
expon = -expon - 1;
} else {
do {
if (dval >= dis_dp10[--pow2]) {
dval *= dis_dn10[pow2];
expon += 1 << pow2;
}
} while (pow2);
}
/* Round the value to the last digit */
dval += 5.0 * disp10d_(-FLT_DIG);
if (dval >= 10.0) {
expon++;
dval *= 0.1;
}
/* Starting in the middle of the buffer, convert coefficient digits, */
/* most significant first. */
ocp = cp = &dis_buffer[DIS_BUFSIZ - FLT_DIG];
ndigs = FLT_DIG;
do {
c = dval;
dval = (dval - c) * 10.0;
*ocp++ = c + '0';
} while (--ndigs);
/* Eliminate trailing zeros. */
while (*--ocp == '0');
/* The decimal point is at the low order end of the coefficient */
/* integer, so adjust the exponent for the number of digits in the */
/* coefficient. */
ndigs = ++ocp - cp;
expon -= ndigs - 1;
/* Put the coefficient sign into the buffer, left of the coefficient. */
*--cp = negate ? '-' : '+';
/* Insert the necessary number of counts on the left. */
while (ndigs > 1)
cp = discui_(cp, ndigs, &ndigs);
/* The complete coefficient integer is done. Put it out. */
retval = (*dis_puts)(stream, cp, (size_t)(ocp - cp)) < 0 ?
DIS_PROTO : DIS_SUCCESS;
/* If that worked, follow with the exponent, commit, and return. */
if (retval == DIS_SUCCESS)
return (diswsi(stream, expon));
/* If coefficient didn't work, negative commit and return the error. */
return (((*disw_commit)(stream, FALSE) < 0) ? DIS_NOCOMMIT : retval);
}
