[thirdparty/glibc.git] / stdlib / strtol_l.c

/* Convert string representing a number to integer value, using given locale.
   Copyright (C) 1997-2014 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C 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
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <http://www.gnu.org/licenses/>.  */


#if HAVE_CONFIG_H
# include <config.h>
#endif

#ifdef _LIBC
# define USE_NUMBER_GROUPING
# define STDC_HEADERS
# define HAVE_LIMITS_H
#endif

#include <ctype.h>
#include <errno.h>
#ifndef __set_errno
# define __set_errno(Val) errno = (Val)
#endif

#ifdef HAVE_LIMITS_H
# include <limits.h>
#endif

#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
#include <xlocale.h>
#include <stdint.h>
#include <bits/wordsize.h>

#ifdef USE_NUMBER_GROUPING
# include "../locale/localeinfo.h"
#endif

/* Nonzero if we are defining `strtoul' or `strtoull', operating on
   unsigned integers.  */
#ifndef UNSIGNED
# define UNSIGNED 0
# define INT LONG int
#else
# define INT unsigned LONG int
#endif

/* Determine the name.  */
#if UNSIGNED
# ifdef USE_WIDE_CHAR
#  ifdef QUAD
#   define strtol_l wcstoull_l
#  else
#   define strtol_l wcstoul_l
#  endif
# else
#  ifdef QUAD
#   define strtol_l strtoull_l
#  else
#   define strtol_l strtoul_l
#  endif
# endif
#else
# ifdef USE_WIDE_CHAR
#  ifdef QUAD
#   define strtol_l wcstoll_l
#  else
#   define strtol_l wcstol_l
#  endif
# else
#  ifdef QUAD
#   define strtol_l strtoll_l
#  else
#   define strtol_l strtol_l
#  endif
# endif
#endif

#define __strtol_l __strtol_l2(strtol_l)
#define __strtol_l2(name) __strtol_l3(name)
#define __strtol_l3(name) __##name


/* If QUAD is defined, we are defining `strtoll' or `strtoull',
   operating on `long long int's.  */
#ifdef QUAD
# define LONG long long
# define STRTOL_LONG_MIN LONG_LONG_MIN
# define STRTOL_LONG_MAX LONG_LONG_MAX
# define STRTOL_ULONG_MAX ULONG_LONG_MAX
#else
# define LONG long

# ifndef ULONG_MAX
#  define ULONG_MAX ((unsigned long int) ~(unsigned long int) 0)
# endif
# ifndef LONG_MAX
#  define LONG_MAX ((long int) (ULONG_MAX >> 1))
# endif
# define STRTOL_LONG_MIN LONG_MIN
# define STRTOL_LONG_MAX LONG_MAX
# define STRTOL_ULONG_MAX ULONG_MAX
#endif


/* We use this code for the extended locale handling where the
   function gets as an additional argument the locale which has to be
   used.  To access the values we have to redefine the _NL_CURRENT and
   _NL_CURRENT_WORD macros.  */
#undef _NL_CURRENT
#define _NL_CURRENT(category, item) \
  (current->values[_NL_ITEM_INDEX (item)].string)
#undef _NL_CURRENT_WORD
#define _NL_CURRENT_WORD(category, item) \
  ((uint32_t) current->values[_NL_ITEM_INDEX (item)].word)

#if defined _LIBC || defined HAVE_WCHAR_H
# include <wchar.h>
#endif

#ifdef USE_WIDE_CHAR
# include <wctype.h>
# define L_(Ch) L##Ch
# define UCHAR_TYPE wint_t
# define STRING_TYPE wchar_t
# define ISSPACE(Ch) __iswspace_l ((Ch), loc)
# define ISALPHA(Ch) __iswalpha_l ((Ch), loc)
# define TOUPPER(Ch) __towupper_l ((Ch), loc)
#else
# if defined _LIBC \
   || defined STDC_HEADERS || (!defined isascii && !defined HAVE_ISASCII)
#  define IN_CTYPE_DOMAIN(c) 1
# else
#  define IN_CTYPE_DOMAIN(c) isascii(c)
# endif
# define L_(Ch) Ch
# define UCHAR_TYPE unsigned char
# define STRING_TYPE char
# define ISSPACE(Ch) __isspace_l ((Ch), loc)
# define ISALPHA(Ch) __isalpha_l ((Ch), loc)
# define TOUPPER(Ch) __toupper_l ((Ch), loc)
#endif

#define INTERNAL(X) INTERNAL1(X)
#define INTERNAL1(X) __##X##_internal
#define WEAKNAME(X) WEAKNAME1(X)

#ifdef USE_NUMBER_GROUPING
/* This file defines a function to check for correct grouping.  */
# include "grouping.h"
#endif


