Add an unpatched version of xz, XZ Utils, to /trunk/deps/third_party

xz/src/xz/util.c

+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       util.c
+/// \brief      Miscellaneous utility functions
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "private.h"
+#include <stdarg.h>
+
+
+extern void *
+xrealloc(void *ptr, size_t size)
+{
+        assert(size > 0);
+
+        ptr = realloc(ptr, size);
+        if (ptr == NULL)
+                message_fatal("%s", strerror(errno));
+
+        return ptr;
+}
+
+
+extern char *
+xstrdup(const char *src)
+{
+        assert(src != NULL);
+        const size_t size = strlen(src) + 1;
+        char *dest = xmalloc(size);
+        return memcpy(dest, src, size);
+}
+
+
+extern uint64_t
+str_to_uint64(const char *name, const char *value, uint64_t min, uint64_t max)
+{
+        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 = *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);
+}
+
+
+extern uint64_t
+round_up_to_mib(uint64_t n)
+{
+        return (n >> 20) + ((n & ((UINT32_C(1) << 20) - 1)) != 0);
+}
+
+
+extern const char *
+uint64_to_str(uint64_t value, uint32_t slot)
+{
+        // 2^64 with thousand separators is 26 bytes plus trailing '\0'.
+        static char bufs[4][32];
+
+        assert(slot < ARRAY_SIZE(bufs));
+
+        static enum { UNKNOWN, WORKS, BROKEN } thousand = UNKNOWN;
+        if (thousand == UNKNOWN) {
+                bufs[slot][0] = '\0';
+                snprintf(bufs[slot], sizeof(bufs[slot]), "%'" PRIu64,
+                                UINT64_C(1));
+                thousand = bufs[slot][0] == '1' ? WORKS : BROKEN;
+        }
+
+        if (thousand == WORKS)
+                snprintf(bufs[slot], sizeof(bufs[slot]), "%'" PRIu64, value);
+        else
+                snprintf(bufs[slot], sizeof(bufs[slot]), "%" PRIu64, value);
+
+        return bufs[slot];
+}
+
+
+extern 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)
+{
+        assert(unit_min <= unit_max);
+        assert(unit_max <= NICESTR_TIB);
+
+        enum nicestr_unit unit = NICESTR_B;
+        const char *str;
+
+        if ((unit_min == NICESTR_B && value < 10000)
+                        || unit_max == NICESTR_B) {
+                // The value is shown as bytes.
+                str = uint64_to_str(value, slot);
+        } 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));
+
+                str = double_to_str(d);
+        }
+
+        static const char suffix[5][4] = { "B", "KiB", "MiB", "GiB", "TiB" };
+
+        // Minimum buffer size:
+        // 26   2^64 with thousand separators
+        //  4   " KiB"
+        //  2   " ("
+        // 26   2^64 with thousand separators
+        //  3   " B)"
+        //  1   '\0'
+        // 62   Total
+        static char buf[4][64];
+        char *pos = buf[slot];
+        size_t left = sizeof(buf[slot]);
+        my_snprintf(&pos, &left, "%s %s", str, suffix[unit]);
+
+        if (always_also_bytes && value >= 10000)
+                snprintf(pos, left, " (%s B)", uint64_to_str(value, slot));
+
+        return buf[slot];
+}
+
+
+extern const char *
+double_to_str(double value)
+{
+        static char buf[64];
+
+        static enum { UNKNOWN, WORKS, BROKEN } thousand = UNKNOWN;
+        if (thousand == UNKNOWN) {
+                buf[0] = '\0';
+                snprintf(buf, sizeof(buf), "%'.1f", 2.0);
+                thousand = buf[0] == '2' ? WORKS : BROKEN;
+        }
+
+        if (thousand == WORKS)
+                snprintf(buf, sizeof(buf), "%'.1f", value);
+        else
+                snprintf(buf, sizeof(buf), "%.1f", value);
+
+        return buf;
+}
+
+
+extern void
+my_snprintf(char **pos, size_t *left, const char *fmt, ...)
+{
+        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.
+        if (len < 0 || (size_t)(len) >= *left) {
+                *left = 0;
+        } else {
+                *pos += len;
+                *left -= len;
+        }
+
+        return;
+}
+
+
+/*
+/// \brief      Simple quoting to get rid of ASCII control characters
+///
+/// This is not so cool and locale-dependent, but should be good enough
+/// At least we don't print any control characters on the terminal.
+///
+extern char *
+str_quote(const char *str)
+{
+        size_t dest_len = 0;
+        bool has_ctrl = false;
+
+        while (str[dest_len] != '\0')
+                if (*(unsigned char *)(str + dest_len++) < 0x20)
+                        has_ctrl = true;
+
+        char *dest = malloc(dest_len + 1);
+        if (dest != NULL) {
+                if (has_ctrl) {
+                        for (size_t i = 0; i < dest_len; ++i)
+                                if (*(unsigned char *)(str + i) < 0x20)
+                                        dest[i] = '?';
+                                else
+                                        dest[i] = str[i];
+
+                        dest[dest_len] = '\0';
+
+                } else {
+                        // Usually there are no control characters,
+                        // so we can optimize.
+                        memcpy(dest, str, dest_len + 1);
+                }
+        }
+
+        return dest;
+}
+*/
+
+
+extern bool
+is_empty_filename(const char *filename)
+{
+        if (filename[0] == '\0') {
+                message_error(_("Empty filename, skipping"));
+                return true;
+        }
+
+        return false;
+}
+
+
+extern bool
+is_tty_stdin(void)
+{
+        const bool ret = isatty(STDIN_FILENO);
+
+        if (ret)
+                message_error(_("Compressed data cannot be read from "
+                                "a terminal"));
+
+        return ret;
+}
+
+
+extern bool
+is_tty_stdout(void)
+{
+        const bool ret = isatty(STDOUT_FILENO);
+
+        if (ret)
+                message_error(_("Compressed data cannot be written to "
+                                "a terminal"));
+
+        return ret;
+}