node-liblzma 1.0.4 → 1.1.4

package/deps/xz/src/liblzma/rangecoder/range_encoder.h

@@ -1,231 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       range_encoder.h
-/// \brief      Range Encoder
-///
-//  Authors:    Igor Pavlov
-//              Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef LZMA_RANGE_ENCODER_H
-#define LZMA_RANGE_ENCODER_H
-
-#include "range_common.h"
-#include "price.h"
-
-
-/// Maximum number of symbols that can be put pending into lzma_range_encoder
-/// structure between calls to lzma_rc_encode(). For LZMA, 52+5 is enough
-/// (match with big distance and length followed by range encoder flush).
-#define RC_SYMBOLS_MAX 58
-
-
-typedef struct {
-	uint64_t low;
-	uint64_t cache_size;
-	uint32_t range;
-	uint8_t cache;
-
-	/// Number of symbols in the tables
-	size_t count;
-
-	/// rc_encode()'s position in the tables
-	size_t pos;
-
-	/// Symbols to encode
-	enum {
-		RC_BIT_0,
-		RC_BIT_1,
-		RC_DIRECT_0,
-		RC_DIRECT_1,
-		RC_FLUSH,
-	} symbols[RC_SYMBOLS_MAX];
-
-	/// Probabilities associated with RC_BIT_0 or RC_BIT_1
-	probability *probs[RC_SYMBOLS_MAX];
-
-} lzma_range_encoder;
-
-
-static inline void
-rc_reset(lzma_range_encoder *rc)
-{
-	rc->low = 0;
-	rc->cache_size = 1;
-	rc->range = UINT32_MAX;
-	rc->cache = 0;
-	rc->count = 0;
-	rc->pos = 0;
-}
-
-
-static inline void
-rc_bit(lzma_range_encoder *rc, probability *prob, uint32_t bit)
-{
-	rc->symbols[rc->count] = bit;
-	rc->probs[rc->count] = prob;
-	++rc->count;
-}
-
-
-static inline void
-rc_bittree(lzma_range_encoder *rc, probability *probs,
-		uint32_t bit_count, uint32_t symbol)
-{
-	uint32_t model_index = 1;
-
-	do {
-		const uint32_t bit = (symbol >> --bit_count) & 1;
-		rc_bit(rc, &probs[model_index], bit);
-		model_index = (model_index << 1) + bit;
-	} while (bit_count != 0);
-}
-
-
-static inline void
-rc_bittree_reverse(lzma_range_encoder *rc, probability *probs,
-		uint32_t bit_count, uint32_t symbol)
-{
-	uint32_t model_index = 1;
-
-	do {
-		const uint32_t bit = symbol & 1;
-		symbol >>= 1;
-		rc_bit(rc, &probs[model_index], bit);
-		model_index = (model_index << 1) + bit;
-	} while (--bit_count != 0);
-}
-
-
-static inline void
-rc_direct(lzma_range_encoder *rc,
-		uint32_t value, uint32_t bit_count)
-{
-	do {
-		rc->symbols[rc->count++]
-				= RC_DIRECT_0 + ((value >> --bit_count) & 1);
-	} while (bit_count != 0);
-}
-
-
-static inline void
-rc_flush(lzma_range_encoder *rc)
-{
-	for (size_t i = 0; i < 5; ++i)
-		rc->symbols[rc->count++] = RC_FLUSH;
-}
-
-
-static inline bool
-rc_shift_low(lzma_range_encoder *rc,
-		uint8_t *out, size_t *out_pos, size_t out_size)
-{
-	if ((uint32_t)(rc->low) < (uint32_t)(0xFF000000)
-			|| (uint32_t)(rc->low >> 32) != 0) {
-		do {
-			if (*out_pos == out_size)
-				return true;
-
-			out[*out_pos] = rc->cache + (uint8_t)(rc->low >> 32);
-			++*out_pos;
-			rc->cache = 0xFF;
-
-		} while (--rc->cache_size != 0);
-
-		rc->cache = (rc->low >> 24) & 0xFF;
-	}
-
-	++rc->cache_size;
-	rc->low = (rc->low & 0x00FFFFFF) << RC_SHIFT_BITS;
-
-	return false;
-}
-
-
-static inline bool
-rc_encode(lzma_range_encoder *rc,
-		uint8_t *out, size_t *out_pos, size_t out_size)
-{
-	assert(rc->count <= RC_SYMBOLS_MAX);
-
-	while (rc->pos < rc->count) {
-		// Normalize
-		if (rc->range < RC_TOP_VALUE) {
-			if (rc_shift_low(rc, out, out_pos, out_size))
-				return true;
-
-			rc->range <<= RC_SHIFT_BITS;
-		}
-
-		// Encode a bit
-		switch (rc->symbols[rc->pos]) {
-		case RC_BIT_0: {
-			probability prob = *rc->probs[rc->pos];
-			rc->range = (rc->range >> RC_BIT_MODEL_TOTAL_BITS)
-					* prob;
-			prob += (RC_BIT_MODEL_TOTAL - prob) >> RC_MOVE_BITS;
-			*rc->probs[rc->pos] = prob;
-			break;
-		}
-
-		case RC_BIT_1: {
-			probability prob = *rc->probs[rc->pos];
-			const uint32_t bound = prob * (rc->range
-					>> RC_BIT_MODEL_TOTAL_BITS);
-			rc->low += bound;
-			rc->range -= bound;
-			prob -= prob >> RC_MOVE_BITS;
-			*rc->probs[rc->pos] = prob;
-			break;
-		}
-
-		case RC_DIRECT_0:
-			rc->range >>= 1;
-			break;
-
-		case RC_DIRECT_1:
-			rc->range >>= 1;
-			rc->low += rc->range;
-			break;
-
-		case RC_FLUSH:
-			// Prevent further normalizations.
-			rc->range = UINT32_MAX;
-
-			// Flush the last five bytes (see rc_flush()).
-			do {
-				if (rc_shift_low(rc, out, out_pos, out_size))
-					return true;
-			} while (++rc->pos < rc->count);
-
-			// Reset the range encoder so we are ready to continue
-			// encoding if we weren't finishing the stream.
-			rc_reset(rc);
-			return false;
-
-		default:
-			assert(0);
-			break;
-		}
-
-		++rc->pos;
-	}
-
-	rc->count = 0;
-	rc->pos = 0;
-
-	return false;
-}
-
-
-static inline uint64_t
-rc_pending(const lzma_range_encoder *rc)
-{
-	return rc->cache_size + 5 - 1;
-}
-
-#endif