/* Define tables of maximum values and remainders in order to detect
   overflow.  Do this at compile-time in order to avoid the runtime
   overhead of the division.  */
extern const unsigned long __strtol_ul_max_tab[] attribute_hidden;
extern const unsigned char __strtol_ul_rem_tab[] attribute_hidden;
#if defined(QUAD) && __WORDSIZE == 32
extern const unsigned long long __strtol_ull_max_tab[] attribute_hidden;
extern const unsigned char __strtol_ull_rem_tab[] attribute_hidden;
#endif

#define DEF(TYPE, NAME)							   \
  const TYPE NAME[] attribute_hidden =					   \
  {									   \
    F(2), F(3), F(4), F(5), F(6), F(7), F(8), F(9), F(10), 		   \
    F(11), F(12), F(13), F(14), F(15), F(16), F(17), F(18), F(19), F(20),  \
    F(21), F(22), F(23), F(24), F(25), F(26), F(27), F(28), F(29), F(30),  \
    F(31), F(32), F(33), F(34), F(35), F(36)				   \
  }

#if !UNSIGNED && !defined (USE_WIDE_CHAR) && !defined (QUAD)
# define F(X)	ULONG_MAX / X
  DEF (unsigned long, __strtol_ul_max_tab);
# undef F
# define F(X)	ULONG_MAX % X
  DEF (unsigned char, __strtol_ul_rem_tab);
# undef F
#endif
#if !UNSIGNED && !defined (USE_WIDE_CHAR) && defined (QUAD) \
    && __WORDSIZE == 32
# define F(X)	ULONG_LONG_MAX / X
  DEF (unsigned long long, __strtol_ull_max_tab);
# undef F
# define F(X)	ULONG_LONG_MAX % X
  DEF (unsigned char, __strtol_ull_rem_tab);
# undef F
#endif
#undef DEF

/* Define some more readable aliases for these arrays which correspond
   to how they'll be used in the function below.  */
#define jmax_tab	__strtol_ul_max_tab
#if defined(QUAD) && __WORDSIZE == 32
# define cutoff_tab	__strtol_ull_max_tab
# define cutlim_tab	__strtol_ull_rem_tab
#else
# define cutoff_tab	__strtol_ul_max_tab
# define cutlim_tab	__strtol_ul_rem_tab
#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.  */

INT
INTERNAL (__strtol_l) (nptr, endptr, base, group, loc)
     const STRING_TYPE *nptr;
     STRING_TYPE **endptr;
     int base;
     int group;
     __locale_t loc;
{
  int negative;
  unsigned LONG int cutoff;
  unsigned int cutlim;
  unsigned LONG int i;
  const STRING_TYPE *s;
  UCHAR_TYPE c;
  const STRING_TYPE *save, *end;
  int overflow;
#ifndef USE_WIDE_CHAR
  size_t cnt;
#endif

#ifdef USE_NUMBER_GROUPING
  struct __locale_data *current = loc->__locales[LC_NUMERIC];
  /* The thousands character of the current locale.  */
# ifdef USE_WIDE_CHAR
  wchar_t thousands = L'\0';
# else
  const char *thousands = NULL;
  size_t thousands_len = 0;
# endif
  /* The numeric grouping specification of the current locale,
     in the format described in <locale.h>.  */
  const char *grouping;

  if (__glibc_unlikely (group))
    {
      grouping = _NL_CURRENT (LC_NUMERIC, GROUPING);
      if (*grouping <= 0 || *grouping == CHAR_MAX)
	grouping = NULL;
      else
	{
	  /* Figure out the thousands separator character.  */
# ifdef USE_WIDE_CHAR
#  ifdef _LIBC
	  thousands = _NL_CURRENT_WORD (LC_NUMERIC,
					_NL_NUMERIC_THOUSANDS_SEP_WC);
#  endif
	  if (thousands == L'\0')
	    grouping = NULL;
# else
#  ifdef _LIBC
	  thousands = _NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP);
#  endif
	  if (*thousands == '\0')
	    {
	      thousands = NULL;
	      grouping = NULL;
	    }
# endif
	}
    }
  else
    grouping = NULL;
#endif

  if (base < 0 || base == 1 || base > 36)
    {
      __set_errno (EINVAL);
      return 0;
    }

  save = s = nptr;

  /* Skip white space.  */
  while (ISSPACE (*s))
    ++s;
  if (__glibc_unlikely (*s == L_('\0')))
    goto noconv;

  /* Check for a sign.  */
  negative = 0;
  if (*s == L_('-'))
    {
      negative = 1;
      ++s;
    }
  else if (*s == L_('+'))
    ++s;

  /* Recognize number prefix and if BASE is zero, figure it out ourselves.  */
  if (*s == L_('0'))
    {
      if ((base == 0 || base == 16) && TOUPPER (s[1]) == L_('X'))
	{
	  s += 2;
	  base = 16;
	}
      else if (base == 0)
	base = 8;
    }
  else if (base == 0)
    base = 10;

  /* Save the pointer so we can check later if anything happened.  */
  save = s;

