message.c File Reference

Printing messages. More...

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

Go to the source code of this file.

Functions
void	message_init (void)
	Initializes the message functions. More...
void	message_verbosity_increase (void)
	Increase verbosity level by one step unless it was at maximum. More...
void	message_verbosity_decrease (void)
	Decrease verbosity level by one step unless it was at minimum. More...
enum message_verbosity	message_verbosity_get (void)
	Get the current verbosity level. More...
void	message_set_files (unsigned int files)
	Set the total number of files to be processed. More...
static void	print_filename (void)
void	message_filename (const char *src_name)
	Set the name of the current file and possibly print it too. More...
void	message_progress_start (lzma_stream *strm, bool is_passthru, uint64_t in_size)
	Start progress info handling. More...
static const char *	progress_percentage (uint64_t in_pos)
	Make the string indicating completion percentage. More...
static const char *	progress_sizes (uint64_t compressed_pos, uint64_t uncompressed_pos, bool final)
static const char *	progress_speed (uint64_t uncompressed_pos, uint64_t elapsed)
	Make the string containing the processing speed of uncompressed data. More...
static const char *	progress_time (uint64_t mseconds)
static const char *	progress_remaining (uint64_t in_pos, uint64_t elapsed)
static void	progress_pos (uint64_t *in_pos, uint64_t *compressed_pos, uint64_t *uncompressed_pos)
	Get how much uncompressed and compressed data has been processed. More...
void	message_progress_update (void)
static void	progress_flush (bool finished)
void	message_progress_end (bool success)
	Finishes the progress message if we were in verbose mode. More...
static void	vmessage (enum message_verbosity v, const char *fmt, va_list ap)
void	message (enum message_verbosity v, const char *fmt,...)
void	message_warning (const char *fmt,...)
void	message_error (const char *fmt,...)
void	message_fatal (const char *fmt,...)
void	message_bug (void)
void	message_signal_handler (void)
const char *	message_strm (lzma_ret code)
	Convert lzma_ret to a string. More...
void	message_mem_needed (enum message_verbosity v, uint64_t memusage)
	Display how much memory was needed and how much the limit was. More...
static const char *	uint32_to_optstr (uint32_t num)
	Convert uint32_t to a nice string for –lzma[12]=dict=SIZE. More...
void	message_filters_to_str (char buf[FILTERS_STR_SIZE], const lzma_filter *filters, bool all_known)
	Get the filter chain as a string. More...
void	message_filters_show (enum message_verbosity v, const lzma_filter *filters)
	Print the filter chain. More...
void	message_try_help (void)
	Print a message that user should try –help. More...
void	message_version (void)
	Prints the version number to stdout and exits with exit status SUCCESS. More...
void	message_help (bool long_help)
	Print the help message. More...

Variables
static unsigned int	files_pos = 0
	Number of the current file. More...
static unsigned int	files_total
	Total number of input files; zero if unknown. More...
static enum message_verbosity	verbosity = V_WARNING
	Verbosity level. More...
static const char *	filename
	Filename which we will print with the verbose messages. More...
static bool	first_filename_printed = false
static bool	current_filename_printed = false
static bool	progress_automatic
static bool	progress_started = false
static bool	progress_active = false
static lzma_stream *	progress_strm
	Pointer to lzma_stream used to do the encoding or decoding. More...
static bool	progress_is_from_passthru
static uint64_t	expected_in_size
static bool	progress_needs_updating = false
static uint64_t	progress_next_update
	Elapsed time when the next progress message update should be done. More...

Detailed Description

Printing messages.

Definition in file message.c.

Function Documentation

message()

void message	(	enum message_verbosity	v,
		const char *	fmt,
			...
	)

Definition at line 740 of file message.c.

{
    va_list ap;
    va_start(ap, fmt);
    vmessage(v, fmt, ap);
    va_end(ap);
    return;
}

References v, and vmessage().

Referenced by message_mem_needed(), and message_try_help().

message_bug()

void message_bug

(

void

)

Print an error message that an internal error occurred and exit with EXIT_ERROR.

Definition at line 789 of file message.c.

{
    message_fatal(_("Internal error (bug)"));
}

References _, and message_fatal().

Referenced by coder_init(), io_read(), options_lzma(), parse_block_header(), and parse_indexes().

message_error()

void message_error	(	const char *	fmt,
			...
	)

Definition at line 764 of file message.c.

{
    va_list ap;
    va_start(ap, fmt);
    vmessage(V_ERROR, fmt, ap);
    va_end(ap);
 
    set_exit_status(E_ERROR);
    return;
}

References E_ERROR, set_exit_status(), V_ERROR, and vmessage().

Referenced by coder_normal(), compressed_name(), io_close(), io_close_dest(), io_close_src(), io_open_dest_real(), io_open_src_real(), io_pread(), io_read(), io_unlink(), io_wait(), io_write(), io_write_buf(), is_empty_filename(), is_tty_stdin(), is_tty_stdout(), list_file(), main(), parse_block_header(), parse_indexes(), read_name(), and uncompressed_name().

message_fatal()

void message_fatal	(	const char *	fmt,
			...
	)

Definition at line 777 of file message.c.

{
    va_list ap;
    va_start(ap, fmt);
    vmessage(V_ERROR, fmt, ap);
    va_end(ap);
 
    tuklib_exit(E_ERROR, E_ERROR, false);
}

References E_ERROR, tuklib_exit, V_ERROR, and vmessage().

Referenced by args_parse(), coder_add_filter(), coder_init(), io_init(), list_file(), lzma_attribute(), main(), message_bug(), message_signal_handler(), options_lzma(), parse_block_list(), parse_environment(), parse_options(), parse_real(), str_to_uint64(), suffix_set(), and xrealloc().

message_filename()

void message_filename

(

const char *

src_name

)

Set the name of the current file and possibly print it too.

The name is printed immediately if –list was used or if –verbose was used and stderr is a terminal. Even when the filename isn't printed, it is stored so that it can be printed later if needed for progress messages.

Definition at line 232 of file message.c.

{
    // Start numbering the files starting from one.
    ++files_pos;
    filename = src_name;
 
    if (verbosity >= V_VERBOSE
            && (progress_automatic || opt_mode == MODE_LIST))
        print_filename();
    else
        current_filename_printed = false;
 
    return;
}

References current_filename_printed, files_pos, MODE_LIST, opt_mode, print_filename(), progress_automatic, V_VERBOSE, and verbosity.

Referenced by coder_run(), and list_file().

message_filters_show()

void message_filters_show	(	enum message_verbosity	v,
		const lzma_filter *	filters
	)

Print the filter chain.

Definition at line 1050 of file message.c.

{
    if (v > verbosity)
        return;
 
    char buf[FILTERS_STR_SIZE];
    message_filters_to_str(buf, filters, true);
    fprintf(stderr, _("%s: Filter chain: %s\n"), progname, buf);
    return;
}

