/* human.c -- print human readable file size
- Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1996, 1997, 1998, 1999, 2000 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
#endif
#ifndef HAVE_DECL_GETENV
+"this configure-time declaration test was not run"
+#endif
+#if !HAVE_DECL_GETENV
char *getenv ();
#endif
'Y' /* Yotta */
};
+/* If INEXACT_STYLE is not human_round_to_even, and if easily
+ possible, adjust VALUE according to the style. */
+static double
+adjust_value (enum human_inexact_style inexact_style, double value)
+{
+ /* Do not use the floor or ceil functions, as that would mean
+ 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_even && value < (uintmax_t) -1)
+ {
+ uintmax_t u = value;
+ value = u + (inexact_style == human_ceiling && u != value);
+ }
+
+ return value;
+}
+
+/* Like human_readable_inexact, except always round to even. */
+char *
+human_readable (uintmax_t n, char *buf,
+ int from_block_size, int output_block_size)
+{
+ return human_readable_inexact (n, buf, from_block_size, output_block_size,
+ human_round_to_even);
+}
+
/* Convert N to a human readable format in BUF.
N is expressed in units of FROM_BLOCK_SIZE. FROM_BLOCK_SIZE must
- be positive.
+ be nonnegative.
+
+ OUTPUT_BLOCK_SIZE must be nonzero. If it is positive, use units of
+ OUTPUT_BLOCK_SIZE in the output number.
- 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.
+ Use INEXACT_STYLE to determine whether to take the ceiling or floor
+ of any result that cannot be expressed exactly.
If OUTPUT_BLOCK_SIZE is negative, use a format like "127k" if
possible, using powers of -OUTPUT_BLOCK_SIZE; otherwise, use
than -OUTPUT_BLOCK_SIZE aren't modified. */
char *
-human_readable (uintmax_t n, char *buf,
- int from_block_size, int output_block_size)
+human_readable_inexact (uintmax_t n, char *buf,
+ int from_block_size, int output_block_size,
+ enum human_inexact_style inexact_style)
{
uintmax_t amt;
int base;
int to_block_size;
- int tenths;
+ int tenths = 0;
int power;
char *p;
1 means AMT.TENTHS < adjusted N < AMT.TENTHS + 0.05;
2 means adjusted N == AMT.TENTHS + 0.05;
3 means AMT.TENTHS + 0.05 < adjusted N < AMT.TENTHS + 0.1. */
- int rounding;
+ int rounding = 0;
if (output_block_size < 0)
{
/* Adjust AMT out of FROM_BLOCK_SIZE units and into TO_BLOCK_SIZE units. */
- 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;
- }
- }
- else
- {
- int divisor = to_block_size / from_block_size;
- int r10 = (n % divisor) * 10;
- int r2 = (r10 % divisor) * 2;
- amt = n / divisor;
- tenths = r10 / divisor;
- rounding = r2 < divisor ? 0 < r2 : 2 + (divisor < r2);
- }
-
+ {
+ int multiplier;
+ int divisor;
+ int r2;
+ int r10;
+ if (to_block_size <= from_block_size
+ ? (from_block_size % to_block_size != 0
+ || (multiplier = from_block_size / to_block_size,
+ (amt = n * multiplier) / multiplier != n))
+ : (from_block_size == 0
+ || to_block_size % from_block_size != 0
+ || (divisor = to_block_size / from_block_size,
+ r10 = (n % divisor) * 10,
+ r2 = (r10 % divisor) * 2,
+ amt = n / divisor,
+ tenths = r10 / divisor,
+ rounding = r2 < divisor ? 0 < r2 : 2 + (divisor < r2),
+ 0)))
+ {
+ /* 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. */
+
+ double damt = n * (from_block_size / (double) to_block_size);
+
+ if (! base)
+ sprintf (buf, "%.0f", adjust_value (inexact_style, 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", adjust_value (inexact_style, damt),
+ suffixes[power]);
+ if (4 < strlen (buf))
+ sprintf (buf, "%.0f%c",
+ adjust_value (inexact_style, damt * 10) / 10,
+ suffixes[power]);
+ }
+
+ return buf;
+ }
+ }
/* Use power of BASE notation if adjusted AMT is large enough. */
if (amt < 10)
{
- tenths += 2 < rounding + (tenths & 1);
-
- if (tenths == 10)
+ if (2 * (1 - (int) inexact_style)
+ < rounding + (tenths & (inexact_style == human_round_to_even)))
{
- amt++;
- tenths = 0;
+ tenths++;
+ rounding = 0;
+
+ if (tenths == 10)
+ {
+ amt++;
+ tenths = 0;
+ }
}
if (amt < 10)
{
*--p = '0' + tenths;
*--p = '.';
- tenths = 0;
+ tenths = rounding = 0;
}
}
}
- if (5 < tenths + (2 < rounding + (amt & 1)))
+ if (inexact_style == human_ceiling
+ ? 0 < tenths + rounding
+ : inexact_style == human_round_to_even
+ ? 5 < tenths + (2 < rounding + (amt & 1))
+ : /* inexact_style == human_floor */ 0)
{
amt++;
static char const *const block_size_args[] = { "human-readable", "si", 0 };
static int const block_size_types[] = { -1024, -1000 };
+static int
+default_block_size (void)
+{
+ return getenv ("POSIXLY_CORRECT") ? 512 : DEFAULT_BLOCK_SIZE;
+}
+
static strtol_error
humblock (char const *spec, int *block_size)
{
int i;
if (! spec && ! (spec = getenv ("BLOCK_SIZE")))
- *block_size = getenv ("POSIXLY_CORRECT") ? 512 : DEFAULT_BLOCK_SIZE;
+ *block_size = default_block_size ();
else if (0 <= (i = ARGMATCH (spec, block_size_args, block_size_types)))
*block_size = block_size_types[i];
else
human_block_size (char const *spec, int report_errors, int *block_size)
{
strtol_error e = humblock (spec, block_size);
+ if (*block_size == 0)
+ {
+ *block_size = default_block_size ();
+ e = LONGINT_INVALID;
+ }
if (e != LONGINT_OK && report_errors)
STRTOL_FATAL_ERROR (spec, _("block size"), e);
}