* main.c: Move entire file except for #ifndef MAIN_OVERRIDE code

[binutils.git] / gas / flonum.h

diff --git a/gas/flonum.h b/gas/flonum.h
index 570bd3acfd24defe8a2f06abd3ec6b0d45284c89..ee45a6e365b5d449c23b567407da8a7b8e40f517 100644 (file)
--- a/gas/flonum.h
+++ b/gas/flonum.h
@@ -1,122 +1,121 @@
 /* flonum.h - Floating point package
 /* flonum.h - Floating point package

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

 
 

-This file is part of GAS, the GNU Assembler.
+   Copyright (C) 1987, 1990, 1991, 1992 Free Software Foundation, Inc.

 
 

-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 1, or (at your option)
-any later version.
+   This file is part of GAS, the GNU Assembler.

 
 

-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.
+   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.

 
 

-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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+   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.

 
 

-/* $Id$ */
+   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, 675 Mass Ave, Cambridge, MA 02139, 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!                   *
-*                                                                      *
-\***********************************************************************/
-#if !defined(__STDC__) && !defined(const)
-#define const /* empty */
+ *                                                                     *
+ *     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!                   *
+ *                                                                     *
+ \***********************************************************************/
+#if (__STDC__ != 1) && !defined(const)
+#define const                  /* empty */

 #endif
 
 #include "bignum.h"
 
 /***********************************************************************\
 #endif
 
 #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.          *
-*                                                                      *
-\***********************************************************************/
+ *                                                                     *
+ *     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
 
 /* 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
 {
 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 '-' */
+  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;
 
 
 /***********************************************************************\
 };
 
 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).           *
-*                                                                      *
-\***********************************************************************/
+ *                                                                     *
+ *     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;
 
 
 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. */
+/* Flonum_XXX_powers_of_ten[] table has */
+/* legal indices from 0 to */
+/* + this number inclusive. */

 
 
 
 /***********************************************************************\
 
 
 
 /***********************************************************************\

-*                                                                      *
-*      Declare worker functions.                                       *
-*                                                                      *
-\***********************************************************************/
+ *                                                                     *
+ *     Declare worker functions.                                       *
+ *                                                                     *
+ \***********************************************************************/

 
 

-#ifdef __STDC__
+#if __STDC__ == 1

 
 

-int atof_generic(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);
+int atof_generic (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(FLONUM_TYPE *in, FLONUM_TYPE *out);
-void flonum_multip(const FLONUM_TYPE *a, const FLONUM_TYPE *b, FLONUM_TYPE *product);
+void flonum_copy (FLONUM_TYPE * in, FLONUM_TYPE * out);
+void flonum_multip (const FLONUM_TYPE * a, const FLONUM_TYPE * b, FLONUM_TYPE * product);

 
 

-#else /* __STDC__ */
+#else /* not __STDC__ */

 
 

-int atof_generic();
-void flonum_copy();
-void flonum_multip();
+int atof_generic ();
+void flonum_copy ();
+void flonum_multip ();

 
 

-#endif /* __STDC__ */
+#endif /* not __STDC__ */

 
 /***********************************************************************\
 
 /***********************************************************************\

-*                                                                      *
-*      Declare error codes.                                            *
-*                                                                      *
-\***********************************************************************/
+ *                                                                     *
+ *     Declare error codes.                                            *
+ *                                                                     *
+ \***********************************************************************/

 
 #define ERROR_EXPONENT_OVERFLOW (2)
 
 
 #define ERROR_EXPONENT_OVERFLOW (2)
 

-/* end: flonum.h */
+/* end of flonum.h */