strtod.h

Go to the documentation of this file.

#ifndef _STRTOD_H_
#define _STRTOD_H_

#include <nlibc.h>

/*  Copyright (C) 2000, 2003     Manuel Novoa III
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Library General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, 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
 *  Library General Public License for more details.
 *
 *  You should have received a copy of the GNU Library General Public
 *  License along with this library; if not, write to the Free
 *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */


/* Notes:
 *
 * The primary objective of this implementation was minimal size and
 * portablility, while providing robustness and resonable accuracy.
 *
 * This implementation depends on IEEE floating point behavior and expects
 * to be able to generate +/- infinity as a result.
 *
 * There are a number of compile-time options below.
 */

/* July 27, 2003
 *
 * General cleanup and some minor size optimizations.
 * Change implementation to support __strtofpmax() rather than strtod().
 *   Now all the strto{floating pt}() funcs are implemented in terms of
 *   of the internal __strtofpmax() function.
 * Support "nan", "inf", and "infinity" strings (case-insensitive).
 * Support hexadecimal floating point notation.
 * Support wchar variants.
 * Support xlocale variants.
 *
 * TODO:
 *
 * Consider accumulating blocks of digits in longs to save floating pt mults.
 *   This would likely be much better on anything that only supported floats
 *   where DECIMAL_DIG == 9.  Actually, if floats have FLT_MAX_10_EXP == 38,
 *   we could calculate almost all the exponent multipliers (p_base) in
 *   long arithmetic as well.
 */

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

/* Defined if we want to recognize "nan", "inf", and "infinity". (C99) */
#define _STRTOD_NAN_INF_STRINGS  1

/* Defined if we want support hexadecimal floating point notation. (C99) */
/* Note!  Now controlled by uClibc configuration.  See below. */
#define _STRTOD_HEXADECIMAL_FLOATS 1

/* Defined if we want to scale with a O(log2(exp)) multiplications.
 * This is generally a good thing to do unless you are really tight
 * on space and do not expect to convert values of large magnitude. */

#define _STRTOD_LOG_SCALING     1

/* WARNING!!!   WARNING!!!   WARNING!!!   WARNING!!!   WARNING!!!
 *
 * Clearing any of the options below this point is not advised (or tested).
 *
 * WARNING!!!   WARNING!!!   WARNING!!!   WARNING!!!   WARNING!!! */

/* Defined if we want strtod to set errno appropriately. */
/* NOTE: Implies all options below. */
#define _STRTOD_ERRNO           1

/* Defined if we want support for the endptr arg. */
/* Implied by _STRTOD_ERRNO. */
#define _STRTOD_ENDPTR          1

/* Defined if we want to prevent overflow in accumulating the exponent. */
/* Implied by _STRTOD_ERRNO. */
#define _STRTOD_RESTRICT_EXP    1

/* Defined if we want to process mantissa digits more intelligently. */
/* Implied by _STRTOD_ERRNO. */
#define _STRTOD_RESTRICT_DIGITS 1

/* Defined if we want to skip scaling 0 for the exponent. */
/* Implied by _STRTOD_ERRNO. */
#define _STRTOD_ZERO_CHECK      1

/**********************************************************************/
/* Don't change anything that follows.                                                                     */
/**********************************************************************/

#ifdef _STRTOD_ERRNO
#undef _STRTOD_ENDPTR
#undef _STRTOD_RESTRICT_EXP
#undef _STRTOD_RESTRICT_DIGITS
#undef _STRTOD_ZERO_CHECK
#define _STRTOD_ENDPTR             1
#define _STRTOD_RESTRICT_EXP     1
#define _STRTOD_RESTRICT_DIGITS  1
#define _STRTOD_ZERO_CHECK         1
#endif

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

#define _ISOC99_SOURCE 1

#define _STRTOD_HEXADECIMAL_FLOATS 1

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

#undef _STRTOD_FPMAX

#define FPMAX_TYPE 2    // double is largest FP type
typedef double  __fpmax_t;
#define FPMAX_MIN_10_EXP DBL_MIN_10_EXP

#define NEED_STRTOD_WRAPPER
#define NEED_STRTOF_WRAPPER

#define __FPMAX_ZERO_OR_INF_CHECK(x)  ((x) == ((x)/4) )

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

#ifdef _STRTOD_RESTRICT_DIGITS
#define EXP_DENORM_ADJUST DECIMAL_DIG
#define MAX_ALLOWED_EXP (DECIMAL_DIG  + EXP_DENORM_ADJUST - FPMAX_MIN_10_EXP)

#if MAX_ALLOWED_EXP > INT_MAX
#error size assumption violated for MAX_ALLOWED_EXP
#endif
#else
/* We want some excess if we're not restricting mantissa digits. */
#define MAX_ALLOWED_EXP ((20 - FPMAX_MIN_10_EXP) * 2)
#endif


