strtod.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:5k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /*
  2.   An alternative implementation of "strtod()" that is both
  3.   simplier, and thread-safe.
  4.   Original code from mit-threads as bundled with MySQL 3.23
  5.   SQL:2003 specifies a number as
  6. <signed numeric literal> ::= [ <sign> ] <unsigned numeric literal>
  7. <unsigned numeric literal> ::=
  8.                     <exact numeric literal>
  9.                   | <approximate numeric literal>
  10. <exact numeric literal> ::=
  11.                     <unsigned integer> [ <period> [ <unsigned integer> ] ]
  12.                   | <period> <unsigned integer>
  13. <approximate numeric literal> ::= <mantissa> E <exponent>
  14. <mantissa> ::= <exact numeric literal>
  15. <exponent> ::= <signed integer>
  16.   So do we.
  17.  */
  18. #include "my_base.h" /* Includes errno.h */
  19. #include "m_ctype.h"
  20. #define MAX_DBL_EXP 308
  21. #define MAX_RESULT_FOR_MAX_EXP 1.79769313486232
  22. static double scaler10[] = {
  23.   1.0, 1e10, 1e20, 1e30, 1e40, 1e50, 1e60, 1e70, 1e80, 1e90
  24. };
  25. static double scaler1[] = {
  26.   1.0, 10.0, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9
  27. };
  28. /*
  29.   Convert string to double (string doesn't have to be null terminated)
  30.   SYNOPSIS
  31.     my_strtod()
  32.     str String to convert
  33.     end_ptr Pointer to pointer that points to end of string
  34. Will be updated to point to end of double.
  35.     error Will contain error number in case of error (else 0)
  36.   RETURN
  37.     value of str as double
  38. */
  39. double my_strtod(const char *str, char **end_ptr, int *error)
  40. {
  41.   double result= 0.0;
  42.   uint negative= 0, ndigits, dec_digits= 0, neg_exp= 0;
  43.   int exp= 0, digits_after_dec_point= 0;
  44.   const char *old_str, *end= *end_ptr, *start_of_number;
  45.   char next_char;
  46.   my_bool overflow=0;
  47.   *error= 0;
  48.   if (str >= end)
  49.     goto done;
  50.   while (my_isspace(&my_charset_latin1, *str))
  51.   {
  52.     if (++str == end)
  53.       goto done;
  54.   }
  55.   start_of_number= str;
  56.   if ((negative= (*str == '-')) || *str=='+')
  57.   {
  58.     if (++str == end)
  59.       goto done;                                /* Could be changed to error */
  60.   }
  61.   /* Skip pre-zero for easier calculation of overflows */
  62.   while (*str == '0')
  63.   {
  64.     if (++str == end)
  65.       goto done;
  66.     start_of_number= 0;                         /* Found digit */
  67.   }
  68.   old_str= str;
  69.   while ((next_char= *str) >= '0' && next_char <= '9')
  70.   {
  71.     result= result*10.0 + (next_char - '0');
  72.     if (++str == end)
  73.     {
  74.       next_char= 0;                             /* Found end of string */
  75.       break;
  76.     }
  77.     start_of_number= 0;                         /* Found digit */
  78.   }
  79.   ndigits= (uint) (str-old_str);
  80.   if (next_char == '.' && str < end-1)
  81.   {
  82.     /*
  83.       Continue to add numbers after decimal point to the result, as if there
  84.       was no decimal point. We will later (in the exponent handling) shift
  85.       the number down with the required number of fractions.  We do it this
  86.       way to be able to get maximum precision for numbers like 123.45E+02,
  87.       which are normal for some ODBC applications.
  88.     */
  89.     old_str= ++str;
  90.     while (my_isdigit(&my_charset_latin1, (next_char= *str)))
  91.     {
  92.       result= result*10.0 + (next_char - '0');
  93.       digits_after_dec_point++;
  94.       if (++str == end)
  95.       {
  96.         next_char= 0;
  97.         break;
  98.       }
  99.     }
  100.     /* If we found just '+.' or '.' then point at first character */
  101.     if (!(dec_digits= (uint) (str-old_str)) && start_of_number)
  102.       str= start_of_number;                     /* Point at '+' or '.' */
  103.   }
  104.   if ((next_char == 'e' || next_char == 'E') &&
  105.       dec_digits + ndigits != 0 && str < end-1)
  106.   {
  107.     const char *old_str= str++;
  108.     if ((neg_exp= (*str == '-')) || *str == '+')
  109.       str++;
  110.     if (str == end || !my_isdigit(&my_charset_latin1, *str))
  111.       str= old_str;
  112.     else
  113.     {
  114.       do
  115.       {
  116.         if (exp < 9999)                         /* prot. against exp overfl. */
  117.           exp= exp*10 + (*str - '0');
  118.         str++;
  119.       } while (str < end && my_isdigit(&my_charset_latin1, *str));
  120.     }
  121.   }
  122.   if ((exp= (neg_exp ? exp + digits_after_dec_point :
  123.              exp - digits_after_dec_point)))
  124.   {
  125.     double scaler;
  126.     if (exp < 0)
  127.     {
  128.       exp= -exp;
  129.       neg_exp= 1;                               /* neg_exp was 0 before */
  130.     }
  131.     if (exp + ndigits >= MAX_DBL_EXP + 1 && result)
  132.     {
  133.       /*
  134.         This is not 100 % as we actually will give an owerflow for
  135.         17E307 but not for 1.7E308 but lets cut some corners to make life
  136.         simpler
  137.       */
  138.       if (exp + ndigits > MAX_DBL_EXP + 1 ||
  139.           result >= MAX_RESULT_FOR_MAX_EXP)
  140.       {
  141.         if (neg_exp)
  142.           result= 0.0;
  143.         else
  144.           overflow= 1;
  145.         goto done;
  146.       }
  147.     }
  148.     scaler= 1.0;
  149.     while (exp >= 100)
  150.     {
  151.       scaler*= 1.0e100;
  152.       exp-= 100;
  153.     }
  154.     scaler*= scaler10[exp/10]*scaler1[exp%10];
  155.     if (neg_exp)
  156.       result/= scaler;
  157.     else
  158.       result*= scaler;
  159.   }
  160. done:
  161.   *end_ptr= (char*) str;                        /* end of number */
  162.   if (overflow || isinf(result))
  163.   {
  164.     result= DBL_MAX;
  165.     *error= EOVERFLOW;
  166.   }
  167.   return negative ? -result : result;
  168. }
  169. double my_atof(const char *nptr)
  170. {
  171.   int error;
  172.   const char *end= nptr+65535;                  /* Should be enough */
  173.   return (my_strtod(nptr, (char**) &end, &error));
  174. }