~drizzle-trunk/drizzle/development

/* Copyright (C) 2000 MySQL AB

   This program 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; version 2 of the License.

   This program 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 program; if not, write to the Free Software

   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

/*

  strtol,strtoul,strtoll,strtoull

  convert string to long, unsigned long, int64_t or uint64_t.

  strtoxx(char *src,char **ptr,int base)

  converts the string pointed to by src to an long of appropriate long and

  returnes it. It skips leading spaces and tabs (but not newlines, formfeeds,

  backspaces), then it accepts an optional sign and a sequence of digits

  in the specified radix.

  If the value of ptr is not (char **)NULL, a pointer to the character

  terminating the scan is returned in the location pointed to by ptr.

  Trailing spaces will NOT be skipped.

  If an error is detected, the result will be LONG_MIN, 0 or LONG_MAX,

  (or LONGLONG..)  and errno will be set to

	EDOM	if there are no digits

	ERANGE	if the result would overflow.

  the ptr will be set to src.

  This file is based on the strtol from the the GNU C Library.

  it can be compiled with the UNSIGNED and/or LONGLONG flag set

*/

#if !defined(DRIZZLE_SERVER_GLOBAL_H) || !defined(_m_string_h)

#  error  Calling file must include 'drizzled/global.h' and 'mystrings/m_string.h'

   /* see 'strtoll.c' and 'strtoull.c' for the reasons */

#endif

#include "m_ctype.h"

#include "my_sys.h"			/* defines errno */

#include <errno.h>

#undef strtoull

#undef strtoll

#undef strtoul

#undef strtol

#ifdef USE_LONGLONG

#define TYPE_MIN LONGLONG_MIN

#define TYPE_MAX LONGLONG_MAX

#define longtype int64_t

#define ulongtype uint64_t

#ifdef USE_UNSIGNED

#define function ulongtype strtoull

#else

#define function longtype strtoll

#endif

#else

#define TYPE_MIN LONG_MIN

#define TYPE_MAX LONG_MAX

#define longtype long

#define ulongtype unsigned long

#ifdef USE_UNSIGNED

#define function ulongtype strtoul

#else

#define function longtype strtol

#endif

#endif

/* Convert NPTR to an `unsigned long int' or `long int' in base BASE.

   If BASE is 0 the base is determined by the presence of a leading

   zero, indicating octal or a leading "0x" or "0X", indicating hexadecimal.

   If BASE is < 2 or > 36, it is reset to 10.

   If ENDPTR is not NULL, a pointer to the character after the last

   one converted is stored in *ENDPTR.	*/

function (const char *nptr,char **endptr,int base)

{

  int negative;

  register ulongtype cutoff;

  register unsigned int cutlim;

  register ulongtype i;

  register const char *s;

  register unsigned char c;

  const char *save;

  int overflow;

  if (base < 0 || base == 1 || base > 36)

    base = 10;

  s = nptr;

  /* Skip white space.	*/

  while (my_isspace(&my_charset_utf8_general_ci, *s))

    ++s;

  if (*s == '\0')

  {

    goto noconv;

  }

  /* Check for a sign.	*/

  negative= 0;

  if (*s == '-')

  {

    negative = 1;

    ++s;

  }

  else if (*s == '+')

  {

    ++s;

  }

  if (base == 16 && s[0] == '0' && my_toupper (&my_charset_utf8_general_ci, s[1]) == 'X')

    s += 2;

  /* If BASE is zero, figure it out ourselves.	*/

  if (base == 0)

  {

    if (*s == '0')

    {

      if (my_toupper (&my_charset_utf8_general_ci, s[1]) == 'X')

      {

	s += 2;

	base = 16;

      }

      else

	base = 8;

    }

    else

      base = 10;

  }

  /* Save the pointer so we can check later if anything happened.  */

  save = s;

  cutoff = UINT64_MAX / (unsigned long int) base;

  cutlim = (uint) (UINT64_MAX % (unsigned long int) base);

  overflow = 0;

  i = 0;

  for (c = *s; c != '\0'; c = *++s)

  {

    if (my_isdigit (&my_charset_utf8_general_ci, c))

      c -= '0';

    else if (my_isalpha (&my_charset_utf8_general_ci, c))

      c = my_toupper (&my_charset_utf8_general_ci, c) - 'A' + 10;

    else

      break;

    if (c >= base)

      break;

    /* Check for overflow.  */

    if (i > cutoff || (i == cutoff && c > cutlim))

      overflow = 1;

    else

    {

      i *= (ulongtype) base;

      i += c;

    }

  }

  /* Check if anything actually happened.  */

  if (s == save)

    goto noconv;

  /* Store in ENDPTR the address of one character

     past the last character we converted.  */

  if (endptr != NULL)

    *endptr = (char *) s;

#ifndef USE_UNSIGNED

  /* Check for a value that is within the range of

     `unsigned long int', but outside the range of `long int'.	*/

  if (negative)

  {

    if (i  > (ulongtype) TYPE_MIN)

      overflow = 1;

  }

  else if (i > (ulongtype) TYPE_MAX)

    overflow = 1;

#endif

  if (overflow)

  {

    my_errno=ERANGE;

#ifdef USE_UNSIGNED

    return UINT64_MAX;

#else

    return negative ? TYPE_MIN : TYPE_MAX;

#endif

  }

  /* Return the result of the appropriate sign.  */

  return (negative ? -((longtype) i) : (longtype) i);

noconv:

  /* There was no number to convert.  */

  my_errno=EDOM;

  if (endptr != NULL)

    *endptr = (char *) nptr;

  return 0L;

}