node-liblzma 1.0.4 → 1.1.6

package/deps/xz/src/liblzma/common/common.h

@@ -1,318 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       common.h
-/// \brief      Definitions common to the whole liblzma library
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef LZMA_COMMON_H
-#define LZMA_COMMON_H
-
-#include "sysdefs.h"
-#include "mythread.h"
-#include "tuklib_integer.h"
-
-#if defined(_WIN32) || defined(__CYGWIN__)
-#	ifdef DLL_EXPORT
-#		define LZMA_API_EXPORT __declspec(dllexport)
-#	else
-#		define LZMA_API_EXPORT
-#	endif
-// Don't use ifdef or defined() below.
-#elif HAVE_VISIBILITY
-#	define LZMA_API_EXPORT __attribute__((__visibility__("default")))
-#else
-#	define LZMA_API_EXPORT
-#endif
-
-#define LZMA_API(type) LZMA_API_EXPORT type LZMA_API_CALL
-
-#include "lzma.h"
-
-// These allow helping the compiler in some often-executed branches, whose
-// result is almost always the same.
-#ifdef __GNUC__
-#	define likely(expr) __builtin_expect(expr, true)
-#	define unlikely(expr) __builtin_expect(expr, false)
-#else
-#	define likely(expr) (expr)
-#	define unlikely(expr) (expr)
-#endif
-
-
-/// Size of temporary buffers needed in some filters
-#define LZMA_BUFFER_SIZE 4096
-
-
-/// Maximum number of worker threads within one multithreaded component.
-/// The limit exists solely to make it simpler to prevent integer overflows
-/// when allocating structures etc. This should be big enough for now...
-/// the code won't scale anywhere close to this number anyway.
-#define LZMA_THREADS_MAX 16384
-
-
-/// Starting value for memory usage estimates. Instead of calculating size
-/// of _every_ structure and taking into account malloc() overhead etc., we
-/// add a base size to all memory usage estimates. It's not very accurate
-/// but should be easily good enough.
-#define LZMA_MEMUSAGE_BASE (UINT64_C(1) << 15)
-
-/// Start of internal Filter ID space. These IDs must never be used
-/// in Streams.
-#define LZMA_FILTER_RESERVED_START (LZMA_VLI_C(1) << 62)
-
-
-/// Supported flags that can be passed to lzma_stream_decoder()
-/// or lzma_auto_decoder().
-#define LZMA_SUPPORTED_FLAGS \
-	( LZMA_TELL_NO_CHECK \
-	| LZMA_TELL_UNSUPPORTED_CHECK \
-	| LZMA_TELL_ANY_CHECK \
-	| LZMA_IGNORE_CHECK \
-	| LZMA_CONCATENATED )
-
-
-/// Largest valid lzma_action value as unsigned integer.
-#define LZMA_ACTION_MAX ((unsigned int)(LZMA_FULL_BARRIER))
-
-
-/// Special return value (lzma_ret) to indicate that a timeout was reached
-/// and lzma_code() must not return LZMA_BUF_ERROR. This is converted to
-/// LZMA_OK in lzma_code(). This is not in the lzma_ret enumeration because
-/// there's no need to have it in the public API.
-#define LZMA_TIMED_OUT 32
-
-
-/// Type of encoder/decoder specific data; the actual structure is defined
-/// differently in different coders.
-typedef struct lzma_coder_s lzma_coder;
-
-typedef struct lzma_next_coder_s lzma_next_coder;
-
-typedef struct lzma_filter_info_s lzma_filter_info;
-
-
-/// Type of a function used to initialize a filter encoder or decoder
-typedef lzma_ret (*lzma_init_function)(
-		lzma_next_coder *next, const lzma_allocator *allocator,
-		const lzma_filter_info *filters);
-
-/// Type of a function to do some kind of coding work (filters, Stream,
-/// Block encoders/decoders etc.). Some special coders use don't use both
-/// input and output buffers, but for simplicity they still use this same
-/// function prototype.
-typedef lzma_ret (*lzma_code_function)(
-		lzma_coder *coder, const lzma_allocator *allocator,
-		const uint8_t *restrict in, size_t *restrict in_pos,
-		size_t in_size, uint8_t *restrict out,
-		size_t *restrict out_pos, size_t out_size,
-		lzma_action action);
-
-/// Type of a function to free the memory allocated for the coder
-typedef void (*lzma_end_function)(
-		lzma_coder *coder, const lzma_allocator *allocator);
-
-
-/// Raw coder validates and converts an array of lzma_filter structures to
-/// an array of lzma_filter_info structures. This array is used with
-/// lzma_next_filter_init to initialize the filter chain.
-struct lzma_filter_info_s {
-	/// Filter ID. This is used only by the encoder
-	/// with lzma_filters_update().
-	lzma_vli id;
-
-	/// Pointer to function used to initialize the filter.
-	/// This is NULL to indicate end of array.
-	lzma_init_function init;
-
-	/// Pointer to filter's options structure
-	void *options;
-};
-
-
-/// Hold data and function pointers of the next filter in the chain.
-struct lzma_next_coder_s {
-	/// Pointer to coder-specific data
-	lzma_coder *coder;
-
-	/// Filter ID. This is LZMA_VLI_UNKNOWN when this structure doesn't
-	/// point to a filter coder.
-	lzma_vli id;
-
-	/// "Pointer" to init function. This is never called here.
-	/// We need only to detect if we are initializing a coder
-	/// that was allocated earlier. See lzma_next_coder_init and
-	/// lzma_next_strm_init macros in this file.
-	uintptr_t init;
-
-	/// Pointer to function to do the actual coding
-	lzma_code_function code;
-
-	/// Pointer to function to free lzma_next_coder.coder. This can
-	/// be NULL; in that case, lzma_free is called to free
-	/// lzma_next_coder.coder.
-	lzma_end_function end;
-
-	/// Pointer to a function to get progress information. If this is NULL,
-	/// lzma_stream.total_in and .total_out are used instead.
-	void (*get_progress)(lzma_coder *coder,
-			uint64_t *progress_in, uint64_t *progress_out);
-
-	/// Pointer to function to return the type of the integrity check.
-	/// Most coders won't support this.
-	lzma_check (*get_check)(const lzma_coder *coder);
-
-	/// Pointer to function to get and/or change the memory usage limit.
-	/// If new_memlimit == 0, the limit is not changed.
-	lzma_ret (*memconfig)(lzma_coder *coder, uint64_t *memusage,
-			uint64_t *old_memlimit, uint64_t new_memlimit);
-
-	/// Update the filter-specific options or the whole filter chain
-	/// in the encoder.
-	lzma_ret (*update)(lzma_coder *coder, const lzma_allocator *allocator,
-			const lzma_filter *filters,
-			const lzma_filter *reversed_filters);
-};
-
-
-/// Macro to initialize lzma_next_coder structure
-#define LZMA_NEXT_CODER_INIT \
-	(lzma_next_coder){ \
-		.coder = NULL, \
-		.init = (uintptr_t)(NULL), \
-		.id = LZMA_VLI_UNKNOWN, \
-		.code = NULL, \
-		.end = NULL, \
-		.get_progress = NULL, \
-		.get_check = NULL, \
-		.memconfig = NULL, \
-		.update = NULL, \
-	}
-
-
-/// Internal data for lzma_strm_init, lzma_code, and lzma_end. A pointer to
-/// this is stored in lzma_stream.
-struct lzma_internal_s {
-	/// The actual coder that should do something useful
-	lzma_next_coder next;
-
-	/// Track the state of the coder. This is used to validate arguments
-	/// so that the actual coders can rely on e.g. that LZMA_SYNC_FLUSH
-	/// is used on every call to lzma_code until next.code has returned
-	/// LZMA_STREAM_END.
-	enum {
-		ISEQ_RUN,
-		ISEQ_SYNC_FLUSH,
-		ISEQ_FULL_FLUSH,
-		ISEQ_FINISH,
-		ISEQ_FULL_BARRIER,
-		ISEQ_END,
-		ISEQ_ERROR,
-	} sequence;
-
-	/// A copy of lzma_stream avail_in. This is used to verify that the
-	/// amount of input doesn't change once e.g. LZMA_FINISH has been
-	/// used.
-	size_t avail_in;
-
-	/// Indicates which lzma_action values are allowed by next.code.
-	bool supported_actions[LZMA_ACTION_MAX + 1];
-
-	/// If true, lzma_code will return LZMA_BUF_ERROR if no progress was
-	/// made (no input consumed and no output produced by next.code).
-	bool allow_buf_error;
-};
-
-
-/// Allocates memory
-extern void *lzma_alloc(size_t size, const lzma_allocator *allocator)
-		lzma_attribute((__malloc__)) lzma_attr_alloc_size(1);
-
-/// Allocates memory and zeroes it (like calloc()). This can be faster
-/// than lzma_alloc() + memzero() while being backward compatible with
-/// custom allocators.
-extern void * lzma_attribute((__malloc__)) lzma_attr_alloc_size(1)
-		lzma_alloc_zero(size_t size, const lzma_allocator *allocator);
-
-/// Frees memory
-extern void lzma_free(void *ptr, const lzma_allocator *allocator);
-
-
-/// Allocates strm->internal if it is NULL, and initializes *strm and
-/// strm->internal. This function is only called via lzma_next_strm_init macro.
-extern lzma_ret lzma_strm_init(lzma_stream *strm);
-
-/// Initializes the next filter in the chain, if any. This takes care of
-/// freeing the memory of previously initialized filter if it is different
-/// than the filter being initialized now. This way the actual filter
-/// initialization functions don't need to use lzma_next_coder_init macro.
-extern lzma_ret lzma_next_filter_init(lzma_next_coder *next,
-		const lzma_allocator *allocator,
-		const lzma_filter_info *filters);
-
-/// Update the next filter in the chain, if any. This checks that
-/// the application is not trying to change the Filter IDs.
-extern lzma_ret lzma_next_filter_update(
-		lzma_next_coder *next, const lzma_allocator *allocator,
-		const lzma_filter *reversed_filters);
-
-/// Frees the memory allocated for next->coder either using next->end or,
-/// if next->end is NULL, using lzma_free.
-extern void lzma_next_end(lzma_next_coder *next,
-		const lzma_allocator *allocator);
-
-
-/// Copy as much data as possible from in[] to out[] and update *in_pos
-/// and *out_pos accordingly. Returns the number of bytes copied.
-extern size_t lzma_bufcpy(const uint8_t *restrict in, size_t *restrict in_pos,
-		size_t in_size, uint8_t *restrict out,
-		size_t *restrict out_pos, size_t out_size);
-
-
-/// \brief      Return if expression doesn't evaluate to LZMA_OK
-///
-/// There are several situations where we want to return immediately
-/// with the value of expr if it isn't LZMA_OK. This macro shortens
-/// the code a little.
-#define return_if_error(expr) \
-do { \
-	const lzma_ret ret_ = (expr); \
-	if (ret_ != LZMA_OK) \
-		return ret_; \
-} while (0)
-
-
-/// If next isn't already initialized, free the previous coder. Then mark
-/// that next is _possibly_ initialized for the coder using this macro.
-/// "Possibly" means that if e.g. allocation of next->coder fails, the
-/// structure isn't actually initialized for this coder, but leaving
-/// next->init to func is still OK.
-#define lzma_next_coder_init(func, next, allocator) \
-do { \
-	if ((uintptr_t)(func) != (next)->init) \
-		lzma_next_end(next, allocator); \
-	(next)->init = (uintptr_t)(func); \
-} while (0)
-
-
-/// Initializes lzma_strm and calls func() to initialize strm->internal->next.
-/// (The function being called will use lzma_next_coder_init()). If
-/// initialization fails, memory that wasn't freed by func() is freed
-/// along strm->internal.
-#define lzma_next_strm_init(func, strm, ...) \
-do { \
-	return_if_error(lzma_strm_init(strm)); \
-	const lzma_ret ret_ = func(&(strm)->internal->next, \
-			(strm)->allocator, __VA_ARGS__); \
-	if (ret_ != LZMA_OK) { \
-		lzma_end(strm); \
-		return ret_; \
-	} \
-} while (0)
-
-#endif

