newlib/libc/stdlib/strtoul.c

   1 /*
   2 FUNCTION
   3         <<strtoul>>, <<strtoul_l>>---string to unsigned long
   4
   5 INDEX
   6         strtoul
   7
   8 INDEX
   9         strtoul_l
  10
  11 INDEX
  12         _strtoul_r
  13
  14 SYNOPSIS
  15         #include <stdlib.h>
  16         unsigned long strtoul(const char *restrict <[s]>,
  17                               char **restrict <[ptr]>, int <[base]>);
  18
  19         #include <stdlib.h>
  20         unsigned long strtoul_l(const char *restrict <[s]>,
  21                                 char **restrict <[ptr]>, int <[base]>,
  22                                 locale_t <[locale]>);
  23
  24         unsigned long _strtoul_r(void *<[reent]>, const char *restrict <[s]>,
  25                                  char **restrict <[ptr]>, int <[base]>);
  26
  27 DESCRIPTION
  28 The function <<strtoul>> converts the string <<*<[s]>>> to
  29 an <<unsigned long>>. First, it breaks down the string into three parts:
  30 leading whitespace, which is ignored; a subject string consisting
  31 of the digits meaningful in the radix specified by <[base]>
  32 (for example, <<0>> through <<7>> if the value of <[base]> is 8);
  33 and a trailing portion consisting of one or more unparseable characters,
  34 which always includes the terminating null character. Then, it attempts
  35 to convert the subject string into an unsigned long integer, and returns the
  36 result.
  37
  38 If the value of <[base]> is zero, the subject string is expected to look
  39 like a normal C integer constant (save that no optional sign is permitted):
  40 a possible <<0x>> indicating hexadecimal radix, and a number.
  41 If <[base]> is between 2 and 36, the expected form of the subject is a
  42 sequence of digits (which may include letters, depending on the
  43 base) representing an integer in the radix specified by <[base]>.
  44 The letters <<a>>--<<z>> (or <<A>>--<<Z>>) are used as digits valued from
  45 10 to 35. If <[base]> is 16, a leading <<0x>> is permitted.
  46
  47 The subject sequence is the longest initial sequence of the input
  48 string that has the expected form, starting with the first
  49 non-whitespace character.  If the string is empty or consists entirely
  50 of whitespace, or if the first non-whitespace character is not a
  51 permissible digit, the subject string is empty.
  52
  53 If the subject string is acceptable, and the value of <[base]> is zero,
  54 <<strtoul>> attempts to determine the radix from the input string. A
  55 string with a leading <<0x>> is treated as a hexadecimal value; a string with
  56 a leading <<0>> and no <<x>> is treated as octal; all other strings are
  57 treated as decimal. If <[base]> is between 2 and 36, it is used as the
  58 conversion radix, as described above. Finally, a pointer to the first
  59 character past the converted subject string is stored in <[ptr]>, if
  60 <[ptr]> is not <<NULL>>.
  61
  62 If the subject string is empty (that is, if <<*>><[s]> does not start
  63 with a substring in acceptable form), no conversion
  64 is performed and the value of <[s]> is stored in <[ptr]> (if <[ptr]> is
  65 not <<NULL>>).
  66
  67 <<strtoul_l>> is like <<strtoul>> but performs the conversion based on the
  68 locale specified by the locale object locale.  If <[locale]> is
  69 LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
  70
  71 The alternate function <<_strtoul_r>> is a reentrant version.  The
  72 extra argument <[reent]> is a pointer to a reentrancy structure.
  73
  74 RETURNS
  75 <<strtoul>>, <<strtoul_l>> return the converted value, if any. If no
  76 conversion was made, <<0>> is returned.
  77
  78 <<strtoul>>, <<strtoul_l>> return <<ULONG_MAX>> if the magnitude of the
  79 converted value is too large, and sets <<errno>> to <<ERANGE>>.
  80
  81 PORTABILITY
  82 <<strtoul>> is ANSI.
  83 <<strtoul_l>> is a GNU extension.
  84
  85 <<strtoul>> requires no supporting OS subroutines.
  86 */
  87
  88 /*
  89  * Copyright (c) 1990 Regents of the University of California.
  90  * All rights reserved.
  91  *
  92  * Redistribution and use in source and binary forms, with or without
  93  * modification, are permitted provided that the following conditions
  94  * are met:
  95  * 1. Redistributions of source code must retain the above copyright
  96  *    notice, this list of conditions and the following disclaimer.
  97  * 2. Redistributions in binary form must reproduce the above copyright
  98  *    notice, this list of conditions and the following disclaimer in the
  99  *    documentation and/or other materials provided with the distribution.
 100  * 3. Neither the name of the University nor the names of its contributors
 101  *    may be used to endorse or promote products derived from this software
 102  *    without specific prior written permission.
 103  *
 104  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 105  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 106  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 107  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 108  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 109  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 110  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 111  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 112  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 113  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 114  * SUCH DAMAGE.
 115  */
 116
 117 #define _GNU_SOURCE
 118 #include <_ansi.h>
 119 #include <limits.h>
 120 #include <ctype.h>
 121 #include <errno.h>
 122 #include <stdlib.h>
 123 #include <reent.h>
 124 #include "../locale/setlocale.h"
 125
 126 /*
 127  * Convert a string to an unsigned long integer.
 128  */
 129 static unsigned long
 130 _strtoul_l (struct _reent *rptr, const char *__restrict nptr,
 131             char **__restrict endptr, int base, locale_t loc)
 132 {
 133         register const unsigned char *s = (const unsigned char *)nptr;
 134         register unsigned long acc;
 135         register int c;
 136         register unsigned long cutoff;
 137         register int neg = 0, any, cutlim;
 138
 139         /*
 140          * See strtol for comments as to the logic used.
 141          */
 142         do {
 143                 c = *s++;
 144         } while (isspace_l(c, loc));
 145         if (c == '-') {
 146                 neg = 1;
 147                 c = *s++;
 148         } else if (c == '+')
 149                 c = *s++;
 150         if ((base == 0 || base == 16) &&
 151             c == '0' && (*s == 'x' || *s == 'X')) {
 152                 c = s[1];
 153                 s += 2;
 154                 base = 16;
 155         }
 156         if (base == 0)
 157                 base = c == '0' ? 8 : 10;
 158         cutoff = (unsigned long)ULONG_MAX / (unsigned long)base;
 159         cutlim = (unsigned long)ULONG_MAX % (unsigned long)base;
 160         for (acc = 0, any = 0;; c = *s++) {
 161                 if (c >= '0' && c <= '9')
 162                         c -= '0';
 163                 else if (c >= 'A' && c <= 'Z')
 164                         c -= 'A' - 10;
 165                 else if (c >= 'a' && c <= 'z')
 166                         c -= 'a' - 10;
 167                 else
 168                         break;
 169                 if (c >= base)
 170                         break;
 171                if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
 172                         any = -1;
 173                 else {
 174                         any = 1;
 175                         acc *= base;
 176                         acc += c;
 177                 }
 178         }
 179         if (any < 0) {
 180                 acc = ULONG_MAX;
 181                 _REENT_ERRNO(rptr) = ERANGE;
 182         } else if (neg)
 183                 acc = -acc;
 184         if (endptr != 0)
 185                 *endptr = (char *) (any ? (char *)s - 1 : nptr);
 186         return (acc);
 187 }
 188
 189 unsigned long
 190 _strtoul_r (struct _reent *rptr,
 191         const char *__restrict nptr,
 192         char **__restrict endptr,
 193         int base)
 194 {
 195   return _strtoul_l (rptr, nptr, endptr, base, __get_current_locale ());
 196 }
 197
 198 #ifndef _REENT_ONLY
 199
 200 unsigned long
 201 strtoul_l (const char *__restrict s, char **__restrict ptr, int base,
 202            locale_t loc)
 203 {
 204         return _strtoul_l (_REENT, s, ptr, base, loc);
 205 }
 206
 207 unsigned long
 208 strtoul (const char *__restrict s,
 209         char **__restrict ptr,
 210         int base)
 211 {
 212         return _strtoul_l (_REENT, s, ptr, base, __get_current_locale ());
 213 }
 214
 215 #endif