package/deps/xz/src/liblzma/simple/Makefile.inc

@@ -1,47 +0,0 @@
-##
-## Author: Lasse Collin
-##
-## This file has been put into the public domain.
-## You can do whatever you want with this file.
-##
-
-liblzma_la_SOURCES += \
-	simple/simple_coder.c \
-	simple/simple_coder.h \
-	simple/simple_private.h
-
-if COND_ENCODER_SIMPLE
-liblzma_la_SOURCES += \
-	simple/simple_encoder.c \
-	simple/simple_encoder.h
-endif
-
-if COND_DECODER_SIMPLE
-liblzma_la_SOURCES += \
-	simple/simple_decoder.c \
-	simple/simple_decoder.h
-endif
-
-if COND_FILTER_X86
-liblzma_la_SOURCES += simple/x86.c
-endif
-
-if COND_FILTER_POWERPC
-liblzma_la_SOURCES += simple/powerpc.c
-endif
-
-if COND_FILTER_IA64
-liblzma_la_SOURCES += simple/ia64.c
-endif
-
-if COND_FILTER_ARM
-liblzma_la_SOURCES += simple/arm.c
-endif
-
-if COND_FILTER_ARMTHUMB
-liblzma_la_SOURCES += simple/armthumb.c
-endif
-
-if COND_FILTER_SPARC
-liblzma_la_SOURCES += simple/sparc.c
-endif

package/deps/xz/src/liblzma/simple/arm.c

@@ -1,71 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       arm.c
-/// \brief      Filter for ARM binaries
-///
-//  Authors:    Igor Pavlov
-//              Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "simple_private.h"
-
-
-static size_t
-arm_code(lzma_simple *simple lzma_attribute((__unused__)),
-		uint32_t now_pos, bool is_encoder,
-		uint8_t *buffer, size_t size)
-{
-	size_t i;
-	for (i = 0; i + 4 <= size; i += 4) {
-		if (buffer[i + 3] == 0xEB) {
-			uint32_t src = (buffer[i + 2] << 16)
-					| (buffer[i + 1] << 8)
-					| (buffer[i + 0]);
-			src <<= 2;
-
-			uint32_t dest;
-			if (is_encoder)
-				dest = now_pos + (uint32_t)(i) + 8 + src;
-			else
-				dest = src - (now_pos + (uint32_t)(i) + 8);
-
-			dest >>= 2;
-			buffer[i + 2] = (dest >> 16);
-			buffer[i + 1] = (dest >> 8);
-			buffer[i + 0] = dest;
-		}
-	}
-
-	return i;
-}
-
-
-static lzma_ret
-arm_coder_init(lzma_next_coder *next, const lzma_allocator *allocator,
-		const lzma_filter_info *filters, bool is_encoder)
-{
-	return lzma_simple_coder_init(next, allocator, filters,
-			&arm_code, 0, 4, 4, is_encoder);
-}
-
-
-extern lzma_ret
-lzma_simple_arm_encoder_init(lzma_next_coder *next,
-		const lzma_allocator *allocator,
-		const lzma_filter_info *filters)
-{
-	return arm_coder_init(next, allocator, filters, true);
-}
-
-
-extern lzma_ret
-lzma_simple_arm_decoder_init(lzma_next_coder *next,
-		const lzma_allocator *allocator,
-		const lzma_filter_info *filters)
-{
-	return arm_coder_init(next, allocator, filters, false);
-}

