1 /* human.c -- print human readable file size
3 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free
4 Software Foundation, Inc.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software Foundation,
18 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20 /* Originally contributed by lm@sgi.com;
21 --si, output block size selection, and large file support
22 added by eggert@twinsun.com. */
28 #include <sys/types.h>
42 #ifndef HAVE_DECL_GETENV
43 "this configure-time declaration test was not run"
50 #define _(msgid) gettext (msgid)
58 static const char suffixes[] =
61 'K', /* kibi ('k' for kilo is a special case) */
62 'M', /* mega or mebi */
63 'G', /* giga or gibi */
64 'T', /* tera or tebi */
65 'P', /* peta or pebi */
66 'E', /* exa or exbi */
67 'Z', /* zetta or 2**70 */
68 'Y' /* yotta or 2**80 */
71 /* Generate into P[-1] (and possibly P[-2]) the proper suffix for
72 POWER and BASE. Return the address of the generated suffix. */
74 generate_suffix_backwards (char *p, int power, int base)
76 char letter = suffixes[power];
89 /* If INEXACT_STYLE is not human_round_to_even, and if easily
90 possible, adjust VALUE according to the style. */
92 adjust_value (enum human_inexact_style inexact_style, double value)
94 /* Do not use the floor or ceil functions, as that would mean
95 linking with the standard math library, which is a porting pain.
96 So leave the value alone if it is too large to easily round. */
97 if (inexact_style != human_round_to_even && value < (uintmax_t) -1)
100 value = u + (inexact_style == human_ceiling && u != value);
106 /* Like human_readable_inexact, except always round to even. */
108 human_readable (uintmax_t n, char *buf,
109 int from_block_size, int output_block_size)
111 return human_readable_inexact (n, buf, from_block_size, output_block_size,
112 human_round_to_even);
115 /* Convert N to a human readable format in BUF.
117 N is expressed in units of FROM_BLOCK_SIZE. FROM_BLOCK_SIZE must
120 OUTPUT_BLOCK_SIZE must be nonzero. If it is positive, use units of
121 OUTPUT_BLOCK_SIZE in the output number.
123 Use INEXACT_STYLE to determine whether to take the ceiling or floor
124 of any result that cannot be expressed exactly.
126 If OUTPUT_BLOCK_SIZE is negative, use a format like "127K" if
127 possible, using powers of -OUTPUT_BLOCK_SIZE; otherwise, use
128 ordinary decimal format. Normally -OUTPUT_BLOCK_SIZE is either
129 1000 or 1024; it must be at least 2. Most people visually process
130 strings of 3-4 digits effectively, but longer strings of digits are
131 more prone to misinterpretation. Hence, converting to an
132 abbreviated form usually improves readability. Use a suffix
133 indicating which power is being used. For example, assuming
134 -OUTPUT_BLOCK_SIZE is 1024, 8500 would be converted to 8.3K,
135 133456345 to 127M, 56990456345 to 53G, and so on. Numbers smaller
136 than -OUTPUT_BLOCK_SIZE aren't modified. If -OUTPUT_BLOCK_SIZE is
137 1024, append a "B" after any size letter. */
140 human_readable_inexact (uintmax_t n, char *buf,
141 int from_block_size, int output_block_size,
142 enum human_inexact_style inexact_style)
151 /* 0 means adjusted N == AMT.TENTHS;
152 1 means AMT.TENTHS < adjusted N < AMT.TENTHS + 0.05;
153 2 means adjusted N == AMT.TENTHS + 0.05;
154 3 means AMT.TENTHS + 0.05 < adjusted N < AMT.TENTHS + 0.1. */
157 if (output_block_size < 0)
159 base = -output_block_size;
165 to_block_size = output_block_size;
168 p = buf + LONGEST_HUMAN_READABLE;
172 /* Suppress `used before initialized' warning. */
176 /* Adjust AMT out of FROM_BLOCK_SIZE units and into TO_BLOCK_SIZE units. */
183 if (to_block_size <= from_block_size
184 ? (from_block_size % to_block_size != 0
185 || (multiplier = from_block_size / to_block_size,
186 (amt = n * multiplier) / multiplier != n))
187 : (from_block_size == 0
188 || to_block_size % from_block_size != 0
189 || (divisor = to_block_size / from_block_size,
190 r10 = (n % divisor) * 10,
191 r2 = (r10 % divisor) * 2,
193 tenths = r10 / divisor,
194 rounding = r2 < divisor ? 0 < r2 : 2 + (divisor < r2),
197 /* Either the result cannot be computed easily using uintmax_t,
198 or from_block_size is zero. Fall back on floating point.
199 FIXME: This can yield answers that are slightly off. */
201 double damt = n * (from_block_size / (double) to_block_size);
204 sprintf (buf, "%.0f", adjust_value (inexact_style, damt));
217 while (e * base <= damt && power < sizeof suffixes - 1);
222 psuffix = generate_suffix_backwards (suffix + 2, power, base);
223 sprintf (buf, "%.1f%s",
224 adjust_value (inexact_style, damt), psuffix);
225 if (4 + (base == 1000) < strlen (buf))
226 sprintf (buf, "%.0f%s",
227 adjust_value (inexact_style, damt * 10) / 10, psuffix);
234 /* Use power of BASE notation if adjusted AMT is large enough. */
236 if (base && base <= amt)
242 int r10 = (amt % base) * 10 + tenths;
243 int r2 = (r10 % base) * 2 + (rounding >> 1);
246 rounding = (r2 < base
248 : 2 + (base < r2 + rounding));
251 while (base <= amt && power < sizeof suffixes - 1);
253 p = generate_suffix_backwards (p, power, base);
257 if (2 * (1 - (int) inexact_style)
258 < rounding + (tenths & (inexact_style == human_round_to_even)))
274 tenths = rounding = 0;
279 if (inexact_style == human_ceiling
280 ? 0 < tenths + rounding
281 : inexact_style == human_round_to_even
282 ? 5 < tenths + (2 < rounding + (amt & 1))
283 : /* inexact_style == human_floor */ 0)
287 if (amt == base && power < sizeof suffixes - 1)
289 *p = suffixes[power + 1];
297 *--p = '0' + (int) (amt % 10);
298 while ((amt /= 10) != 0);
304 /* The default block size used for output. This number may change in
305 the future as disks get larger. */
306 #ifndef DEFAULT_BLOCK_SIZE
307 # define DEFAULT_BLOCK_SIZE 1024
310 static char const *const block_size_args[] = { "human-readable", "si", 0 };
311 static int const block_size_types[] = { -1024, -1000 };
314 default_block_size (void)
316 return getenv ("POSIXLY_CORRECT") ? 512 : DEFAULT_BLOCK_SIZE;
320 humblock (char const *spec, int *block_size)
324 if (! spec && ! (spec = getenv ("BLOCK_SIZE")))
325 *block_size = default_block_size ();
326 else if (0 <= (i = ARGMATCH (spec, block_size_args, block_size_types)))
327 *block_size = block_size_types[i];
332 strtol_error e = xstrtoul (spec, &ptr, 0, &val, "eEgGkKmMpPtTyYzZ0");
336 return LONGINT_INVALID_SUFFIX_CHAR;
337 if ((int) val < 0 || val != (int) val)
338 return LONGINT_OVERFLOW;
339 *block_size = (int) val;
346 human_block_size (char const *spec, int report_errors, int *block_size)
348 strtol_error e = humblock (spec, block_size);
349 if (*block_size == 0)
351 *block_size = default_block_size ();
354 if (e != LONGINT_OK && report_errors)
355 STRTOL_FATAL_ERROR (spec, _("block size"), e);