package/deps/xz/src/liblzma/common/easy_buffer_encoder.c

@@ -1,27 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       easy_buffer_encoder.c
-/// \brief      Easy single-call .xz Stream encoder
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "easy_preset.h"
-
-
-extern LZMA_API(lzma_ret)
-lzma_easy_buffer_encode(uint32_t preset, lzma_check check,
-		const lzma_allocator *allocator, const uint8_t *in,
-		size_t in_size, uint8_t *out, size_t *out_pos, size_t out_size)
-{
-	lzma_options_easy opt_easy;
-	if (lzma_easy_preset(&opt_easy, preset))
-		return LZMA_OPTIONS_ERROR;
-
-	return lzma_stream_buffer_encode(opt_easy.filters, check,
-			allocator, in, in_size, out, out_pos, out_size);
-}

package/deps/xz/src/liblzma/common/easy_decoder_memusage.c

@@ -1,24 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       easy_decoder_memusage.c
-/// \brief      Decoder memory usage calculation to match easy encoder presets
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "easy_preset.h"
-
-
-extern LZMA_API(uint64_t)
-lzma_easy_decoder_memusage(uint32_t preset)
-{
-	lzma_options_easy opt_easy;
-	if (lzma_easy_preset(&opt_easy, preset))
-		return UINT32_MAX;
-
-	return lzma_raw_decoder_memusage(opt_easy.filters);
-}

