[binutils.git] / gas / flonum.h

/* flonum.h - Floating point package

   Copyright (C) 1987, 1990, 1991, 1992, 1994 Free Software Foundation, Inc.

   This file is part of GAS, the GNU Assembler.

   GAS is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   GAS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GAS; see the file COPYING.  If not, write to
   the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

/***********************************************************************\
 *									*
 *	Arbitrary-precision floating point arithmetic.			*
 *									*
 *									*
 *	Notation: a floating point number is expressed as		*
 *	MANTISSA * (2 ** EXPONENT).					*
 *									*
 *	If this offends more traditional mathematicians, then		*
 *	please tell me your nomenclature for flonums!			*
 *									*
 \***********************************************************************/

#include "bignum.h"

/***********************************************************************\
 *									*
 *	Variable precision floating point numbers.			*
 *									*
 *	Exponent is the place value of the low littlenum. E.g.:		*
 *	If  0:  low points to the units             littlenum.		*
 *	If  1:  low points to the LITTLENUM_RADIX   littlenum.		*
 *	If -1:  low points to the 1/LITTLENUM_RADIX littlenum.		*
 *									*
 \***********************************************************************/

/* JF:  A sign value of 0 means we have been asked to assemble NaN
   A sign value of 'P' means we've been asked to assemble +Inf
   A sign value of 'N' means we've been asked to assemble -Inf
   */
struct FLONUM_STRUCT
{
  LITTLENUM_TYPE *low;		/* low order littlenum of a bignum */
  LITTLENUM_TYPE *high;		/* high order littlenum of a bignum */
  LITTLENUM_TYPE *leader;	/* -> 1st non-zero littlenum */
  /* If flonum is 0.0, leader==low-1 */
  long exponent;		/* base LITTLENUM_RADIX */
  char sign;			/* '+' or '-' */
};

typedef struct FLONUM_STRUCT FLONUM_TYPE;


/***********************************************************************\
 *									*
 *	Since we can (& do) meet with exponents like 10^5000, it	*
 *	is silly to make a table of ~ 10,000 entries, one for each	*
 *	power of 10. We keep a table where item [n] is a struct		*
 *	FLONUM_FLOATING_POINT representing 10^(2^n). We then		*
 *	multiply appropriate entries from this table to get any		*
 *	particular power of 10. For the example of 10^5000, a table	*
 *	of just 25 entries suffices: 10^(2^-12)...10^(2^+12).		*
 *									*
 \***********************************************************************/


extern const FLONUM_TYPE flonum_positive_powers_of_ten[];
extern const FLONUM_TYPE flonum_negative_powers_of_ten[];
extern const int table_size_of_flonum_powers_of_ten;
/* Flonum_XXX_powers_of_ten[] table has */
/* legal indices from 0 to */
/* + this number inclusive. */


/***********************************************************************\
 *									*
 *	Declare worker functions.					*
 *									*
 \***********************************************************************/

int atof_generic PARAMS ((char **address_of_string_pointer,
			  const char *string_of_decimal_marks,
			  const char *string_of_decimal_exponent_marks,
			  FLONUM_TYPE * address_of_generic_floating_point_number));

void flonum_copy PARAMS ((FLONUM_TYPE * in, FLONUM_TYPE * out));
void flonum_multip PARAMS ((const FLONUM_TYPE * a, const FLONUM_TYPE * b,
			    FLONUM_TYPE * product));

/***********************************************************************\
 *									*
 *	Declare error codes.						*
 *									*
 \***********************************************************************/

#define ERROR_EXPONENT_OVERFLOW (2)

/* end of flonum.h */
Commit	Line	Data
fecd2382	1	/* flonum.h - Floating point package
6efd877d	2
a5a78175	3	Copyright (C) 1987, 1990, 1991, 1992, 1994 Free Software Foundation, Inc.
6efd877d	4
a39116f1	5	This file is part of GAS, the GNU Assembler.
6efd877d	6
a39116f1 RP	7	GAS is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2, or (at your option)
	10	any later version.
6efd877d	11
a39116f1 RP	12	GAS is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
6efd877d	16
a39116f1 RP	17	You should have received a copy of the GNU General Public License
a39116f1 RP	18	along with GAS; see the file COPYING. If not, write to
a5a78175	19	the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
fecd2382	20
fecd2382	21	/***********************************************************************\
a39116f1 RP	22	* *
	23	* Arbitrary-precision floating point arithmetic. *
	24	* *
	25	* *
	26	* Notation: a floating point number is expressed as *
	27	* MANTISSA * (2 ** EXPONENT). *
	28	* *
	29	* If this offends more traditional mathematicians, then *
	30	* please tell me your nomenclature for flonums! *
	31	* *
	32	\***********************************************************************/