#ifdef USE_NUMBER_GROUPING
  if (base != 10)
    grouping = NULL;

  if (__glibc_unlikely (grouping != NULL))
    {
# ifndef USE_WIDE_CHAR
      thousands_len = strlen (thousands);
# endif

      /* Find the end of the digit string and check its grouping.  */
      end = s;
      if (
# ifdef USE_WIDE_CHAR
	  *s != thousands
# else
	  ({ for (cnt = 0; cnt < thousands_len; ++cnt)
	       if (thousands[cnt] != end[cnt])
		 break;
	     cnt < thousands_len; })
# endif
	  )
	{
	  for (c = *end; c != L_('\0'); c = *++end)
	    if (((STRING_TYPE) c < L_('0') || (STRING_TYPE) c > L_('9'))
# ifdef USE_WIDE_CHAR
		&& (wchar_t) c != thousands
# else
		&& ({ for (cnt = 0; cnt < thousands_len; ++cnt)
		      if (thousands[cnt] != end[cnt])
			break;
		      cnt < thousands_len; })
# endif
		&& (!ISALPHA (c)
		    || (int) (TOUPPER (c) - L_('A') + 10) >= base))
	      break;

# ifdef USE_WIDE_CHAR
	  end = __correctly_grouped_prefixwc (s, end, thousands, grouping);
# else
	  end = __correctly_grouped_prefixmb (s, end, thousands, grouping);
# endif
	}
    }
  else