package/deps/xz/src/liblzma/common/easy_encoder.c

@@ -1,24 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       easy_encoder.c
-/// \brief      Easy .xz Stream encoder initialization
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "easy_preset.h"
-
-
-extern LZMA_API(lzma_ret)
-lzma_easy_encoder(lzma_stream *strm, uint32_t preset, lzma_check check)
-{
-	lzma_options_easy opt_easy;
-	if (lzma_easy_preset(&opt_easy, preset))
-		return LZMA_OPTIONS_ERROR;
-
-	return lzma_stream_encoder(strm, opt_easy.filters, check);
-}

package/deps/xz/src/liblzma/common/easy_encoder_memusage.c

@@ -1,24 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       easy_encoder_memusage.c
-/// \brief      Easy .xz Stream encoder memory usage calculation
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "easy_preset.h"
-
-
-extern LZMA_API(uint64_t)
-lzma_easy_encoder_memusage(uint32_t preset)
-{
-	lzma_options_easy opt_easy;
-	if (lzma_easy_preset(&opt_easy, preset))
-		return UINT32_MAX;
-
-	return lzma_raw_encoder_memusage(opt_easy.filters);
-}

package/deps/xz/src/liblzma/common/easy_preset.c

@@ -1,27 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       easy_preset.c
-/// \brief      Preset handling for easy encoder and decoder
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "easy_preset.h"
-
-
-extern bool
-lzma_easy_preset(lzma_options_easy *opt_easy, uint32_t preset)
-{
-	if (lzma_lzma_preset(&opt_easy->opt_lzma, preset))
-		return true;
-
-	opt_easy->filters[0].id = LZMA_FILTER_LZMA2;
-	opt_easy->filters[0].options = &opt_easy->opt_lzma;
-	opt_easy->filters[1].id = LZMA_VLI_UNKNOWN;
-
-	return false;
-}

