Initial revision

[chaz/tar] / lib / human.c

diff --git a/lib/human.c b/lib/human.c
index 5cfbce9df4ddef46b66ab67d8b1216f759344985..92b051cae593ce9c41e0e54ee8eae1ae9e1a2ab8 100644 (file)
--- a/lib/human.c
+++ b/lib/human.c
@@ -76,6 +76,23 @@ static const char suffixes[] =
   '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,
@@ -90,9 +107,8 @@ 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.
@@ -148,57 +164,58 @@ human_readable_inexact (uintmax_t n, char *buf,
 
   /* 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.  */