X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=libbb%2Fhuman_readable.c;h=09221a186440808043b443c7f477468669c47694;hb=3d27d435dbe7d39894257894b9dd32bfa607604c;hp=7714abecb7cbd70e08a13d49016862a8c9f8cfe8;hpb=9a7d38fe2448617df98ecaea7dbe6f3131088586;p=oweals%2Fbusybox.git diff --git a/libbb/human_readable.c b/libbb/human_readable.c index 7714abecb..09221a186 100644 --- a/libbb/human_readable.c +++ b/libbb/human_readable.c @@ -14,75 +14,173 @@ * 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 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 - * that case. This could be either an additional parameter, or a - * special value of display_unit. Such a flag would also be nice for du. + * If block_size is also 0, no decimal digits are printed. * - * 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 "libbb.h" -const char *make_human_readable_str(unsigned long long size, +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[] = "%llu"; - static const char fmt_tenths[] = "%llu.%d%c"; - - static char str[21]; /* Sufficient for 64 bit unsigned integers. */ + static const char unit_chars[] ALIGN1 = { + '\0', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y' + }; - unsigned long long val; - int frac; + 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 = 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 >= 1024) - && (u < zero_and_units + sizeof(zero_and_units) - 1) + /* && (u < unit_chars + sizeof(unit_chars) - 1) - always true */ ) { - f = fmt_tenths; - ++u; - frac = (((int)(val % 1024)) * 10 + 1024/2) / 1024; + 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 1 + /* If block_size is 0, dont print fractional part */ + if (block_size == 0) { if (frac >= 5) { ++val; } - f = "%llu%*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); + return auto_string(xasprintf(fmt, val, frac, *u)); +} + + +/* 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) */ +char* 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..." */ + } + return buf + 5; +} + +/* Convert unsigned long long value into compact 4-char + * representation. Examples: "1234", "1.2k", " 27M", "123T" + * String is not terminated (buf[4] is untouched) */ +char* 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 - return str; + 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..." */ + } + return buf + 4; }