fecd2382 RP	33
	34	#include "bignum.h"
	35
	36	/***********************************************************************\
a39116f1 RP	37	* *
	38	* Variable precision floating point numbers. *
	39	* *
	40	* Exponent is the place value of the low littlenum. E.g.: *
	41	* If 0: low points to the units littlenum. *
	42	* If 1: low points to the LITTLENUM_RADIX littlenum. *
	43	* If -1: low points to the 1/LITTLENUM_RADIX littlenum. *
	44	* *
	45	\***********************************************************************/
fecd2382 RP	46
	47	/* JF: A sign value of 0 means we have been asked to assemble NaN
	48	A sign value of 'P' means we've been asked to assemble +Inf
	49	A sign value of 'N' means we've been asked to assemble -Inf
a39116f1	50	*/
fecd2382 RP	51	struct FLONUM_STRUCT
fecd2382 RP	52	{
6efd877d KR	53	LITTLENUM_TYPE low; / low order littlenum of a bignum */
	54	LITTLENUM_TYPE high; / high order littlenum of a bignum */
	55	LITTLENUM_TYPE leader; / -> 1st non-zero littlenum */
	56	/* If flonum is 0.0, leader==low-1 */
	57	long exponent; /* base LITTLENUM_RADIX */
	58	char sign; /* '+' or '-' */
fecd2382 RP	59	};
	60
	61	typedef struct FLONUM_STRUCT FLONUM_TYPE;
	62
	63
	64	/***********************************************************************\
a39116f1 RP	65	* *
	66	* Since we can (& do) meet with exponents like 10^5000, it *
	67	* is silly to make a table of ~ 10,000 entries, one for each *
	68	* power of 10. We keep a table where item [n] is a struct *
	69	* FLONUM_FLOATING_POINT representing 10^(2^n). We then *
	70	* multiply appropriate entries from this table to get any *
	71	* particular power of 10. For the example of 10^5000, a table *
	72	* of just 25 entries suffices: 10^(2^-12)...10^(2^+12). *
	73	* *
	74	\***********************************************************************/
fecd2382 RP	75
	76
	77	extern const FLONUM_TYPE flonum_positive_powers_of_ten[];
	78	extern const FLONUM_TYPE flonum_negative_powers_of_ten[];
	79	extern const int table_size_of_flonum_powers_of_ten;
a39116f1 RP	80	/* Flonum_XXX_powers_of_ten[] table has */
	81	/* legal indices from 0 to */
	82	/* + this number inclusive. */
fecd2382 RP	83
	84
	85
	86	/***********************************************************************\
a39116f1 RP	87	* *
	88	* Declare worker functions. *
	89	* *
	90	\***********************************************************************/
fecd2382	91
a5a78175 ILT	92	int atof_generic PARAMS ((char **address_of_string_pointer,
	93	const char *string_of_decimal_marks,
	94	const char *string_of_decimal_exponent_marks,
	95	FLONUM_TYPE * address_of_generic_floating_point_number));
fecd2382	96
a5a78175 ILT	97	void flonum_copy PARAMS ((FLONUM_TYPE * in, FLONUM_TYPE * out));
	98	void flonum_multip PARAMS ((const FLONUM_TYPE * a, const FLONUM_TYPE * b,
	99	FLONUM_TYPE * product));
fecd2382 RP	100
fecd2382 RP	101	/***********************************************************************\
a39116f1 RP	102	* *
	103	* Declare error codes. *
	104	* *
	105	\***********************************************************************/
fecd2382 RP	106
	107	#define ERROR_EXPONENT_OVERFLOW (2)
	108
8b228fe9	109	/* end of flonum.h */