References _, filters, FILTERS_STR_SIZE, message_filters_to_str(), progname, v, and verbosity.

Referenced by coder_init().

message_filters_to_str()

void message_filters_to_str	(	char	buf[FILTERS_STR_SIZE],
		const lzma_filter *	filters,
		bool	all_known
	)

Get the filter chain as a string.

Parameters

buf	Pointer to caller allocated buffer to hold the filter chain string
filters	Pointer to the filter chain
all_known	If true, all filter options are printed. If false, only the options that get stored into .xz headers are printed.

Definition at line 917 of file message.c.

{
    char *pos = buf;
    size_t left = FILTERS_STR_SIZE;
 
    for (size_t i = 0; filters[i].id != LZMA_VLI_UNKNOWN; ++i) {
        // Add the dashes for the filter option. A space is
        // needed after the first and later filters.
        my_snprintf(&pos, &left, "%s", i == 0 ? "--" : " --");
 
        switch (filters[i].id) {
        case LZMA_FILTER_LZMA1:
        case LZMA_FILTER_LZMA2: {
            const lzma_options_lzma *opt = filters[i].options;
            const char *mode = NULL;
            const char *mf = NULL;
 
            if (all_known) {
                switch (opt->mode) {
                case LZMA_MODE_FAST:
                    mode = "fast";
                    break;
 
                case LZMA_MODE_NORMAL:
                    mode = "normal";
                    break;
 
                default:
                    mode = "UNKNOWN";
                    break;
                }
 
                switch (opt->mf) {
                case LZMA_MF_HC3:
                    mf = "hc3";
                    break;
 
                case LZMA_MF_HC4:
                    mf = "hc4";
                    break;
 
                case LZMA_MF_BT2:
                    mf = "bt2";
                    break;
 
                case LZMA_MF_BT3:
                    mf = "bt3";
                    break;
 
                case LZMA_MF_BT4:
                    mf = "bt4";
                    break;
 
                default:
                    mf = "UNKNOWN";
                    break;
                }
            }
 
            // Add the filter name and dictionary size, which
            // is always known.
            my_snprintf(&pos, &left, "lzma%c=dict=%s",
                    filters[i].id == LZMA_FILTER_LZMA2
                        ? '2' : '1',
                    uint32_to_optstr(opt->dict_size));
 
            // With LZMA1 also lc/lp/pb are known when
            // decompressing, but this function is never
            // used to print information about .lzma headers.
            assert(filters[i].id == LZMA_FILTER_LZMA2
                    || all_known);
 
            // Print the rest of the options, which are known
            // only when compressing.
            if (all_known)
                my_snprintf(&pos, &left,
                    ",lc=%" PRIu32 ",lp=%" PRIu32
                    ",pb=%" PRIu32
                    ",mode=%s,nice=%" PRIu32 ",mf=%s"
                    ",depth=%" PRIu32,
                    opt->lc, opt->lp, opt->pb,
                    mode, opt->nice_len, mf, opt->depth);
            break;
        }
 
        case LZMA_FILTER_X86:
        case LZMA_FILTER_POWERPC:
        case LZMA_FILTER_IA64:
        case LZMA_FILTER_ARM:
        case LZMA_FILTER_ARMTHUMB:
        case LZMA_FILTER_SPARC: {
            static const char bcj_names[][9] = {
                "x86",
                "powerpc",
                "ia64",
                "arm",
                "armthumb",
                "sparc",
            };
 
            const lzma_options_bcj *opt = filters[i].options;
            my_snprintf(&pos, &left, "%s", bcj_names[filters[i].id
                    - LZMA_FILTER_X86]);
 
            // Show the start offset only when really needed.
            if (opt != NULL && opt->start_offset != 0)
                my_snprintf(&pos, &left, "=start=%" PRIu32,
                        opt->start_offset);
 
            break;
        }
 
        case LZMA_FILTER_DELTA: {
            const lzma_options_delta *opt = filters[i].options;
            my_snprintf(&pos, &left, "delta=dist=%" PRIu32,
                    opt->dist);
            break;
        }
 
        default:
            // This should be possible only if liblzma is
            // newer than the xz tool.
            my_snprintf(&pos, &left, "UNKNOWN");
            break;
        }
    }
 
    return;
}

References assert(), lzma_options_lzma::depth, lzma_options_lzma::dict_size, lzma_options_delta::dist, filters, FILTERS_STR_SIZE, i, lzma_filter::id, lzma_options_lzma::lc, lzma_options_lzma::lp, LZMA_FILTER_ARM, LZMA_FILTER_ARMTHUMB, LZMA_FILTER_DELTA, LZMA_FILTER_IA64, LZMA_FILTER_LZMA1, LZMA_FILTER_LZMA2, LZMA_FILTER_POWERPC, LZMA_FILTER_SPARC, LZMA_FILTER_X86, LZMA_MF_BT2, LZMA_MF_BT3, LZMA_MF_BT4, LZMA_MF_HC3, LZMA_MF_HC4, LZMA_MODE_FAST, LZMA_MODE_NORMAL, LZMA_VLI_UNKNOWN, lzma_options_lzma::mf, lzma_options_lzma::mode, my_snprintf(), lzma_options_lzma::nice_len, NULL, lzma_filter::options, lzma_options_lzma::pb, pos, PRIu32, lzma_options_bcj::start_offset, and uint32_to_optstr().

Referenced by message_filters_show(), and parse_block_header().

message_help()

void message_help

(

bool

long_help

)

Print the help message.

Definition at line 1091 of file message.c.

