/* human.c -- print human readable file size
- Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
- This program is free software; you can redistribute it and/or modify
+ Copyright (C) 1996-2007, 2009-2013 Free Software Foundation, Inc.
+
+ This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software Foundation,
- Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
-/* Originally contributed by lm@sgi.com;
- --si, output block size selection, and large file support
- added by eggert@twinsun.com. */
+/* Written by Paul Eggert and Larry McVoy. */
-#if HAVE_CONFIG_H
-# include <config.h>
-#endif
+#include <config.h>
+
+#include "human.h"
-#include <sys/types.h>
+#include <locale.h>
#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
-#if HAVE_LIMITS_H
-# include <limits.h>
-#endif
+#include <argmatch.h>
+#include <error.h>
+#include <intprops.h>
-#ifndef CHAR_BIT
-# define CHAR_BIT 8
-#endif
-#if HAVE_STDLIB_H
-# include <stdlib.h>
-#endif
+/* The maximum length of a suffix like "KiB". */
+#define HUMAN_READABLE_SUFFIX_LENGTH_MAX 3
-#ifndef HAVE_DECL_GETENV
-char *getenv ();
-#endif
+static const char power_letter[] =
+{
+ 0, /* not used */
+ 'K', /* kibi ('k' for kilo is a special case) */
+ 'M', /* mega or mebi */
+ 'G', /* giga or gibi */
+ 'T', /* tera or tebi */
+ 'P', /* peta or pebi */
+ 'E', /* exa or exbi */
+ 'Z', /* zetta or 2**70 */
+ 'Y' /* yotta or 2**80 */
+};
-#if ENABLE_NLS
-# include <libintl.h>
-# define _(Text) gettext (Text)
-#else
-# define _(Text) Text
-#endif
-#include <argmatch.h>
-#include <error.h>
-#include <xstrtol.h>
+/* If INEXACT_STYLE is not human_round_to_nearest, and if easily
+ possible, adjust VALUE according to the style. */
-#include "human.h"
+static long double
+adjust_value (int inexact_style, long double value)
+{
+ /* Do not use the floorl or ceill functions, as that would mean
+ checking for their presence and possibly linking with the
+ standard math library, which is a porting pain. So leave the
+ value alone if it is too large to easily round. */
+ if (inexact_style != human_round_to_nearest && value < UINTMAX_MAX)
+ {
+ uintmax_t u = value;
+ value = u + (inexact_style == human_ceiling && u != value);
+ }
+
+ return value;
+}
-static const char suffixes[] =
+/* Group the digits of NUMBER according to the grouping rules of the
+ current locale. NUMBER contains NUMBERLEN digits. Modify the
+ bytes pointed to by NUMBER in place, subtracting 1 from NUMBER for
+ each byte inserted. Return the starting address of the modified
+ number.
+
+ To group the digits, use GROUPING and THOUSANDS_SEP as in 'struct
+ lconv' from <locale.h>. */
+
+static char *
+group_number (char *number, size_t numberlen,
+ char const *grouping, char const *thousands_sep)
{
- 0, /* not used */
- 'k', /* kilo */
- 'M', /* Mega */
- 'G', /* Giga */
- 'T', /* Tera */
- 'P', /* Peta */
- 'E', /* Exa */
- 'Z', /* Zetta */
- 'Y' /* Yotta */
-};
+ register char *d;
+ size_t grouplen = SIZE_MAX;
+ size_t thousands_seplen = strlen (thousands_sep);
+ size_t i = numberlen;
+
+ /* The maximum possible value for NUMBERLEN is the number of digits
+ in the square of the largest uintmax_t, so double the size needed. */
+ char buf[2 * INT_STRLEN_BOUND (uintmax_t) + 1];
+
+ memcpy (buf, number, numberlen);
+ d = number + numberlen;
+
+ for (;;)
+ {
+ unsigned char g = *grouping;
-/* Convert N to a human readable format in BUF.
+ if (g)
+ {
+ grouplen = g < CHAR_MAX ? g : i;
+ grouping++;
+ }
+
+ if (i < grouplen)
+ grouplen = i;
+
+ d -= grouplen;
+ i -= grouplen;
+ memcpy (d, buf + i, grouplen);
+ if (i == 0)
+ return d;
+
+ d -= thousands_seplen;
+ memcpy (d, thousands_sep, thousands_seplen);
+ }
+}
+
+/* Convert N to a human readable format in BUF, using the options OPTS.
N is expressed in units of FROM_BLOCK_SIZE. FROM_BLOCK_SIZE must
- be positive.
-
- If OUTPUT_BLOCK_SIZE is positive, use units of OUTPUT_BLOCK_SIZE in
- the output number. OUTPUT_BLOCK_SIZE must be a multiple of
- FROM_BLOCK_SIZE or vice versa.
-
- If OUTPUT_BLOCK_SIZE is negative, use a format like "127k" if
- possible, using powers of -OUTPUT_BLOCK_SIZE; otherwise, use
- ordinary decimal format. Normally -OUTPUT_BLOCK_SIZE is either
- 1000 or 1024; it must be at least 2. Most people visually process
- strings of 3-4 digits effectively, but longer strings of digits are
- more prone to misinterpretation. Hence, converting to an
- abbreviated form usually improves readability. Use a suffix
- indicating which power is being used. For example, assuming
- -OUTPUT_BLOCK_SIZE is 1024, 8500 would be converted to 8.3k,
- 133456345 to 127M, 56990456345 to 53G, and so on. Numbers smaller
- than -OUTPUT_BLOCK_SIZE aren't modified. */
+ be nonnegative.
+
+ Use units of TO_BLOCK_SIZE in the output number. TO_BLOCK_SIZE
+ must be positive.
+
+ Use (OPTS & (human_round_to_nearest | human_floor | human_ceiling))
+ to determine whether to take the ceiling or floor of any result
+ that cannot be expressed exactly.
+
+ If (OPTS & human_group_digits), group the thousands digits
+ according to the locale, e.g., "1,000,000" in an American English
+ locale.
+
+ If (OPTS & human_autoscale), deduce the output block size
+ automatically; TO_BLOCK_SIZE must be 1 but it has no effect on the
+ output. Use powers of 1024 if (OPTS & human_base_1024), and powers
+ of 1000 otherwise. For example, assuming powers of 1024, 8500
+ would be converted to 8.3, 133456345 to 127, 56990456345 to 53, and
+ so on. Numbers smaller than the power aren't modified.
+ human_autoscale is normally used together with human_SI.
+
+ If (OPTS & human_space_before_unit), use a space to separate the
+ number from any suffix that is appended as described below.
+
+ If (OPTS & human_SI), append an SI prefix indicating which power is
+ being used. If in addition (OPTS & human_B), append "B" (if base
+ 1000) or "iB" (if base 1024) to the SI prefix. When ((OPTS &
+ human_SI) && ! (OPTS & human_autoscale)), TO_BLOCK_SIZE must be a
+ power of 1024 or of 1000, depending on (OPTS &
+ human_base_1024). */
char *
-human_readable (uintmax_t n, char *buf,
- int from_block_size, int output_block_size)
+human_readable (uintmax_t n, char *buf, int opts,
+ uintmax_t from_block_size, uintmax_t to_block_size)
{
+ int inexact_style =
+ opts & (human_round_to_nearest | human_floor | human_ceiling);
+ unsigned int base = opts & human_base_1024 ? 1024 : 1000;
uintmax_t amt;
- int base;
- int to_block_size;
int tenths;
- int power;
+ int exponent = -1;
+ int exponent_max = sizeof power_letter - 1;
char *p;
+ char *psuffix;
+ char const *integerlim;
/* 0 means adjusted N == AMT.TENTHS;
1 means AMT.TENTHS < adjusted N < AMT.TENTHS + 0.05;
3 means AMT.TENTHS + 0.05 < adjusted N < AMT.TENTHS + 0.1. */
int rounding;
- if (output_block_size < 0)
- {
- base = -output_block_size;
- to_block_size = 1;
- }
- else
+ char const *decimal_point = ".";
+ size_t decimal_pointlen = 1;
+ char const *grouping = "";
+ char const *thousands_sep = "";
+ struct lconv const *l = localeconv ();
+ size_t pointlen = strlen (l->decimal_point);
+ if (0 < pointlen && pointlen <= MB_LEN_MAX)
{
- base = 0;
- to_block_size = output_block_size;
+ decimal_point = l->decimal_point;
+ decimal_pointlen = pointlen;
}
+ grouping = l->grouping;
+ if (strlen (l->thousands_sep) <= MB_LEN_MAX)
+ thousands_sep = l->thousands_sep;
- p = buf + LONGEST_HUMAN_READABLE;
- *p = '\0';
-
-#ifdef lint
- /* Suppress `used before initialized' warning. */
- power = 0;
-#endif
-
- /* Adjust AMT out of FROM_BLOCK_SIZE units and into TO_BLOCK_SIZE units. */
+ psuffix = buf + LONGEST_HUMAN_READABLE - HUMAN_READABLE_SUFFIX_LENGTH_MAX;
+ p = psuffix;
+ /* Adjust AMT out of FROM_BLOCK_SIZE units and into TO_BLOCK_SIZE
+ units. If this can be done exactly with integer arithmetic, do
+ not use floating point operations. */
if (to_block_size <= from_block_size)
{
- int multiplier = from_block_size / to_block_size;
- amt = n * multiplier;
- tenths = rounding = 0;
-
- if (amt / multiplier != n)
- {
- /* Overflow occurred during multiplication. We should use
- multiple precision arithmetic here, but we'll be lazy and
- resort to floating point. This can yield answers that
- are slightly off. In practice it is quite rare to
- overflow uintmax_t, so this is good enough for now. */
-
- double damt = n * (double) multiplier;
-
- if (! base)
- sprintf (buf, "%.0f", damt);
- else
- {
- double e = 1;
- power = 0;
-
- do
- {
- e *= base;
- power++;
- }
- while (e * base <= damt && power < sizeof suffixes - 1);
-
- damt /= e;
-
- sprintf (buf, "%.1f%c", damt, suffixes[power]);
- if (4 < strlen (buf))
- sprintf (buf, "%.0f%c", damt, suffixes[power]);
- }
-
- return buf;
- }
+ if (from_block_size % to_block_size == 0)
+ {
+ uintmax_t multiplier = from_block_size / to_block_size;
+ amt = n * multiplier;
+ if (amt / multiplier == n)
+ {
+ tenths = 0;
+ rounding = 0;
+ goto use_integer_arithmetic;
+ }
+ }
}
- else
+ else if (from_block_size != 0 && to_block_size % from_block_size == 0)
{
- int divisor = to_block_size / from_block_size;
- int r10 = (n % divisor) * 10;
- int r2 = (r10 % divisor) * 2;
+ uintmax_t divisor = to_block_size / from_block_size;
+ uintmax_t r10 = (n % divisor) * 10;
+ uintmax_t r2 = (r10 % divisor) * 2;
amt = n / divisor;
tenths = r10 / divisor;
rounding = r2 < divisor ? 0 < r2 : 2 + (divisor < r2);
+ goto use_integer_arithmetic;
}
-
- /* Use power of BASE notation if adjusted AMT is large enough. */
-
- if (base && base <= amt)
- {
- power = 0;
-
- do
- {
- int r10 = (amt % base) * 10 + tenths;
- int r2 = (r10 % base) * 2 + (rounding >> 1);
- amt /= base;
- tenths = r10 / base;
- rounding = (r2 < base
- ? 0 < r2 + rounding
- : 2 + (base < r2 + rounding));
- power++;
- }
- while (base <= amt && power < sizeof suffixes - 1);
-
- *--p = suffixes[power];
-
- if (amt < 10)
- {
- tenths += 2 < rounding + (tenths & 1);
-
- if (tenths == 10)
- {
- amt++;
- tenths = 0;
- }
-
- if (amt < 10)
- {
- *--p = '0' + tenths;
- *--p = '.';
- tenths = 0;
- }
- }
- }
-
- if (5 < tenths + (2 < rounding + (amt & 1)))
+ {
+ /* Either the result cannot be computed easily using uintmax_t,
+ or from_block_size is zero. Fall back on floating point.
+ FIXME: This can yield answers that are slightly off. */
+
+ long double dto_block_size = to_block_size;
+ long double damt = n * (from_block_size / dto_block_size);
+ size_t buflen;
+ size_t nonintegerlen;
+
+ if (! (opts & human_autoscale))
+ {
+ sprintf (buf, "%.0Lf", adjust_value (inexact_style, damt));
+ buflen = strlen (buf);
+ nonintegerlen = 0;
+ }
+ else
+ {
+ long double e = 1;
+ exponent = 0;
+
+ do
+ {
+ e *= base;
+ exponent++;
+ }
+ while (e * base <= damt && exponent < exponent_max);
+
+ damt /= e;
+
+ sprintf (buf, "%.1Lf", adjust_value (inexact_style, damt));
+ buflen = strlen (buf);
+ nonintegerlen = decimal_pointlen + 1;
+
+ if (1 + nonintegerlen + ! (opts & human_base_1024) < buflen
+ || ((opts & human_suppress_point_zero)
+ && buf[buflen - 1] == '0'))
+ {
+ sprintf (buf, "%.0Lf",
+ adjust_value (inexact_style, damt * 10) / 10);
+ buflen = strlen (buf);
+ nonintegerlen = 0;
+ }
+ }
+
+ p = psuffix - buflen;
+ memmove (p, buf, buflen);
+ integerlim = p + buflen - nonintegerlen;
+ }
+ goto do_grouping;
+
+ use_integer_arithmetic:
+ {
+ /* The computation can be done exactly, with integer arithmetic.
+
+ Use power of BASE notation if requested and if adjusted AMT is
+ large enough. */
+
+ if (opts & human_autoscale)
+ {
+ exponent = 0;
+
+ if (base <= amt)
+ {
+ do
+ {
+ unsigned int r10 = (amt % base) * 10 + tenths;
+ unsigned int r2 = (r10 % base) * 2 + (rounding >> 1);
+ amt /= base;
+ tenths = r10 / base;
+ rounding = (r2 < base
+ ? (r2 + rounding) != 0
+ : 2 + (base < r2 + rounding));
+ exponent++;
+ }
+ while (base <= amt && exponent < exponent_max);
+
+ if (amt < 10)
+ {
+ if (inexact_style == human_round_to_nearest
+ ? 2 < rounding + (tenths & 1)
+ : inexact_style == human_ceiling && 0 < rounding)
+ {
+ tenths++;
+ rounding = 0;
+
+ if (tenths == 10)
+ {
+ amt++;
+ tenths = 0;
+ }
+ }
+
+ if (amt < 10
+ && (tenths || ! (opts & human_suppress_point_zero)))
+ {
+ *--p = '0' + tenths;
+ p -= decimal_pointlen;
+ memcpy (p, decimal_point, decimal_pointlen);
+ tenths = rounding = 0;
+ }
+ }
+ }
+ }
+
+ if (inexact_style == human_round_to_nearest
+ ? 5 < tenths + (0 < rounding + (amt & 1))
+ : inexact_style == human_ceiling && 0 < tenths + rounding)
+ {
+ amt++;
+
+ if ((opts & human_autoscale)
+ && amt == base && exponent < exponent_max)
+ {
+ exponent++;
+ if (! (opts & human_suppress_point_zero))
+ {
+ *--p = '0';
+ p -= decimal_pointlen;
+ memcpy (p, decimal_point, decimal_pointlen);
+ }
+ amt = 1;
+ }
+ }
+
+ integerlim = p;
+
+ do
+ {
+ int digit = amt % 10;
+ *--p = digit + '0';
+ }
+ while ((amt /= 10) != 0);
+ }
+
+ do_grouping:
+ if (opts & human_group_digits)
+ p = group_number (p, integerlim - p, grouping, thousands_sep);
+
+ if (opts & human_SI)
{
- amt++;
-
- if (amt == base && power < sizeof suffixes - 1)
- {
- *p = suffixes[power + 1];
- *--p = '0';
- *--p = '.';
- amt = 1;
- }
+ if (exponent < 0)
+ {
+ uintmax_t power;
+ exponent = 0;
+ for (power = 1; power < to_block_size; power *= base)
+ if (++exponent == exponent_max)
+ break;
+ }
+
+ if ((exponent | (opts & human_B)) && (opts & human_space_before_unit))
+ *psuffix++ = ' ';
+
+ if (exponent)
+ *psuffix++ = (! (opts & human_base_1024) && exponent == 1
+ ? 'k'
+ : power_letter[exponent]);
+
+ if (opts & human_B)
+ {
+ if ((opts & human_base_1024) && exponent)
+ *psuffix++ = 'i';
+ *psuffix++ = 'B';
+ }
}
- do
- *--p = '0' + (int) (amt % 10);
- while ((amt /= 10) != 0);
+ *psuffix = '\0';
return p;
}
#endif
static char const *const block_size_args[] = { "human-readable", "si", 0 };
-static int const block_size_types[] = { -1024, -1000 };
+static int const block_size_opts[] =
+ {
+ human_autoscale + human_SI + human_base_1024,
+ human_autoscale + human_SI
+ };
+
+static uintmax_t
+default_block_size (void)
+{
+ return getenv ("POSIXLY_CORRECT") ? 512 : DEFAULT_BLOCK_SIZE;
+}
static strtol_error
-humblock (char const *spec, int *block_size)
+humblock (char const *spec, uintmax_t *block_size, int *options)
{
int i;
+ int opts = 0;
- if (! spec && ! (spec = getenv ("BLOCK_SIZE")))
- *block_size = getenv ("POSIXLY_CORRECT") ? 512 : DEFAULT_BLOCK_SIZE;
- else if (0 <= (i = ARGMATCH (spec, block_size_args, block_size_types)))
- *block_size = block_size_types[i];
+ if (! spec
+ && ! (spec = getenv ("BLOCK_SIZE"))
+ && ! (spec = getenv ("BLOCKSIZE")))
+ *block_size = default_block_size ();
else
{
- char *ptr;
- unsigned long val;
- strtol_error e = xstrtoul (spec, &ptr, 0, &val, "eEgGkKmMpPtTyYzZ0");
- if (e != LONGINT_OK)
- return e;
- if (*ptr)
- return LONGINT_INVALID_SUFFIX_CHAR;
- if ((int) val < 0 || val != (int) val)
- return LONGINT_OVERFLOW;
- *block_size = (int) val;
+ if (*spec == '\'')
+ {
+ opts |= human_group_digits;
+ spec++;
+ }
+
+ if (0 <= (i = ARGMATCH (spec, block_size_args, block_size_opts)))
+ {
+ opts |= block_size_opts[i];
+ *block_size = 1;
+ }
+ else
+ {
+ char *ptr;
+ strtol_error e = xstrtoumax (spec, &ptr, 0, block_size,
+ "eEgGkKmMpPtTyYzZ0");
+ if (e != LONGINT_OK)
+ {
+ *options = 0;
+ return e;
+ }
+ for (; ! ('0' <= *spec && *spec <= '9'); spec++)
+ if (spec == ptr)
+ {
+ opts |= human_SI;
+ if (ptr[-1] == 'B')
+ opts |= human_B;
+ if (ptr[-1] != 'B' || ptr[-2] == 'i')
+ opts |= human_base_1024;
+ break;
+ }
+ }
}
+ *options = opts;
return LONGINT_OK;
}
-void
-human_block_size (char const *spec, int report_errors, int *block_size)
+enum strtol_error
+human_options (char const *spec, int *opts, uintmax_t *block_size)
{
- strtol_error e = humblock (spec, block_size);
- if (e != LONGINT_OK && report_errors)
- STRTOL_FATAL_ERROR (spec, _("block size"), e);
+ strtol_error e = humblock (spec, block_size, opts);
+ if (*block_size == 0)
+ {
+ *block_size = default_block_size ();
+ e = LONGINT_INVALID;
+ }
+ return e;
}