#endif
#ifndef HAVE_DECL_GETENV
-'this configure-time declaration test was not run'
+"this configure-time declaration test was not run"
#endif
#if !HAVE_DECL_GETENV
char *getenv ();
'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,
N is expressed in units of FROM_BLOCK_SIZE. FROM_BLOCK_SIZE must
be nonnegative.
- 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.
+ OUTPUT_BLOCK_SIZE must be nonzero. If it is positive, use units of
+ OUTPUT_BLOCK_SIZE in the output number.
Use INEXACT_STYLE to determine whether to take the ceiling or floor
of any result that cannot be expressed exactly.
/* 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;
-
- 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 if (from_block_size == 0)
- amt = 0;
- 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. */