floatconv.c

vxworks源码源码解读是学习vxworks的最佳途径

/* This has been copied from the gnu source tree */
/* Make all changes there, not here! */
#ifdef __cplusplus
extern "C" {
#endif
#ifndef _N_
char __floatconv_o = 0;
#else
char _N_ = 0;
#endif
#ifdef __cplusplus
}
#endif
#include "vxWorks.h"
/* 
Copyright (C) 1993, 1994 Free Software Foundation

This file is part of the GNU IO Library.  This library 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.

This library 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 this library; see the file COPYING.  If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

As a special exception, if you link this library with files
compiled with a GNU compiler to produce an executable, this does not cause
the resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why
the executable file might be covered by the GNU General Public License. */

#include <libioP.h>
#ifdef _IO_USE_DTOA
/****************************************************************
 *
 * The author of this software is David M. Gay.
 *
 * Copyright (c) 1991 by AT&T.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose without fee is hereby granted, provided that this entire notice
 * is included in all copies of any software which is or includes a copy
 * or modification of this software and in all copies of the supporting
 * documentation for such software.
 *
 * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
 * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHOR NOR AT&T MAKES ANY
 * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
 * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
 *
 ***************************************************************/

/* Some cleaning up by Per Bothner, [e-mail], 1992, 1993.
   Re-written to not need static variables
   (except result, result_k, HIWORD, LOWORD). */

/* Note that the checking of _DOUBLE_IS_32BITS is for use with the
   cross targets that employ the newlib ieeefp.h header.  -- brendan */

/* Please send bug reports to
        David M. Gay
        AT&T Bell Laboratories, Room 2C-463
        600 Mountain Avenue
        Murray Hill, NJ 07974-2070
        U.S.A.
        [e-mail] or research!dmg
 */

/* strtod for IEEE-, VAX-, and IBM-arithmetic machines.
 *
 * This strtod returns a nearest machine number to the input decimal
 * string (or sets errno to ERANGE).  With IEEE arithmetic, ties are
 * broken by the IEEE round-even rule.  Otherwise ties are broken by
 * biased rounding (add half and chop).
 *
 * Inspired loosely by William D. Clinger's paper "How to Read Floating
 * Point Numbers Accurately" [Proc. ACM SIGPLAN '90, pp. 92-101].
 *
 * Modifications:
 *
 *      1. We only require IEEE, IBM, or VAX double-precision
 *              arithmetic (not IEEE double-extended).
 *      2. We get by with floating-point arithmetic in a case that
 *              Clinger missed -- when we're computing d * 10^n
 *              for a small integer d and the integer n is not too
 *              much larger than 22 (the maximum integer k for which
 *              we can represent 10^k exactly), we may be able to
 *              compute (d*10^k) * 10^(e-k) with just one roundoff.
 *      3. Rather than a bit-at-a-time adjustment of the binary
 *              result in the hard case, we use floating-point
 *              arithmetic to determine the adjustment to within
 *              one bit; only in really hard cases do we need to
 *              compute a second residual.
 *      4. Because of 3., we don't need a large table of powers of 10
 *              for ten-to-e (just some small tables, e.g. of 10^k
 *              for 0 <= k <= 22).
 */

/*
 * #define IEEE_8087 for IEEE-arithmetic machines where the least
 *      significant byte has the lowest address.
 * #define IEEE_MC68k for IEEE-arithmetic machines where the most
 *      significant byte has the lowest address.
 * #define Sudden_Underflow for IEEE-format machines without gradual
 *      underflow (i.e., that flush to zero on underflow).
 * #define IBM for IBM mainframe-style floating-point arithmetic.
 * #define VAX for VAX-style floating-point arithmetic.
 * #define Unsigned_Shifts if >> does treats its left operand as unsigned.
 * #define No_leftright to omit left-right logic in fast floating-point
 *      computation of dtoa.
 * #define Check_FLT_ROUNDS if FLT_ROUNDS can assume the values 2 or 3.
 * #define RND_PRODQUOT to use rnd_prod and rnd_quot (assembly routines
 *      that use extended-precision instructions to compute rounded
 *      products and quotients) with IBM.
 * #define ROUND_BIASED for IEEE-format with biased rounding.
 * #define Inaccurate_Divide for IEEE-format with correctly rounded
 *      products but inaccurate quotients, e.g., for Intel i860.
 * #define KR_headers for old-style C function headers.
 */

#ifdef DEBUG
#include <stdio.h>
#define Bug(x) {fprintf(stderr, "%s\n", x); exit(1);}
#endif

#ifdef __STDC__
#include <stdlib.h>
#include <string.h>
#include <float.h>
#define CONST const
#else
#define CONST
#define KR_headers