{
    printf(_("Usage: %s [OPTION]... [FILE]...\n"
            "Compress or decompress FILEs in the .xz format.\n\n"),
            progname);
 
    // NOTE: The short help doesn't currently have options that
    // take arguments.
    if (long_help)
        puts(_("Mandatory arguments to long options are mandatory "
                "for short options too.\n"));
 
    if (long_help)
        puts(_(" Operation mode:\n"));
 
    puts(_(
"  -z, --compress      force compression\n"
"  -d, --decompress    force decompression\n"
"  -t, --test          test compressed file integrity\n"
"  -l, --list          list information about .xz files"));
 
    if (long_help)
        puts(_("\n Operation modifiers:\n"));
 
    puts(_(
"  -k, --keep          keep (don't delete) input files\n"
"  -f, --force         force overwrite of output file and (de)compress links\n"
"  -c, --stdout        write to standard output and don't delete input files"));
 
    if (long_help) {
        puts(_(
"      --single-stream decompress only the first stream, and silently\n"
"                      ignore possible remaining input data"));
        puts(_(
"      --no-sparse     do not create sparse files when decompressing\n"
"  -S, --suffix=.SUF   use the suffix `.SUF' on compressed files\n"
"      --files[=FILE]  read filenames to process from FILE; if FILE is\n"
"                      omitted, filenames are read from the standard input;\n"
"                      filenames must be terminated with the newline character\n"
"      --files0[=FILE] like --files but use the null character as terminator"));
    }
 
    if (long_help) {
        puts(_("\n Basic file format and compression options:\n"));
        puts(_(
"  -F, --format=FMT    file format to encode or decode; possible values are\n"
"                      `auto' (default), `xz', `lzma', and `raw'\n"
"  -C, --check=CHECK   integrity check type: `none' (use with caution),\n"
"                      `crc32', `crc64' (default), or `sha256'"));
        puts(_(
"      --ignore-check  don't verify the integrity check when decompressing"));
    }
 
    puts(_(
"  -0 ... -9           compression preset; default is 6; take compressor *and*\n"
"                      decompressor memory usage into account before using 7-9!"));
 
    puts(_(
"  -e, --extreme       try to improve compression ratio by using more CPU time;\n"
"                      does not affect decompressor memory requirements"));
 
    puts(_(
"  -T, --threads=NUM   use at most NUM threads; the default is 1; set to 0\n"
"                      to use as many threads as there are processor cores"));
 
    if (long_help) {
        puts(_(
"      --block-size=SIZE\n"
"                      start a new .xz block after every SIZE bytes of input;\n"
"                      use this to set the block size for threaded compression"));
        puts(_(
"      --block-list=SIZES\n"
"                      start a new .xz block after the given comma-separated\n"
"                      intervals of uncompressed data"));
        puts(_(
"      --flush-timeout=TIMEOUT\n"
"                      when compressing, if more than TIMEOUT milliseconds has\n"
"                      passed since the previous flush and reading more input\n"
"                      would block, all pending data is flushed out"
        ));
        puts(_( // xgettext:no-c-format
"      --memlimit-compress=LIMIT\n"
"      --memlimit-decompress=LIMIT\n"
"  -M, --memlimit=LIMIT\n"
"                      set memory usage limit for compression, decompression,\n"
"                      or both; LIMIT is in bytes, % of RAM, or 0 for defaults"));
 
        puts(_(
"      --no-adjust     if compression settings exceed the memory usage limit,\n"
"                      give an error instead of adjusting the settings downwards"));
    }
 
    if (long_help) {
        puts(_(
"\n Custom filter chain for compression (alternative for using presets):"));
 
#if defined(HAVE_ENCODER_LZMA1) || defined(HAVE_DECODER_LZMA1) \
        || defined(HAVE_ENCODER_LZMA2) || defined(HAVE_DECODER_LZMA2)
        // TRANSLATORS: The word "literal" in "literal context bits"
        // means how many "context bits" to use when encoding
        // literals. A literal is a single 8-bit byte. It doesn't
        // mean "literally" here.
        puts(_(
"\n"
"  --lzma1[=OPTS]      LZMA1 or LZMA2; OPTS is a comma-separated list of zero or\n"
"  --lzma2[=OPTS]      more of the following options (valid values; default):\n"
"                        preset=PRE reset options to a preset (0-9[e])\n"
"                        dict=NUM   dictionary size (4KiB - 1536MiB; 8MiB)\n"
"                        lc=NUM     number of literal context bits (0-4; 3)\n"
"                        lp=NUM     number of literal position bits (0-4; 0)\n"
"                        pb=NUM     number of position bits (0-4; 2)\n"
"                        mode=MODE  compression mode (fast, normal; normal)\n"
"                        nice=NUM   nice length of a match (2-273; 64)\n"
"                        mf=NAME    match finder (hc3, hc4, bt2, bt3, bt4; bt4)\n"
"                        depth=NUM  maximum search depth; 0=automatic (default)"));
#endif
 
        puts(_(
"\n"
"  --x86[=OPTS]        x86 BCJ filter (32-bit and 64-bit)\n"
"  --powerpc[=OPTS]    PowerPC BCJ filter (big endian only)\n"
"  --ia64[=OPTS]       IA-64 (Itanium) BCJ filter\n"
"  --arm[=OPTS]        ARM BCJ filter (little endian only)\n"
"  --armthumb[=OPTS]   ARM-Thumb BCJ filter (little endian only)\n"
"  --sparc[=OPTS]      SPARC BCJ filter\n"
"                      Valid OPTS for all BCJ filters:\n"
"                        start=NUM  start offset for conversions (default=0)"));
 
#if defined(HAVE_ENCODER_DELTA) || defined(HAVE_DECODER_DELTA)
        puts(_(
"\n"
"  --delta[=OPTS]      Delta filter; valid OPTS (valid values; default):\n"
"                        dist=NUM   distance between bytes being subtracted\n"
"                                   from each other (1-256; 1)"));
#endif
    }
 
    if (long_help)
        puts(_("\n Other options:\n"));
 
    puts(_(
"  -q, --quiet         suppress warnings; specify twice to suppress errors too\n"
"  -v, --verbose       be verbose; specify twice for even more verbose"));
 
    if (long_help) {
        puts(_(
"  -Q, --no-warn       make warnings not affect the exit status"));
        puts(_(
"      --robot         use machine-parsable messages (useful for scripts)"));
        puts("");
        puts(_(
"      --info-memory   display the total amount of RAM and the currently active\n"
"                      memory usage limits, and exit"));
        puts(_(
"  -h, --help          display the short help (lists only the basic options)\n"
"  -H, --long-help     display this long help and exit"));
    } else {
        puts(_(
"  -h, --help          display this short help and exit\n"
"  -H, --long-help     display the long help (lists also the advanced options)"));
    }
 
    puts(_(
"  -V, --version       display the version number and exit"));
 
    puts(_("\nWith no FILE, or when FILE is -, read standard input.\n"));
 
    // TRANSLATORS: This message indicates the bug reporting address
    // for this package. Please add _another line_ saying
    // "Report translation bugs to <...>\n" with the email or WWW
    // address for translation bugs. Thanks.
    printf(_("Report bugs to <%s> (in English or Finnish).\n"),
            PACKAGE_BUGREPORT);
    printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
 
#if LZMA_VERSION_STABILITY != LZMA_VERSION_STABILITY_STABLE
    puts(_(
"THIS IS A DEVELOPMENT VERSION NOT INTENDED FOR PRODUCTION USE."));
#endif
 
    tuklib_exit(E_SUCCESS, E_ERROR, verbosity != V_SILENT);
}

References _, E_ERROR, E_SUCCESS, PACKAGE_BUGREPORT, PACKAGE_NAME, PACKAGE_URL, printf(), progname, tuklib_exit, V_SILENT, and verbosity.

Referenced by parse_real().

message_init()

void message_init

(

void

)

Initializes the message functions.

If an error occurs, this function doesn't return.

Definition at line 114 of file message.c.