#endif
    end = NULL;

  /* Avoid runtime division; lookup cutoff and limit.  */
  cutoff = cutoff_tab[base - 2];
  cutlim = cutlim_tab[base - 2];

  overflow = 0;
  i = 0;
  c = *s;
  if (sizeof (long int) != sizeof (LONG int))
    {
      unsigned long int j = 0;
      unsigned long int jmax = jmax_tab[base - 2];

      for (;c != L_('\0'); c = *++s)
	{
	  if (s == end)
	    break;
	  if (c >= L_('0') && c <= L_('9'))
	    c -= L_('0');
#ifdef USE_NUMBER_GROUPING
# ifdef USE_WIDE_CHAR
	  else if (grouping && (wchar_t) c == thousands)
	    continue;
# else
	  else if (thousands_len)
	    {
	      for (cnt = 0; cnt < thousands_len; ++cnt)
		if (thousands[cnt] != s[cnt])
		  break;
	      if (cnt == thousands_len)
		{
		  s += thousands_len - 1;
		  continue;
		}
	      if (ISALPHA (c))
		c = TOUPPER (c) - L_('A') + 10;
	      else
		break;
	    }
# endif
#endif
	  else if (ISALPHA (c))
	    c = TOUPPER (c) - L_('A') + 10;
	  else
	    break;
	  if ((int) c >= base)
	    break;
	  /* Note that we never can have an overflow.  */
	  else if (j >= jmax)
	    {
	      /* We have an overflow.  Now use the long representation.  */
	      i = (unsigned LONG int) j;
	      goto use_long;
	    }
	  else
	    j = j * (unsigned long int) base + c;
	}

      i = (unsigned LONG int) j;
    }
  else
    for (;c != L_('\0'); c = *++s)
      {
	if (s == end)
	  break;
	if (c >= L_('0') && c <= L_('9'))
	  c -= L_('0');
#ifdef USE_NUMBER_GROUPING
# ifdef USE_WIDE_CHAR
	else if (grouping && (wchar_t) c == thousands)
	  continue;
# else
	else if (thousands_len)
	  {
	    for (cnt = 0; cnt < thousands_len; ++cnt)
	      if (thousands[cnt] != s[cnt])
		break;
	    if (cnt == thousands_len)
	      {
		s += thousands_len - 1;
		continue;
	      }
	    if (ISALPHA (c))
	      c = TOUPPER (c) - L_('A') + 10;
	    else
	      break;
	  }
# endif
#endif
	else if (ISALPHA (c))
	  c = TOUPPER (c) - L_('A') + 10;
	else
	  break;
	if ((int) c >= base)
	  break;
	/* Check for overflow.  */
	if (i > cutoff || (i == cutoff && c > cutlim))
	  overflow = 1;
	else
	  {
	  use_long:
	    i *= (unsigned LONG int) 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 = (STRING_TYPE *) s;

#if !UNSIGNED
  /* Check for a value that is within the range of
     `unsigned LONG int', but outside the range of `LONG int'.  */
  if (overflow == 0
      && i > (negative
	      ? -((unsigned LONG int) (STRTOL_LONG_MIN + 1)) + 1
	      : (unsigned LONG int) STRTOL_LONG_MAX))
    overflow = 1;
#endif

  if (__glibc_unlikely (overflow))
    {
      __set_errno (ERANGE);
#if UNSIGNED
      return STRTOL_ULONG_MAX;
#else
      return negative ? STRTOL_LONG_MIN : STRTOL_LONG_MAX;
#endif
    }

  /* Return the result of the appropriate sign.  */
  return negative ? -i : i;

noconv:
  /* We must handle a special case here: the base is 0 or 16 and the
     first two characters are '0' and 'x', but the rest are no
     hexadecimal digits.  This is no error case.  We return 0 and
     ENDPTR points to the `x`.  */
  if (endptr != NULL)
    {
      if (save - nptr >= 2 && TOUPPER (save[-1]) == L_('X')
	  && save[-2] == L_('0'))
	*endptr = (STRING_TYPE *) &save[-1];
      else
	/*  There was no number to convert.  */
	*endptr = (STRING_TYPE *) nptr;
    }

  return 0L;
}
#if defined _LIBC && !defined USE_WIDE_CHAR
libc_hidden_def (INTERNAL (__strtol_l))
#endif
\f
/* External user entry point.  */

#if _LIBC - 0 == 0

/* Prototype.  */
extern INT __strtol_l (const STRING_TYPE *nptr, STRING_TYPE **endptr,
		       int base);
#endif


INT
#ifdef weak_function
weak_function
#endif
__strtol_l (nptr, endptr, base, loc)
     const STRING_TYPE *nptr;
     STRING_TYPE **endptr;
     int base;
     __locale_t loc;
{
  return INTERNAL (__strtol_l) (nptr, endptr, base, 0, loc);
}
libc_hidden_def (__strtol_l)
weak_alias (__strtol_l, strtol_l)
Commit	Line	Data
0501d603	1	/* Convert string representing a number to integer value, using given locale.
d4697bc9	2	Copyright (C) 1997-2014 Free Software Foundation, Inc.
0501d603 UD	3	This file is part of the GNU C Library.
	4	Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
	5
	6	The GNU C Library is free software; you can redistribute it and/or
41bdb6e2 AJ	7	modify it under the terms of the GNU Lesser General Public
	8	License as published by the Free Software Foundation; either
	9	version 2.1 of the License, or (at your option) any later version.
0501d603 UD	10
	11	The GNU C Library is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
41bdb6e2	14	Lesser General Public License for more details.
0501d603	15
41bdb6e2	16	You should have received a copy of the GNU Lesser General Public
59ba27a6 PE	17	License along with the GNU C Library; if not, see
59ba27a6 PE	18	<http://www.gnu.org/licenses/>. */
0501d603	19
0501d603	20
ccadf7b5 UD	21	#if HAVE_CONFIG_H
	22	# include <config.h>
	23	#endif
	24
	25	#ifdef _LIBC
	26	# define USE_NUMBER_GROUPING
	27	# define STDC_HEADERS
	28	# define HAVE_LIMITS_H
	29	#endif
	30
	31	#include <ctype.h>
	32	#include <errno.h>
	33	#ifndef __set_errno
	34	# define __set_errno(Val) errno = (Val)
	35	#endif
	36
	37	#ifdef HAVE_LIMITS_H
	38	# include <limits.h>
	39	#endif
	40
	41	#include <stddef.h>
	42	#include <stdlib.h>
	43	#include <string.h>
	44	#include <locale.h>
ebbad4cc	45	#include <xlocale.h>
e054f494	46	#include <stdint.h>
af15df12	47	#include <bits/wordsize.h>
ebbad4cc	48
ccadf7b5 UD	49	#ifdef USE_NUMBER_GROUPING
	50	# include "../locale/localeinfo.h"
	51	#endif
	52
	53	/* Nonzero if we are defining `strtoul' or `strtoull', operating on
	54	unsigned integers. */
	55	#ifndef UNSIGNED
	56	# define UNSIGNED 0
	57	# define INT LONG int
	58	#else
	59	# define INT unsigned LONG int
	60	#endif
	61
	62	/* Determine the name. */
	63	#if UNSIGNED
	64	# ifdef USE_WIDE_CHAR
	65	# ifdef QUAD
	66	# define strtol_l wcstoull_l
	67	# else
	68	# define strtol_l wcstoul_l
	69	# endif
	70	# else
	71	# ifdef QUAD
	72	# define strtol_l strtoull_l
	73	# else
	74	# define strtol_l strtoul_l
	75	# endif
	76	# endif
	77	#else
	78	# ifdef USE_WIDE_CHAR
	79	# ifdef QUAD
	80	# define strtol_l wcstoll_l
	81	# else
	82	# define strtol_l wcstol_l
	83	# endif
	84	# else
	85	# ifdef QUAD
	86	# define strtol_l strtoll_l
	87	# else
	88	# define strtol_l strtol_l
	89	# endif
	90	# endif
	91	#endif
	92
	93	#define __strtol_l __strtol_l2(strtol_l)
	94	#define __strtol_l2(name) __strtol_l3(name)
	95	#define __strtol_l3(name) __##name
	96
	97
	98	/* If QUAD is defined, we are defining `strtoll' or `strtoull',
	99	operating on `long long int's. */
	100	#ifdef QUAD
	101	# define LONG long long
	102	# define STRTOL_LONG_MIN LONG_LONG_MIN
	103	# define STRTOL_LONG_MAX LONG_LONG_MAX
	104	# define STRTOL_ULONG_MAX ULONG_LONG_MAX
	105	#else
	106	# define LONG long
	107
	108	# ifndef ULONG_MAX
	109	# define ULONG_MAX ((unsigned long int) ~(unsigned long int) 0)
	110	# endif
	111	# ifndef LONG_MAX
	112	# define LONG_MAX ((long int) (ULONG_MAX >> 1))
113	# endif
114	# define STRTOL_LONG_MIN LONG_MIN
115	# define STRTOL_LONG_MAX LONG_MAX
116	# define STRTOL_ULONG_MAX ULONG_MAX
117	#endif
118
119
120	/* We use this code for the extended locale handling where the
121	function gets as an additional argument the locale which has to be
122	used. To access the values we have to redefine the _NL_CURRENT and
123	_NL_CURRENT_WORD macros. */
124	#undef _NL_CURRENT
125	#define _NL_CURRENT(category, item) \
126	(current->values[_NL_ITEM_INDEX (item)].string)
127	#undef _NL_CURRENT_WORD
128	#define _NL_CURRENT_WORD(category, item) \
129	((uint32_t) current->values[_NL_ITEM_INDEX (item)].word)
130
131	#if defined _LIBC \|\| defined HAVE_WCHAR_H
132	# include <wchar.h>
133	#endif
134
135	#ifdef USE_WIDE_CHAR
136	# include <wctype.h>
137	# define L_(Ch) L##Ch
138	# define UCHAR_TYPE wint_t
139	# define STRING_TYPE wchar_t
140	# define ISSPACE(Ch) __iswspace_l ((Ch), loc)
141	# define ISALPHA(Ch) __iswalpha_l ((Ch), loc)
142	# define TOUPPER(Ch) __towupper_l ((Ch), loc)
143	#else
144	# if defined _LIBC \
145	\|\| defined STDC_HEADERS \|\| (!defined isascii && !defined HAVE_ISASCII)
146	# define IN_CTYPE_DOMAIN(c) 1
147	# else
148	# define IN_CTYPE_DOMAIN(c) isascii(c)
149	# endif
150	# define L_(Ch) Ch
151	# define UCHAR_TYPE unsigned char
152	# define STRING_TYPE char
153	# define ISSPACE(Ch) __isspace_l ((Ch), loc)
154	# define ISALPHA(Ch) __isalpha_l ((Ch), loc)
155	# define TOUPPER(Ch) __toupper_l ((Ch), loc)
156	#endif
157
158	#define INTERNAL(X) INTERNAL1(X)
159	#define INTERNAL1(X) __##X##_internal
160	#define WEAKNAME(X) WEAKNAME1(X)
161
162	#ifdef USE_NUMBER_GROUPING
163	/* This file defines a function to check for correct grouping. */
164	# include "grouping.h"
165	#endif
166
167
af15df12 UD	168	/* Define tables of maximum values and remainders in order to detect
	169	overflow. Do this at compile-time in order to avoid the runtime
	170	overhead of the division. */
2d1e6277 UD	171	extern const unsigned long __strtol_ul_max_tab[] attribute_hidden;
	172	extern const unsigned char __strtol_ul_rem_tab[] attribute_hidden;
	173	#if defined(QUAD) && __WORDSIZE == 32
	174	extern const unsigned long long __strtol_ull_max_tab[] attribute_hidden;
	175	extern const unsigned char __strtol_ull_rem_tab[] attribute_hidden;
	176	#endif
af15df12 UD	177
af15df12 UD	178	#define DEF(TYPE, NAME) \
2d1e6277	179	const TYPE NAME[] attribute_hidden = \
af15df12 UD	180	{ \
	181	F(2), F(3), F(4), F(5), F(6), F(7), F(8), F(9), F(10), \
	182	F(11), F(12), F(13), F(14), F(15), F(16), F(17), F(18), F(19), F(20), \
	183	F(21), F(22), F(23), F(24), F(25), F(26), F(27), F(28), F(29), F(30), \
	184	F(31), F(32), F(33), F(34), F(35), F(36) \
	185	}
	186
2d1e6277 UD	187	#if !UNSIGNED && !defined (USE_WIDE_CHAR) && !defined (QUAD)
2d1e6277 UD	188	# define F(X) ULONG_MAX / X
af15df12	189	DEF (unsigned long, __strtol_ul_max_tab);
2d1e6277 UD	190	# undef F
	191	# define F(X) ULONG_MAX % X
	192	DEF (unsigned char, __strtol_ul_rem_tab);
	193	# undef F
	194	#endif
	195	#if !UNSIGNED && !defined (USE_WIDE_CHAR) && defined (QUAD) \
	196	&& __WORDSIZE == 32
af15df12 UD	197	# define F(X) ULONG_LONG_MAX / X
	198	DEF (unsigned long long, __strtol_ull_max_tab);
	199	# undef F
	200	# define F(X) ULONG_LONG_MAX % X
	201	DEF (unsigned char, __strtol_ull_rem_tab);
	202	# undef F
af15df12 UD	203	#endif
	204	#undef DEF
	205
	206	/* Define some more readable aliases for these arrays which correspond
	207	to how they'll be used in the function below. */
	208	#define jmax_tab __strtol_ul_max_tab
	209	#if defined(QUAD) && __WORDSIZE == 32
	210	# define cutoff_tab __strtol_ull_max_tab
	211	# define cutlim_tab __strtol_ull_rem_tab
	212	#else
	213	# define cutoff_tab __strtol_ul_max_tab
	214	# define cutlim_tab __strtol_ul_rem_tab
	215	#endif
	216
ccadf7b5 UD	217
	218	/* Convert NPTR to an `unsigned long int' or `long int' in base BASE.
	219	If BASE is 0 the base is determined by the presence of a leading
	220	zero, indicating octal or a leading "0x" or "0X", indicating hexadecimal.
	221	If BASE is < 2 or > 36, it is reset to 10.
	222	If ENDPTR is not NULL, a pointer to the character after the last
	223	one converted is stored in ENDPTR. /
	224
	225	INT
	226	INTERNAL (__strtol_l) (nptr, endptr, base, group, loc)
	227	const STRING_TYPE *nptr;
	228	STRING_TYPE **endptr;
	229	int base;
	230	int group;
	231	__locale_t loc;
	232	{
	233	int negative;
2e09a79a JM	234	unsigned LONG int cutoff;
	235	unsigned int cutlim;
	236	unsigned LONG int i;
	237	const STRING_TYPE *s;
	238	UCHAR_TYPE c;
ccadf7b5 UD	239	const STRING_TYPE save, end;
	240	int overflow;
	241	#ifndef USE_WIDE_CHAR
	242	size_t cnt;
	243	#endif
	244
	245	#ifdef USE_NUMBER_GROUPING
f095bb72	246	struct __locale_data *current = loc->__locales[LC_NUMERIC];
ccadf7b5 UD	247	/* The thousands character of the current locale. */
	248	# ifdef USE_WIDE_CHAR
	249	wchar_t thousands = L'\0';
	250	# else
	251	const char *thousands = NULL;
	252	size_t thousands_len = 0;
	253	# endif
	254	/* The numeric grouping specification of the current locale,
	255	in the format described in <locale.h>. */
	256	const char *grouping;
	257
a1ffb40e	258	if (__glibc_unlikely (group))
ccadf7b5 UD	259	{
	260	grouping = _NL_CURRENT (LC_NUMERIC, GROUPING);
	261	if (grouping <= 0 \|\| grouping == CHAR_MAX)
	262	grouping = NULL;
	263	else
	264	{
	265	/* Figure out the thousands separator character. */
	266	# ifdef USE_WIDE_CHAR
	267	# ifdef _LIBC
	268	thousands = _NL_CURRENT_WORD (LC_NUMERIC,
	269	_NL_NUMERIC_THOUSANDS_SEP_WC);
	270	# endif
	271	if (thousands == L'\0')
	272	grouping = NULL;
	273	# else
	274	# ifdef _LIBC
	275	thousands = _NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP);
	276	# endif
	277	if (*thousands == '\0')
	278	{
	279	thousands = NULL;
	280	grouping = NULL;
	281	}
	282	# endif
	283	}
	284	}
	285	else
	286	grouping = NULL;
	287	#endif
	288
	289	if (base < 0 \|\| base == 1 \|\| base > 36)
	290	{
	291	__set_errno (EINVAL);
	292	return 0;
	293	}
	294
	295	save = s = nptr;
	296
	297	/* Skip white space. */
	298	while (ISSPACE (*s))
	299	++s;
