lib/strutil/xstrtol.c

   1 /* A more useful interface to strtol.
   2
   3    Copyright (C) 1995-2016
   4    Free Software Foundation, Inc.
   5
   6    This program is free software: you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program 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
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 /* Written by Jim Meyering. */
  20
  21 #include <config.h>
  22
  23 /* Some pre-ANSI implementations (e.g. SunOS 4)
  24    need stderr defined if assertion checking is enabled.  */
  25 #include <stdio.h>
  26
  27 #ifdef HAVE_ASSERT_H
  28 #include <assert.h>
  29 #endif
  30 #include <ctype.h>
  31 #include <errno.h>
  32 #include <inttypes.h>
  33 #include <limits.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36
  37 #include "lib/strutil.h"
  38
  39 /*** global variables ****************************************************************************/
  40
  41 /*** file scope macro definitions ****************************************************************/
  42
  43 /*** file scope type declarations ****************************************************************/
  44
  45 /*** file scope variables ************************************************************************/
  46
  47 /* --------------------------------------------------------------------------------------------- */
  48 /*** file scope functions ************************************************************************/
  49 /* --------------------------------------------------------------------------------------------- */
  50
  51 static strtol_error_t
  52 bkm_scale (uintmax_t * x, int scale_factor)
  53 {
  54     if (UINTMAX_MAX / scale_factor < *x)
  55     {
  56         *x = UINTMAX_MAX;
  57         return LONGINT_OVERFLOW;
  58     }
  59
  60     *x *= scale_factor;
  61     return LONGINT_OK;
  62 }
  63
  64 /* --------------------------------------------------------------------------------------------- */
  65
  66 static strtol_error_t
  67 bkm_scale_by_power (uintmax_t * x, int base, int power)
  68 {
  69     strtol_error_t err = LONGINT_OK;
  70     while (power-- != 0)
  71         err |= bkm_scale (x, base);
  72     return err;
  73 }
  74
  75 /* --------------------------------------------------------------------------------------------- */
  76 /*** public functions ****************************************************************************/
  77 /* --------------------------------------------------------------------------------------------- */
  78
  79 strtol_error_t
  80 xstrtoumax (const char *s, char **ptr, int base, uintmax_t * val, const char *valid_suffixes)
  81 {
  82     char *t_ptr;
  83     char **p;
  84     uintmax_t tmp;
  85     strtol_error_t err = LONGINT_OK;
  86
  87 #ifdef HAVE_ASSERT_H
  88     assert (0 <= base && base <= 36);
  89 #endif
  90
  91     p = (ptr != NULL ? ptr : &t_ptr);
  92
  93     {
  94         const char *q = s;
  95         unsigned char ch = *q;
  96
  97         while (isspace (ch))
  98             ch = *++q;
  99
 100         if (ch == '-')
 101             return LONGINT_INVALID;
 102     }
 103
 104     errno = 0;
 105     tmp = strtol (s, p, base);
 106
 107     if (*p == s)
 108     {
 109         /* If there is no number but there is a valid suffix, assume the
 110            number is 1.  The string is invalid otherwise.  */
 111         if (valid_suffixes != NULL && **p != '\0' && strchr (valid_suffixes, **p) != NULL)
 112             tmp = 1;
 113         else
 114             return LONGINT_INVALID;
 115     }
 116     else if (errno != 0)
 117     {
 118         if (errno != ERANGE)
 119             return LONGINT_INVALID;
 120         err = LONGINT_OVERFLOW;
 121     }
 122
 123     /* Let valid_suffixes == NULL mean "allow any suffix".  */
 124     /* FIXME: update all callers except the ones that allow suffixes
 125        after the number, changing last parameter NULL to "".  */
 126     if (valid_suffixes == NULL)
 127     {
 128         *val = tmp;
 129         return err;
 130     }
 131
 132     if (**p != '\0')
 133     {
 134         int suffixes = 1;
 135         strtol_error_t overflow;
 136
 137         if (strchr (valid_suffixes, **p) == NULL)
 138         {
 139             *val = tmp;
 140             return err | LONGINT_INVALID_SUFFIX_CHAR;
 141         }
 142
 143         base = 1024;
 144
 145         if (strchr (valid_suffixes, '0') != NULL)
 146         {
 147             /* The "valid suffix" '0' is a special flag meaning that
 148                an optional second suffix is allowed, which can change
 149                the base.  A suffix "B" (e.g. "100MB") stands for a power
 150                of 1000, whereas a suffix "iB" (e.g. "100MiB") stands for
 151                a power of 1024.  If no suffix (e.g. "100M"), assume
 152                power-of-1024.  */
 153
 154             switch (p[0][1])
 155             {
 156             case 'i':
 157                 if (p[0][2] == 'B')
 158                     suffixes += 2;
 159                 break;
 160
 161             case 'B':
 162             case 'D':          /* 'D' is obsolescent */
 163                 base = 1000;
 164                 suffixes++;
 165                 break;
 166             default:
 167                 break;
 168             }
 169         }
 170
 171         switch (**p)
 172         {
 173         case 'b':
 174             overflow = bkm_scale (&tmp, 512);
 175             break;
 176
 177         case 'B':
 178             overflow = bkm_scale (&tmp, 1024);
 179             break;
 180
 181         case 'c':
 182             overflow = LONGINT_OK;
 183             break;
 184
 185         case 'E':              /* exa or exbi */
 186             overflow = bkm_scale_by_power (&tmp, base, 6);
 187             break;
 188
 189         case 'G':              /* giga or gibi */
 190         case 'g':              /* 'g' is undocumented; for compatibility only */
 191             overflow = bkm_scale_by_power (&tmp, base, 3);
 192             break;
 193
 194         case 'k':              /* kilo */
 195         case 'K':              /* kibi */
 196             overflow = bkm_scale_by_power (&tmp, base, 1);
 197             break;
 198
 199         case 'M':              /* mega or mebi */
 200         case 'm':              /* 'm' is undocumented; for compatibility only */
 201             overflow = bkm_scale_by_power (&tmp, base, 2);
 202             break;
 203
 204         case 'P':              /* peta or pebi */
 205             overflow = bkm_scale_by_power (&tmp, base, 5);
 206             break;
 207
 208         case 'T':              /* tera or tebi */
 209         case 't':              /* 't' is undocumented; for compatibility only */
 210             overflow = bkm_scale_by_power (&tmp, base, 4);
 211             break;
 212
 213         case 'w':
 214             overflow = bkm_scale (&tmp, 2);
 215             break;
 216
 217         case 'Y':              /* yotta or 2**80 */
 218             overflow = bkm_scale_by_power (&tmp, base, 8);
 219             break;
 220
 221         case 'Z':              /* zetta or 2**70 */
 222             overflow = bkm_scale_by_power (&tmp, base, 7);
 223             break;
 224
 225         default:
 226             *val = tmp;
 227             return err | LONGINT_INVALID_SUFFIX_CHAR;
 228         }
 229
 230         err |= overflow;
 231         *p += suffixes;
 232         if (**p != '\0')
 233             err |= LONGINT_INVALID_SUFFIX_CHAR;
 234     }
 235
 236     *val = tmp;
 237     return err;
 238 }
 239
 240 /* --------------------------------------------------------------------------------------------- */