{
    // If --verbose is used, we use a progress indicator if and only
    // if stderr is a terminal. If stderr is not a terminal, we print
    // verbose information only after finishing the file. As a special
    // exception, even if --verbose was not used, user can send SIGALRM
    // to make us print progress information once without automatic
    // updating.
    progress_automatic = isatty(STDERR_FILENO);
 
    // Commented out because COLUMNS is rarely exported to environment.
    // Most users have at least 80 columns anyway, let's think something
    // fancy here if enough people complain.
/*
    if (progress_automatic) {
        // stderr is a terminal. Check the COLUMNS environment
        // variable to see if the terminal is wide enough. If COLUMNS
        // doesn't exist or it has some unparsable value, we assume
        // that the terminal is wide enough.
        const char *columns_str = getenv("COLUMNS");
        if (columns_str != NULL) {
            char *endptr;
            const long columns = strtol(columns_str, &endptr, 10);
            if (*endptr != '\0' || columns < 80)
                progress_automatic = false;
        }
    }
*/
 
#ifdef SIGALRM
    // Establish the signal handlers which set a flag to tell us that
    // progress info should be updated.
    struct sigaction sa;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    sa.sa_handler = &progress_signal_handler;
 
    for (size_t i = 0; message_progress_sigs[i] != 0; ++i)
        if (sigaction(message_progress_sigs[i], &sa, NULL))
            message_signal_handler();
#endif
 
    return;
}

References i, message_progress_sigs, message_signal_handler(), NULL, progress_automatic, and STDERR_FILENO.

Referenced by main().

message_mem_needed()

void message_mem_needed	(	enum message_verbosity	v,
		uint64_t	memusage
	)

Display how much memory was needed and how much the limit was.

Definition at line 846 of file message.c.

{
    if (v > verbosity)
        return;
 
    // Convert memusage to MiB, rounding up to the next full MiB.
    // This way the user can always use the displayed usage as
    // the new memory usage limit. (If we rounded to the nearest,
    // the user might need to +1 MiB to get high enough limit.)
    memusage = round_up_to_mib(memusage);
 
    uint64_t memlimit = hardware_memlimit_get(opt_mode);
 
    // Handle the case when there is no memory usage limit.
    // This way we don't print a weird message with a huge number.
    if (memlimit == UINT64_MAX) {
        message(v, _("%s MiB of memory is required. "
                "The limiter is disabled."),
                uint64_to_str(memusage, 0));
        return;
    }
 
    // With US-ASCII:
    // 2^64 with thousand separators + " MiB" suffix + '\0' = 26 + 4 + 1
    // But there may be multibyte chars so reserve enough space.
    char memlimitstr[128];
 
    // Show the memory usage limit as MiB unless it is less than 1 MiB.
    // This way it's easy to notice errors where one has typed
    // --memory=123 instead of --memory=123MiB.
    if (memlimit < (UINT32_C(1) << 20)) {
        snprintf(memlimitstr, sizeof(memlimitstr), "%s B",
                uint64_to_str(memlimit, 1));
    } else {
        // Round up just like with memusage. If this function is
        // called for informational purposes (to just show the
        // current usage and limit), we should never show that
        // the usage is higher than the limit, which would give
        // a false impression that the memory usage limit isn't
        // properly enforced.
        snprintf(memlimitstr, sizeof(memlimitstr), "%s MiB",
                uint64_to_str(round_up_to_mib(memlimit), 1));
    }
 
    message(v, _("%s MiB of memory is required. The limit is %s."),
            uint64_to_str(memusage, 0), memlimitstr);
 
    return;
}

References _, hardware_memlimit_get(), memlimit, message(), opt_mode, round_up_to_mib(), snprintf, UINT32_C, UINT64_MAX, uint64_to_str(), v, and verbosity.

Referenced by coder_init(), coder_normal(), lzma_attribute(), and parse_indexes().

message_progress_end()

void message_progress_end

(

bool

finished

)

Finishes the progress message if we were in verbose mode.

Parameters

finished

True if the whole stream was successfully coded and output written to the output stream.

Definition at line 707 of file message.c.

{
    assert(progress_started);
    progress_flush(success);
    progress_started = false;
    return;
}

References assert(), progress_flush(), and progress_started.

Referenced by coder_run().

message_progress_start()

void message_progress_start	(	lzma_stream *	strm,
		bool	is_passthru,
		uint64_t	in_size
	)

Start progress info handling.

message_filename() must be called before this function to set the filename.

This must be paired with a call to message_progress_end() before the given *strm becomes invalid.

Parameters

strm	Pointer to lzma_stream used for the coding.
in_size	Size of the input file, or zero if unknown.

Definition at line 249 of file message.c.

{
    // Store the pointer to the lzma_stream used to do the coding.
    // It is needed to find out the position in the stream.
    progress_strm = strm;
    progress_is_from_passthru = is_passthru;
 
    // Store the expected size of the file. If we aren't printing any
    // statistics, then is will be unused. But since it is possible
    // that the user sends us a signal to show statistics, we need
    // to have it available anyway.
    expected_in_size = in_size;
 
    // Indicate that progress info may need to be printed before
    // printing error messages.
    progress_started = true;
 
    // If progress indicator is wanted, print the filename and possibly
    // the file count now.
    if (verbosity >= V_VERBOSE && progress_automatic) {
        // Start the timer to display the first progress message
        // after one second. An alternative would be to show the
        // first message almost immediately, but delaying by one
        // second looks better to me, since extremely early
        // progress info is pretty much useless.
#ifdef SIGALRM
        // First disable a possibly existing alarm.
        alarm(0);
        progress_needs_updating = false;
        alarm(1);
#else
        progress_needs_updating = true;
        progress_next_update = 1000;
#endif
    }
 
    return;
}

References alarm, expected_in_size, in_size, progress_automatic, progress_is_from_passthru, progress_needs_updating, progress_next_update, progress_started, progress_strm, strm, V_VERBOSE, and verbosity.

Referenced by coder_run().

message_progress_update()

void message_progress_update

(

void

)

Update the progress info if in verbose mode and enough time has passed since the previous update. This can be called only when message_progress_start() has already been used.

Definition at line 545 of file message.c.

