rename archival/libunarchive -> archival/libarchive; move bz/ into it

Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>

1 files changed, 0 insertions, 431 deletions

diff --git a/archival/bz/bzlib.c b/archival/bz/bzlib.c
deleted file mode 100644
index b3beeab..0000000
--- a/archival/bz/bzlib.c
+++ /dev/null
@@ -1,431 +0,0 @@
-/*
- * bzip2 is written by Julian Seward <jseward@bzip.org>.
- * Adapted for busybox by Denys Vlasenko <vda.linux@googlemail.com>.
- * See README and LICENSE files in this directory for more information.
- */
-
-/*-------------------------------------------------------------*/
-/*--- Library top-level functions.                          ---*/
-/*---                                               bzlib.c ---*/
-/*-------------------------------------------------------------*/
-
-/* ------------------------------------------------------------------
-This file is part of bzip2/libbzip2, a program and library for
-lossless, block-sorting data compression.
-
-bzip2/libbzip2 version 1.0.4 of 20 December 2006
-Copyright (C) 1996-2006 Julian Seward <jseward@bzip.org>
-
-Please read the WARNING, DISCLAIMER and PATENTS sections in the
-README file.
-
-This program is released under the terms of the license contained
-in the file LICENSE.
------------------------------------------------------------------- */
-
-/* CHANGES
- * 0.9.0    -- original version.
- * 0.9.0a/b -- no changes in this file.
- * 0.9.0c   -- made zero-length BZ_FLUSH work correctly in bzCompress().
- *             fixed bzWrite/bzRead to ignore zero-length requests.
- *             fixed bzread to correctly handle read requests after EOF.
- *             wrong parameter order in call to bzDecompressInit in
- *             bzBuffToBuffDecompress.  Fixed.
- */
-
-/* #include "bzlib_private.h" */
-
-/*---------------------------------------------------*/
-/*--- Compression stuff                           ---*/
-/*---------------------------------------------------*/
-
-/*---------------------------------------------------*/
-#if BZ_LIGHT_DEBUG
-static
-void bz_assert_fail(int errcode)
-{
-	/* if (errcode == 1007) bb_error_msg_and_die("probably bad RAM"); */
-	bb_error_msg_and_die("internal error %d", errcode);
-}
-#endif
-
-/*---------------------------------------------------*/
-static
-void prepare_new_block(EState* s)
-{
-	int i;
-	s->nblock = 0;
-	s->numZ = 0;
-	s->state_out_pos = 0;
-	BZ_INITIALISE_CRC(s->blockCRC);
-	/* inlined memset would be nice to have here */
-	for (i = 0; i < 256; i++)
-		s->inUse[i] = 0;
-	s->blockNo++;
-}
-
-
-/*---------------------------------------------------*/
-static
-ALWAYS_INLINE
-void init_RL(EState* s)
-{
-	s->state_in_ch = 256;
-	s->state_in_len = 0;
-}
-
-
-static
-int isempty_RL(EState* s)
-{
-	return (s->state_in_ch >= 256 || s->state_in_len <= 0);
-}
-
-
-/*---------------------------------------------------*/
-static
-void BZ2_bzCompressInit(bz_stream *strm, int blockSize100k)
-{
-	int32_t n;
-	EState* s;
-
-	s = xzalloc(sizeof(EState));
-	s->strm = strm;
-
-	n        = 100000 * blockSize100k;
-	s->arr1  = xmalloc(n                    * sizeof(uint32_t));
-	s->mtfv  = (uint16_t*)s->arr1;
-	s->ptr   = (uint32_t*)s->arr1;
-	s->arr2  = xmalloc((n + BZ_N_OVERSHOOT) * sizeof(uint32_t));
-	s->block = (uint8_t*)s->arr2;
-	s->ftab  = xmalloc(65537                * sizeof(uint32_t));
-
-	s->crc32table = crc32_filltable(NULL, 1);
-
-	s->state             = BZ_S_INPUT;
-	s->mode              = BZ_M_RUNNING;
-	s->blockSize100k     = blockSize100k;
-	s->nblockMAX         = n - 19;
-
-	strm->state          = s;
-	/*strm->total_in     = 0;*/
-	strm->total_out      = 0;
-	init_RL(s);
-	prepare_new_block(s);
-}
-
-
-/*---------------------------------------------------*/
-static
-void add_pair_to_block(EState* s)
-{
-	int32_t i;
-	uint8_t ch = (uint8_t)(s->state_in_ch);
-	for (i = 0; i < s->state_in_len; i++) {
-		BZ_UPDATE_CRC(s, s->blockCRC, ch);
-	}
-	s->inUse[s->state_in_ch] = 1;
-	switch (s->state_in_len) {
-		case 3:
-			s->block[s->nblock] = (uint8_t)ch; s->nblock++;
-			/* fall through */
-		case 2:
-			s->block[s->nblock] = (uint8_t)ch; s->nblock++;
-			/* fall through */
-		case 1:
-			s->block[s->nblock] = (uint8_t)ch; s->nblock++;
-			break;
-		default:
-			s->inUse[s->state_in_len - 4] = 1;
-			s->block[s->nblock] = (uint8_t)ch; s->nblock++;
-			s->block[s->nblock] = (uint8_t)ch; s->nblock++;
-			s->block[s->nblock] = (uint8_t)ch; s->nblock++;
-			s->block[s->nblock] = (uint8_t)ch; s->nblock++;
-			s->block[s->nblock] = (uint8_t)(s->state_in_len - 4);
-			s->nblock++;
-			break;
-	}
-}
-
-
-/*---------------------------------------------------*/
-static
-void flush_RL(EState* s)
-{
-	if (s->state_in_ch < 256) add_pair_to_block(s);
-	init_RL(s);
-}
-
-
-/*---------------------------------------------------*/
-#define ADD_CHAR_TO_BLOCK(zs, zchh0) \
-{ \
-	uint32_t zchh = (uint32_t)(zchh0); \
-	/*-- fast track the common case --*/ \
-	if (zchh != zs->state_in_ch && zs->state_in_len == 1) { \
-		uint8_t ch = (uint8_t)(zs->state_in_ch); \
-		BZ_UPDATE_CRC(zs, zs->blockCRC, ch); \
-		zs->inUse[zs->state_in_ch] = 1; \
-		zs->block[zs->nblock] = (uint8_t)ch; \
-		zs->nblock++; \
-		zs->state_in_ch = zchh; \
-	} \
-	else \
-	/*-- general, uncommon cases --*/ \
-	if (zchh != zs->state_in_ch || zs->state_in_len == 255) { \
-		if (zs->state_in_ch < 256) \
-			add_pair_to_block(zs); \
-		zs->state_in_ch = zchh; \
-		zs->state_in_len = 1; \
-	} else { \
-		zs->state_in_len++; \
-	} \
-}
-
-
-/*---------------------------------------------------*/
-static
-void /*Bool*/ copy_input_until_stop(EState* s)
-{
-	/*Bool progress_in = False;*/
-
-#ifdef SAME_CODE_AS_BELOW
-	if (s->mode == BZ_M_RUNNING) {
-		/*-- fast track the common case --*/
-		while (1) {
-			/*-- no input? --*/
-			if (s->strm->avail_in == 0) break;
-			/*-- block full? --*/
-			if (s->nblock >= s->nblockMAX) break;
-			/*progress_in = True;*/
-			ADD_CHAR_TO_BLOCK(s, (uint32_t)(*(uint8_t*)(s->strm->next_in)));
-			s->strm->next_in++;
-			s->strm->avail_in--;
-			/*s->strm->total_in++;*/
-		}
-	} else
-#endif
-	{
-		/*-- general, uncommon case --*/
-		while (1) {
-			/*-- no input? --*/
-			if (s->strm->avail_in == 0) break;
-			/*-- block full? --*/
-			if (s->nblock >= s->nblockMAX) break;
-		//#	/*-- flush/finish end? --*/
-		//#	if (s->avail_in_expect == 0) break;
-			/*progress_in = True;*/
-			ADD_CHAR_TO_BLOCK(s, *(uint8_t*)(s->strm->next_in));
-			s->strm->next_in++;
-			s->strm->avail_in--;
-			/*s->strm->total_in++;*/
-		//#	s->avail_in_expect--;
-		}
-	}
-	/*return progress_in;*/
-}
-
-
-/*---------------------------------------------------*/
-static
-void /*Bool*/ copy_output_until_stop(EState* s)
-{
-	/*Bool progress_out = False;*/
-
-	while (1) {
-		/*-- no output space? --*/
-		if (s->strm->avail_out == 0) break;
-
-		/*-- block done? --*/
-		if (s->state_out_pos >= s->numZ) break;
-
-		/*progress_out = True;*/
-		*(s->strm->next_out) = s->zbits[s->state_out_pos];
-		s->state_out_pos++;
-		s->strm->avail_out--;
-		s->strm->next_out++;
-		s->strm->total_out++;
-	}
-	/*return progress_out;*/
-}
-
-
-/*---------------------------------------------------*/
-static
-void /*Bool*/ handle_compress(bz_stream *strm)
-{
-	/*Bool progress_in  = False;*/
-	/*Bool progress_out = False;*/
-	EState* s = strm->state;
-
-	while (1) {
-		if (s->state == BZ_S_OUTPUT) {
-			/*progress_out |=*/ copy_output_until_stop(s);
-			if (s->state_out_pos < s->numZ) break;
-			if (s->mode == BZ_M_FINISHING
-			//# && s->avail_in_expect == 0
-			 && s->strm->avail_in == 0
-			 && isempty_RL(s))
-				break;
-			prepare_new_block(s);
-			s->state = BZ_S_INPUT;
-#ifdef FLUSH_IS_UNUSED
-			if (s->mode == BZ_M_FLUSHING
-			 && s->avail_in_expect == 0
-			 && isempty_RL(s))
-				break;
-#endif
-		}
-
-		if (s->state == BZ_S_INPUT) {
-			/*progress_in |=*/ copy_input_until_stop(s);
-			//#if (s->mode != BZ_M_RUNNING && s->avail_in_expect == 0) {
-			if (s->mode != BZ_M_RUNNING && s->strm->avail_in == 0) {
-				flush_RL(s);
-				BZ2_compressBlock(s, (s->mode == BZ_M_FINISHING));
-				s->state = BZ_S_OUTPUT;
-			} else
-			if (s->nblock >= s->nblockMAX) {
-				BZ2_compressBlock(s, 0);
-				s->state = BZ_S_OUTPUT;
-			} else
-			if (s->strm->avail_in == 0) {
-				break;
-			}
-		}
-	}
-
-	/*return progress_in || progress_out;*/
-}
-
-
-/*---------------------------------------------------*/
-static
-int BZ2_bzCompress(bz_stream *strm, int action)
-{
-	/*Bool progress;*/
-	EState* s;
-
-	s = strm->state;
-
-	switch (s->mode) {
-		case BZ_M_RUNNING:
-			if (action == BZ_RUN) {
-				/*progress =*/ handle_compress(strm);
-				/*return progress ? BZ_RUN_OK : BZ_PARAM_ERROR;*/
-				return BZ_RUN_OK;
-			}
-#ifdef FLUSH_IS_UNUSED
-			else
-			if (action == BZ_FLUSH) {
-				//#s->avail_in_expect = strm->avail_in;
-				s->mode = BZ_M_FLUSHING;
-				goto case_BZ_M_FLUSHING;
-			}
-#endif
-			else
-			/*if (action == BZ_FINISH)*/ {
-				//#s->avail_in_expect = strm->avail_in;
-				s->mode = BZ_M_FINISHING;
-				goto case_BZ_M_FINISHING;
-			}
-
-#ifdef FLUSH_IS_UNUSED
- case_BZ_M_FLUSHING:
-		case BZ_M_FLUSHING:
-			/*if (s->avail_in_expect != s->strm->avail_in)
-				return BZ_SEQUENCE_ERROR;*/
-			/*progress =*/ handle_compress(strm);
-			if (s->avail_in_expect > 0 || !isempty_RL(s) || s->state_out_pos < s->numZ)
-				return BZ_FLUSH_OK;
-			s->mode = BZ_M_RUNNING;
-			return BZ_RUN_OK;
-#endif
-
- case_BZ_M_FINISHING:
-		/*case BZ_M_FINISHING:*/
-		default:
-			/*if (s->avail_in_expect != s->strm->avail_in)
-				return BZ_SEQUENCE_ERROR;*/
-			/*progress =*/ handle_compress(strm);
-			/*if (!progress) return BZ_SEQUENCE_ERROR;*/
-			//#if (s->avail_in_expect > 0 || !isempty_RL(s) || s->state_out_pos < s->numZ)
-			//#	return BZ_FINISH_OK;
-			if (s->strm->avail_in > 0 || !isempty_RL(s) || s->state_out_pos < s->numZ)
-				return BZ_FINISH_OK;
-			/*s->mode = BZ_M_IDLE;*/
-			return BZ_STREAM_END;
-	}
-	/* return BZ_OK; --not reached--*/
-}
-
-
-/*---------------------------------------------------*/
-#if ENABLE_FEATURE_CLEAN_UP
-static
-void BZ2_bzCompressEnd(bz_stream *strm)
-{
-	EState* s;
-
-	s = strm->state;
-	free(s->arr1);
-	free(s->arr2);
-	free(s->ftab);
-	free(s->crc32table);
-	free(strm->state);
-}
-#endif
-
-
-/*---------------------------------------------------*/
-/*--- Misc convenience stuff                      ---*/
-/*---------------------------------------------------*/
-
-/*---------------------------------------------------*/
-#ifdef EXAMPLE_CODE_FOR_MEM_TO_MEM_COMPRESSION
-static
-int BZ2_bzBuffToBuffCompress(char* dest,
-		unsigned int* destLen,
-		char*         source,
-		unsigned int  sourceLen,
-		int           blockSize100k)
-{
-	bz_stream strm;
-	int ret;
-
-	if (dest == NULL || destLen == NULL
-	 || source == NULL
-	 || blockSize100k < 1 || blockSize100k > 9
-	) {
-		return BZ_PARAM_ERROR;
-	}
-
-	BZ2_bzCompressInit(&strm, blockSize100k);
-
-	strm.next_in = source;
-	strm.next_out = dest;
-	strm.avail_in = sourceLen;
-	strm.avail_out = *destLen;
-
-	ret = BZ2_bzCompress(&strm, BZ_FINISH);
-	if (ret == BZ_FINISH_OK) goto output_overflow;
-	if (ret != BZ_STREAM_END) goto errhandler;
-
-	/* normal termination */
-	*destLen -= strm.avail_out;
-	BZ2_bzCompressEnd(&strm);
-	return BZ_OK;
-
- output_overflow:
-	BZ2_bzCompressEnd(&strm);
-	return BZ_OUTBUFF_FULL;
-
- errhandler:
-	BZ2_bzCompressEnd(&strm);
-	return ret;
-}
-#endif
-
-/*-------------------------------------------------------------*/
-/*--- end                                           bzlib.c ---*/
-/*-------------------------------------------------------------*/