#include <namespace.h>
#include "xlocale_private.h"
#include <stdio.h>
#include <wchar.h>
#include <assert.h>
#include <locale.h>
#include <limits.h>
#define dtoa __dtoa
#define freedtoa __freedtoa
#include <float.h>
#include <math.h>
#include "gdtoa.h"
#include "floatio.h"
#include "printf.h"
#include "xprintf_private.h"
#include <un-namespace.h>
#define BUF 100
#define DEFPREC 6
#define PRINTANDPAD(p, ep, len, with) do { \
n2 = (ep) - (p); \
if (n2 > (len)) \
n2 = (len); \
if (n2 > 0) \
ret += __printf_puts(io, (p), n2); \
ret += __printf_pad(io, (len) - (n2 > 0 ? n2 : 0), (with)); \
} while(0)
extern const char *__fix_nogrouping(const char *str);
#define to_char(n) ((n) + '0')
static int
exponent(char *p0, int expo, int fmtch)
{
char *p, *t;
char expbuf[MAXEXPDIG];
p = p0;
*p++ = fmtch;
if (expo < 0) {
expo = -expo;
*p++ = '-';
}
else
*p++ = '+';
t = expbuf + MAXEXPDIG;
if (expo > 9) {
do {
*--t = to_char(expo % 10);
} while ((expo /= 10) > 9);
*--t = to_char(expo);
for (; t < expbuf + MAXEXPDIG; *p++ = *t++)
;
}
else {
if (fmtch == 'e' || fmtch == 'E')
*p++ = '0';
*p++ = to_char(expo);
}
return (p - p0);
}
__private_extern__ int
__printf_arginfo_float(const struct printf_info *pi, size_t n, int *argt)
{
assert (n > 0);
#ifdef VECTORS
if (pi->is_vec)
argt[0] = PA_VECTOR;
else {
#endif
argt[0] = PA_DOUBLE;
if (pi->is_long_double)
argt[0] |= PA_FLAG_LONG_DOUBLE;
#ifdef VECTORS
}
#endif
return (1);
}
__private_extern__ int
__printf_render_float(struct __printf_io *io, const struct printf_info *pi, const void *const *arg)
{
int prec;
char *dtoaresult;
char expchar;
char *cp;
int expt;
int signflag;
char *dtoaend;
char sign;
int size;
int ndig;
int expsize;
char expstr[MAXEXPDIG+2];
int nseps;
int nrepeats;
const char *grouping;
int lead;
long double ld;
double d;
int realsz;
int dprec;
char ox[2];
int prsize;
int ret;
const char *decimal_point;
int decimal_point_len;
int n2;
const char *thousands_sep;
int thousands_sep_len;
char buf[BUF];
const char *xdigs;
int flag;
#ifdef VECTORS
if (pi->is_vec) return __xprintf_vector(io, pi, arg);
#endif
prec = pi->prec;
ox[1] = '\0';
sign = pi->signchar;
flag = 0;
ret = 0;
thousands_sep = localeconv_l(pi->loc)->thousands_sep;
thousands_sep_len = strlen(thousands_sep);
grouping = NULL;
if (pi->group)
grouping = __fix_nogrouping(localeconv_l(pi->loc)->grouping);
decimal_point = localeconv_l(pi->loc)->decimal_point;
decimal_point_len = strlen(decimal_point);
dprec = -1;
switch(pi->spec) {
case 'a':
case 'A':
if (pi->spec == 'a') {
ox[1] = 'x';
xdigs = __lowercase_hex;
expchar = 'p';
} else {
ox[1] = 'X';
xdigs = __uppercase_hex;
expchar = 'P';
}
if (prec >= 0)
prec++;
if (pi->is_long_double) {
ld = *((long double *)arg[0]);
dtoaresult = cp =
__hldtoa(ld, xdigs, prec,
&expt, &signflag, &dtoaend);
} else {
d = *((double *)arg[0]);
dtoaresult = cp =
__hdtoa(d, xdigs, prec,
&expt, &signflag, &dtoaend);
}
if (prec < 0)
prec = dtoaend - cp;
if (expt == INT_MAX)
ox[1] = '\0';
goto fp_common;
case 'e':
case 'E':
expchar = pi->spec;
if (prec < 0)
prec = DEFPREC + 1;
else
prec++;
break;
case 'f':
case 'F':
expchar = '\0';
break;
case 'g':
case 'G':
expchar = pi->spec - ('g' - 'e');
if (prec == 0)
prec = 1;
break;
default:
assert(pi->spec == 'f');
}
if (prec < 0)
prec = DEFPREC;
if (pi->is_long_double) {
ld = *((long double *)arg[0]);
dtoaresult = cp =
__ldtoa(&ld, expchar ? 2 : 3, prec,
&expt, &signflag, &dtoaend);
} else {
d = *((double *)arg[0]);
dtoaresult = cp =
dtoa(d, expchar ? 2 : 3, prec,
&expt, &signflag, &dtoaend);
if (expt == 9999)
expt = INT_MAX;
}
fp_common:
if (signflag)
sign = '-';
if (expt == INT_MAX) {
if (*cp == 'N') {
cp = (pi->spec >= 'a') ? "nan" : "NAN";
sign = '\0';
} else
cp = (pi->spec >= 'a') ? "inf" : "INF";
size = 3;
flag = 1;
goto here;
}
ndig = dtoaend - cp;
if (pi->spec == 'g' || pi->spec == 'G') {
if (expt > -4 && expt <= prec) {
expchar = '\0';
if (pi->alt)
prec -= expt;
else
prec = ndig - expt;
if (prec < 0)
prec = 0;
} else {
if (!pi->alt)
prec = ndig;
}
}
if (expchar) {
expsize = exponent(expstr, expt - 1, expchar);
size = expsize + prec;
if (prec > 1 || pi->alt)
++size;
} else {
if (expt > 0)
size = expt;
else
size = 1;
if (prec || pi->alt)
size += prec + 1;
if (grouping && expt > 0) {
nseps = nrepeats = 0;
lead = expt;
while (*grouping != CHAR_MAX) {
if (lead <= *grouping)
break;
lead -= *grouping;
if (*(grouping+1)) {
nseps++;
grouping++;
} else
nrepeats++;
}
size += nseps + nrepeats;
} else
lead = expt;
}
here:
realsz = dprec > size ? dprec : size;
if (sign)
realsz++;
if (ox[1])
realsz += 2;
prsize = pi->width > realsz ? pi->width : realsz;
if (pi->pad != '0' && pi->left == 0)
ret += __printf_pad(io, pi->width - realsz, 0);
if (sign)
ret += __printf_puts(io, &sign, 1);
if (ox[1]) {
ox[0] = '0';
ret += __printf_puts(io, ox, 2);
}
if (pi->pad == '0' && pi->left == 0)
ret += __printf_pad(io, pi->width - realsz, 1);
ret += __printf_pad(io, dprec - size, 1);
if (flag)
ret += __printf_puts(io, cp, size);
else {
if (!expchar) {
if (expt <= 0) {
ret += __printf_puts(io, "0", 1);
if (prec || pi->alt)
ret += __printf_puts(io, decimal_point, decimal_point_len);
ret += __printf_pad(io, -expt, 1);
prec += expt;
} else {
PRINTANDPAD(cp, dtoaend, lead, 1);
cp += lead;
if (grouping) {
while (nseps>0 || nrepeats>0) {
if (nrepeats > 0)
nrepeats--;
else {
grouping--;
nseps--;
}
ret += __printf_puts(io, thousands_sep, thousands_sep_len);
PRINTANDPAD(cp,dtoaend,
*grouping, 1);
cp += *grouping;
}
if (cp > dtoaend)
cp = dtoaend;
}
if (prec || pi->alt)
ret += __printf_puts(io, decimal_point, decimal_point_len);
}
PRINTANDPAD(cp, dtoaend, prec, 1);
} else {
if (prec > 1 || pi->alt) {
buf[0] = *cp++;
memcpy(buf + 1, decimal_point, decimal_point_len);
ret += __printf_puts(io, buf, decimal_point_len + 1);
ret += __printf_puts(io, cp, ndig-1);
ret += __printf_pad(io, prec - ndig, 1);
} else
ret += __printf_puts(io, cp, 1);
ret += __printf_puts(io, expstr, expsize);
}
}
if (pi->left)
ret += __printf_pad(io, pi->width - realsz, 0);
__printf_flush(io);
if (dtoaresult != NULL)
freedtoa(dtoaresult);
return (ret);
}