{
    if (!progress_needs_updating)
        return;
 
    // Calculate how long we have been processing this file.
    const uint64_t elapsed = mytime_get_elapsed();
 
#ifndef SIGALRM
    if (progress_next_update > elapsed)
        return;
 
    progress_next_update = elapsed + 1000;
#endif
 
    // Get our current position in the stream.
    uint64_t in_pos;
    uint64_t compressed_pos;
    uint64_t uncompressed_pos;
    progress_pos(&in_pos, &compressed_pos, &uncompressed_pos);
 
    // Block signals so that fprintf() doesn't get interrupted.
    signals_block();
 
    // Print the filename if it hasn't been printed yet.
    if (!current_filename_printed)
        print_filename();
 
    // Print the actual progress message. The idea is that there is at
    // least three spaces between the fields in typical situations, but
    // even in rare situations there is at least one space.
    const char *cols[5] = {
        progress_percentage(in_pos),
        progress_sizes(compressed_pos, uncompressed_pos, false),
        progress_speed(uncompressed_pos, elapsed),
        progress_time(elapsed),
        progress_remaining(in_pos, elapsed),
    };
    fprintf(stderr, "\r %*s %*s   %*s %10s   %10s\r",
            tuklib_mbstr_fw(cols[0], 6), cols[0],
            tuklib_mbstr_fw(cols[1], 35), cols[1],
            tuklib_mbstr_fw(cols[2], 9), cols[2],
            cols[3],
            cols[4]);
 
#ifdef SIGALRM
    // Updating the progress info was finished. Reset
    // progress_needs_updating to wait for the next SIGALRM.
    //
    // NOTE: This has to be done before alarm(1) or with (very) bad
    // luck we could be setting this to false after the alarm has already
    // been triggered.
    progress_needs_updating = false;
 
    if (verbosity >= V_VERBOSE && progress_automatic) {
        // Mark that the progress indicator is active, so if an error
        // occurs, the error message gets printed cleanly.
        progress_active = true;
 
        // Restart the timer so that progress_needs_updating gets
        // set to true after about one second.
        alarm(1);
    } else {
        // The progress message was printed because user had sent us
        // SIGALRM. In this case, each progress message is printed
        // on its own line.
        fputc('\n', stderr);
    }
#else
    // When SIGALRM isn't supported and we get here, it's always due to
    // automatic progress update. We set progress_active here too like
    // described above.
    assert(verbosity >= V_VERBOSE);
    assert(progress_automatic);
    progress_active = true;
#endif
 
    signals_unblock();
 
    return;
}

References alarm, assert(), current_filename_printed, in_pos, mytime_get_elapsed(), print_filename(), progress_active, progress_automatic, progress_needs_updating, progress_next_update, progress_percentage(), progress_pos(), progress_remaining(), progress_sizes(), progress_speed(), progress_time(), signals_block(), signals_unblock(), tuklib_mbstr_fw, V_VERBOSE, and verbosity.

Referenced by coder_normal(), and coder_passthru().

message_set_files()

void message_set_files

(

unsigned int

files

)

Set the total number of files to be processed.

Standard input is counted as a file here. This is used when printing the filename via message_filename().

Definition at line 188 of file message.c.

{
    files_total = files;
    return;
}

References files, and files_total.

Referenced by main().

message_signal_handler()

void message_signal_handler

(

void

)

Print a message that establishing signal handlers failed, and exit with exit status ERROR.

Definition at line 796 of file message.c.

{
    message_fatal(_("Cannot establish signal handlers"));
}

References _, and message_fatal().

Referenced by message_init(), and signals_init().

message_strm()

const char* message_strm

(

lzma_ret

code

)

Convert lzma_ret to a string.

Definition at line 803 of file message.c.

{
    switch (code) {
    case LZMA_NO_CHECK:
        return _("No integrity check; not verifying file integrity");
 
    case LZMA_UNSUPPORTED_CHECK:
        return _("Unsupported type of integrity check; "
                "not verifying file integrity");
 
    case LZMA_MEM_ERROR:
        return strerror(ENOMEM);
 
    case LZMA_MEMLIMIT_ERROR:
        return _("Memory usage limit reached");
 
    case LZMA_FORMAT_ERROR:
        return _("File format not recognized");
 
    case LZMA_OPTIONS_ERROR:
        return _("Unsupported options");
 
    case LZMA_DATA_ERROR:
        return _("Compressed data is corrupt");
 
    case LZMA_BUF_ERROR:
        return _("Unexpected end of input");
 
    case LZMA_OK:
    case LZMA_STREAM_END:
    case LZMA_GET_CHECK:
    case LZMA_PROG_ERROR:
        // Without "default", compiler will warn if new constants
        // are added to lzma_ret, it is not too easy to forget to
        // add the new constants to this function.
        break;
    }
 
    return _("Internal error (bug)");
}

References _, ENOMEM, LZMA_BUF_ERROR, LZMA_DATA_ERROR, LZMA_FORMAT_ERROR, LZMA_GET_CHECK, LZMA_MEM_ERROR, LZMA_MEMLIMIT_ERROR, LZMA_NO_CHECK, LZMA_OK, LZMA_OPTIONS_ERROR, LZMA_PROG_ERROR, LZMA_STREAM_END, and LZMA_UNSUPPORTED_CHECK.

Referenced by coder_normal(), parse_block_header(), and parse_indexes().

message_try_help()

void message_try_help

(

void

)

Print a message that user should try –help.

Definition at line 1063 of file message.c.

{
    // Print this with V_WARNING instead of V_ERROR to prevent it from
    // showing up when --quiet has been specified.
    message(V_WARNING, _("Try `%s --help' for more information."),
            progname);
    return;
}

References _, message(), progname, and V_WARNING.

Referenced by main(), and parse_real().

message_verbosity_decrease()

void message_verbosity_decrease

(

void

)

Decrease verbosity level by one step unless it was at minimum.

Definition at line 171 of file message.c.

{
    if (verbosity > V_SILENT)
        --verbosity;
 
    return;
}

References V_SILENT, and verbosity.

Referenced by parse_real().

message_verbosity_get()

enum message_verbosity message_verbosity_get

(

void

)

Get the current verbosity level.

Definition at line 171 of file message.c.

{
    return verbosity;
}

Referenced by hardware_memlimit_show(), list_file(), list_totals(), main(), print_info_adv(), print_info_robot(), print_totals_adv(), and print_totals_robot().

message_verbosity_increase()

void message_verbosity_increase

(

void

)

Increase verbosity level by one step unless it was at maximum.

Definition at line 161 of file message.c.

{
    if (verbosity < V_DEBUG)
        ++verbosity;
 
    return;
}

References V_DEBUG, and verbosity.

Referenced by parse_real().

message_version()

void message_version

(

void

)

Prints the version number to stdout and exits with exit status SUCCESS.

Definition at line 1074 of file message.c.

{
    // It is possible that liblzma version is different than the command
    // line tool version, so print both.
    if (opt_robot) {
        printf("XZ_VERSION=%" PRIu32 "\nLIBLZMA_VERSION=%" PRIu32 "\n",
                LZMA_VERSION, lzma_version_number());
    } else {
        printf("xz (" PACKAGE_NAME ") " LZMA_VERSION_STRING "\n");
        printf("liblzma %s\n", lzma_version_string());
    }
 
    tuklib_exit(E_SUCCESS, E_ERROR, verbosity != V_SILENT);
}

