[apple/libc.git] / gdtoa / FreeBSD / _ldtoa.c

/*-
 * Copyright (c) 2003 David Schultz <das@FreeBSD.ORG>
 * All rights reserved.
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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 <sys/cdefs.h>
__FBSDID("$FreeBSD: src/lib/libc/gdtoa/_ldtoa.c,v 1.5 2007/12/09 19:48:57 das Exp $");

#include <float.h>
#include <inttypes.h>
#include <limits.h>
#include <math.h>
#include <stdlib.h>
#include "fpmath.h"
#include "gdtoaimp.h"

/*
 * ldtoa() is a wrapper for gdtoa() that makes it smell like dtoa(),
 * except that the floating point argument is passed by reference.
 * When dtoa() is passed a NaN or infinity, it sets expt to 9999.
 * However, a long double could have a valid exponent of 9999, so we
 * use INT_MAX in ldtoa() instead.
 */
char *
__ldtoa(long double *ld, int mode, int ndigits, int *decpt, int *sign,
    char **rve)
{
#if defined(__arm__) || defined(__arm64__)
	/* On arm, double == long double, so short circuit this */
	char * ret = __dtoa((double)*ld, mode, ndigits, decpt, sign, rve);
	if (*decpt == 9999)
		*decpt = INT_MAX;
	return ret;
#else
	FPI fpi = {
		LDBL_MANT_DIG,			/* nbits */
		LDBL_MIN_EXP - LDBL_MANT_DIG,	/* emin */
		LDBL_MAX_EXP - LDBL_MANT_DIG,	/* emax */
		FLT_ROUNDS,	       		/* rounding */
#ifdef Sudden_Underflow	/* unused, but correct anyway */
		1
#else
		0
#endif
	};
	int be, kind;
	char *ret;
	union IEEEl2bits u;
	uint32_t bits[(LDBL_MANT_DIG + 31) / 32];
	void *vbits = bits;
	int type;

	u.e = *ld;
	type = fpclassify(u.e);

	/*
	 * gdtoa doesn't know anything about the sign of the number, so
	 * if the number is negative, we need to swap rounding modes of
	 * 2 (upwards) and 3 (downwards).
	 */
	*sign = u.bits.sign;
	fpi.rounding ^= (fpi.rounding >> 1) & u.bits.sign;

	be = u.bits.exp - (LDBL_MAX_EXP - 1) - (LDBL_MANT_DIG - 1);
	LDBL_TO_ARRAY32(u, bits);

	switch (type) {
	case FP_NORMAL:
	case FP_SUPERNORMAL:
		kind = STRTOG_Normal;
#ifdef	LDBL_IMPLICIT_NBIT
		bits[LDBL_MANT_DIG / 32] |= 1 << ((LDBL_MANT_DIG - 1) % 32);
#endif /* LDBL_IMPLICIT_NBIT */
		break;
	case FP_ZERO:
		kind = STRTOG_Zero;
		break;
	case FP_SUBNORMAL:
		kind = STRTOG_Denormal;
		be++;
		break;
	case FP_INFINITE:
		kind = STRTOG_Infinite;
		break;
	case FP_NAN:
		kind = STRTOG_NaN;
		break;
	default:
		LIBC_ABORT("fpclassify returned %d", type);
	}

	ret = gdtoa(&fpi, be, vbits, &kind, mode, ndigits, decpt, rve);
	if (*decpt == -32768)
		*decpt = INT_MAX;
	return ret;
#endif
}
Commit	Line	Data
9385eb3d A	1	/*-
	2	* Copyright (c) 2003 David Schultz <das@FreeBSD.ORG>
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	* 1. Redistributions of source code must retain the above copyright
	9	* notice, this list of conditions and the following disclaimer.
	10	* 2. Redistributions in binary form must reproduce the above copyright
	11	* notice, this list of conditions and the following disclaimer in the
	12	* documentation and/or other materials provided with the distribution.
	13	*
	14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
	15	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	16	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	17	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
	18	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	19	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	20	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	21	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	22	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	23	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	24	* SUCH DAMAGE.
	25	*/
	26
	27	#include <sys/cdefs.h>
