util.c File Reference

Miscellaneous utility functions. More...

#include "private.h"
#include <stdarg.h>

Go to the source code of this file.

Enumerations
enum	{ UNKNOWN , WORKS , BROKEN }
	Thousand separator support in uint64_to_str() and uint64_to_nicestr() More...

Functions
void *	xrealloc (void *ptr, size_t size)
	Safe realloc() that never returns NULL. More...
char *	xstrdup (const char *src)
	Safe strdup() that never returns NULL. More...
uint64_t	str_to_uint64 (const char *name, const char *value, uint64_t min, uint64_t max)
	Fancy version of strtoull() More...
uint64_t	round_up_to_mib (uint64_t n)
	Round an integer up to the next full MiB and convert to MiB. More...
static void	check_thousand_sep (uint32_t slot)
const char *	uint64_to_str (uint64_t value, uint32_t slot)
	Convert uint64_t to a string. More...
const char *	uint64_to_nicestr (uint64_t value, enum nicestr_unit unit_min, enum nicestr_unit unit_max, bool always_also_bytes, uint32_t slot)
	Convert uint64_t to a nice human readable string. More...
void	my_snprintf (char **pos, size_t *left, const char *fmt,...)
bool	is_empty_filename (const char *filename)
	Check if filename is empty and print an error message. More...
bool	is_tty_stdin (void)
	Test if stdin is a terminal. More...
bool	is_tty_stdout (void)
	Test if stdout is a terminal. More...

Variables
static char	bufs [4][128]
	Buffers for uint64_to_str() and uint64_to_nicestr() More...
static enum { ... }	thousand = UNKNOWN
	Thousand separator support in uint64_to_str() and uint64_to_nicestr() More...

Detailed Description

Miscellaneous utility functions.

Definition in file util.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Thousand separator support in uint64_to_str() and uint64_to_nicestr()

Enumerator
UNKNOWN
WORKS
BROKEN

Definition at line 21 of file util.c.

{ UNKNOWN, WORKS, BROKEN } thousand = UNKNOWN;

Function Documentation

check_thousand_sep()

static void check_thousand_sep ( uint32_t  slot )

static

Check if thousands separator is supported. Run-time checking is easiest because it seems to be sometimes lacking even on a POSIXish system. Note that trying to use thousands separators when snprintf() doesn't support them results in undefined behavior. This just has happened to work well enough in practice.

DJGPP 2.05 added support for thousands separators but it's broken at least under WinXP with Finnish locale that uses a non-breaking space as the thousands separator. Workaround by disabling thousands separators for DJGPP builds.

Definition at line 156 of file util.c.

{
    if (thousand == UNKNOWN) {
        bufs[slot][0] = '\0';
#ifndef __DJGPP__
        snprintf(bufs[slot], sizeof(bufs[slot]), "%'u", 1U);
#endif
        thousand = bufs[slot][0] == '1' ? WORKS : BROKEN;
    }
 
    return;
}

References BROKEN, bufs, snprintf, thousand, UNKNOWN, and WORKS.

Referenced by uint64_to_nicestr(), and uint64_to_str().

is_empty_filename()

bool is_empty_filename

(

const char *

filename

)

Check if filename is empty and print an error message.

Definition at line 264 of file util.c.

{
    if (filename[0] == '\0') {
        message_error(_("Empty filename, skipping"));
        return true;
    }
 
    return false;
}

References _, and message_error().

Referenced by io_open_src().

is_tty_stdin()

bool is_tty_stdin

(

void

)

Test if stdin is a terminal.

If stdin is a terminal, an error message is printed and exit status set to EXIT_ERROR.

Definition at line 276 of file util.c.

{
    const bool ret = isatty(STDIN_FILENO);
 
    if (ret)
        message_error(_("Compressed data cannot be read from "
                "a terminal"));
 
    return ret;
}

References _, message_error(), and STDIN_FILENO.

Referenced by main().

is_tty_stdout()

bool is_tty_stdout

(

void

)

Test if stdout is a terminal.

If stdout is a terminal, an error message is printed and exit status set to EXIT_ERROR.

Definition at line 289 of file util.c.

{
    const bool ret = isatty(STDOUT_FILENO);
 
    if (ret)
        message_error(_("Compressed data cannot be written to "
                "a terminal"));
 
    return ret;
}

References _, message_error(), and STDOUT_FILENO.

Referenced by main().

my_snprintf()

void my_snprintf	(	char **	pos,
		size_t *	left,
		const char *	fmt,
			...
	)

Definition at line 239 of file util.c.

{
    va_list ap;
    va_start(ap, fmt);
    const int len = vsnprintf(*pos, *left, fmt, ap);
    va_end(ap);
 
    // If an error occurred, we want the caller to think that the whole
    // buffer was used. This way no more data will be written to the
    // buffer. We don't need better error handling here, although it
    // is possible that the result looks garbage on the terminal if
    // e.g. an UTF-8 character gets split. That shouldn't (easily)
    // happen though, because the buffers used have some extra room.
    if (len < 0 || (size_t)(len) >= *left) {
        *left = 0;
    } else {
        *pos += len;
        *left -= (size_t)(len);
    }
 
    return;
}