References E_ERROR, E_SUCCESS, LZMA_VERSION, LZMA_VERSION_STRING, opt_robot, PACKAGE_NAME, printf(), PRIu32, tuklib_exit, V_SILENT, and verbosity.

Referenced by parse_real().

message_warning()

void message_warning	(	const char *	fmt,
			...
	)

Definition at line 751 of file message.c.

{
    va_list ap;
    va_start(ap, fmt);
    vmessage(V_WARNING, fmt, ap);
    va_end(ap);
 
    set_exit_status(E_WARNING);
    return;
}

References E_WARNING, set_exit_status(), V_WARNING, and vmessage().

Referenced by coder_normal(), io_copy_attrs(), io_open_src_real(), msg_suffix(), and uncompressed_name().

print_filename()

static void print_filename ( void  )

static

Prints the name of the current file if it hasn't been printed already, except if we are processing exactly one stream from stdin to stdout. I think it looks nicer to not print "(stdin)" when –verbose is used in a pipe and no other files are processed.

Definition at line 200 of file message.c.

{
    if (!opt_robot && (files_total != 1 || filename != stdin_filename)) {
        signals_block();
 
        FILE *file = opt_mode == MODE_LIST ? stdout : stderr;
 
        // If a file was already processed, put an empty line
        // before the next filename to improve readability.
        if (first_filename_printed)
            fputc('\n', file);
 
        first_filename_printed = true;
        current_filename_printed = true;
 
        // If we don't know how many files there will be due
        // to usage of --files or --files0.
        if (files_total == 0)
            fprintf(file, "%s (%u)\n", filename,
                    files_pos);
        else
            fprintf(file, "%s (%u/%u)\n", filename,
                    files_pos, files_total);
 
        signals_unblock();
    }
 
    return;
}

References current_filename_printed, benchmark::FILE, files_pos, files_total, first_filename_printed, MODE_LIST, opt_mode, opt_robot, signals_block(), signals_unblock(), and stdin_filename.

Referenced by message_filename(), and message_progress_update().

progress_flush()

static void progress_flush ( bool  finished )

static

Definition at line 629 of file message.c.

{
    if (!progress_started || verbosity < V_VERBOSE)
        return;
 
    uint64_t in_pos;
    uint64_t compressed_pos;
    uint64_t uncompressed_pos;
    progress_pos(&in_pos, &compressed_pos, &uncompressed_pos);
 
    // Avoid printing intermediate progress info if some error occurs
    // in the beginning of the stream. (If something goes wrong later in
    // the stream, it is sometimes useful to tell the user where the
    // error approximately occurred, especially if the error occurs
    // after a time-consuming operation.)
    if (!finished && !progress_active
            && (compressed_pos == 0 || uncompressed_pos == 0))
        return;
 
    progress_active = false;
 
    const uint64_t elapsed = mytime_get_elapsed();
 
    signals_block();
 
    // When using the auto-updating progress indicator, the final
    // statistics are printed in the same format as the progress
    // indicator itself.
    if (progress_automatic) {
        const char *cols[5] = {
            finished ? "100 %" : progress_percentage(in_pos),
            progress_sizes(compressed_pos, uncompressed_pos, true),
            progress_speed(uncompressed_pos, elapsed),
            progress_time(elapsed),
            finished ? "" : progress_remaining(in_pos, elapsed),
        };
        fprintf(stderr, "\r %*s %*s   %*s %10s   %10s\n",
                tuklib_mbstr_fw(cols[0], 6), cols[0],
                tuklib_mbstr_fw(cols[1], 35), cols[1],
                tuklib_mbstr_fw(cols[2], 9), cols[2],
                cols[3],
                cols[4]);
    } else {
        // The filename is always printed.
        fprintf(stderr, "%s: ", filename);
 
        // Percentage is printed only if we didn't finish yet.
        if (!finished) {
            // Don't print the percentage when it isn't known
            // (starts with a dash).
            const char *percentage = progress_percentage(in_pos);
            if (percentage[0] != '-')
                fprintf(stderr, "%s, ", percentage);
        }
 
        // Size information is always printed.
        fprintf(stderr, "%s", progress_sizes(
                compressed_pos, uncompressed_pos, true));
 
        // The speed and elapsed time aren't always shown.
        const char *speed = progress_speed(uncompressed_pos, elapsed);
        if (speed[0] != '\0')
            fprintf(stderr, ", %s", speed);
 
        const char *elapsed_str = progress_time(elapsed);
        if (elapsed_str[0] != '\0')
            fprintf(stderr, ", %s", elapsed_str);
 
        fputc('\n', stderr);
    }
 
    signals_unblock();
 
    return;
}

References in_pos, mytime_get_elapsed(), percentage, progress_active, progress_automatic, progress_percentage(), progress_pos(), progress_remaining(), progress_sizes(), progress_speed(), progress_started, progress_time(), signals_block(), signals_unblock(), tuklib_mbstr_fw, V_VERBOSE, and verbosity.

Referenced by message_progress_end(), and vmessage().

progress_percentage()

static const char* progress_percentage ( uint64_t  in_pos )

static

Make the string indicating completion percentage.

Definition at line 291 of file message.c.

{
    // If the size of the input file is unknown or the size told us is
    // clearly wrong since we have processed more data than the alleged
    // size of the file, show a static string indicating that we have
    // no idea of the completion percentage.
    if (expected_in_size == 0 || in_pos > expected_in_size)
        return "--- %";
 
    // Never show 100.0 % before we actually are finished.
    double percentage = (double)(in_pos) / (double)(expected_in_size)
            * 99.9;
 
    // Use big enough buffer to hold e.g. a multibyte decimal point.
    static char buf[16];
    snprintf(buf, sizeof(buf), "%.1f %%", percentage);
 
    return buf;
}

References expected_in_size, in_pos, percentage, and snprintf.

Referenced by message_progress_update(), and progress_flush().

progress_pos()

static void progress_pos ( uint64_t *  in_pos, uint64_t *  compressed_pos, uint64_t *  uncompressed_pos  )

static

Get how much uncompressed and compressed data has been processed.

Definition at line 512 of file message.c.

{
    uint64_t out_pos;
    if (progress_is_from_passthru) {
        // In passthru mode the progress info is in total_in/out but
        // the *progress_strm itself isn't initialized and thus we
        // cannot use lzma_get_progress().
        *in_pos = progress_strm->total_in;
        out_pos = progress_strm->total_out;
    } else {
        lzma_get_progress(progress_strm, in_pos, &out_pos);
    }
 
    // It cannot have processed more input than it has been given.
    assert(*in_pos <= progress_strm->total_in);
 
    // It cannot have produced more output than it claims to have ready.
    assert(out_pos >= progress_strm->total_out);
 
    if (opt_mode == MODE_COMPRESS) {
        *compressed_pos = out_pos;
        *uncompressed_pos = *in_pos;
    } else {
        *compressed_pos = *in_pos;
        *uncompressed_pos = out_pos;
    }
 
    return;
}

