message.h File Reference

Printing messages to stderr. More...

Go to the source code of this file.

Macros
#define	FILTERS_STR_SIZE   512
	Buffer size for message_filters_to_str() More...

Enumerations
enum	message_verbosity {   V_SILENT , V_ERROR , V_WARNING , V_VERBOSE ,   V_DEBUG }
	Verbosity levels. More...

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 (enum message_verbosity verbosity, const char *fmt,...) lzma_attribute((__format__(__printf__
	Print a message if verbosity level is at least "verbosity". More...
void void	message_warning (const char *fmt,...) lzma_attribute((__format__(__printf__
	Prints a warning and possibly sets exit status. More...
void void void	message_error (const char *fmt,...) lzma_attribute((__format__(__printf__
	Prints an error message and sets exit status. More...
void void void void	message_fatal (const char *fmt,...) lzma_attribute((__format__(__printf__
	Prints an error message and exits with EXIT_ERROR. More...
void void void void	lzma_attribute ((__noreturn__))
void	message_bug (void) lzma_attribute((__noreturn__))
void	message_signal_handler (void) lzma_attribute((__noreturn__))
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...
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) lzma_attribute((__noreturn__))
	Prints the version number to stdout and exits with exit status SUCCESS. More...
void	message_help (bool long_help) lzma_attribute((__noreturn__))
	Print the help message. More...
void	message_set_files (unsigned int files)
	Set the total number of files to be processed. More...
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...
void	message_progress_update (void)
void	message_progress_end (bool finished)
	Finishes the progress message if we were in verbose mode. More...

Variables
const int	message_progress_sigs []
	Signals used for progress message handling. More...

Detailed Description

Printing messages to stderr.

Definition in file message.h.

Macro Definition Documentation

FILTERS_STR_SIZE

#define FILTERS_STR_SIZE   512

Buffer size for message_filters_to_str()

Definition at line 94 of file message.h.

Enumeration Type Documentation

message_verbosity

enum message_verbosity

Verbosity levels.

Enumerator
V_SILENT	No messages.
V_ERROR	Only error messages.
V_WARNING	Errors and warnings.
V_VERBOSE	Errors, warnings, and verbose statistics.
V_DEBUG	Very verbose.

Definition at line 14 of file message.h.

                       {
    V_SILENT,   
    V_ERROR,    
    V_WARNING,  
    V_VERBOSE,  
    V_DEBUG,    
};

Function Documentation

lzma_attribute()

static void lzma_attribute

(

(__noreturn__)

)

Definition at line 84 of file xzdec.c.

{
    printf(TOOL_FORMAT "dec (" PACKAGE_NAME ") " LZMA_VERSION_STRING "\n"
            "liblzma %s\n", lzma_version_string());
 
    tuklib_exit(EXIT_SUCCESS, EXIT_FAILURE, display_errors);
}

References display_errors, LZMA_VERSION_STRING, PACKAGE_NAME, printf(), TOOL_FORMAT, and tuklib_exit.

message()

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

Print a message if verbosity level is at least "verbosity".

This doesn't touch the exit status.

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 void void message_error	(	const char *	fmt,
			...
	)

Prints an error message and sets exit status.

The message is printed only if verbosity level is at least V_ERROR. The exit status is set to ERROR.

message_fatal()

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

Prints an error message and exits with EXIT_ERROR.

The message is printed only if verbosity level is at least V_ERROR.

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 void message_warning	(	const char *	fmt,
			...
	)

Prints a warning and possibly sets exit status.

The message is printed only if verbosity level is at least V_WARNING. The exit status is set to WARNING unless it was already at ERROR.

Variable Documentation

message_progress_sigs

const int message_progress_sigs[]

extern

Signals used for progress message handling.

Referenced by message_init(), and signals_init().