/* In this case, we assume IEEE floats. */
#define FLT_ROUNDS 1
#define FLT_RADIX 2
#define DBL_MANT_DIG 53
#define DBL_DIG 15
#define DBL_MAX_10_EXP 308
#define DBL_MAX_EXP 1024
#endif

#include <errno.h>
#ifndef __MATH_H__
#include <math.h>
#endif

#ifdef Unsigned_Shifts
#define Sign_Extend(a,b) if (b < 0) a |= 0xffff0000;
#else
#define Sign_Extend(a,b) /*no-op*/
#endif

#if defined(__i386__) || defined(__i860__) || defined(clipper)
#define IEEE_8087
#endif
#if defined(MIPSEL) || defined(__alpha__)
#define IEEE_8087
#endif
#if defined(__sparc__) || defined(sparc) || defined(MIPSEB)
#define IEEE_MC68k
#endif

#if defined(IEEE_8087) + defined(IEEE_MC68k) + defined(VAX) + defined(IBM) != 1

#ifndef _DOUBLE_IS_32BITS
#if FLT_RADIX==16
#define IBM
#else
#if DBL_MANT_DIG==56
#define VAX
#else
#if DBL_MANT_DIG==53 && DBL_MAX_10_EXP==308
#define IEEE_Unknown
#else
Exactly one of IEEE_8087, IEEE_MC68k, VAX, or IBM should be defined.
#endif
#endif
#endif
#endif /* !_DOUBLE_IS_32BITS */
#endif

typedef _G_uint32_t unsigned32;

union doubleword {
  double d;
  unsigned32 u[2];
};

#ifdef IEEE_8087
#define HIWORD 1
#define LOWORD 0
#define TEST_ENDIANNESS  /* nothing */
#else
#if defined(IEEE_MC68k)
#define HIWORD 0
#define LOWORD 1
#define TEST_ENDIANNESS  /* nothing */
#else
static int HIWORD = -1, LOWORD;
static void test_endianness()
{
    union doubleword dw;
    dw.d = 10;
    if (dw.u[0] != 0) /* big-endian */
	HIWORD=0, LOWORD=1;
    else
	HIWORD=1, LOWORD=0;
}
#define TEST_ENDIANNESS  if (HIWORD<0) test_endianness();
#endif
#endif

#if 0
union doubleword _temp;
#endif
#if defined(__GNUC__) && !defined(_DOUBLE_IS_32BITS)
#define word0(x) ({ union doubleword _du; _du.d = (x); _du.u[HIWORD]; })
#define word1(x) ({ union doubleword _du; _du.d = (x); _du.u[LOWORD]; })
#define setword0(D,W) \
  ({ union doubleword _du; _du.d = (D); _du.u[HIWORD]=(W); (D)=_du.d; })
#define setword1(D,W) \
  ({ union doubleword _du; _du.d = (D); _du.u[LOWORD]=(W); (D)=_du.d; })
#define setwords(D,W0,W1) ({ union doubleword _du; \
  _du.u[HIWORD]=(W0); _du.u[LOWORD]=(W1); (D)=_du.d; })
#define addword0(D,W) \
  ({ union doubleword _du; _du.d = (D); _du.u[HIWORD]+=(W); (D)=_du.d; })
#else
#define word0(x) ((unsigned32 *)&x)[HIWORD]
#ifndef _DOUBLE_IS_32BITS
#define word1(x) ((unsigned32 *)&x)[LOWORD]
#else
#define word1(x) 0
#endif
#define setword0(D,W) word0(D) = (W)
#ifndef _DOUBLE_IS_32BITS
#define setword1(D,W) word1(D) = (W)
#define setwords(D,W0,W1) (setword0(D,W0),setword1(D,W1))
#else
#define setword1(D,W)
#define setwords(D,W0,W1) (setword0(D,W0))
#endif
#define addword0(D,X) (word0(D) += (X))
#endif

/* The following definition of Storeinc is appropriate for MIPS processors. */
#if defined(IEEE_8087) + defined(VAX)
#define Storeinc(a,b,c) (((unsigned short *)a)[1] = (unsigned short)b, \
((unsigned short *)a)[0] = (unsigned short)c, a++)
#else
#if defined(IEEE_MC68k)
#define Storeinc(a,b,c) (((unsigned short *)a)[0] = (unsigned short)b, \
((unsigned short *)a)[1] = (unsigned short)c, a++)
#else
#define Storeinc(a,b,c) (*a++ = b << 16 | c & 0xffff)
#endif
#endif

/* #define P DBL_MANT_DIG */
/* Ten_pmax = floor(P*log(2)/log(5)) */
/* Bletch = (highest power of 2 < DBL_MAX_10_EXP) / 16 */
/* Quick_max = floor((P-1)*log(FLT_RADIX)/log(10) - 1) */
/* Int_max = floor(P*log(FLT_RADIX)/log(10) - 1) */