References assert(), in_pos, MODE_COMPRESS, opt_mode, out_pos, progress_is_from_passthru, progress_strm, lzma_stream::total_in, and lzma_stream::total_out.

Referenced by message_progress_update(), and progress_flush().

progress_remaining()

static const char* progress_remaining ( uint64_t  in_pos, uint64_t  elapsed  )

static

Return a string containing estimated remaining time when reasonably possible.

Definition at line 426 of file message.c.

{
    // Don't show the estimated remaining time when it wouldn't
    // make sense:
    //  - Input size is unknown.
    //  - Input has grown bigger since we started (de)compressing.
    //  - We haven't processed much data yet, so estimate would be
    //    too inaccurate.
    //  - Only a few seconds has passed since we started (de)compressing,
    //    so estimate would be too inaccurate.
    if (expected_in_size == 0 || in_pos > expected_in_size
            || in_pos < (UINT64_C(1) << 19) || elapsed < 8000)
        return "";
 
    // Calculate the estimate. Don't give an estimate of zero seconds,
    // since it is possible that all the input has been already passed
    // to the library, but there is still quite a bit of output pending.
    uint32_t remaining = (uint32_t)((double)(expected_in_size - in_pos)
            * ((double)(elapsed) / 1000.0) / (double)(in_pos));
    if (remaining < 1)
        remaining = 1;
 
    static char buf[sizeof("9 h 55 min")];
 
    // Select appropriate precision for the estimated remaining time.
    if (remaining <= 10) {
        // A maximum of 10 seconds remaining.
        // Show the number of seconds as is.
        snprintf(buf, sizeof(buf), "%" PRIu32 " s", remaining);
 
    } else if (remaining <= 50) {
        // A maximum of 50 seconds remaining.
        // Round up to the next multiple of five seconds.
        remaining = (remaining + 4) / 5 * 5;
        snprintf(buf, sizeof(buf), "%" PRIu32 " s", remaining);
 
    } else if (remaining <= 590) {
        // A maximum of 9 minutes and 50 seconds remaining.
        // Round up to the next multiple of ten seconds.
        remaining = (remaining + 9) / 10 * 10;
        snprintf(buf, sizeof(buf), "%" PRIu32 " min %" PRIu32 " s",
                remaining / 60, remaining % 60);
 
    } else if (remaining <= 59 * 60) {
        // A maximum of 59 minutes remaining.
        // Round up to the next multiple of a minute.
        remaining = (remaining + 59) / 60;
        snprintf(buf, sizeof(buf), "%" PRIu32 " min", remaining);
 
    } else if (remaining <= 9 * 3600 + 50 * 60) {
        // A maximum of 9 hours and 50 minutes left.
        // Round up to the next multiple of ten minutes.
        remaining = (remaining + 599) / 600 * 10;
        snprintf(buf, sizeof(buf), "%" PRIu32 " h %" PRIu32 " min",
                remaining / 60, remaining % 60);
 
    } else if (remaining <= 23 * 3600) {
        // A maximum of 23 hours remaining.
        // Round up to the next multiple of an hour.
        remaining = (remaining + 3599) / 3600;
        snprintf(buf, sizeof(buf), "%" PRIu32 " h", remaining);
 
    } else if (remaining <= 9 * 24 * 3600 + 23 * 3600) {
        // A maximum of 9 days and 23 hours remaining.
        // Round up to the next multiple of an hour.
        remaining = (remaining + 3599) / 3600;
        snprintf(buf, sizeof(buf), "%" PRIu32 " d %" PRIu32 " h",
                remaining / 24, remaining % 24);
 
    } else if (remaining <= 999 * 24 * 3600) {
        // A maximum of 999 days remaining. ;-)
        // Round up to the next multiple of a day.
        remaining = (remaining + 24 * 3600 - 1) / (24 * 3600);
        snprintf(buf, sizeof(buf), "%" PRIu32 " d", remaining);
 
    } else {
        // The estimated remaining time is too big. Don't show it.
        return "";
    }
 
    return buf;
}

References expected_in_size, in_pos, PRIu32, snprintf, and UINT64_C.

Referenced by message_progress_update(), and progress_flush().

progress_sizes()

static const char* progress_sizes ( uint64_t  compressed_pos, uint64_t  uncompressed_pos, bool  final  )

static

Make the string containing the amount of input processed, amount of output produced, and the compression ratio.

Definition at line 315 of file message.c.

{
    // Use big enough buffer to hold e.g. a multibyte thousand separators.
    static char buf[128];
    char *pos = buf;
    size_t left = sizeof(buf);
 
    // Print the sizes. If this the final message, use more reasonable
    // units than MiB if the file was small.
    const enum nicestr_unit unit_min = final ? NICESTR_B : NICESTR_MIB;
    my_snprintf(&pos, &left, "%s / %s",
            uint64_to_nicestr(compressed_pos,
                unit_min, NICESTR_TIB, false, 0),
            uint64_to_nicestr(uncompressed_pos,
                unit_min, NICESTR_TIB, false, 1));
 
    // Avoid division by zero. If we cannot calculate the ratio, set
    // it to some nice number greater than 10.0 so that it gets caught
    // in the next if-clause.
    const double ratio = uncompressed_pos > 0
            ? (double)(compressed_pos) / (double)(uncompressed_pos)
            : 16.0;
 
    // If the ratio is very bad, just indicate that it is greater than
    // 9.999. This way the length of the ratio field stays fixed.
    if (ratio > 9.999)
        snprintf(pos, left, " > %.3f", 9.999);
    else
        snprintf(pos, left, " = %.3f", ratio);
 
    return buf;
}

References my_snprintf(), NICESTR_B, NICESTR_MIB, NICESTR_TIB, pos, snprintf, and uint64_to_nicestr().

Referenced by message_progress_update(), and progress_flush().

progress_speed()

static const char* progress_speed ( uint64_t  uncompressed_pos, uint64_t  elapsed  )

static

Make the string containing the processing speed of uncompressed data.

Definition at line 351 of file message.c.

{
    // Don't print the speed immediately, since the early values look
    // somewhat random.
    if (elapsed < 3000)
        return "";
 
    static const char unit[][8] = {
        "KiB/s",
        "MiB/s",
        "GiB/s",
    };
 
    size_t unit_index = 0;
 
    // Calculate the speed as KiB/s.
    double speed = (double)(uncompressed_pos)
            / ((double)(elapsed) * (1024.0 / 1000.0));
 
    // Adjust the unit of the speed if needed.
    while (speed > 999.0) {
        speed /= 1024.0;
        if (++unit_index == ARRAY_SIZE(unit))
            return ""; // Way too fast ;-)
    }
 
    // Use decimal point only if the number is small. Examples:
    //  - 0.1 KiB/s
    //  - 9.9 KiB/s
    //  - 99 KiB/s
    //  - 999 KiB/s
    // Use big enough buffer to hold e.g. a multibyte decimal point.
    static char buf[16];
    snprintf(buf, sizeof(buf), "%.*f %s",
            speed > 9.9 ? 0 : 1, speed, unit[unit_index]);
    return buf;
}

