X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=libbb%2Fhuman_readable.c;h=8b22b0cb55c5cc954ecf095ba1a4146548b8fca8;hb=d84b175cb6948eb17f847313bf912174e2f934e1;hp=7bdad36a9f3ffe2773a0858d2509ce730b7a35b9;hpb=0159597bd6d1ed98c8b1067f59a1e5008ed0169d;p=oweals%2Fbusybox.git diff --git a/libbb/human_readable.c b/libbb/human_readable.c index 7bdad36a9..8b22b0cb5 100644 --- a/libbb/human_readable.c +++ b/libbb/human_readable.c @@ -1,3 +1,4 @@ +/* vi: set sw=4 ts=4: */ /* * June 30, 2001 Manuel Novoa III * @@ -13,8 +14,8 @@ * representations (say, powers of 1024) and manipulating coefficients. * The base ten "bytes" output could be handled similarly. * - * 2) This routine always outputs a decimal point and a tenths digit when - * display_unit != 0. Hence, it isn't uncommon for the returned string + * 2) This routine always outputs a decimal point and a tenths digit when + * display_unit != 0. Hence, it isn't uncommon for the returned string * to have a length of 5 or 6. * * It might be nice to add a flag to indicate no decimal digits in @@ -23,66 +24,174 @@ * * Some code to omit the decimal point and tenths digit is sketched out * and "#if 0"'d below. + * + * Licensed under GPLv2, see file LICENSE in this source tree. */ -#include #include "libbb.h" -const char *make_human_readable_str(unsigned long size, - unsigned long block_size, - unsigned long display_unit) +const char* FAST_FUNC make_human_readable_str(unsigned long long val, + unsigned long block_size, unsigned long display_unit) { - /* The code will adjust for additional (appended) units. */ - static const char zero_and_units[] = { '0', 0, 'k', 'M', 'G', 'T' }; - static const char fmt[] = "%Lu"; - static const char fmt_tenths[] = "%Lu.%d%c"; - - static char str[21]; /* Sufficient for 64 bit unsigned integers. */ - - unsigned long long val; - int frac; + static const char unit_chars[] ALIGN1 = { + '\0', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y' + }; + + static char *str; + + unsigned frac; /* 0..9 - the fractional digit */ const char *u; - const char *f; + const char *fmt; - u = zero_and_units; - f = fmt; - frac = 0; + if (val == 0) + return "0"; - val = ((unsigned long long) size) * block_size; - if (val == 0) { - return u; - } + fmt = "%llu"; + if (block_size > 1) + val *= block_size; + frac = 0; + u = unit_chars; if (display_unit) { - val += display_unit/2; /* Deal with rounding. */ - val /= display_unit; /* Don't combine with the line above!!! */ + val += display_unit/2; /* Deal with rounding */ + val /= display_unit; /* Don't combine with the line above! */ + /* will just print it as ulonglong (below) */ } else { - ++u; - while ((val >= KILOBYTE) - && (u < zero_and_units + sizeof(zero_and_units) - 1)) { - f = fmt_tenths; - ++u; - frac = ((((int)(val % KILOBYTE)) * 10) + (KILOBYTE/2)) / KILOBYTE; - val /= KILOBYTE; + while ((val >= 1024) + /* && (u < unit_chars + sizeof(unit_chars) - 1) - always true */ + ) { + fmt = "%llu.%u%c"; + u++; + frac = (((unsigned)val % 1024) * 10 + 1024/2) / 1024; + val /= 1024; } - if (frac >= 10) { /* We need to round up here. */ + if (frac >= 10) { /* we need to round up here */ ++val; frac = 0; } -#if 0 - /* Sample code to omit decimal point and tenths digit. */ - if ( /* no_tenths */ 1 ) { - if ( frac >= 5 ) { +#if 1 + /* If block_size is 0, dont print fractional part */ + if (block_size == 0) { + if (frac >= 5) { ++val; } - f = "%Lu%*c" /* fmt_no_tenths */ ; + fmt = "%llu%*c"; frac = 1; } #endif } - /* If f==fmt then 'frac' and 'u' are ignored. */ - snprintf(str, sizeof(str), f, val, frac, *u); - + if (!str) { + /* sufficient for any width of val */ + str = xmalloc(sizeof(val)*3 + 2 + 3); + } + sprintf(str, fmt, val, frac, *u); return str; } + + +/* vda's implementations of the similar idea */ + +/* Convert unsigned long long value into compact 5-char representation. + * String is not terminated (buf[5] is untouched) */ +void FAST_FUNC smart_ulltoa5(unsigned long long ul, char buf[5], const char *scale) +{ + const char *fmt; + char c; + unsigned v, u, idx = 0; + + if (ul > 99999) { // do not scale if 99999 or less + ul *= 10; + do { + ul /= 1024; + idx++; + } while (ul >= 100000); + } + v = ul; // ullong divisions are expensive, avoid them + + fmt = " 123456789"; + u = v / 10; + v = v % 10; + if (!idx) { + // 99999 or less: use "12345" format + // u is value/10, v is last digit + c = buf[0] = " 123456789"[u/1000]; + if (c != ' ') fmt = "0123456789"; + c = buf[1] = fmt[u/100%10]; + if (c != ' ') fmt = "0123456789"; + c = buf[2] = fmt[u/10%10]; + if (c != ' ') fmt = "0123456789"; + buf[3] = fmt[u%10]; + buf[4] = "0123456789"[v]; + } else { + // value has been scaled into 0..9999.9 range + // u is value, v is 1/10ths (allows for 92.1M format) + if (u >= 100) { + // value is >= 100: use "1234M', " 123M" formats + c = buf[0] = " 123456789"[u/1000]; + if (c != ' ') fmt = "0123456789"; + c = buf[1] = fmt[u/100%10]; + if (c != ' ') fmt = "0123456789"; + v = u % 10; + u = u / 10; + buf[2] = fmt[u%10]; + } else { + // value is < 100: use "92.1M" format + c = buf[0] = " 123456789"[u/10]; + if (c != ' ') fmt = "0123456789"; + buf[1] = fmt[u%10]; + buf[2] = '.'; + } + buf[3] = "0123456789"[v]; + buf[4] = scale[idx]; /* typically scale = " kmgt..." */ + } +} + +/* Convert unsigned long long value into compact 4-char + * representation. Examples: "1234", "1.2k", " 27M", "123T" + * String is not terminated (buf[4] is untouched) */ +void FAST_FUNC smart_ulltoa4(unsigned long long ul, char buf[4], const char *scale) +{ + const char *fmt; + char c; + unsigned v, u, idx = 0; + + if (ul > 9999) { // do not scale if 9999 or less + ul *= 10; + do { + ul /= 1024; + idx++; + } while (ul >= 10000); + } + v = ul; // ullong divisions are expensive, avoid them + + fmt = " 123456789"; + u = v / 10; + v = v % 10; + if (!idx) { + // 9999 or less: use "1234" format + // u is value/10, v is last digit + c = buf[0] = " 123456789"[u/100]; + if (c != ' ') fmt = "0123456789"; + c = buf[1] = fmt[u/10%10]; + if (c != ' ') fmt = "0123456789"; + buf[2] = fmt[u%10]; + buf[3] = "0123456789"[v]; + } else { + // u is value, v is 1/10ths (allows for 9.2M format) + if (u >= 10) { + // value is >= 10: use "123M', " 12M" formats + c = buf[0] = " 123456789"[u/100]; + if (c != ' ') fmt = "0123456789"; + v = u % 10; + u = u / 10; + buf[1] = fmt[u%10]; + } else { + // value is < 10: use "9.2M" format + buf[0] = "0123456789"[u]; + buf[1] = '.'; + } + buf[2] = "0123456789"[v]; + buf[3] = scale[idx]; /* typically scale = " kmgt..." */ + } +}