References len, pos, and vsnprintf.

Referenced by get_check_names(), message_filters_to_str(), progress_sizes(), and uint64_to_nicestr().

round_up_to_mib()

uint64_t round_up_to_mib

(

uint64_t

n

)

Round an integer up to the next full MiB and convert to MiB.

This is used when printing memory usage and limit.

Definition at line 139 of file util.c.

{
    return (n >> 20) + ((n & ((UINT32_C(1) << 20) - 1)) != 0);
}

References n, and UINT32_C.

Referenced by coder_init(), memlimit_show(), message_mem_needed(), print_info_adv(), and print_totals_adv().

str_to_uint64()

uint64_t str_to_uint64	(	const char *	name,
		const char *	value,
		uint64_t	min,
		uint64_t	max
	)

Fancy version of strtoull()

Parameters

name	Name of the option to show in case of an error
value	String containing the number to be parsed; may contain suffixes "k", "M", "G", "Ki", "Mi", or "Gi"
min	Minimum valid value
max	Maximum valid value

Returns

Parsed value that is in the range [min, max]. Does not return if an error occurs.

Definition at line 58 of file util.c.

{
    uint64_t result = 0;
 
    // Skip blanks.
    while (*value == ' ' || *value == '\t')
        ++value;
 
    // Accept special value "max". Supporting "min" doesn't seem useful.
    if (strcmp(value, "max") == 0)
        return max;
 
    if (*value < '0' || *value > '9')
        message_fatal(_("%s: Value is not a non-negative "
                "decimal integer"), value);
 
    do {
        // Don't overflow.
        if (result > UINT64_MAX / 10)
            goto error;
 
        result *= 10;
 
        // Another overflow check
        const uint32_t add = (uint32_t)(*value - '0');
        if (UINT64_MAX - add < result)
            goto error;
 
        result += add;
        ++value;
    } while (*value >= '0' && *value <= '9');
 
    if (*value != '\0') {
        // Look for suffix. Originally this supported both base-2
        // and base-10, but since there seems to be little need
        // for base-10 in this program, treat everything as base-2
        // and also be more relaxed about the case of the first
        // letter of the suffix.
        uint64_t multiplier = 0;
        if (*value == 'k' || *value == 'K')
            multiplier = UINT64_C(1) << 10;
        else if (*value == 'm' || *value == 'M')
            multiplier = UINT64_C(1) << 20;
        else if (*value == 'g' || *value == 'G')
            multiplier = UINT64_C(1) << 30;
 
        ++value;
 
        // Allow also e.g. Ki, KiB, and KB.
        if (*value != '\0' && strcmp(value, "i") != 0
                && strcmp(value, "iB") != 0
                && strcmp(value, "B") != 0)
            multiplier = 0;
 
        if (multiplier == 0) {
            message(V_ERROR, _("%s: Invalid multiplier suffix"),
                    value - 1);
            message_fatal(_("Valid suffixes are `KiB' (2^10), "
                    "`MiB' (2^20), and `GiB' (2^30)."));
        }
 
        // Don't overflow here either.
        if (result > UINT64_MAX / multiplier)
            goto error;
 
        result *= multiplier;
    }
 
    if (result < min || result > max)
        goto error;
 
    return result;
 
error:
    message_fatal(_("Value of the option `%s' must be in the range "
                "[%" PRIu64 ", %" PRIu64 "]"),
                name, min, max);
}

References _, add(), error(), max, message, message_fatal(), min, PRIu64, UINT64_C, UINT64_MAX, V_ERROR, and value.

Referenced by parse_block_list(), parse_memlimit(), parse_options(), and parse_real().

uint64_to_nicestr()

const char* uint64_to_nicestr	(	uint64_t	value,
		enum nicestr_unit	unit_min,
		enum nicestr_unit	unit_max,
		bool	always_also_bytes,
		uint32_t	slot
	)

Convert uint64_t to a nice human readable string.

This is like uint64_to_str() but uses B, KiB, MiB, GiB, or TiB suffix and optionally includes the exact size in parenthesis.

Parameters

value	Value to be printed
unit_min	Smallest unit to use. This and unit_max are used e.g. when showing the progress indicator to force the unit to MiB.
unit_max	Biggest unit to use. assert(unit_min <= unit_max).
always_also_bytes	Show also the exact byte value in parenthesis if the nicely formatted string uses bigger unit than bytes.
slot	Which static buffer to use to hold the string. This is shared with uint64_to_str().

Returns

Pointer to statically allocated buffer containing the string.

Note

This uses double_to_str() internally so the static buffer in double_to_str() will be overwritten.

Definition at line 187 of file util.c.

