[apple/libc.git] / gdtoa / FreeBSD / gdtoa-gethex.c

/****************************************************************

The author of this software is David M. Gay.

Copyright (C) 1998 by Lucent Technologies
All Rights Reserved

Permission to use, copy, modify, and distribute this software and
its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the name of Lucent or any of its entities
not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission.

LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY
SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
THIS SOFTWARE.

****************************************************************/

/* Please send bug reports to David M. Gay (dmg at acm dot org,
 * with " at " changed at "@" and " dot " changed to ".").	*/

#include "gdtoaimp.h"

#ifdef USE_LOCALE
#include "locale.h"
#endif

 int
#ifdef KR_headers
gethex(sp, fpi, exp, bp, sign)
	CONST char **sp; FPI *fpi; Long *exp; Bigint **bp; int sign;
#else
gethex( CONST char **sp, FPI *fpi, Long *exp, Bigint **bp, int sign)
#endif
{
	Bigint *b;
	CONST unsigned char *decpt, *s0, *s, *s1;
	int esign, havedig, irv, k, n, nbits, up, zret;
	ULong L, lostbits, *x;
	Long e, e1;
#ifdef USE_LOCALE
	unsigned char decimalpoint = *localeconv()->decimal_point;
#else
#define decimalpoint '.'
#endif

	if (!hexdig['0'])
		hexdig_init_D2A();
	havedig = 0;
	s0 = *(CONST unsigned char **)sp + 2;
	while(s0[havedig] == '0')
		havedig++;
	s0 += havedig;
	s = s0;
	decpt = 0;
	zret = 0;
	e = 0;
	if (!hexdig[*s]) {
		zret = 1;
		if (*s != decimalpoint)
			goto pcheck;
		decpt = ++s;
		if (!hexdig[*s])
			goto pcheck;
		while(*s == '0')
			s++;
		if (hexdig[*s])
			zret = 0;
		havedig = 1;
		s0 = s;
		}
	while(hexdig[*s])
		s++;
	if (*s == decimalpoint && !decpt) {
		decpt = ++s;
		while(hexdig[*s])
			s++;
		}
	if (decpt)
		e = -(((Long)(s-decpt)) << 2);
 pcheck:
	s1 = s;
	switch(*s) {
	  case 'p':
	  case 'P':
		esign = 0;
		switch(*++s) {
		  case '-':
			esign = 1;
			/* no break */
		  case '+':
			s++;
		  }
		if ((n = hexdig[*s]) == 0 || n > 0x19) {
			s = s1;
			break;
			}
		e1 = n - 0x10;
		while((n = hexdig[*++s]) !=0 && n <= 0x19)
			e1 = 10*e1 + n - 0x10;
		if (esign)
			e1 = -e1;
		e += e1;
	  }
	*sp = (char*)s;
	if (zret)
		return havedig ? STRTOG_Zero : STRTOG_NoNumber;
	n = s1 - s0 - 1;
	for(k = 0; n > 7; n >>= 1)
		k++;
	b = Balloc(k);
	x = b->x;
	n = 0;
	L = 0;
	while(s1 > s0) {
		if (*--s1 == decimalpoint)
			continue;
		if (n == 32) {
			*x++ = L;
			L = 0;
			n = 0;
			}
		L |= (hexdig[*s1] & 0x0f) << n;
		n += 4;
		}
	*x++ = L;
	b->wds = n = x - b->x;
	n = 32*n - hi0bits(L);
	nbits = fpi->nbits;
	lostbits = 0;
	x = b->x;
	if (n > nbits) {
		n -= nbits;
		if (any_on(b,n)) {
			lostbits = 1;
			k = n - 1;
			if (x[k>>kshift] & 1 << (k & kmask)) {
				lostbits = 2;
				if (k > 1 && any_on(b,k-1))
					lostbits = 3;
				}
			}
		rshift(b, n);
		e += n;
		}
	else if (n < nbits) {
		n = nbits - n;
		b = lshift(b, n);
		e -= n;
		x = b->x;
		}
	if (e > fpi->emax) {
 ovfl:
		Bfree(b);
		*bp = 0;
		return STRTOG_Infinite | STRTOG_Overflow | STRTOG_Inexhi;
		}
	irv = STRTOG_Normal;
	if (e < fpi->emin) {
		irv = STRTOG_Denormal;
		n = fpi->emin - e;
		if (n >= nbits) {
			switch (fpi->rounding) {
			  case FPI_Round_near:
				if (n == nbits && (n < 2 || any_on(b,n-1)))
					goto one_bit;
				break;
			  case FPI_Round_up:
				if (!sign)
					goto one_bit;
				break;
			  case FPI_Round_down:
				if (sign) {
 one_bit:
					*exp = fpi->emin;
					x[0] = b->wds = 1;
					*bp = b;
					return STRTOG_Denormal | STRTOG_Inexhi
						| STRTOG_Underflow;
					}
			  }
			Bfree(b);
			*bp = 0;
			return STRTOG_Zero | STRTOG_Inexlo | STRTOG_Underflow;
			}
		k = n - 1;
		if (lostbits)
			lostbits = 1;
		else if (k > 0)
			lostbits = any_on(b,k);
		if (x[k>>kshift] & 1 << (k & kmask))
			lostbits |= 2;
		nbits -= n;
		rshift(b,n);
		e = fpi->emin;
		}
	if (lostbits) {
		up = 0;
		switch(fpi->rounding) {
		  case FPI_Round_zero:
			break;
		  case FPI_Round_near:
			if (lostbits & 2
			 && (lostbits & 1) | x[0] & 1)
				up = 1;
			break;
		  case FPI_Round_up:
			up = 1 - sign;
			break;
		  case FPI_Round_down:
			up = sign;
		  }
		if (up) {
			k = b->wds;
			b = increment(b);
			x = b->x;
			if (irv == STRTOG_Denormal) {
				if (nbits == fpi->nbits - 1
				 && x[nbits >> kshift] & 1 << (nbits & kmask))
					irv =  STRTOG_Normal;
				}
			else if (b->wds > k
			 || (n = nbits & kmask) !=0
			     && hi0bits(x[k-1]) < 32-n) {
				rshift(b,1);
				if (++e > fpi->emax)
					goto ovfl;
				}
			irv |= STRTOG_Inexhi;
			}
		else
			irv |= STRTOG_Inexlo;
		}
	*bp = b;
	*exp = e;
	return irv;
	}
