--- a/lib/ChangeLog
+++ b/lib/ChangeLog
@@ -1,5 +1,44 @@
 2003-06-04  Paul Eggert  <eggert@twinsun.com>
 
+	Merge 'human' changes from coreutils.  Rewrite to support
+	locale-specific notations like thousands separators.
+	* human.c: Simplify authorship notice.
+	Include human.h immediately after config.h.
+	<sys/types.h>, <stdio.h>: Do not include; no longer needed.
+	<limits.h>: Do not include, since human.h does.
+	(SIZE_MAX, UINTMAX_MAX): New macros.
+	<strings.h>: Include if HAVE_STRINGS_H, not if !HAVE_STRING_H.
+	<locale.h>: Include if HAVE_LOCALE_H and HAVE_LOCALECONV.
+	(HUMAN_READABLE_SUFFIX_LENGTH_MAX): New macro.
+	(power_letter): Renamed from suffixes.
+	(generate_suffix_backwards): Remove.
+	(adjust_value): Now takes int style (because of human.h changes)
+	and long double value (for greater precision on some platforms).
+	(group_number): New function.
+	(human_readable): Use it.  Use integer options, not enum.
+	Put the options before the sizes in the arg list.
+	Support all the new options.
+	The old human_readable function has been removed;
+	use inttostr.h instead.
+	(human_readable, default_block_size, humblock):
+	Use uintmax_t, not int, for block sizes.
+	(human_readable_inexact, block_size_types): Remove.
+	(block_size_opts): New constant.
+	(human_options): Renamed from human_block_size, with new signature
+	that allows block sizes up to UINTMAX_MAX.  All callers changed.
+	* human.h: Add copyright and authorship notice.
+	Include <limits.h> and <stdbool.h> unconditionally.
+	(PARAMS): Remove.  All uses removed.
+	(LONGEST_HUMAN_READABLE): Add support for thousands separator.
+	(enum human_inexact_style): Remove tag; now a nameless enum.
+	(human_floor, human_ceiling, human_round_to_even): Now have
+	values 2, 0, 1 rather than -1, 1, 0.
+	(human_group_digits, human_suppress_point_zero, human_autoscale,
+	human_base_1024, human_SI, human_B): New constants.
+	(human_readable_inexact, human_block_size): Remove.
+	(human_readable): Size args are now uintmax_t, not int.
+	(human_options): New decl.
+
 	* exclude.c: (new_exclude, add_exclude): Remove casts that are
 	unnecessary now that we assume C89 or better.  This change
 	imported from coreutils.

--- a/lib/human.c
+++ b/lib/human.c
@@ -17,28 +17,28 @@
    along with this program; if not, write to the Free Software Foundation,
    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
-/* 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 <sys/types.h>
-#include <stdio.h>
-#include <limits.h>
+#include "human.h"
 
-#if HAVE_STRING_H
-# include <string.h>
-#else
-# include <strings.h>
+#ifndef SIZE_MAX
+# define SIZE_MAX ((size_t) -1)
+#endif
+#ifndef UINTMAX_MAX
+# define UINTMAX_MAX ((uintmax_t) -1)
+#endif
+
+#if HAVE_LOCALE_H && HAVE_LOCALECONV
+# include <locale.h>
 #endif
 
 #if HAVE_STDLIB_H
 # include <stdlib.h>
 #endif
-
 #ifndef HAVE_DECL_GETENV
 "this configure-time declaration test was not run"
 #endif
@@ -46,6 +46,14 @@
 char *getenv ();
 #endif
 
+#if HAVE_STRING_H
+# include <string.h>
+#endif
+
+#if HAVE_STRINGS_H
+# include <strings.h>
+#endif
+
 #include "gettext.h"
 #define _(msgid) gettext (msgid)
 
@@ -53,9 +61,10 @@
 #include <error.h>
 #include <xstrtol.h>
 
-#include "human.h"
+/* The maximum length of a suffix like "KiB".  */
+#define HUMAN_READABLE_SUFFIX_LENGTH_MAX 3
 
