(nanosleep):

[gnulib.git] / lib / human.c

diff --git a/lib/human.c b/lib/human.c
index 7b923dc..600614e 100644 (file)
--- a/lib/human.c
+++ b/lib/human.c
@@ -73,6 +73,15 @@ static const char suffixes[] =
   'Y'  /* Yotta */
 };
 
+/* 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
@@ -82,6 +91,9 @@ static const char suffixes[] =
    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
    ordinary decimal format.  Normally -OUTPUT_BLOCK_SIZE is either
@@ -95,8 +107,9 @@ static const char suffixes[] =
    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;
@@ -207,24 +220,33 @@ human_readable (uintmax_t n, char *buf,
 
       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++;
 
@@ -254,13 +276,19 @@ human_readable (uintmax_t n, char *buf,
 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
@@ -284,6 +312,11 @@ void
 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);
 }