node-liblzma 1.0.4 → 1.1.4

package/deps/xz/src/xz/message.h

@@ -1,167 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       message.h
-/// \brief      Printing messages to stderr
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-/// Verbosity levels
-enum message_verbosity {
-	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
-};
-
-
-/// \brief      Signals used for progress message handling
-extern const int message_progress_sigs[];
-
-
-/// \brief      Initializes the message functions
-///
-/// If an error occurs, this function doesn't return.
-///
-extern void message_init(void);
-
-
-/// Increase verbosity level by one step unless it was at maximum.
-extern void message_verbosity_increase(void);
-
-/// Decrease verbosity level by one step unless it was at minimum.
-extern void message_verbosity_decrease(void);
-
-/// Get the current verbosity level.
-extern enum message_verbosity message_verbosity_get(void);
-
-
-/// \brief      Print a message if verbosity level is at least "verbosity"
-///
-/// This doesn't touch the exit status.
-extern void message(enum message_verbosity verbosity, const char *fmt, ...)
-		lzma_attribute((__format__(__printf__, 2, 3)));
-
-
-/// \brief      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.
-extern void message_warning(const char *fmt, ...)
-		lzma_attribute((__format__(__printf__, 1, 2)));
-
-
-/// \brief      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.
-extern void message_error(const char *fmt, ...)
-		lzma_attribute((__format__(__printf__, 1, 2)));
-
-
-/// \brief      Prints an error message and exits with EXIT_ERROR
-///
-/// The message is printed only if verbosity level is at least V_ERROR.
-extern void message_fatal(const char *fmt, ...)
-		lzma_attribute((__format__(__printf__, 1, 2)))
-		lzma_attribute((__noreturn__));
-
-
-/// Print an error message that an internal error occurred and exit with
-/// EXIT_ERROR.
-extern void message_bug(void) lzma_attribute((__noreturn__));
-
-
-/// Print a message that establishing signal handlers failed, and exit with
-/// exit status ERROR.
-extern void message_signal_handler(void) lzma_attribute((__noreturn__));
-
-
-/// Convert lzma_ret to a string.
-extern const char *message_strm(lzma_ret code);
-
-
-/// Display how much memory was needed and how much the limit was.
-extern void message_mem_needed(enum message_verbosity v, uint64_t memusage);
-
-
-/// Buffer size for message_filters_to_str()
-#define FILTERS_STR_SIZE 512
-
-
-/// \brief      Get the filter chain as a string
-///
-/// \param      buf         Pointer to caller allocated buffer to hold
-///                         the filter chain string
-/// \param      filters     Pointer to the filter chain
-/// \param      all_known   If true, all filter options are printed.
-///                         If false, only the options that get stored
-///                         into .xz headers are printed.
-extern void message_filters_to_str(char buf[FILTERS_STR_SIZE],
-		const lzma_filter *filters, bool all_known);
-
-
-/// Print the filter chain.
-extern void message_filters_show(
-		enum message_verbosity v, const lzma_filter *filters);
-
-
-/// Print a message that user should try --help.
-extern void message_try_help(void);
-
-
-/// Prints the version number to stdout and exits with exit status SUCCESS.
-extern void message_version(void) lzma_attribute((__noreturn__));
-
-
-/// Print the help message.
-extern void message_help(bool long_help) lzma_attribute((__noreturn__));
-
-
-/// \brief      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().
-extern void message_set_files(unsigned int files);
-
-
-/// \brief      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.
-extern void message_filename(const char *src_name);
-
-
-/// \brief      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.
-///
-/// \param      strm      Pointer to lzma_stream used for the coding.
-/// \param      in_size   Size of the input file, or zero if unknown.
-///
-extern void message_progress_start(lzma_stream *strm, uint64_t in_size);
-
-
-/// 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.
-extern void message_progress_update(void);
-
-
-/// \brief      Finishes the progress message if we were in verbose mode
-///
-/// \param      finished    True if the whole stream was successfully coded
-///                         and output written to the output stream.
-///
-extern void message_progress_end(bool finished);

package/deps/xz/src/xz/mytime.c