a1ffb40e	300	if (__glibc_unlikely (*s == L_('\0')))
ccadf7b5 UD	301	goto noconv;
	302
	303	/* Check for a sign. */
	304	negative = 0;
	305	if (*s == L_('-'))
	306	{
	307	negative = 1;
	308	++s;
	309	}
	310	else if (*s == L_('+'))
	311	++s;
	312
	313	/* Recognize number prefix and if BASE is zero, figure it out ourselves. */
	314	if (*s == L_('0'))
	315	{
	316	if ((base == 0 \|\| base == 16) && TOUPPER (s[1]) == L_('X'))
	317	{
	318	s += 2;
	319	base = 16;
	320	}
	321	else if (base == 0)
	322	base = 8;
	323	}
	324	else if (base == 0)
	325	base = 10;
	326
	327	/* Save the pointer so we can check later if anything happened. */
	328	save = s;
	329
	330	#ifdef USE_NUMBER_GROUPING
	331	if (base != 10)
	332	grouping = NULL;
	333
a1ffb40e	334	if (__glibc_unlikely (grouping != NULL))
ccadf7b5 UD	335	{
	336	# ifndef USE_WIDE_CHAR
	337	thousands_len = strlen (thousands);
	338	# endif
	339
	340	/* Find the end of the digit string and check its grouping. */
	341	end = s;
	342	if (
	343	# ifdef USE_WIDE_CHAR
	344	*s != thousands
	345	# else
	346	({ for (cnt = 0; cnt < thousands_len; ++cnt)
	347	if (thousands[cnt] != end[cnt])
	348	break;
	349	cnt < thousands_len; })
	350	# endif
	351	)
	352	{
	353	for (c = end; c != L_('\0'); c = ++end)
	354	if (((STRING_TYPE) c < L_('0') \|\| (STRING_TYPE) c > L_('9'))
	355	# ifdef USE_WIDE_CHAR
	356	&& (wchar_t) c != thousands
	357	# else
	358	&& ({ for (cnt = 0; cnt < thousands_len; ++cnt)
	359	if (thousands[cnt] != end[cnt])
	360	break;
	361	cnt < thousands_len; })
	362	# endif
	363	&& (!ISALPHA (c)
	364	\|\| (int) (TOUPPER (c) - L_('A') + 10) >= base))
	365	break;
	366
	367	# ifdef USE_WIDE_CHAR
	368	end = __correctly_grouped_prefixwc (s, end, thousands, grouping);
	369	# else
	370	end = __correctly_grouped_prefixmb (s, end, thousands, grouping);
	371	# endif
	372	}
	373	}
	374	else
	375	#endif
	376	end = NULL;
	377