package/deps/xz/src/liblzma/simple/armthumb.c

@@ -1,76 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       armthumb.c
-/// \brief      Filter for ARM-Thumb binaries
-///
-//  Authors:    Igor Pavlov
-//              Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "simple_private.h"
-
-
-static size_t
-armthumb_code(lzma_simple *simple lzma_attribute((__unused__)),
-		uint32_t now_pos, bool is_encoder,
-		uint8_t *buffer, size_t size)
-{
-	size_t i;
-	for (i = 0; i + 4 <= size; i += 2) {
-		if ((buffer[i + 1] & 0xF8) == 0xF0
-				&& (buffer[i + 3] & 0xF8) == 0xF8) {
-			uint32_t src = ((buffer[i + 1] & 0x7) << 19)
-					| (buffer[i + 0] << 11)
-					| ((buffer[i + 3] & 0x7) << 8)
-					| (buffer[i + 2]);
-
-			src <<= 1;
-
-			uint32_t dest;
-			if (is_encoder)
-				dest = now_pos + (uint32_t)(i) + 4 + src;
-			else
-				dest = src - (now_pos + (uint32_t)(i) + 4);
-
-			dest >>= 1;
-			buffer[i + 1] = 0xF0 | ((dest >> 19) & 0x7);
-			buffer[i + 0] = (dest >> 11);
-			buffer[i + 3] = 0xF8 | ((dest >> 8) & 0x7);
-			buffer[i + 2] = (dest);
-			i += 2;
-		}
-	}
-
-	return i;
-}
-
-
-static lzma_ret
-armthumb_coder_init(lzma_next_coder *next, const lzma_allocator *allocator,
-		const lzma_filter_info *filters, bool is_encoder)
-{
-	return lzma_simple_coder_init(next, allocator, filters,
-			&armthumb_code, 0, 4, 2, is_encoder);
-}
-
-
-extern lzma_ret
-lzma_simple_armthumb_encoder_init(lzma_next_coder *next,
-		const lzma_allocator *allocator,
-		const lzma_filter_info *filters)
-{
-	return armthumb_coder_init(next, allocator, filters, true);
-}
-
-
-extern lzma_ret
-lzma_simple_armthumb_decoder_init(lzma_next_coder *next,
-		const lzma_allocator *allocator,
-		const lzma_filter_info *filters)
-{
-	return armthumb_coder_init(next, allocator, filters, false);
-}

package/deps/xz/src/liblzma/simple/ia64.c