Commit	Line	Data
9385eb3d A	1	/****************************************************************
	2
	3	The author of this software is David M. Gay.
	4
	5	Copyright (C) 1998 by Lucent Technologies
	6	All Rights Reserved
	7
	8	Permission to use, copy, modify, and distribute this software and
	9	its documentation for any purpose and without fee is hereby
	10	granted, provided that the above copyright notice appear in all
	11	copies and that both that the copyright notice and this
	12	permission notice and warranty disclaimer appear in supporting
	13	documentation, and that the name of Lucent or any of its entities
	14	not be used in advertising or publicity pertaining to
	15	distribution of the software without specific, written prior
	16	permission.
	17
	18	LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
	19	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
	20	IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY
	21	SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	22	WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
	23	IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
	24	ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
	25	THIS SOFTWARE.
	26
	27	****************************************************************/
	28
3d9156a7 A	29	/* Please send bug reports to David M. Gay (dmg at acm dot org,
3d9156a7 A	30	* with " at " changed at "@" and " dot " changed to "."). */
9385eb3d A	31
	32	#include "gdtoaimp.h"
	33
	34	#ifdef USE_LOCALE
	35	#include "locale.h"
	36	#endif
	37
	38	int
	39	#ifdef KR_headers
	40	gethex(sp, fpi, exp, bp, sign)
	41	CONST char *sp; FPI fpi; Long exp; Bigint *bp; int sign;
	42	#else
	43	gethex( CONST char *sp, FPI fpi, Long exp, Bigint *bp, int sign)
	44	#endif
	45	{
	46	Bigint *b;
	47	CONST unsigned char decpt, s0, s, s1;
3d9156a7	48	int esign, havedig, irv, k, n, nbits, up, zret;
9385eb3d A	49	ULong L, lostbits, *x;
	50	Long e, e1;
	51	#ifdef USE_LOCALE
59e0d9fe	52	unsigned char decimalpoint = *localeconv()->decimal_point;
9385eb3d A	53	#else
	54	#define decimalpoint '.'
	55	#endif
	56
	57	if (!hexdig['0'])
	58	hexdig_init_D2A();
	59	havedig = 0;
	60	s0 = (CONST unsigned char *)sp + 2;
	61	while(s0[havedig] == '0')
	62	havedig++;
	63	s0 += havedig;
	64	s = s0;
	65	decpt = 0;
3d9156a7 A	66	zret = 0;
3d9156a7 A	67	e = 0;
9385eb3d	68	if (!hexdig[*s]) {
3d9156a7 A	69	zret = 1;
	70	if (*s != decimalpoint)
	71	goto pcheck;
	72	decpt = ++s;
	73	if (!hexdig[*s])
	74	goto pcheck;
9385eb3d A	75	while(*s == '0')
9385eb3d A	76	s++;
3d9156a7 A	77	if (hexdig[*s])
3d9156a7 A	78	zret = 0;
9385eb3d	79	havedig = 1;
9385eb3d A	80	s0 = s;
	81	}
	82	while(hexdig[*s])
	83	s++;
	84	if (*s == decimalpoint && !decpt) {
	85	decpt = ++s;
	86	while(hexdig[*s])
	87	s++;
	88	}
9385eb3d A	89	if (decpt)
9385eb3d A	90	e = -(((Long)(s-decpt)) << 2);
3d9156a7	91	pcheck:
9385eb3d A	92	s1 = s;
	93	switch(*s) {
	94	case 'p':
	95	case 'P':
	96	esign = 0;
	97	switch(*++s) {
	98	case '-':
	99	esign = 1;
	100	/* no break */
	101	case '+':
	102	s++;
	103	}
	104	if ((n = hexdig[*s]) == 0 \|\| n > 0x19) {
	105	s = s1;
	106	break;
	107	}
	108	e1 = n - 0x10;
	109	while((n = hexdig[*++s]) !=0 && n <= 0x19)
	110	e1 = 10*e1 + n - 0x10;
	111	if (esign)
	112	e1 = -e1;
	113	e += e1;
	114	}
	115	sp = (char)s;
3d9156a7 A	116	if (zret)
3d9156a7 A	117	return havedig ? STRTOG_Zero : STRTOG_NoNumber;
9385eb3d A	118	n = s1 - s0 - 1;
	119	for(k = 0; n > 7; n >>= 1)
	120	k++;
	121	b = Balloc(k);
	122	x = b->x;
	123	n = 0;
	124	L = 0;
	125	while(s1 > s0) {
	126	if (*--s1 == decimalpoint)
	127	continue;
	128	if (n == 32) {
	129	*x++ = L;
	130	L = 0;
	131	n = 0;
	132	}
	133	L \|= (hexdig[*s1] & 0x0f) << n;
	134	n += 4;
	135	}
	136	*x++ = L;
	137	b->wds = n = x - b->x;
	138	n = 32*n - hi0bits(L);
	139	nbits = fpi->nbits;
	140	lostbits = 0;
	141	x = b->x;
	142	if (n > nbits) {
	143	n -= nbits;
	144	if (any_on(b,n)) {
	145	lostbits = 1;
	146	k = n - 1;
	147	if (x[k>>kshift] & 1 << (k & kmask)) {
	148	lostbits = 2;
	149	if (k > 1 && any_on(b,k-1))
	150	lostbits = 3;
	151	}
	152	}
	153	rshift(b, n);
	154	e += n;
	155	}
	156	else if (n < nbits) {
	157	n = nbits - n;
	158	b = lshift(b, n);
	159	e -= n;
	160	x = b->x;
	161	}
	162	if (e > fpi->emax) {
	163	ovfl:
	164	Bfree(b);
59e0d9fe	165	*bp = 0;
9385eb3d A	166	return STRTOG_Infinite \| STRTOG_Overflow \| STRTOG_Inexhi;
	167	}
	168	irv = STRTOG_Normal;
	169	if (e < fpi->emin) {
	170	irv = STRTOG_Denormal;
	171	n = fpi->emin - e;
	172	if (n >= nbits) {
	173	switch (fpi->rounding) {
	174	case FPI_Round_near:
59e0d9fe	175	if (n == nbits && (n < 2 \|\| any_on(b,n-1)))
9385eb3d A	176	goto one_bit;
	177	break;
	178	case FPI_Round_up:
	179	if (!sign)
	180	goto one_bit;
	181	break;
	182	case FPI_Round_down:
	183	if (sign) {
	184	one_bit:
	185	*exp = fpi->emin;
	186	x[0] = b->wds = 1;
	187	*bp = b;
	188	return STRTOG_Denormal \| STRTOG_Inexhi
	189	\| STRTOG_Underflow;
	190	}
	191	}
	192	Bfree(b);
59e0d9fe	193	*bp = 0;
9385eb3d A	194	return STRTOG_Zero \| STRTOG_Inexlo \| STRTOG_Underflow;
	195	}
	196	k = n - 1;
	197	if (lostbits)
	198	lostbits = 1;
	199	else if (k > 0)
	200	lostbits = any_on(b,k);
	201	if (x[k>>kshift] & 1 << (k & kmask))
	202	lostbits \|= 2;
	203	nbits -= n;
	204	rshift(b,n);
	205	e = fpi->emin;
	206	}
	207	if (lostbits) {
	208	up = 0;
	209	switch(fpi->rounding) {
	210	case FPI_Round_zero:
	211	break;
	212	case FPI_Round_near:
	213	if (lostbits & 2
	214	&& (lostbits & 1) \| x[0] & 1)
	215	up = 1;
	216	break;
	217	case FPI_Round_up:
	218	up = 1 - sign;
	219	break;
	220	case FPI_Round_down:
	221	up = sign;
	222	}
	223	if (up) {
	224	k = b->wds;
	225	b = increment(b);
	226	x = b->x;
59e0d9fe A	227	if (irv == STRTOG_Denormal) {
	228	if (nbits == fpi->nbits - 1
	229	&& x[nbits >> kshift] & 1 << (nbits & kmask))
	230	irv = STRTOG_Normal;
	231	}
	232	else if (b->wds > k
9385eb3d A	233	\|\| (n = nbits & kmask) !=0
	234	&& hi0bits(x[k-1]) < 32-n) {
	235	rshift(b,1);
	236	if (++e > fpi->emax)
	237	goto ovfl;
	238	}
9385eb3d A	239	irv \|= STRTOG_Inexhi;
	240	}
	241	else
	242	irv \|= STRTOG_Inexlo;
	243	}
	244	*bp = b;
	245	*exp = e;
	246	return irv;
	247	}