@@ -1,89 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       mytime.c
-/// \brief      Time handling 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"
-
-#if !(defined(HAVE_CLOCK_GETTIME) && HAVE_DECL_CLOCK_MONOTONIC)
-#	include <sys/time.h>
-#endif
-
-uint64_t opt_flush_timeout = 0;
-bool flush_needed;
-
-static uint64_t start_time;
-static uint64_t next_flush;
-
-
-/// \brief      Get the current time as milliseconds
-///
-/// It's relative to some point but not necessarily to the UNIX Epoch.
-static uint64_t
-mytime_now(void)
-{
-	// NOTE: HAVE_DECL_CLOCK_MONOTONIC is always defined to 0 or 1.
-#if defined(HAVE_CLOCK_GETTIME) && HAVE_DECL_CLOCK_MONOTONIC
-	// If CLOCK_MONOTONIC was available at compile time but for some
-	// reason isn't at runtime, fallback to CLOCK_REALTIME which
-	// according to POSIX is mandatory for all implementations.
-	static clockid_t clk_id = CLOCK_MONOTONIC;
-	struct timespec tv;
-	while (clock_gettime(clk_id, &tv))
-		clk_id = CLOCK_REALTIME;
-
-	return (uint64_t)(tv.tv_sec) * UINT64_C(1000) + tv.tv_nsec / 1000000;
-#else
-	struct timeval tv;
-	gettimeofday(&tv, NULL);
-	return (uint64_t)(tv.tv_sec) * UINT64_C(1000) + tv.tv_usec / 1000;
-#endif
-}
-
-
-extern void
-mytime_set_start_time(void)
-{
-	start_time = mytime_now();
-	next_flush = start_time + opt_flush_timeout;
-	flush_needed = false;
-	return;
-}
-
-
-extern uint64_t
-mytime_get_elapsed(void)
-{
-	return mytime_now() - start_time;
-}
-
-
-extern void
-mytime_set_flush_time(void)
-{
-	next_flush = mytime_now() + opt_flush_timeout;
-	flush_needed = false;
-	return;
-}
-
-
-extern int
-mytime_get_flush_timeout(void)
-{
-	if (opt_flush_timeout == 0 || opt_mode != MODE_COMPRESS)
-		return -1;
-
-	const uint64_t now = mytime_now();
-	if (now >= next_flush)
-		return 0;
-
-	const uint64_t remaining = next_flush - now;
-	return remaining > INT_MAX ? INT_MAX : (int)remaining;
-}

package/deps/xz/src/xz/mytime.h

@@ -1,47 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       mytime.h
-/// \brief      Time handling functions
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-
-/// \brief      Number of milliseconds to between LZMA_SYNC_FLUSHes
-///
-/// If 0, timed flushing is disabled. Otherwise if no more input is available
-/// and not at the end of the file and at least opt_flush_timeout milliseconds
-/// has elapsed since the start of compression or the previous flushing
-/// (LZMA_SYNC_FLUSH or LZMA_FULL_FLUSH), set LZMA_SYNC_FLUSH to flush
-/// the pending data.
-extern uint64_t opt_flush_timeout;
-
-
-/// \brief      True when flushing is needed due to expired timeout
-extern bool flush_needed;
-
-
-/// \brief      Store the time when (de)compression was started
-///
-/// The start time is also stored as the time of the first flush.
-extern void mytime_set_start_time(void);
-
-
-/// \brief      Get the number of milliseconds since the operation started
-extern uint64_t mytime_get_elapsed(void);
-
-
-/// \brief      Store the time of when compressor was flushed
-extern void mytime_set_flush_time(void);
-
-
-/// \brief      Get the number of milliseconds until the next flush
-///
-/// This returns -1 if no timed flushing is used.
-///
-/// The return value is inteded for use with poll().
-extern int mytime_get_flush_timeout(void);

package/deps/xz/src/xz/options.c