{
    assert(unit_min <= unit_max);
    assert(unit_max <= NICESTR_TIB);
    assert(slot < ARRAY_SIZE(bufs));
 
    check_thousand_sep(slot);
 
    enum nicestr_unit unit = NICESTR_B;
    char *pos = bufs[slot];
    size_t left = sizeof(bufs[slot]);
 
    if ((unit_min == NICESTR_B && value < 10000)
            || unit_max == NICESTR_B) {
        // The value is shown as bytes.
        if (thousand == WORKS)
            my_snprintf(&pos, &left, "%'u", (unsigned int)value);
        else
            my_snprintf(&pos, &left, "%u", (unsigned int)value);
    } else {
        // Scale the value to a nicer unit. Unless unit_min and
        // unit_max limit us, we will show at most five significant
        // digits with one decimal place.
        double d = (double)(value);
        do {
            d /= 1024.0;
            ++unit;
        } while (unit < unit_min || (d > 9999.9 && unit < unit_max));
 
        if (thousand == WORKS)
            my_snprintf(&pos, &left, "%'.1f", d);
        else
            my_snprintf(&pos, &left, "%.1f", d);
    }
 
    static const char suffix[5][4] = { "B", "KiB", "MiB", "GiB", "TiB" };
    my_snprintf(&pos, &left, " %s", suffix[unit]);
 
    if (always_also_bytes && value >= 10000) {
        if (thousand == WORKS)
            snprintf(pos, left, " (%'" PRIu64 " B)", value);
        else
            snprintf(pos, left, " (%" PRIu64 " B)", value);
    }
 
    return bufs[slot];
}

References ARRAY_SIZE, assert(), bufs, check_thousand_sep(), d, my_snprintf(), NICESTR_B, NICESTR_TIB, pos, PRIu64, snprintf, suffix, thousand, value, and WORKS.

Referenced by print_adv_helper(), print_info_basic(), print_totals_basic(), and progress_sizes().

uint64_to_str()

const char* uint64_to_str	(	uint64_t	value,
		uint32_t	slot
	)

Convert uint64_t to a string.

Convert the given value to a string with locale-specific thousand separators, if supported by the snprintf() implementation. The string is stored into an internal static buffer indicated by the slot argument. A pointer to the selected buffer is returned.

This function exists, because non-POSIX systems don't support thousand separator in format strings. Solving the problem in a simple way doesn't work, because it breaks gettext (specifically, the xgettext tool).

Definition at line 171 of file util.c.

{
    assert(slot < ARRAY_SIZE(bufs));
 
    check_thousand_sep(slot);
 
    if (thousand == WORKS)
        snprintf(bufs[slot], sizeof(bufs[slot]), "%'" PRIu64, value);
    else
        snprintf(bufs[slot], sizeof(bufs[slot]), "%" PRIu64, value);
 
    return bufs[slot];
}

References ARRAY_SIZE, assert(), bufs, check_thousand_sep(), PRIu64, snprintf, thousand, value, and WORKS.

Referenced by coder_init(), memlimit_show(), message_mem_needed(), print_adv_helper(), print_info_adv(), print_info_basic(), print_totals_adv(), and print_totals_basic().

xrealloc()

void* xrealloc	(	void *	ptr,
		size_t	size
	)

Safe realloc() that never returns NULL.

Definition at line 25 of file util.c.

{
    assert(size > 0);
 
    // Save ptr so that we can free it if realloc fails.
    // The point is that message_fatal ends up calling stdio functions
    // which in some libc implementations might allocate memory from
    // the heap. Freeing ptr improves the chances that there's free
    // memory for stdio functions if they need it.
    void *p = ptr;
    ptr = realloc(ptr, size);
 
    if (ptr == NULL) {
        const int saved_errno = errno;
        free(p);
        message_fatal("%s", strerror(saved_errno));
    }
 
    return ptr;
}

References assert(), free(), message_fatal(), NULL, p, and realloc().

Referenced by read_name().

xstrdup()

char* xstrdup

(

const char *

src

)

Safe strdup() that never returns NULL.

Definition at line 48 of file util.c.

{
    assert(src != NULL);
    const size_t size = strlen(src) + 1;
    char *dest = xmalloc(size);
    return memcpy(dest, src, size);
}

References assert(), dest, memcpy(), NULL, src, and xmalloc.

Referenced by parse_environment(), parse_options(), and suffix_set().

Variable Documentation

bufs

char bufs[4][128]

static

Buffers for uint64_to_str() and uint64_to_nicestr()

Definition at line 18 of file util.c.

Referenced by check_thousand_sep(), uint64_to_nicestr(), uint64_to_str(), uv__build_coalesced_write_req(), uv__count_bufs(), uv__fs_buf_offset(), uv__fs_preadv(), uv__fs_write_all(), uv__pipe_write(), uv__pipe_write_data(), uv__pipe_write_ipc(), uv__send(), uv__tcp_try_write(), uv__tty_try_write(), uv__udp_send(), uv__udp_try_send(), uv_fs_read(), uv_fs_write(), uv_tcp_write(), uv_try_write(), uv_tty_write(), uv_tty_write_bufs(), uv_udp_send(), uv_udp_try_send(), uv_write(), and uv_write2().

enum { ... } thousand

Thousand separator support in uint64_to_str() and uint64_to_nicestr()

Referenced by check_thousand_sep(), uint64_to_nicestr(), and uint64_to_str().