References ARRAY_SIZE, and snprintf.

Referenced by message_progress_update(), and progress_flush().

progress_time()

static const char* progress_time ( uint64_t  mseconds )

static

Make a string indicating elapsed time. The format is either M:SS or H:MM:SS depending on if the time is an hour or more.

Definition at line 393 of file message.c.

{
    // 9999 hours = 416 days
    static char buf[sizeof("9999:59:59")];
 
    // 32-bit variable is enough for elapsed time (136 years).
    uint32_t seconds = (uint32_t)(mseconds / 1000);
 
    // Don't show anything if the time is zero or ridiculously big.
    if (seconds == 0 || seconds > ((9999 * 60) + 59) * 60 + 59)
        return "";
 
    uint32_t minutes = seconds / 60;
    seconds %= 60;
 
    if (minutes >= 60) {
        const uint32_t hours = minutes / 60;
        minutes %= 60;
        snprintf(buf, sizeof(buf),
                "%" PRIu32 ":%02" PRIu32 ":%02" PRIu32,
                hours, minutes, seconds);
    } else {
        snprintf(buf, sizeof(buf), "%" PRIu32 ":%02" PRIu32,
                minutes, seconds);
    }
 
    return buf;
}

References PRIu32, and snprintf.

Referenced by message_progress_update(), and progress_flush().

uint32_to_optstr()

static const char* uint32_to_optstr ( uint32_t  num )

static

Convert uint32_t to a nice string for –lzma[12]=dict=SIZE.

The idea is to use KiB or MiB suffix when possible.

Definition at line 901 of file message.c.

{
    static char buf[16];
 
    if ((num & ((UINT32_C(1) << 20) - 1)) == 0)
        snprintf(buf, sizeof(buf), "%" PRIu32 "MiB", num >> 20);
    else if ((num & ((UINT32_C(1) << 10) - 1)) == 0)
        snprintf(buf, sizeof(buf), "%" PRIu32 "KiB", num >> 10);
    else
        snprintf(buf, sizeof(buf), "%" PRIu32, num);
 
    return buf;
}

References num, PRIu32, snprintf, and UINT32_C.

Referenced by message_filters_to_str().

vmessage()

static void vmessage ( enum message_verbosity  v, const char *  fmt, va_list  ap  )

static

Definition at line 717 of file message.c.

{
    if (v <= verbosity) {
        signals_block();
 
        progress_flush(false);
 
        // TRANSLATORS: This is the program name in the beginning
        // of the line in messages. Usually it becomes "xz: ".
        // This is a translatable string because French needs
        // a space before a colon.
        fprintf(stderr, _("%s: "), progname);
        vfprintf(stderr, fmt, ap);
        fputc('\n', stderr);
 
        signals_unblock();
    }
 
    return;
}

References _, progname, progress_flush(), signals_block(), signals_unblock(), v, and verbosity.

Referenced by message(), message_error(), message_fatal(), and message_warning().

Variable Documentation

current_filename_printed

bool current_filename_printed = false

static

This is set to true when we have printed the current filename to stderr as part of a progress message. This variable is useful only if not updating progress automatically: if user sends many SIGINFO, SIGUSR1, or SIGALRM signals, we won't print the name of the same file multiple times.

Definition at line 41 of file message.c.

Referenced by message_filename(), message_progress_update(), and print_filename().

expected_in_size

uint64_t expected_in_size

static

Expected size of the input stream is needed to show completion percentage and estimate remaining time.

Definition at line 66 of file message.c.

Referenced by message_progress_start(), progress_percentage(), and progress_remaining().

filename

const char* filename

static

Filename which we will print with the verbose messages.

Definition at line 28 of file message.c.

files_pos

unsigned int files_pos = 0

static

Number of the current file.

Definition at line 19 of file message.c.

Referenced by message_filename(), and print_filename().

files_total

unsigned int files_total

static

Total number of input files; zero if unknown.

Definition at line 22 of file message.c.

Referenced by message_set_files(), and print_filename().

first_filename_printed

bool first_filename_printed = false

static

True once the a filename has been printed to stderr as part of progress message. If automatic progress updating isn't enabled, this becomes true after the first progress message has been printed due to user sending SIGINFO, SIGUSR1, or SIGALRM. Once this variable is true, we will print an empty line before the next filename to make the output more readable.

Definition at line 35 of file message.c.

Referenced by print_filename().

progress_active

bool progress_active = false

static

This is true when a progress message was printed and the cursor is still on the same line with the progress message. In that case, a newline has to be printed before any error messages.

Definition at line 54 of file message.c.

Referenced by message_progress_update(), and progress_flush().

progress_automatic

bool progress_automatic

static

True if we should print progress indicator and update it automatically if also verbose >= V_VERBOSE.

Definition at line 45 of file message.c.

Referenced by message_filename(), message_init(), message_progress_start(), message_progress_update(), and progress_flush().

progress_is_from_passthru

bool progress_is_from_passthru

static

This is true if we are in passthru mode (not actually compressing or decompressing) and thus cannot use lzma_get_progress(progress_strm, ...). That is, we are using coder_passthru() in coder.c.

Definition at line 62 of file message.c.

Referenced by message_progress_start(), and progress_pos().

progress_needs_updating

bool progress_needs_updating = false

static

This is true when progress message printing is wanted. Using the same variable name as above to avoid some ifdefs.

Definition at line 105 of file message.c.

Referenced by message_progress_start(), and message_progress_update().

progress_next_update

uint64_t progress_next_update

static

Elapsed time when the next progress message update should be done.

Definition at line 108 of file message.c.

Referenced by message_progress_start(), and message_progress_update().

progress_started

bool progress_started = false

static

True if message_progress_start() has been called but message_progress_end() hasn't been called yet.

Definition at line 49 of file message.c.

Referenced by message_progress_end(), message_progress_start(), and progress_flush().

progress_strm

lzma_stream* progress_strm

static

Pointer to lzma_stream used to do the encoding or decoding.

Definition at line 57 of file message.c.

Referenced by message_progress_start(), and progress_pos().

verbosity

enum message_verbosity verbosity = V_WARNING

static

Verbosity level.

Definition at line 22 of file message.c.

Referenced by message_filename(), message_filters_show(), message_help(), message_mem_needed(), message_progress_start(), message_progress_update(), message_verbosity_decrease(), message_verbosity_increase(), message_version(), progress_flush(), and vmessage().