@@ -1,363 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       options.c
-/// \brief      Parser for filter-specific options
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "private.h"
-
-
-///////////////////
-// Generic stuff //
-///////////////////
-
-typedef struct {
-	const char *name;
-	uint64_t id;
-} name_id_map;
-
-
-typedef struct {
-	const char *name;
-	const name_id_map *map;
-	uint64_t min;
-	uint64_t max;
-} option_map;
-
-
-/// Parses option=value pairs that are separated with commas:
-/// opt=val,opt=val,opt=val
-///
-/// Each option is a string, that is converted to an integer using the
-/// index where the option string is in the array.
-///
-/// Value can be
-///  - a string-id map mapping a list of possible string values to integers
-///    (opts[i].map != NULL, opts[i].min and opts[i].max are ignored);
-///  - a number with minimum and maximum value limit
-///    (opts[i].map == NULL && opts[i].min != UINT64_MAX);
-///  - a string that will be parsed by the filter-specific code
-///    (opts[i].map == NULL && opts[i].min == UINT64_MAX, opts[i].max ignored)
-///
-/// When parsing both option and value succeed, a filter-specific function
-/// is called, which should update the given value to filter-specific
-/// options structure.
-///
-/// \param      str     String containing the options from the command line
-/// \param      opts    Filter-specific option map
-/// \param      set     Filter-specific function to update filter_options
-/// \param      filter_options  Pointer to filter-specific options structure
-///
-/// \return     Returns only if no errors occur.
-///
-static void
-parse_options(const char *str, const option_map *opts,
-		void (*set)(void *filter_options,
-			unsigned key, uint64_t value, const char *valuestr),
-		void *filter_options)
-{
-	if (str == NULL || str[0] == '\0')
-		return;
-
-	char *s = xstrdup(str);
-	char *name = s;
-
-	while (*name != '\0') {
-		if (*name == ',') {
-			++name;
-			continue;
-		}
-
-		char *split = strchr(name, ',');
-		if (split != NULL)
-			*split = '\0';
-
-		char *value = strchr(name, '=');
-		if (value != NULL)
-			*value++ = '\0';
-
-		if (value == NULL || value[0] == '\0')
-			message_fatal(_("%s: Options must be `name=value' "
-					"pairs separated with commas"), str);
-
-		// Look for the option name from the option map.
-		unsigned i = 0;
-		while (true) {
-			if (opts[i].name == NULL)
-				message_fatal(_("%s: Invalid option name"),
-						name);
-
-			if (strcmp(name, opts[i].name) == 0)
-				break;
-
-			++i;
-		}
-
-		// Option was found from the map. See how we should handle it.
-		if (opts[i].map != NULL) {
-			// value is a string which we should map
-			// to an integer.
-			unsigned j;
-			for (j = 0; opts[i].map[j].name != NULL; ++j) {
-				if (strcmp(opts[i].map[j].name, value) == 0)
-					break;
-			}
-
-			if (opts[i].map[j].name == NULL)
-				message_fatal(_("%s: Invalid option value"),
-						value);
-
-			set(filter_options, i, opts[i].map[j].id, value);
-
-		} else if (opts[i].min == UINT64_MAX) {
-			// value is a special string that will be
-			// parsed by set().
-			set(filter_options, i, 0, value);
-
-		} else {
-			// value is an integer.
-			const uint64_t v = str_to_uint64(name, value,
-					opts[i].min, opts[i].max);
-			set(filter_options, i, v, value);
-		}
-
-		// Check if it was the last option.
-		if (split == NULL)
-			break;
-
-		name = split + 1;
-	}
-
-	free(s);
-	return;
-}
-
-
-///////////
-// Delta //
-///////////
-
-enum {
-	OPT_DIST,
-};
-
-
-static void
-set_delta(void *options, unsigned key, uint64_t value,
-		const char *valuestr lzma_attribute((__unused__)))
-{
-	lzma_options_delta *opt = options;
-	switch (key) {
-	case OPT_DIST:
-		opt->dist = value;
-		break;
-	}
-}
-
-
-extern lzma_options_delta *
-options_delta(const char *str)
-{
-	static const option_map opts[] = {
-		{ "dist",     NULL,  LZMA_DELTA_DIST_MIN,
-		                     LZMA_DELTA_DIST_MAX },
-		{ NULL,       NULL,  0, 0 }
-	};
-
-	lzma_options_delta *options = xmalloc(sizeof(lzma_options_delta));
-	*options = (lzma_options_delta){
-		// It's hard to give a useful default for this.
-		.type = LZMA_DELTA_TYPE_BYTE,
-		.dist = LZMA_DELTA_DIST_MIN,
-	};
-
-	parse_options(str, opts, &set_delta, options);
-
-	return options;
-}
-
-
-/////////
-// BCJ //
-/////////
-
-enum {
-	OPT_START_OFFSET,
-};
-
-
-static void
-set_bcj(void *options, unsigned key, uint64_t value,
-		const char *valuestr lzma_attribute((__unused__)))
-{
-	lzma_options_bcj *opt = options;
-	switch (key) {
-	case OPT_START_OFFSET:
-		opt->start_offset = value;
-		break;
-	}
-}
-
-
-extern lzma_options_bcj *
-options_bcj(const char *str)
-{
-	static const option_map opts[] = {
-		{ "start",    NULL,  0, UINT32_MAX },
-		{ NULL,       NULL,  0, 0 }
-	};
-
-	lzma_options_bcj *options = xmalloc(sizeof(lzma_options_bcj));
-	*options = (lzma_options_bcj){
-		.start_offset = 0,
-	};
-
-	parse_options(str, opts, &set_bcj, options);
-
-	return options;
-}
-
-
-//////////
-// LZMA //
-//////////
-
-enum {
-	OPT_PRESET,
-	OPT_DICT,
-	OPT_LC,
-	OPT_LP,
-	OPT_PB,
-	OPT_MODE,
-	OPT_NICE,
-	OPT_MF,
-	OPT_DEPTH,
-};
-
-
-static void lzma_attribute((__noreturn__))
-error_lzma_preset(const char *valuestr)
-{
-	message_fatal(_("Unsupported LZMA1/LZMA2 preset: %s"), valuestr);
-}
-
-
-static void
-set_lzma(void *options, unsigned key, uint64_t value, const char *valuestr)
-{
-	lzma_options_lzma *opt = options;
-
-	switch (key) {
-	case OPT_PRESET: {
-		if (valuestr[0] < '0' || valuestr[0] > '9')
-			error_lzma_preset(valuestr);
-
-		uint32_t preset = valuestr[0] - '0';
-
-		// Currently only "e" is supported as a modifier,
-		// so keep this simple for now.
-		if (valuestr[1] != '\0') {
-			if (valuestr[1] == 'e')
-				preset |= LZMA_PRESET_EXTREME;
-			else
-				error_lzma_preset(valuestr);
-
-			if (valuestr[2] != '\0')
-				error_lzma_preset(valuestr);
-		}
-
-		if (lzma_lzma_preset(options, preset))
-			error_lzma_preset(valuestr);
-
-		break;
-	}
-
-	case OPT_DICT:
-		opt->dict_size = value;
-		break;
-
-	case OPT_LC:
-		opt->lc = value;
-		break;
-
-	case OPT_LP:
-		opt->lp = value;
-		break;
-
-	case OPT_PB:
-		opt->pb = value;
-		break;
-
-	case OPT_MODE:
-		opt->mode = value;
-		break;
-
-	case OPT_NICE:
-		opt->nice_len = value;
-		break;
-
-	case OPT_MF:
-		opt->mf = value;
-		break;
-
-	case OPT_DEPTH:
-		opt->depth = value;
-		break;
-	}
-}
-
-
-extern lzma_options_lzma *
-options_lzma(const char *str)
-{
-	static const name_id_map modes[] = {
-		{ "fast",   LZMA_MODE_FAST },
-		{ "normal", LZMA_MODE_NORMAL },
-		{ NULL,     0 }
-	};
-
-	static const name_id_map mfs[] = {
-		{ "hc3", LZMA_MF_HC3 },
-		{ "hc4", LZMA_MF_HC4 },
-		{ "bt2", LZMA_MF_BT2 },
-		{ "bt3", LZMA_MF_BT3 },
-		{ "bt4", LZMA_MF_BT4 },
-		{ NULL,  0 }
-	};
-
-	static const option_map opts[] = {
-		{ "preset", NULL,   UINT64_MAX, 0 },
-		{ "dict",   NULL,   LZMA_DICT_SIZE_MIN,
-				(UINT32_C(1) << 30) + (UINT32_C(1) << 29) },
-		{ "lc",     NULL,   LZMA_LCLP_MIN, LZMA_LCLP_MAX },
-		{ "lp",     NULL,   LZMA_LCLP_MIN, LZMA_LCLP_MAX },
-		{ "pb",     NULL,   LZMA_PB_MIN, LZMA_PB_MAX },
-		{ "mode",   modes,  0, 0 },
-		{ "nice",   NULL,   2, 273 },
-		{ "mf",     mfs,    0, 0 },
-		{ "depth",  NULL,   0, UINT32_MAX },
-		{ NULL,     NULL,   0, 0 }
-	};
-
-	lzma_options_lzma *options = xmalloc(sizeof(lzma_options_lzma));
-	if (lzma_lzma_preset(options, LZMA_PRESET_DEFAULT))
-		message_bug();
-
-	parse_options(str, opts, &set_lzma, options);
-
-	if (options->lc + options->lp > LZMA_LCLP_MAX)
-		message_fatal(_("The sum of lc and lp must not exceed 4"));
-
-	const uint32_t nice_len_min = options->mf & 0x0F;
-	if (options->nice_len < nice_len_min)
-		message_fatal(_("The selected match finder requires at "
-				"least nice=%" PRIu32), nice_len_min);
-
-	return options;
-}

package/deps/xz/src/xz/options.h

@@ -1,31 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       options.h
-/// \brief      Parser for filter-specific options
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-/// \brief      Parser for Delta options
-///
-/// \return     Pointer to allocated options structure.
-///             Doesn't return on error.
-extern lzma_options_delta *options_delta(const char *str);
-
-
-/// \brief      Parser for BCJ options
-///
-/// \return     Pointer to allocated options structure.
-///             Doesn't return on error.
-extern lzma_options_bcj *options_bcj(const char *str);
-
-
-/// \brief      Parser for LZMA options
-///
-/// \return     Pointer to allocated options structure.
-///             Doesn't return on error.
-extern lzma_options_lzma *options_lzma(const char *str);