#if defined(_STRTOD_RESTRICT_DIGITS) || defined(_STRTOD_ENDPTR) || defined(_STRTOD_HEXADECIMAL_FLOATS)
#undef _STRTOD_NEED_NUM_DIGITS
#define _STRTOD_NEED_NUM_DIGITS 1
#endif

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

#ifndef __HAS_MAIN
extern __fpmax_t strtod( const char *cstr, char **endptr );
#else
#if !defined(__cflow_processed) || defined(_uses_strtod_strtod_h)
__fpmax_t strtod( const char *cstr, char **endptr )
{
        __fpmax_t number;
        __fpmax_t p_base = 10;                  /* Adjusted to 16 in the hex case. */
        __fpmax_t exponent_power = 0;
        char *pos0;
#ifdef _STRTOD_ENDPTR
        char *pos1;
#endif
        char *pos;
        int exponent_temp;
        int negative; /* A flag for the number, a multiplier for the exponent. */
#ifdef _STRTOD_NEED_NUM_DIGITS
        int num_digits;
#endif

#ifdef _STRTOD_HEXADECIMAL_FLOATS
        char expchar = 'e';
        char *poshex = NULL;
        typedef enum { ISdigit=0, ISXdigit=1 } cclass_t;
        cclass_t is_mask = ISdigit;
#define EXPCHAR         expchar
#define IS_X_DIGIT(c) ((is_mask==ISdigit) ? (isdigit((c))) : (isxdigit((c))))
#else  /* _STRTOD_HEXADECIMAL_FLOATS */
#define EXPCHAR         'e'
#define IS_X_DIGIT(C) isdigit((C))
#endif /* _STRTOD_HEXADECIMAL_FLOATS */

        /*
         * expand compacted string to char array for easy 
         * handling
         */
        char *str;
        int len = strlen( cstr );
        str = stringexpand( cstr, len );

        pos = (char *)str;
        while (isspace(*pos)) {         /* Skip leading whitespace. */
                ++pos;
        }

        negative = 0;
        switch(*pos) {                          /* Handle optional sign. */
                case '-': negative = 1; /* Fall through to increment position. */
                case '+': ++pos;
        }

#ifdef _STRTOD_HEXADECIMAL_FLOATS
        if ((*pos == '0') && (((pos[1])|0x20) == 'x')) {
                poshex = ++pos;                 /* Save position of 'x' in case no digits */
                ++pos;                                  /*   and advance past it.  */
                is_mask = ISXdigit;     /* Used by IS_X_DIGIT. */
                expchar = 'p';                  /* Adjust exponent char. */
                p_base = 16;                    /* Adjust base multiplier. */
        }
#endif

        number = 0.;
#ifdef _STRTOD_NEED_NUM_DIGITS
        num_digits = -1;
#endif
        pos0 = NULL;

 LOOP:
        while (IS_X_DIGIT(*pos)) {      /* Process string of (hex) digits. */
#ifdef _STRTOD_RESTRICT_DIGITS
                if (num_digits < 0) {   /* First time through? */
                        ++num_digits;           /* We've now seen a digit. */
                }
                if (num_digits || (*pos != '0')) { /* Had/have nonzero. */
                        ++num_digits;
                        if (num_digits <= DECIMAL_DIG) { /* Is digit significant? */
#ifdef _STRTOD_HEXADECIMAL_FLOATS
                                number = number * p_base
                                        + (isdigit(*pos)
                                           ? (*pos - '0')
                                           : (((*pos)|0x20) - ('a' - 10)));
#else  /* _STRTOD_HEXADECIMAL_FLOATS */
                                number = number * p_base + (*pos - '0');
#endif /* _STRTOD_HEXADECIMAL_FLOATS */
                        }
                }
#else  /* _STRTOD_RESTRICT_DIGITS */
#ifdef _STRTOD_NEED_NUM_DIGITS
                ++num_digits;
#endif
#ifdef _STRTOD_HEXADECIMAL_FLOATS
                number = number * p_base
                        + (isdigit(*pos)
                           ? (*pos - '0')
                           : (((*pos)|0x20) - ('a' - 10)));
#else  /* _STRTOD_HEXADECIMAL_FLOATS */
                number = number * p_base + (*pos - '0');
#endif /* _STRTOD_HEXADECIMAL_FLOATS */
#endif /* _STRTOD_RESTRICT_DIGITS */
                ++pos;
        }
        if ((*pos == '.') && !pos0) { /* First decimal point? */
                pos0 = ++pos;                   /* Save position of decimal point */
                goto LOOP;                              /*   and process rest of digits. */
        }

#ifdef _STRTOD_NEED_NUM_DIGITS
        if (num_digits<0) {                     /* Must have at least one digit. */
#ifdef _STRTOD_HEXADECIMAL_FLOATS
                if (poshex) {                   /* Back up to '0' in '0x' prefix. */
                        pos = poshex;
                        goto DONE;
                }
#endif /* _STRTOD_HEXADECIMAL_FLOATS */

#ifdef _STRTOD_NAN_INF_STRINGS
                if (!pos0) {                    /* No decimal point, so check for inf/nan. */
                        /* Note: nan is the first string so 'number = i/0.;' works. */
                        static const char nan_inf_str[] = "\05nan\0\012infinity\0\05inf\0";
                        int i = 0;

                        do {
                                /* Unfortunately, we have no memcasecmp(). */
                                int j = 0;
                                while (tolower(pos[j]) == nan_inf_str[i+1+j]) {
                                        ++j;
                                        if (!nan_inf_str[i+1+j]) {
                                                number = i / 0.;
                                                if (negative) { /* Correct for sign. */
                                                        number = -number;
                                                }
                                                pos += nan_inf_str[i] - 2;
                                                goto DONE;
                                        }
                                }
                                i += nan_inf_str[i];
                        } while (nan_inf_str[i]);
                }

#endif /* STRTOD_NAN_INF_STRINGS */
#ifdef _STRTOD_ENDPTR
                pos = (char *) str;
#endif
                goto DONE;
        }
#endif /* _STRTOD_NEED_NUM_DIGITS */

#ifdef _STRTOD_RESTRICT_DIGITS
        if (num_digits > DECIMAL_DIG) { /* Adjust exponent for skipped digits. */
                exponent_power += num_digits - DECIMAL_DIG;
        }
#endif

        if (pos0) {
                exponent_power += pos0 - pos; /* Adjust exponent for decimal point. */
        }

#ifdef _STRTOD_HEXADECIMAL_FLOATS
        if (poshex) {
                exponent_power *= 4;    /* Above is 2**4, but below is 2. */
                p_base = 2;
        }
#endif /* _STRTOD_HEXADECIMAL_FLOATS */

        if (negative) {                         /* Correct for sign. */
                number = -number;
        }

        /* process an exponent string */
        if (((*pos)|0x20) == EXPCHAR) {
#ifdef _STRTOD_ENDPTR
                pos1 = pos;
#endif
                negative = 1;
                switch(*++pos) {                /* Handle optional sign. */
                        case '-': negative = -1; /* Fall through to increment pos. */
                        case '+': ++pos;
                }

                pos0 = pos;
                exponent_temp = 0;
                while (isdigit(*pos)) { /* Process string of digits. */
#ifdef _STRTOD_RESTRICT_EXP
                        if (exponent_temp < MAX_ALLOWED_EXP) { /* Avoid overflow. */
                                exponent_temp = exponent_temp * 10 + (*pos - '0');
                        }
#else
                        exponent_temp = exponent_temp * 10 + (*pos - '0');
#endif
                        ++pos;
                }

#ifdef _STRTOD_ENDPTR
                if (pos == pos0) {      /* No digits? */
                        pos = pos1;             /* Back up to {e|E}/{p|P}. */
                } /* else */
#endif

                exponent_power += negative * exponent_temp;
        }

#ifdef _STRTOD_ZERO_CHECK
        if (number == 0.) {
                goto DONE;
        }
#endif

        /* scale the result */
#ifdef _STRTOD_LOG_SCALING
        exponent_temp = exponent_power;

        if (exponent_temp < 0) {
                exponent_temp = -exponent_temp;
        }

        while (exponent_temp) {
                if (exponent_temp & 1) {
                        if (exponent_power < 0) {
                                /* Warning... caluclating a factor for the exponent and
                                 * then dividing could easily be faster.  But doing so
                                 * might cause problems when dealing with denormals. */
                                number /= p_base;
                        } else {
                                number *= p_base;
                        }
                }
                exponent_temp >>= 1;
                p_base *= p_base;
        }

#else  /* _STRTOD_LOG_SCALING */
        while (exponent_power) {
                if (exponent_power < 0) {
                        number /= p_base;
                        exponent_power++;
                } else {
                        number *= p_base;
                        exponent_power--;
                }
        }
#endif /* _STRTOD_LOG_SCALING */

#ifdef _STRTOD_ERRNO
        if (__FPMAX_ZERO_OR_INF_CHECK(number)) {
                errno = ERANGE;
        }
#endif /* _STRTOD_ERRNO */

 DONE:
#ifdef _STRTOD_ENDPTR
        if (endptr) {
                *endptr = cstr + (pos-str);
        }
#endif  /* _STRTOD_ENDPTR */

        return number;
}
#endif // _uses_strtod_strtod_h
#endif // Has Main

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

#define strtof(NPTR,ENDPTR) strtod((NPTR),(ENDPTR))
#define strtold(NPTR,ENDPTR) strtod((NPTR),(ENDPTR))


#endif // _STRTOD_H_

---