af15df12 UD	378	/* Avoid runtime division; lookup cutoff and limit. */
	379	cutoff = cutoff_tab[base - 2];
	380	cutlim = cutlim_tab[base - 2];
ccadf7b5 UD	381
	382	overflow = 0;
	383	i = 0;
	384	c = *s;
	385	if (sizeof (long int) != sizeof (LONG int))
	386	{
	387	unsigned long int j = 0;
af15df12	388	unsigned long int jmax = jmax_tab[base - 2];
ccadf7b5 UD	389
	390	for (;c != L_('\0'); c = *++s)
	391	{
	392	if (s == end)
	393	break;
	394	if (c >= L_('0') && c <= L_('9'))
	395	c -= L_('0');
	396	#ifdef USE_NUMBER_GROUPING
	397	# ifdef USE_WIDE_CHAR
	398	else if (grouping && (wchar_t) c == thousands)
	399	continue;
	400	# else
	401	else if (thousands_len)
	402	{
	403	for (cnt = 0; cnt < thousands_len; ++cnt)
	404	if (thousands[cnt] != s[cnt])
	405	break;
	406	if (cnt == thousands_len)
	407	{
	408	s += thousands_len - 1;
	409	continue;
	410	}
	411	if (ISALPHA (c))
	412	c = TOUPPER (c) - L_('A') + 10;
	413	else
	414	break;
	415	}
	416	# endif
	417	#endif
	418	else if (ISALPHA (c))
	419	c = TOUPPER (c) - L_('A') + 10;
	420	else
	421	break;
	422	if ((int) c >= base)
	423	break;
	424	/* Note that we never can have an overflow. */
	425	else if (j >= jmax)
	426	{
	427	/* We have an overflow. Now use the long representation. */
	428	i = (unsigned LONG int) j;
	429	goto use_long;
	430	}
	431	else
	432	j = j * (unsigned long int) base + c;
	433	}
	434
	435	i = (unsigned LONG int) j;
	436	}
	437	else
	438	for (;c != L_('\0'); c = *++s)
	439	{
	440	if (s == end)
	441	break;
	442	if (c >= L_('0') && c <= L_('9'))
	443	c -= L_('0');
	444	#ifdef USE_NUMBER_GROUPING
	445	# ifdef USE_WIDE_CHAR
	446	else if (grouping && (wchar_t) c == thousands)
	447	continue;
	448	# else
	449	else if (thousands_len)
	450	{
	451	for (cnt = 0; cnt < thousands_len; ++cnt)
	452	if (thousands[cnt] != s[cnt])
453	break;
454	if (cnt == thousands_len)
455	{
456	s += thousands_len - 1;
457	continue;
458	}
459	if (ISALPHA (c))
460	c = TOUPPER (c) - L_('A') + 10;
461	else
462	break;
463	}
464	# endif
465	#endif
466	else if (ISALPHA (c))
467	c = TOUPPER (c) - L_('A') + 10;
468	else
469	break;
470	if ((int) c >= base)
471	break;
472	/* Check for overflow. */
473	if (i > cutoff \|\| (i == cutoff && c > cutlim))
474	overflow = 1;
475	else
476	{
477	use_long:
478	i *= (unsigned LONG int) base;
479	i += c;
480	}
481	}
482
483	/* Check if anything actually happened. */
484	if (s == save)
485	goto noconv;
486
487	/* Store in ENDPTR the address of one character
488	past the last character we converted. */
489	if (endptr != NULL)
490	endptr = (STRING_TYPE ) s;
491
492	#if !UNSIGNED
493	/* Check for a value that is within the range of
494	`unsigned LONG int', but outside the range of `LONG int'. */
495	if (overflow == 0
496	&& i > (negative
497	? -((unsigned LONG int) (STRTOL_LONG_MIN + 1)) + 1
498	: (unsigned LONG int) STRTOL_LONG_MAX))
499	overflow = 1;
500	#endif
501
a1ffb40e	502	if (__glibc_unlikely (overflow))
ccadf7b5 UD	503	{
	504	__set_errno (ERANGE);
	505	#if UNSIGNED
	506	return STRTOL_ULONG_MAX;
	507	#else
	508	return negative ? STRTOL_LONG_MIN : STRTOL_LONG_MAX;
	509	#endif
	510	}
	511
	512	/* Return the result of the appropriate sign. */
	513	return negative ? -i : i;
	514
	515	noconv:
	516	/* We must handle a special case here: the base is 0 or 16 and the
	517	first two characters are '0' and 'x', but the rest are no
	518	hexadecimal digits. This is no error case. We return 0 and
	519	ENDPTR points to the `x`. */
	520	if (endptr != NULL)
	521	{
	522	if (save - nptr >= 2 && TOUPPER (save[-1]) == L_('X')
	523	&& save[-2] == L_('0'))
	524	endptr = (STRING_TYPE ) &save[-1];
	525	else
	526	/* There was no number to convert. */
	527	endptr = (STRING_TYPE ) nptr;
	528	}
	529
	530	return 0L;
	531	}
	532	#if defined _LIBC && !defined USE_WIDE_CHAR
	533	libc_hidden_def (INTERNAL (__strtol_l))
	534	#endif
	535	\f
	536	/* External user entry point. */
	537
	538	#if _LIBC - 0 == 0
ccadf7b5 UD	539
ccadf7b5 UD	540	/* Prototype. */
69db4f8f MP	541	extern INT __strtol_l (const STRING_TYPE nptr, STRING_TYPE *endptr,
69db4f8f MP	542	int base);
ccadf7b5	543	#endif
0501d603	544
da4cfe38	545
ccadf7b5 UD	546	INT
	547	#ifdef weak_function
	548	weak_function
	549	#endif
	550	__strtol_l (nptr, endptr, base, loc)
	551	const STRING_TYPE *nptr;
	552	STRING_TYPE **endptr;
	553	int base;
	554	__locale_t loc;
	555	{
	556	return INTERNAL (__strtol_l) (nptr, endptr, base, 0, loc);
	557	}
773e305e	558	libc_hidden_def (__strtol_l)
da4cfe38	559	weak_alias (__strtol_l, strtol_l)