package/deps/xz/src/liblzma/common/easy_preset.h

@@ -1,32 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       easy_preset.h
-/// \brief      Preset handling for easy encoder and decoder
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "common.h"
-
-
-typedef struct {
-	/// We need to keep the filters array available in case
-	/// LZMA_FULL_FLUSH is used.
-	lzma_filter filters[LZMA_FILTERS_MAX + 1];
-
-	/// Options for LZMA2
-	lzma_options_lzma opt_lzma;
-
-	// Options for more filters can be added later, so this struct
-	// is not ready to be put into the public API.
-
-} lzma_options_easy;
-
-
-/// Set *easy to the settings given by the preset. Returns true on error,
-/// false on success.
-extern bool lzma_easy_preset(lzma_options_easy *easy, uint32_t preset);

package/deps/xz/src/liblzma/common/filter_buffer_decoder.c

@@ -1,88 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       filter_buffer_decoder.c
-/// \brief      Single-call raw decoding
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "filter_decoder.h"
-
-
-extern LZMA_API(lzma_ret)
-lzma_raw_buffer_decode(
-		const lzma_filter *filters, const lzma_allocator *allocator,
-		const uint8_t *in, size_t *in_pos, size_t in_size,
-		uint8_t *out, size_t *out_pos, size_t out_size)
-{
-	// Validate what isn't validated later in filter_common.c.
-	if (in == NULL || in_pos == NULL || *in_pos > in_size || out == NULL
-			|| out_pos == NULL || *out_pos > out_size)
-		return LZMA_PROG_ERROR;
-
-	// Initialize the decoer.
-	lzma_next_coder next = LZMA_NEXT_CODER_INIT;
-	return_if_error(lzma_raw_decoder_init(&next, allocator, filters));
-
-	// Store the positions so that we can restore them if something
-	// goes wrong.
-	const size_t in_start = *in_pos;
-	const size_t out_start = *out_pos;
-
-	// Do the actual decoding and free decoder's memory.
-	lzma_ret ret = next.code(next.coder, allocator, in, in_pos, in_size,
-			out, out_pos, out_size, LZMA_FINISH);
-
-	if (ret == LZMA_STREAM_END) {
-		ret = LZMA_OK;
-	} else {
-		if (ret == LZMA_OK) {
-			// Either the input was truncated or the
-			// output buffer was too small.
-			assert(*in_pos == in_size || *out_pos == out_size);
-
-			if (*in_pos != in_size) {
-				// Since input wasn't consumed completely,
-				// the output buffer became full and is
-				// too small.
-				ret = LZMA_BUF_ERROR;
-
-			} else if (*out_pos != out_size) {
-				// Since output didn't became full, the input
-				// has to be truncated.
-				ret = LZMA_DATA_ERROR;
-
-			} else {
-				// All the input was consumed and output
-				// buffer is full. Now we don't immediately
-				// know the reason for the error. Try
-				// decoding one more byte. If it succeeds,
-				// then the output buffer was too small. If
-				// we cannot get a new output byte, the input
-				// is truncated.
-				uint8_t tmp[1];
-				size_t tmp_pos = 0;
-				(void)next.code(next.coder, allocator,
-						in, in_pos, in_size,
-						tmp, &tmp_pos, 1, LZMA_FINISH);
-
-				if (tmp_pos == 1)
-					ret = LZMA_BUF_ERROR;
-				else
-					ret = LZMA_DATA_ERROR;
-			}
-		}
-
-		// Restore the positions.
-		*in_pos = in_start;
-		*out_pos = out_start;
-	}
-
-	lzma_next_end(&next, allocator);
-
-	return ret;
-}