#if defined(IEEE_8087) + defined(IEEE_MC68k) + defined(IEEE_Unknown)
#define Exp_shift  20
#define Exp_shift1 20
#define Exp_msk1    0x100000
#define Exp_msk11   0x100000
#define Exp_mask  0x7ff00000
#define P 53
#define Bias 1023
#define IEEE_Arith
#define Emin (-1022)
#define Exp_1  0x3ff00000
#define Exp_11 0x3ff00000
#define Ebits 11
#define Frac_mask  0xfffff
#define Frac_mask1 0xfffff
#define Ten_pmax 22
#define Bletch 0x10
#define Bndry_mask  0xfffff
#define Bndry_mask1 0xfffff
#define LSB 1
#define Sign_bit 0x80000000
#define Log2P 1
#define Tiny0 0
#define Tiny1 1
#define Quick_max 14
#define Int_max 14
#define Infinite(x) (word0(x) == 0x7ff00000) /* sufficient test for here */
#else
#undef  Sudden_Underflow
#define Sudden_Underflow
#ifdef IBM
#define Exp_shift  24
#define Exp_shift1 24
#define Exp_msk1   0x1000000
#define Exp_msk11  0x1000000
#define Exp_mask  0x7f000000
#define P 14
#define Bias 65
#define Exp_1  0x41000000
#define Exp_11 0x41000000
#define Ebits 8 /* exponent has 7 bits, but 8 is the right value in b2d */
#define Frac_mask  0xffffff
#define Frac_mask1 0xffffff
#define Bletch 4
#define Ten_pmax 22
#define Bndry_mask  0xefffff
#define Bndry_mask1 0xffffff
#define LSB 1
#define Sign_bit 0x80000000
#define Log2P 4
#define Tiny0 0x100000
#define Tiny1 0
#define Quick_max 14
#define Int_max 15
#else /* VAX */
#define Exp_shift  23
#define Exp_shift1 7
#define Exp_msk1    0x80
#define Exp_msk11   0x800000
#define Exp_mask  0x7f80
#define P 56
#define Bias 129
#define Exp_1  0x40800000
#define Exp_11 0x4080
#define Ebits 8
#define Frac_mask  0x7fffff
#define Frac_mask1 0xffff007f
#define Ten_pmax 24
#define Bletch 2
#define Bndry_mask  0xffff007f
#define Bndry_mask1 0xffff007f
#define LSB 0x10000
#define Sign_bit 0x8000
#define Log2P 1
#define Tiny0 0x80
#define Tiny1 0
#define Quick_max 15
#define Int_max 15
#endif
#endif

#ifndef IEEE_Arith
#define ROUND_BIASED
#endif

#ifdef RND_PRODQUOT
#define rounded_product(a,b) a = rnd_prod(a, b)
#define rounded_quotient(a,b) a = rnd_quot(a, b)
extern double rnd_prod(double, double), rnd_quot(double, double);
#else
#define rounded_product(a,b) a *= b
#define rounded_quotient(a,b) a /= b
#endif

#define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1))
#define Big1 0xffffffff

#define Kmax 15

/* (1<<BIGINT_MINIMUM_K) is the minimum number of words to allocate
   in a Bigint.  dtoa usually manages with 1<<2, and has not been
   known to need more than 1<<3.  */

#define BIGINT_MINIMUM_K 3

struct Bigint {
  struct Bigint *next;
  int k;		/* Parameter given to Balloc(k) */
  int maxwds;		/* Allocated space: equals 1<<k. */
  short on_stack;	/* 1 if stack-allocated. */
  short sign;		/* 0 if value is positive or zero; 1 if negative. */
  int wds;		/* Current length. */
  unsigned32 x[1<<BIGINT_MINIMUM_K]; /* Actually: x[maxwds] */
};

#define BIGINT_HEADER_SIZE \
  (sizeof(Bigint) - (1<<BIGINT_MINIMUM_K) * sizeof(unsigned32))

typedef struct Bigint Bigint;

/* Initialize a stack-allocated Bigint. */

static Bigint *
Binit
#ifdef KR_headers
        (v) Bigint *v;
#else
        (Bigint *v)
#endif
{
  v->on_stack = 1;
  v->k = BIGINT_MINIMUM_K;
  v->maxwds = 1 << BIGINT_MINIMUM_K;
  v->sign = v->wds = 0;
  return v;
}

/* Allocate a Bigint with '1<<k' big digits. */

static Bigint *
Balloc
#ifdef KR_headers
        (k) int k;
#else
        (int k)
#endif
{
  int x;
  Bigint *rv;

  if (k < BIGINT_MINIMUM_K)
    k = BIGINT_MINIMUM_K;

  x = 1 << k;
  rv = (Bigint *)