← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/internal/my_strtoll10.cc

  • Committer: Brian Aker
  • Date: 2010-05-27 01:25:56 UTC
  • mfrom: (1567.1.4 new-staging)
  • Revision ID: brian@gaz-20100527012556-5zgkirkl7swbigd6
Merge of Brian, Paul. PBXT compile issue, and test framework cleanup. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/internal/my_strtoll10.cc
13
13
   along with this program; if not, write to the Free Software
14
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
 
#include <m_string.h>
 
16
#include "config.h"
 
17
#include "drizzled/internal/m_string.h"
17
18
#include <errno.h>
18
19
 
19
 
#undef  ULONGLONG_MAX
20
 
#define ULONGLONG_MAX           (~(uint64_t) 0)
 
20
namespace drizzled
 
21
{
 
22
namespace internal
 
23
{
 
24
 
21
25
#define MAX_NEGATIVE_NUMBER     ((uint64_t) 0x8000000000000000LL)
22
26
#define INIT_CNT  9
23
27
#define LFACTOR   1000000000ULL
24
28
#define LFACTOR1  10000000000ULL
25
29
#define LFACTOR2  100000000000ULL
26
30
 
27
 
static unsigned long lfactor[9]=
 
31
static uint64_t lfactor[9]=
28
32
{
29
33
  1L, 10L, 100L, 1000L, 10000L, 100000L, 1000000L, 10000000L, 100000000L
30
34
};
31
35
 
32
36
/*
33
 
  Convert a string to an to unsigned long long integer value
34
 
  
 
37
  Convert a string to an to uint64_t integer value
 
38
 
35
39
  SYNOPSYS
36
40
    my_strtoll10()
37
41
      nptr     in       pointer to the string to be converted
38
42
      endptr   in/out   pointer to the end of the string/
39
43
                        pointer to the stop character
40
44
      error    out      returned error code
41
 
 
 
45
 
42
46
  DESCRIPTION
43
47
    This function takes the decimal representation of integer number
44
48
    from string nptr and converts it to an signed or unsigned
45
 
    long long integer value.
 
49
    int64_t value.
46
50
    Space characters and tab are ignored.
47
51
    A sign character might precede the digit characters. The number
48
52
    may have any number of pre-zero digits.
50
54
    The function stops reading the string nptr at the first character
51
55
    that is not a decimal digit. If endptr is not NULL then the function
52
56
    will not read characters after *endptr.
53
 
 
 
57
 
54
58
  RETURN VALUES
55
59
    Value of string as a signed/unsigned int64_t integer
56
60
 
61
65
    -1          Number was an ok negative number
62
66
    0           ok
63
67
    ERANGE      If the the value of the converted number exceeded the
64
 
                maximum negative/unsigned long long integer.
65
 
                In this case the return value is ~0 if value was
66
 
                positive and LONGLONG_MIN if value was negative.
 
68
                maximum negative/uint64_t integer.
 
69
                In this case the return value is UINT64_MAX if value was
 
70
                positive and UINT64_MIN if value was negative.
67
71
    EDOM        If the string didn't contain any digits. In this case
68
72
                the return value is 0.
69
73
 
80
84
  unsigned long i, j, k;
81
85
  uint64_t li;
82
86
  int negative;
83
 
  unsigned long cutoff, cutoff2, cutoff3;
 
87
  uint64_t cutoff, cutoff2, cutoff3;
84
88
 
85
89
  s= nptr;
86
90
  /* If fixed length string */
123
127
      if (++s == end)
124
128
        goto no_conv;
125
129
    }
126
 
    cutoff=  ULONGLONG_MAX / LFACTOR2;
127
 
    cutoff2= ULONGLONG_MAX % LFACTOR2 / 100;
128
 
    cutoff3=  ULONGLONG_MAX % 100;
 
130
    cutoff=  UINT64_MAX / LFACTOR2;
 
131
    cutoff2= UINT64_MAX % LFACTOR2 / 100;
 
132
    cutoff3=  UINT64_MAX % 100;
129
133
  }
130
134
 
131
135
  /* Handle case where we have a lot of pre-zero */
202
206
 
203
207
overflow:                                       /* *endptr is set here */
204
208
  *error= ERANGE;
205
 
  return negative ? INT64_MIN: (int64_t) ULONGLONG_MAX;
 
209
  return negative ? INT64_MIN: INT64_MAX;
206
210
 
207
211
end_i:
208
212
  *endptr= (char*) s;
235
239
  *endptr= (char *) nptr;
236
240
  return 0;
237
241
}
 
242
 
 
243
} /* namespace internal */
 
244
} /* namespace drizzled */