Dogcows Code - chaz/tar/blob - lib/human.c

   1 /* human.c -- print human readable file size
   2    Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software Foundation,
  16    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17
  18 /* Originally contributed by lm@sgi.com;
  19    --si, output block size selection, and large file support
  20    added by eggert@twinsun.com.  */
  21
  22 #if HAVE_CONFIG_H
  23 # include <config.h>
  24 #endif
  25
  26 #include <sys/types.h>
  27 #include <stdio.h>
  28
  29 #if HAVE_LIMITS_H
  30 # include <limits.h>
  31 #endif
  32
  33 #if HAVE_STRING_H
  34 # include <string.h>
  35 #else
  36 # include <strings.h>
  37 #endif
  38
  39 #ifndef CHAR_BIT
  40 # define CHAR_BIT 8
  41 #endif
  42 #if HAVE_STDLIB_H
  43 # include <stdlib.h>
  44 #endif
  45
  46 #ifndef HAVE_DECL_GETENV
  47 "this configure-time declaration test was not run"
  48 #endif
  49 #if !HAVE_DECL_GETENV
  50 char *getenv ();
  51 #endif
  52
  53 #if ENABLE_NLS
  54 # include <libintl.h>
  55 # define _(Text) gettext (Text)
  56 #else
  57 # define _(Text) Text
  58 #endif
  59
  60 #include <argmatch.h>
  61 #include <error.h>
  62 #include <xstrtol.h>
  63
  64 #include "human.h"
  65
  66 static const char suffixes[] =
  67 {
  68   0,    /* not used */
  69   'k',  /* kilo */
  70   'M',  /* Mega */
  71   'G',  /* Giga */
  72   'T',  /* Tera */
  73   'P',  /* Peta */
  74   'E',  /* Exa */
  75   'Z',  /* Zetta */
  76   'Y'   /* Yotta */
  77 };
  78
  79 /* Like human_readable_inexact, except always round to even.  */
  80 char *
  81 human_readable (uintmax_t n, char *buf,
  82                 int from_block_size, int output_block_size)
  83 {
  84   return human_readable_inexact (n, buf, from_block_size, output_block_size,
  85                                  human_round_to_even);
  86 }
  87
  88 /* Convert N to a human readable format in BUF.
  89
  90    N is expressed in units of FROM_BLOCK_SIZE.  FROM_BLOCK_SIZE must
  91    be nonnegative.
  92
  93    OUTPUT_BLOCK_SIZE must be nonzero.  If it is positive, use units of
  94    OUTPUT_BLOCK_SIZE in the output number.
  95
  96    Use INEXACT_STYLE to determine whether to take the ceiling or floor
  97    of any result that cannot be expressed exactly.
  98
  99    If OUTPUT_BLOCK_SIZE is negative, use a format like "127k" if
 100    possible, using powers of -OUTPUT_BLOCK_SIZE; otherwise, use
 101    ordinary decimal format.  Normally -OUTPUT_BLOCK_SIZE is either
 102    1000 or 1024; it must be at least 2.  Most people visually process
 103    strings of 3-4 digits effectively, but longer strings of digits are
 104    more prone to misinterpretation.  Hence, converting to an
 105    abbreviated form usually improves readability.  Use a suffix
 106    indicating which power is being used.  For example, assuming
 107    -OUTPUT_BLOCK_SIZE is 1024, 8500 would be converted to 8.3k,
 108    133456345 to 127M, 56990456345 to 53G, and so on.  Numbers smaller
 109    than -OUTPUT_BLOCK_SIZE aren't modified.  */
 110
 111 char *
 112 human_readable_inexact (uintmax_t n, char *buf,
 113                         int from_block_size, int output_block_size,
 114                         enum human_inexact_style inexact_style)
 115 {
 116   uintmax_t amt;
 117   int base;
 118   int to_block_size;
 119   int tenths = 0;
 120   int power;
 121   char *p;
 122
 123   /* 0 means adjusted N == AMT.TENTHS;
 124      1 means AMT.TENTHS < adjusted N < AMT.TENTHS + 0.05;
 125      2 means adjusted N == AMT.TENTHS + 0.05;
 126      3 means AMT.TENTHS + 0.05 < adjusted N < AMT.TENTHS + 0.1.  */
 127   int rounding = 0;
 128
 129   if (output_block_size < 0)
 130     {
 131       base = -output_block_size;
 132       to_block_size = 1;
 133     }
 134   else
 135     {
 136       base = 0;
 137       to_block_size = output_block_size;
 138     }
 139
 140   p = buf + LONGEST_HUMAN_READABLE;
 141   *p = '\0';
 142
 143 #ifdef lint
 144   /* Suppress `used before initialized' warning.  */
 145   power = 0;
 146 #endif
 147
 148   /* Adjust AMT out of FROM_BLOCK_SIZE units and into TO_BLOCK_SIZE units.  */
 149
 150   {
 151     int multiplier;
 152     int divisor;
 153     int r2;
 154     int r10;
 155     if (to_block_size <= from_block_size
 156         ? (from_block_size % to_block_size != 0
 157            || (multiplier = from_block_size / to_block_size,
 158                (amt = n * multiplier) / multiplier != n))
 159         : (from_block_size == 0
 160            || to_block_size % from_block_size != 0
 161            || (divisor = to_block_size / from_block_size,
 162                r10 = (n % divisor) * 10,
 163                r2 = (r10 % divisor) * 2,
 164                amt = n / divisor,
 165                tenths = r10 / divisor,
 166                rounding = r2 < divisor ? 0 < r2 : 2 + (divisor < r2),
 167                0)))
 168       {
 169         /* Either the result cannot be computed easily using uintmax_t,
 170            or from_block_size is zero.  Fall back on floating point.
 171            FIXME: This can yield answers that are slightly off.  */
 172
 173         double damt = n * (from_block_size / (double) to_block_size);
 174
 175         if (! base)
 176           sprintf (buf, "%.0f", damt);
 177         else
 178           {
 179             double e = 1;
 180             power = 0;
 181
 182             do
 183               {
 184                 e *= base;
 185                 power++;
 186               }
 187             while (e * base <= damt && power < sizeof suffixes - 1);
 188
 189             damt /= e;
 190
 191             sprintf (buf, "%.1f%c", damt, suffixes[power]);
 192             if (4 < strlen (buf))
 193               sprintf (buf, "%.0f%c", damt, suffixes[power]);
 194           }
 195
 196         return buf;
 197       }
 198   }
 199
 200   /* Use power of BASE notation if adjusted AMT is large enough.  */
 201
 202   if (base && base <= amt)
 203     {
 204       power = 0;
 205
 206       do
 207         {
 208           int r10 = (amt % base) * 10 + tenths;
 209           int r2 = (r10 % base) * 2 + (rounding >> 1);
 210           amt /= base;
 211           tenths = r10 / base;
 212           rounding = (r2 < base
 213                       ? 0 < r2 + rounding
 214                       : 2 + (base < r2 + rounding));
 215           power++;
 216         }
 217       while (base <= amt && power < sizeof suffixes - 1);
 218
 219       *--p = suffixes[power];
 220
 221       if (amt < 10)
 222         {
 223           if (2 * (1 - (int) inexact_style)
 224               < rounding + (tenths & (inexact_style == human_round_to_even)))
 225             {
 226               tenths++;
 227               rounding = 0;
 228
 229               if (tenths == 10)
 230                 {
 231                   amt++;
 232                   tenths = 0;
 233                 }
 234             }
 235
 236           if (amt < 10)
 237             {
 238               *--p = '0' + tenths;
 239               *--p = '.';
 240               tenths = rounding = 0;
 241             }
 242         }
 243     }
 244
 245   if (inexact_style == human_ceiling
 246       ? 0 < tenths + rounding
 247       : inexact_style == human_round_to_even
 248       ? 5 < tenths + (2 < rounding + (amt & 1))
 249       : /* inexact_style == human_floor */ 0)
 250     {
 251       amt++;
 252
 253       if (amt == base && power < sizeof suffixes - 1)
 254         {
 255           *p = suffixes[power + 1];
 256           *--p = '0';
 257           *--p = '.';
 258           amt = 1;
 259         }
 260     }
 261
 262   do
 263     *--p = '0' + (int) (amt % 10);
 264   while ((amt /= 10) != 0);
 265
 266   return p;
 267 }
 268
 269
 270 /* The default block size used for output.  This number may change in
 271    the future as disks get larger.  */
 272 #ifndef DEFAULT_BLOCK_SIZE
 273 # define DEFAULT_BLOCK_SIZE 1024
 274 #endif
 275
 276 static char const *const block_size_args[] = { "human-readable", "si", 0 };
 277 static int const block_size_types[] = { -1024, -1000 };
 278
 279 static int
 280 default_block_size (void)
 281 {
 282   return getenv ("POSIXLY_CORRECT") ? 512 : DEFAULT_BLOCK_SIZE;
 283 }
 284
 285 static strtol_error
 286 humblock (char const *spec, int *block_size)
 287 {
 288   int i;
 289
 290   if (! spec && ! (spec = getenv ("BLOCK_SIZE")))
 291     *block_size = default_block_size ();
 292   else if (0 <= (i = ARGMATCH (spec, block_size_args, block_size_types)))
 293     *block_size = block_size_types[i];
 294   else
 295     {
 296       char *ptr;
 297       unsigned long val;
 298       strtol_error e = xstrtoul (spec, &ptr, 0, &val, "eEgGkKmMpPtTyYzZ0");
 299       if (e != LONGINT_OK)
 300         return e;
 301       if (*ptr)
 302         return LONGINT_INVALID_SUFFIX_CHAR;
 303       if ((int) val < 0 || val != (int) val)
 304         return LONGINT_OVERFLOW;
 305       *block_size = (int) val;
 306     }
 307
 308   return LONGINT_OK;
 309 }
 310
 311 void
 312 human_block_size (char const *spec, int report_errors, int *block_size)
 313 {
 314   strtol_error e = humblock (spec, block_size);
 315   if (*block_size == 0)
 316     {
 317       *block_size = default_block_size ();
 318       e = LONGINT_INVALID;
 319     }
 320   if (e != LONGINT_OK && report_errors)
 321     STRTOL_FATAL_ERROR (spec, _("block size"), e);
 322 }