HardenedBSD/lib/libc/stdio/xprintf_float.c

/*-
 * SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright (c) 2005 Poul-Henning Kamp
 * Copyright (c) 1990, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Chris Torek.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <namespace.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 <un-namespace.h>

/*
 * The size of the buffer we use as scratch space for integer
 * conversions, among other things.  Technically, we would need the
 * most space for base 10 conversions with thousands' grouping
 * characters between each pair of digits.  100 bytes is a
 * conservative overestimate even for a 128-bit uintmax_t.
 */
#define	BUF	100

#define	DEFPREC		6	/* Default FP precision */


/* various globals ---------------------------------------------------*/


/* padding function---------------------------------------------------*/

#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)

/* misc --------------------------------------------------------------*/

#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 {
		/*
		 * Exponents for decimal floating point conversions
		 * (%[eEgG]) must be at least two characters long,
		 * whereas exponents for hexadecimal conversions can
		 * be only one character long.
		 */
		if (fmtch == 'e' || fmtch == 'E')
			*p++ = '0';
		*p++ = to_char(expo);
	}
	return (p - p0);
}

/* 'f' ---------------------------------------------------------------*/

int
__printf_arginfo_float(const struct printf_info *pi, size_t n, int *argt)
{
	assert (n > 0);
	argt[0] = PA_DOUBLE;
	if (pi->is_long_double)
		argt[0] |= PA_FLAG_LONG_DOUBLE;
	return (1);
}

/*
 * We can decompose the printed representation of floating
 * point numbers into several parts, some of which may be empty:
 *
 * [+|-| ] [0x|0X] MMM . NNN [e|E|p|P] [+|-] ZZ
 *    A       B     ---C---      D       E   F
 *
 * A:	'sign' holds this value if present; '\0' otherwise
 * B:	ox[1] holds the 'x' or 'X'; '\0' if not hexadecimal
 * C:	cp points to the string MMMNNN.  Leading and trailing
 *	zeros are not in the string and must be added.
 * D:	expchar holds this character; '\0' if no exponent, e.g. %f
 * F:	at least two digits for decimal, at least one digit for hex
 */