-static const char suffixes[] =
+static const char power_letter[] =
 {
   0,	/* not used */
   'K',	/* kibi ('k' for kilo is a special case) */
@@ -68,33 +77,18 @@
   'Y'	/* yotta or 2**80 */
 };
 
-/* Generate into P[-1] (and possibly P[-2]) the proper suffix for
-   POWER and BASE.  Return the address of the generated suffix.  */
-static char *
-generate_suffix_backwards (char *p, int power, int base)
-{
-  char letter = suffixes[power];
 
-  if (base == 1000)
-    {
-      *--p = 'B';
-      if (power == 1)
-	letter = 'k';
-    }
+/* If INEXACT_STYLE is not human_round_to_nearest, and if easily
+   possible, adjust VALUE according to the style.  */
 
-  *--p = letter;
-  return p;
-}
-
-/* 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)
+static long double
+adjust_value (int inexact_style, long 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)
+  /* 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);
@@ -103,199 +97,323 @@
   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)
+/* 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)
 {
-  return human_readable_inexact (n, buf, from_block_size, output_block_size,
-				 human_round_to_even);
+  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 of
+     uintmax_t before converting to a bound.  302 / 1000 is ceil
+     (log10 (2.0)).  Add 1 for integer division truncation.  */
+  char buf[2 * sizeof (uintmax_t) * CHAR_BIT * 302 / 1000 + 1];
+
+  memcpy (buf, number, numberlen);
+  d = number + numberlen;
+
+  for (;;)
+    {
+      unsigned char g = *grouping;
+
+      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.
+/* 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 nonnegative.
 
-   OUTPUT_BLOCK_SIZE must be nonzero.  If it is positive, use units of
-   OUTPUT_BLOCK_SIZE in the output number.
+   Use units of TO_BLOCK_SIZE in the output number.  TO_BLOCK_SIZE
+   must be positive.
 
-   Use INEXACT_STYLE to determine whether to take the ceiling or floor
-   of any result that cannot be expressed exactly.
+   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 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.  If -OUTPUT_BLOCK_SIZE is
-   1024, append a "B" after any size letter.  */
+   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_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_inexact (uintmax_t n, char *buf,
-			int from_block_size, int output_block_size,
-			enum human_inexact_style inexact_style)
+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 = 0;
-  int power;
+  int tenths;
+  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;
      2 means adjusted N == AMT.TENTHS + 0.05;
      3 means AMT.TENTHS + 0.05 < adjusted N < AMT.TENTHS + 0.1.  */
-  int rounding = 0;
+  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 = "";
+#if HAVE_LOCALE_H && HAVE_LOCALECONV
+  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;
     }
-
-  p = buf + LONGEST_HUMAN_READABLE;
-  *p = '\0';
-
-#ifdef lint
-  /* Suppress `used before initialized' warning.  */
-  power = 0;
+  grouping = l->grouping;
+  if (strlen (l->thousands_sep) <= MB_LEN_MAX)
+    thousands_sep = l->thousands_sep;
 #endif
 