@@ -1,112 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       ia64.c
-/// \brief      Filter for IA64 (Itanium) binaries
-///
-//  Authors:    Igor Pavlov
-//              Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "simple_private.h"
-
-
-static size_t
-ia64_code(lzma_simple *simple lzma_attribute((__unused__)),
-		uint32_t now_pos, bool is_encoder,
-		uint8_t *buffer, size_t size)
-{
-	static const uint32_t BRANCH_TABLE[32] = {
-		0, 0, 0, 0, 0, 0, 0, 0,
-		0, 0, 0, 0, 0, 0, 0, 0,
-		4, 4, 6, 6, 0, 0, 7, 7,
-		4, 4, 0, 0, 4, 4, 0, 0
-	};
-
-	size_t i;
-	for (i = 0; i + 16 <= size; i += 16) {
-		const uint32_t instr_template = buffer[i] & 0x1F;
-		const uint32_t mask = BRANCH_TABLE[instr_template];
-		uint32_t bit_pos = 5;
-
-		for (size_t slot = 0; slot < 3; ++slot, bit_pos += 41) {
-			if (((mask >> slot) & 1) == 0)
-				continue;
-
-			const size_t byte_pos = (bit_pos >> 3);
-			const uint32_t bit_res = bit_pos & 0x7;
-			uint64_t instruction = 0;
-
-			for (size_t j = 0; j < 6; ++j)
-				instruction += (uint64_t)(
-						buffer[i + j + byte_pos])
-						<< (8 * j);
-
-			uint64_t inst_norm = instruction >> bit_res;
-
-			if (((inst_norm >> 37) & 0xF) == 0x5
-					&& ((inst_norm >> 9) & 0x7) == 0
-					/* &&  (inst_norm & 0x3F)== 0 */
-					) {
-				uint32_t src = (uint32_t)(
-						(inst_norm >> 13) & 0xFFFFF);
-				src |= ((inst_norm >> 36) & 1) << 20;
-
-				src <<= 4;
-
-				uint32_t dest;
-				if (is_encoder)
-					dest = now_pos + (uint32_t)(i) + src;
-				else
-					dest = src - (now_pos + (uint32_t)(i));
-
-				dest >>= 4;
-
-				inst_norm &= ~((uint64_t)(0x8FFFFF) << 13);
-				inst_norm |= (uint64_t)(dest & 0xFFFFF) << 13;
-				inst_norm |= (uint64_t)(dest & 0x100000)
-						<< (36 - 20);
-
-				instruction &= (1 << bit_res) - 1;
-				instruction |= (inst_norm << bit_res);
-
-				for (size_t j = 0; j < 6; j++)
-					buffer[i + j + byte_pos] = (uint8_t)(
-							instruction
-							>> (8 * j));
-			}
-		}
-	}
-
-	return i;
-}
-
-
-static lzma_ret
-ia64_coder_init(lzma_next_coder *next, const lzma_allocator *allocator,
-		const lzma_filter_info *filters, bool is_encoder)
-{
-	return lzma_simple_coder_init(next, allocator, filters,
-			&ia64_code, 0, 16, 16, is_encoder);
-}
-
-
-extern lzma_ret
-lzma_simple_ia64_encoder_init(lzma_next_coder *next,
-		const lzma_allocator *allocator,
-		const lzma_filter_info *filters)
-{
-	return ia64_coder_init(next, allocator, filters, true);
-}
-
-
-extern lzma_ret
-lzma_simple_ia64_decoder_init(lzma_next_coder *next,
-		const lzma_allocator *allocator,
-		const lzma_filter_info *filters)
-{
-	return ia64_coder_init(next, allocator, filters, false);
-}

package/deps/xz/src/liblzma/simple/powerpc.c

@@ -1,75 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       powerpc.c
-/// \brief      Filter for PowerPC (big endian) binaries
-///
-//  Authors:    Igor Pavlov
-//              Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "simple_private.h"
-
-
-static size_t
-powerpc_code(lzma_simple *simple lzma_attribute((__unused__)),
-		uint32_t now_pos, bool is_encoder,
-		uint8_t *buffer, size_t size)
-{
-	size_t i;
-	for (i = 0; i + 4 <= size; i += 4) {
-		// PowerPC branch 6(48) 24(Offset) 1(Abs) 1(Link)
-		if ((buffer[i] >> 2) == 0x12
-				&& ((buffer[i + 3] & 3) == 1)) {
-
-			const uint32_t src = ((buffer[i + 0] & 3) << 24)
-					| (buffer[i + 1] << 16)
-					| (buffer[i + 2] << 8)
-					| (buffer[i + 3] & (~3));
-
-			uint32_t dest;
-			if (is_encoder)
-				dest = now_pos + (uint32_t)(i) + src;
-			else
-				dest = src - (now_pos + (uint32_t)(i));
-
-			buffer[i + 0] = 0x48 | ((dest >> 24) &  0x03);
-			buffer[i + 1] = (dest >> 16);
-			buffer[i + 2] = (dest >> 8);
-			buffer[i + 3] &= 0x03;
-			buffer[i + 3] |= dest;
-		}
-	}
-
-	return i;
-}
-
-
-static lzma_ret
-powerpc_coder_init(lzma_next_coder *next, const lzma_allocator *allocator,
-		const lzma_filter_info *filters, bool is_encoder)
-{
-	return lzma_simple_coder_init(next, allocator, filters,
-			&powerpc_code, 0, 4, 4, is_encoder);
-}
-
-
-extern lzma_ret
-lzma_simple_powerpc_encoder_init(lzma_next_coder *next,
-		const lzma_allocator *allocator,
-		const lzma_filter_info *filters)
-{
-	return powerpc_coder_init(next, allocator, filters, true);
-}
-
-
-extern lzma_ret
-lzma_simple_powerpc_decoder_init(lzma_next_coder *next,
-		const lzma_allocator *allocator,
-		const lzma_filter_info *filters)
-{
-	return powerpc_coder_init(next, allocator, filters, false);
-}