ad3c9f2a	28	__FBSDID("$FreeBSD: src/lib/libc/gdtoa/_ldtoa.c,v 1.5 2007/12/09 19:48:57 das Exp $");
9385eb3d A	29
	30	#include <float.h>
	31	#include <inttypes.h>
	32	#include <limits.h>
	33	#include <math.h>
	34	#include <stdlib.h>
	35	#include "fpmath.h"
	36	#include "gdtoaimp.h"
	37
	38	/*
	39	* ldtoa() is a wrapper for gdtoa() that makes it smell like dtoa(),
	40	* except that the floating point argument is passed by reference.
	41	* When dtoa() is passed a NaN or infinity, it sets expt to 9999.
	42	* However, a long double could have a valid exponent of 9999, so we
	43	* use INT_MAX in ldtoa() instead.
	44	*/
	45	char *
	46	__ldtoa(long double ld, int mode, int ndigits, int decpt, int *sign,
	47	char **rve)
	48	{
b061a43b	49	#if defined(__arm__) \|\| defined(__arm64__)
ad3c9f2a A	50	/* On arm, double == long double, so short circuit this */
	51	char * ret = __dtoa((double)*ld, mode, ndigits, decpt, sign, rve);
	52	if (*decpt == 9999)
	53	*decpt = INT_MAX;
	54	return ret;
	55	#else
	56	FPI fpi = {
9385eb3d A	57	LDBL_MANT_DIG, /* nbits */
	58	LDBL_MIN_EXP - LDBL_MANT_DIG, /* emin */
	59	LDBL_MAX_EXP - LDBL_MANT_DIG, /* emax */
ad3c9f2a	60	FLT_ROUNDS, /* rounding */
9385eb3d A	61	#ifdef Sudden_Underflow /* unused, but correct anyway */
	62	1
	63	#else
	64	0
	65	#endif
	66	};
	67	int be, kind;
	68	char *ret;
	69	union IEEEl2bits u;
	70	uint32_t bits[(LDBL_MANT_DIG + 31) / 32];
ad3c9f2a A	71	void *vbits = bits;
ad3c9f2a A	72	int type;
9385eb3d A	73
9385eb3d A	74	u.e = *ld;
ad3c9f2a A	75	type = fpclassify(u.e);
	76
	77	/*
	78	* gdtoa doesn't know anything about the sign of the number, so
	79	* if the number is negative, we need to swap rounding modes of
	80	* 2 (upwards) and 3 (downwards).
	81	*/
9385eb3d	82	*sign = u.bits.sign;
ad3c9f2a A	83	fpi.rounding ^= (fpi.rounding >> 1) & u.bits.sign;
ad3c9f2a A	84
9385eb3d A	85	be = u.bits.exp - (LDBL_MAX_EXP - 1) - (LDBL_MANT_DIG - 1);
	86	LDBL_TO_ARRAY32(u, bits);
	87
ad3c9f2a	88	switch (type) {
9385eb3d	89	case FP_NORMAL:
ad3c9f2a	90	case FP_SUPERNORMAL:
9385eb3d A	91	kind = STRTOG_Normal;
	92	#ifdef LDBL_IMPLICIT_NBIT
	93	bits[LDBL_MANT_DIG / 32] \|= 1 << ((LDBL_MANT_DIG - 1) % 32);
	94	#endif /* LDBL_IMPLICIT_NBIT */
	95	break;
	96	case FP_ZERO:
	97	kind = STRTOG_Zero;
	98	break;
	99	case FP_SUBNORMAL:
	100	kind = STRTOG_Denormal;
59e0d9fe	101	be++;
9385eb3d A	102	break;
	103	case FP_INFINITE:
	104	kind = STRTOG_Infinite;
	105	break;
	106	case FP_NAN:
	107	kind = STRTOG_NaN;
	108	break;
	109	default:
ad3c9f2a	110	LIBC_ABORT("fpclassify returned %d", type);
9385eb3d A	111	}
9385eb3d A	112
ad3c9f2a	113	ret = gdtoa(&fpi, be, vbits, &kind, mode, ndigits, decpt, rve);
9385eb3d A	114	if (*decpt == -32768)
	115	*decpt = INT_MAX;
	116	return ret;
ad3c9f2a	117	#endif
9385eb3d	118	}