-  /* Adjust AMT out of FROM_BLOCK_SIZE units and into TO_BLOCK_SIZE units.  */
-
-  {
-    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
-	  {
-	    char suffix[3];
-	    char const *psuffix;
-	    double e = 1;
-	    power = 0;
-
-	    do
-	      {
-		e *= base;
-		power++;
-	      }
-	    while (e * base <= damt && power < sizeof suffixes - 1);
-
-	    damt /= e;
+  psuffix = buf + LONGEST_HUMAN_READABLE - HUMAN_READABLE_SUFFIX_LENGTH_MAX;
+  p = psuffix;
 
-	    suffix[2] = '\0';
-	    psuffix = generate_suffix_backwards (suffix + 2, power, base);
-	    sprintf (buf, "%.1f%s",
-		     adjust_value (inexact_style, damt), psuffix);
-	    if (4 + (base == 1000) < strlen (buf))
-	      sprintf (buf, "%.0f%s",
-		       adjust_value (inexact_style, damt * 10) / 10, psuffix);
-	  }
-
-	return buf;
-      }
-  }
-
-  /* Use power of BASE notation if adjusted AMT is large enough.  */
-
-  if (base && base <= amt)
+  /* 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)
     {
-      power = 0;
-
-      do
+      if (from_block_size % to_block_size == 0)
 	{
-	  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 = generate_suffix_backwards (p, power, base);
-
-      if (amt < 10)
-	{
-	  if (2 * (1 - (int) inexact_style)
-	      < rounding + (tenths & (inexact_style == human_round_to_even)))
+	  uintmax_t multiplier = from_block_size / to_block_size;
+	  amt = n * multiplier;
+	  if (amt / multiplier == n)
 	    {
-	      tenths++;
+	      tenths = 0;
 	      rounding = 0;
-
-	      if (tenths == 10)
-		{
-		  amt++;
-		  tenths = 0;
-		}
-	    }
-
-	  if (amt < 10)
-	    {
-	      *--p = '0' + tenths;
-	      *--p = '.';
-	      tenths = rounding = 0;
+	      goto use_integer_arithmetic;
 	    }
 	}
     }
-
-  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)
+  else if (from_block_size != 0 && to_block_size % from_block_size == 0)
     {
-      amt++;
+      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;
+    }
+
+  {
+    /* 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 (amt == base && power < sizeof suffixes - 1)
+	if (base <= amt)
+	  {
+	    do
+	      {
+		unsigned r10 = (amt % base) * 10 + tenths;
+		unsigned 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_ceiling
+	? 0 < tenths + rounding
+	: inexact_style == human_round_to_nearest
+	? 5 < tenths + (2 < rounding + (amt & 1))
+	: /* inexact_style == human_floor */ 0)
+      {
+	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)
+    {
+      if (exponent < 0)
 	{
-	  *p = suffixes[power + 1];
-	  *--p = '0';
-	  *--p = '.';
-	  amt = 1;
+	  uintmax_t power;
+	  exponent = 0;
+	  for (power = 1; power < to_block_size; power *= base)
+	    if (++exponent == exponent_max)
+	      break;
+	}
+
+      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;
 }
@@ -308,44 +426,70 @@
 #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 int
+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 = default_block_size ();
-  else if (0 <= (i = ARGMATCH (spec, block_size_args, block_size_types)))
-    *block_size = block_size_types[i];
   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)
+	    return e;
+	  if (*ptr)
+	    return LONGINT_INVALID_SUFFIX_CHAR;
+	  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)
+int
+human_options (char const *spec, bool report_errors, uintmax_t *block_size)
 {
-  strtol_error e = humblock (spec, block_size);
+  int opts;
+  strtol_error e = humblock (spec, block_size, &opts);
   if (*block_size == 0)
     {
       *block_size = default_block_size ();
@@ -353,4 +497,5 @@
     }
   if (e != LONGINT_OK && report_errors)
     STRTOL_FATAL_ERROR (spec, _("block size"), e);
+  return opts;
 }

--- a/lib/human.h
+++ b/lib/human.h
@@ -1,3 +1,24 @@
+/* human.h -- print human readable file size
+
+   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 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.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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.  */
+
+/* Written by Paul Eggert and Larry McVoy.  */
+
 #ifndef HUMAN_H_
 # define HUMAN_H_ 1
 
@@ -5,6 +26,9 @@
 #  include <config.h>
 # endif
 
+# include <limits.h>
+# include <stdbool.h>
+
 # if HAVE_INTTYPES_H
 #  include <inttypes.h>
 # else
