compat/fmt_scaled.c

   1 /*
   2  * Copyright (c) 2001, 2002, 2003 Ian F. Darwin.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  * 3. The name of the author may not be used to endorse or promote products
  13  *    derived from this software without specific prior written permission.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 /*
  28  * fmt_scaled: Format numbers scaled for human comprehension
  29  * scan_scaled: Scan numbers in this format.
  30  *
  31  * "Human-readable" output uses 4 digits max, and puts a unit suffix at
  32  * the end.  Makes output compact and easy-to-read esp. on huge disks.
  33  * Formatting code was originally in OpenBSD "df", converted to library routine.
  34  * Scanning code written for OpenBSD libutil.
  35  */
  36
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <errno.h>
  40 #include <string.h>
  41 #include <ctype.h>
  42 #include <limits.h>
  43
  44 #include "got_compat.h"
  45
  46 typedef enum {
  47         NONE = 0, KILO = 1, MEGA = 2, GIGA = 3, TERA = 4, PETA = 5, EXA = 6
  48 } unit_type;
  49
  50 /* These three arrays MUST be in sync!  XXX make a struct */
  51 static unit_type units[] = { NONE, KILO, MEGA, GIGA, TERA, PETA, EXA };
  52 static char scale_chars[] = "BKMGTPE";
  53 static long long scale_factors[] = {
  54         1LL,
  55         1024LL,
  56         1024LL*1024,
  57         1024LL*1024*1024,
  58         1024LL*1024*1024*1024,
  59         1024LL*1024*1024*1024*1024,
  60         1024LL*1024*1024*1024*1024*1024,
  61 };
  62 #define SCALE_LENGTH (sizeof(units)/sizeof(units[0]))
  63
  64 #define MAX_DIGITS (SCALE_LENGTH * 3)   /* XXX strlen(sprintf("%lld", -1)? */
  65
  66 /* Convert the given input string "scaled" into numeric in "result".
  67  * Return 0 on success, -1 and errno set on error.
  68  */
  69 int
  70 scan_scaled(char *scaled, long long *result)
  71 {
  72         char *p = scaled;
  73         int sign = 0;
  74         unsigned int i, ndigits = 0, fract_digits = 0;
  75         long long scale_fact = 1, whole = 0, fpart = 0;
  76
  77         /* Skip leading whitespace */
  78         while (isascii(*p) && isspace(*p))
  79                 ++p;
  80
  81         /* Then at most one leading + or - */
  82         while (*p == '-' || *p == '+') {
  83                 if (*p == '-') {
  84                         if (sign) {
  85                                 errno = EINVAL;
  86                                 return -1;
  87                         }
  88                         sign = -1;
  89                         ++p;
  90                 } else if (*p == '+') {
  91                         if (sign) {
  92                                 errno = EINVAL;
  93                                 return -1;
  94                         }
  95                         sign = +1;
  96                         ++p;
  97                 }
  98         }
  99
 100         /* Main loop: Scan digits, find decimal point, if present.
 101          * We don't allow exponentials, so no scientific notation
 102          * (but note that E for Exa might look like e to some!).
 103          * Advance 'p' to end, to get scale factor.
 104          */
 105         for (; isascii(*p) && (isdigit(*p) || *p=='.'); ++p) {
 106                 if (*p == '.') {
 107                         if (fract_digits > 0) { /* oops, more than one '.' */
 108                                 errno = EINVAL;
 109                                 return -1;
 110                         }
 111                         fract_digits = 1;
 112                         continue;
 113                 }
 114
 115                 i = (*p) - '0';                 /* whew! finally a digit we can use */
 116                 if (fract_digits > 0) {
 117                         if (fract_digits >= MAX_DIGITS-1)
 118                                 /* ignore extra fractional digits */
 119                                 continue;
 120                         fract_digits++;         /* for later scaling */
 121                         fpart *= 10;
 122                         fpart += i;
 123                 } else {                                /* normal digit */
 124                         if (++ndigits >= MAX_DIGITS) {
 125                                 errno = ERANGE;
 126                                 return -1;
 127                         }
 128                         whole *= 10;
 129                         whole += i;
 130                 }
 131         }
 132
 133         if (sign) {
 134                 whole *= sign;
 135                 fpart *= sign;
 136         }
 137
 138         /* If no scale factor given, we're done. fraction is discarded. */
 139         if (!*p) {
 140                 *result = whole;
 141                 return 0;
 142         }
 143
 144         /* Validate scale factor, and scale whole and fraction by it. */
 145         for (i = 0; i < SCALE_LENGTH; i++) {
 146
 147                 /* Are we there yet? */
 148                 if (*p == scale_chars[i] ||
 149                         *p == tolower(scale_chars[i])) {
 150
 151                         /* If it ends with alphanumerics after the scale char, bad. */
 152                         if (isalnum(*(p+1))) {
 153                                 errno = EINVAL;
 154                                 return -1;
 155                         }
 156                         scale_fact = scale_factors[i];
 157
 158                         /* scale whole part */
 159                         whole *= scale_fact;
 160
 161                         /* truncate fpart so it does't overflow.
 162                          * then scale fractional part.
 163                          */
 164                         while (fpart >= LLONG_MAX / scale_fact) {
 165                                 fpart /= 10;
 166                                 fract_digits--;
 167                         }
 168                         fpart *= scale_fact;
 169                         if (fract_digits > 0) {
 170                                 for (i = 0; i < fract_digits -1; i++)
 171                                         fpart /= 10;
 172                         }
 173                         whole += fpart;
 174                         *result = whole;
 175                         return 0;
 176                 }
 177         }
 178         errno = ERANGE;
 179         return -1;
 180 }
 181
 182 /* Format the given "number" into human-readable form in "result".
 183  * Result must point to an allocated buffer of length FMT_SCALED_STRSIZE.
 184  * Return 0 on success, -1 and errno set if error.
 185  */
 186 int
 187 fmt_scaled(long long number, char *result)
 188 {
 189         long long abval, fract = 0;
 190         unsigned int i;
 191         unit_type unit = NONE;
 192
 193         abval = llabs(number);
 194
 195         /* Not every negative long long has a positive representation.
 196          * Also check for numbers that are just too darned big to format
 197          */
 198         if (abval < 0 || abval / 1024 >= scale_factors[SCALE_LENGTH-1]) {
 199                 errno = ERANGE;
 200                 return -1;
 201         }
 202
 203         /* scale whole part; get unscaled fraction */
 204         for (i = 0; i < SCALE_LENGTH; i++) {
 205                 if (abval/1024 < scale_factors[i]) {
 206                         unit = units[i];
 207                         fract = (i == 0) ? 0 : abval % scale_factors[i];
 208                         number /= scale_factors[i];
 209                         if (i > 0)
 210                                 fract /= scale_factors[i - 1];
 211                         break;
 212                 }
 213         }
 214
 215         fract = (10 * fract + 512) / 1024;
 216         /* if the result would be >= 10, round main number */
 217         if (fract == 10) {
 218                 if (number >= 0)
 219                         number++;
 220                 else
 221                         number--;
 222                 fract = 0;
 223         }
 224
 225         if (number == 0)
 226                 strlcpy(result, "0B", FMT_SCALED_STRSIZE);
 227         else if (unit == NONE || number >= 100 || number <= -100) {
 228                 if (fract >= 5) {
 229                         if (number >= 0)
 230                                 number++;
 231                         else
 232                                 number--;
 233                 }
 234                 (void)snprintf(result, FMT_SCALED_STRSIZE, "%lld%c",
 235                         number, scale_chars[unit]);
 236         } else
 237                 (void)snprintf(result, FMT_SCALED_STRSIZE, "%lld.%1lld%c",
 238                         number, fract, scale_chars[unit]);
 239
 240         return 0;
 241 }