int
__printf_render_float(struct __printf_io *io, const struct printf_info *pi, const void *const *arg)
{
	int prec;		/* precision from format; <0 for N/A */
	char *dtoaresult;	/* buffer allocated by dtoa */
	char expchar;		/* exponent character: [eEpP\0] */
	char *cp;
	int expt;		/* integer value of exponent */
	int signflag;		/* true if float is negative */
	char *dtoaend;		/* pointer to end of converted digits */
	char sign;		/* sign prefix (' ', '+', '-', or \0) */
	int size;		/* size of converted field or string */
	int ndig;		/* actual number of digits returned by dtoa */
	int expsize;		/* character count for expstr */
	char expstr[MAXEXPDIG+2];	/* buffer for exponent string: e+ZZZ */
	int nseps;		/* number of group separators with ' */
	int nrepeats;		/* number of repeats of the last group */
	const char *grouping;	/* locale specific numeric grouping rules */
	int lead;		/* sig figs before decimal or group sep */
	long double ld;
	double d;
	int realsz;		/* field size expanded by dprec, sign, etc */
	int dprec;		/* a copy of prec if [diouxX], 0 otherwise */
	char ox[2];		/* space for 0x; ox[1] is either x, X, or \0 */
	int ret;		/* return value accumulator */
	char *decimal_point;	/* locale specific decimal point */
	int n2;			/* XXX: for PRINTANDPAD */
	char thousands_sep;	/* locale specific thousands separator */
	char buf[BUF];		/* buffer with space for digits of uintmax_t */
	const char *xdigs;
	int flag;

	prec = pi->prec;
	ox[1] = '\0';
	sign = pi->showsign;
	flag = 0;
	ret = 0;

	thousands_sep = *(localeconv()->thousands_sep);
	grouping = NULL;
	if (pi->alt)
		grouping = localeconv()->grouping;
	decimal_point = localeconv()->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)	/* account for digit before decpt */
			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) {	/* inf or nan */
		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) {
			/* Make %[gG] smell like %[fF] */
			expchar = '\0';
			if (pi->alt)
				prec -= expt;
			else
				prec = ndig - expt;
			if (prec < 0)
				prec = 0;
		} else {
			/*
			 * Make %[gG] smell like %[eE], but
			 * trim trailing zeroes if no # flag.
			 */
			if (!pi->alt)
				prec = ndig;
		}
	}
	if (expchar) {
		expsize = exponent(expstr, expt - 1, expchar);
		size = expsize + prec;
		if (prec > 1 || pi->alt)
			++size;
	} else {
		/* space for digits before decimal point */
		if (expt > 0)
			size = expt;
		else	/* "0" */
			size = 1;
		/* space for decimal pt and following digits */
		if (prec || pi->alt)
			size += prec + 1;
		if (grouping && expt > 0) {
			/* space for thousands' grouping */
			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:
	/*
	 * All reasonable formats wind up here.  At this point, `cp'
	 * points to a string which (if not flags&LADJUST) should be
	 * padded out to `width' places.  If flags&ZEROPAD, it should
	 * first be prefixed by any sign or other prefix; otherwise,
	 * it should be blank padded before the prefix is emitted.
	 * After any left-hand padding and prefixing, emit zeroes
	 * required by a decimal [diouxX] precision, then print the
	 * string proper, then emit zeroes required by any leftover
	 * floating precision; finally, if LADJUST, pad with blanks.
	 *
	 * Compute actual size, so we know how much to pad.
	 * size excludes decimal prec; realsz includes it.
	 */
	realsz = dprec > size ? dprec : size;
	if (sign)
		realsz++;
	if (ox[1])
		realsz += 2;

	/* right-adjusting blank padding */
	if (pi->pad != '0' && pi->left == 0)
		ret += __printf_pad(io, pi->width - realsz, 0);

	/* prefix */
	if (sign)
		ret += __printf_puts(io, &sign, 1);

	if (ox[1]) {	/* ox[1] is either x, X, or \0 */
		ox[0] = '0';
		ret += __printf_puts(io, ox, 2);
	}

	/* right-adjusting zero padding */
	if (pi->pad == '0' && pi->left == 0)
		ret += __printf_pad(io, pi->width - realsz, 1);

	/* leading zeroes from decimal precision */
	ret += __printf_pad(io, dprec - size, 1);

	if (flag)
		ret += __printf_puts(io, cp, size);
	else {
		/* glue together f_p fragments */
		if (!expchar) {	/* %[fF] or sufficiently short %[gG] */
			if (expt <= 0) {
				ret += __printf_puts(io, "0", 1);
				if (prec || pi->alt)
					ret += __printf_puts(io, decimal_point, 1);
				ret += __printf_pad(io, -expt, 1);
				/* already handled initial 0's */
				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, 1);
						PRINTANDPAD(cp,dtoaend,
						    *grouping, 1);
						cp += *grouping;
					}
					if (cp > dtoaend)
						cp = dtoaend;
				}
				if (prec || pi->alt)
					ret += __printf_puts(io, decimal_point,1);
			}
			PRINTANDPAD(cp, dtoaend, prec, 1);
		} else {	/* %[eE] or sufficiently long %[gG] */
			if (prec > 1 || pi->alt) {
				buf[0] = *cp++;
				buf[1] = *decimal_point;
				ret += __printf_puts(io, buf, 2);
				ret += __printf_puts(io, cp, ndig-1);
				ret += __printf_pad(io, prec - ndig, 1);
			} else	/* XeYYY */
				ret += __printf_puts(io, cp, 1);
			ret += __printf_puts(io, expstr, expsize);
		}
	}
	/* left-adjusting padding (always blank) */
	if (pi->left)
		ret += __printf_pad(io, pi->width - realsz, 0);

	__printf_flush(io);
	if (dtoaresult != NULL)
		freedtoa(dtoaresult);

	return (ret);
}