@@ -14,30 +38,52 @@
 # endif
 
 /* A conservative bound on the maximum length of a human-readable string.
-   The output can be the product of the largest uintmax_t and the largest int,
-   so add their sizes before converting to a bound on digits.  */
-# define LONGEST_HUMAN_READABLE ((sizeof (uintmax_t) + sizeof (int)) \
-				 * CHAR_BIT / 3)
+   The output can be the square of the largest uintmax_t, so double
+   its size before converting to a bound.
+   302 / 1000 is ceil (log10 (2.0)).  Add 1 for integer division truncation.
+   Also, the output can have a thousands separator between every digit,
+   so multiply by MB_LEN_MAX + 1 and then subtract MB_LEN_MAX.
+   Finally, append 3, the maximum length of a suffix.  */
+# define LONGEST_HUMAN_READABLE \
+  ((2 * sizeof (uintmax_t) * CHAR_BIT * 302 / 1000 + 1) * (MB_LEN_MAX + 1) \
+   - MB_LEN_MAX + 3)
+
+/* Options for human_readable.  */
+enum
+{
+  /* Unless otherwise specified these options may be ORed together.  */
 
-# ifndef PARAMS
-#  if defined PROTOTYPES || (defined __STDC__ && __STDC__)
-#   define PARAMS(Args) Args
-#  else
-#   define PARAMS(Args) ()
-#  endif
-# endif
+  /* The following three options are mutually exclusive.  */
+  /* Round to plus infinity (default).  */
+  human_ceiling = 0,
+  /* Round to nearest, ties to even.  */
+  human_round_to_nearest = 1,
+  /* Round to minus infinity.  */
+  human_floor = 2,
+
+  /* Group digits together, e.g. `1,000,000'.  This uses the
+     locale-defined grouping; the traditional C locale does not group,
+     so this has effect only if some other locale is in use.  */
+  human_group_digits = 4,
 
-enum human_inexact_style
-{
-  human_floor = -1,
-  human_round_to_even = 0,
-  human_ceiling = 1
+  /* When autoscaling, suppress ".0" at end.  */
+  human_suppress_point_zero = 8,
+
+  /* Scale output and use SI-style units, ignoring the output block size.  */
+  human_autoscale = 16,
+
+  /* Prefer base 1024 to base 1000.  */
+  human_base_1024 = 32,
+
+  /* Append SI prefix, e.g. "k" or "M".  */
+  human_SI = 64,
+
+  /* Append "B" (if base 1000) or "iB" (if base 1024) to SI prefix.  */
+  human_B = 128
 };
 
-char *human_readable PARAMS ((uintmax_t, char *, int, int));
-char *human_readable_inexact PARAMS ((uintmax_t, char *, int, int,
-				      enum human_inexact_style));
+char *human_readable (uintmax_t, char *, int, uintmax_t, uintmax_t);
 
-void human_block_size PARAMS ((char const *, int, int *));
+int human_options (char const *, bool, uintmax_t *);
 
 #endif /* HUMAN_H_ */

--- a/m4/ChangeLog
+++ b/m4/ChangeLog
@@ -1,5 +1,8 @@
 2003-06-04  Paul Eggert  <eggert@twinsun.com>
 
+	* human.m4 (gl_HUMAN): Require AM_STDBOOL_H.  Check for
+	locale.h, localeconv.  This merges changes from coreutils.
+
 	* mktime.m4 (AC_FUNC_MKTIME): New macro, taken from Autoconf CVS.
 	It can be removed after the next Autoconf is released.
 	* exclude.m4 (gl_EXCLUDE): Don't check for sys/types.h; no loner

--- a/m4/human.m4
+++ b/m4/human.m4
@@ -1,4 +1,4 @@
-# human.m4 serial 2
+# human.m4 serial 3
 dnl Copyright (C) 2002, 2003 Free Software Foundation, Inc.
 dnl This file is free software, distributed under the terms of the GNU
 dnl General Public License.  As a special exception to the GNU General
@@ -9,9 +9,11 @@
 AC_DEFUN([gl_HUMAN],
 [
   dnl Prerequisites of lib/human.h.
+  AC_REQUIRE([AM_STDBOOL_H])
   AC_REQUIRE([jm_AC_TYPE_UINTMAX_T])
 
   dnl Prerequisites of lib/human.c.
-  AC_CHECK_HEADERS_ONCE(stdlib.h string.h)
-  AC_CHECK_DECLS_ONCE([getenv])
+  AC_CHECK_HEADERS_ONCE(locale.h stdlib.h string.h)
+  AC_CHECK_DECLS_ONCE(getenv)
+  AC_CHECK_FUNCS_ONCE(localeconv)
 ])