package/deps/xz/src/liblzma/common/filter_buffer_encoder.c

@@ -1,55 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       filter_buffer_encoder.c
-/// \brief      Single-call raw encoding
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "filter_encoder.h"
-
-
-extern LZMA_API(lzma_ret)
-lzma_raw_buffer_encode(
-		const lzma_filter *filters, const lzma_allocator *allocator,
-		const uint8_t *in, size_t in_size,
-		uint8_t *out, size_t *out_pos, size_t out_size)
-{
-	// Validate what isn't validated later in filter_common.c.
-	if ((in == NULL && in_size != 0) || out == NULL
-			|| out_pos == NULL || *out_pos > out_size)
-		return LZMA_PROG_ERROR;
-
-	// Initialize the encoder
-	lzma_next_coder next = LZMA_NEXT_CODER_INIT;
-	return_if_error(lzma_raw_encoder_init(&next, allocator, filters));
-
-	// Store the output position so that we can restore it if
-	// something goes wrong.
-	const size_t out_start = *out_pos;
-
-	// Do the actual encoding and free coder's memory.
-	size_t in_pos = 0;
-	lzma_ret ret = next.code(next.coder, allocator, in, &in_pos, in_size,
-			out, out_pos, out_size, LZMA_FINISH);
-	lzma_next_end(&next, allocator);
-
-	if (ret == LZMA_STREAM_END) {
-		ret = LZMA_OK;
-	} else {
-		if (ret == LZMA_OK) {
-			// Output buffer was too small.
-			assert(*out_pos == out_size);
-			ret = LZMA_BUF_ERROR;
-		}
-
-		// Restore the output position.
-		*out_pos = out_start;
-	}
-
-	return ret;
-}