diff options
author | Glenn L McGrath <bug1@ihug.co.nz> | 2001-10-05 07:48:57 +0400 |
---|---|---|
committer | Glenn L McGrath <bug1@ihug.co.nz> | 2001-10-05 07:48:57 +0400 |
commit | 24e2833cdfcba3505bbde9b56906bbcbb67aa2be (patch) | |
tree | 9555ce149062ec16167d77aa6a5d7a55850c511d | |
parent | 2e772edacf70e9ff45a00a34af4c94e04d490fc2 (diff) |
Initial support for for bunzip2....
This code could be improvemed by
1) supporting more options,
2) Creating a shared crc table with gunzip, or perhaps generated on the fly.
3) Removing any remaining unneccessary code (e.g. if (noisy))
-rw-r--r-- | Config.h | 1 | ||||
-rw-r--r-- | applets.h | 3 | ||||
-rw-r--r-- | applets/usage.h | 6 | ||||
-rw-r--r-- | archival/bunzip2.c | 2340 | ||||
-rw-r--r-- | bunzip2.c | 2340 | ||||
-rw-r--r-- | include/applets.h | 3 | ||||
-rw-r--r-- | include/usage.h | 6 | ||||
-rw-r--r-- | usage.h | 6 |
8 files changed, 4705 insertions, 0 deletions
@@ -13,6 +13,7 @@ //#define BB_AR //#define BB_ASH #define BB_BASENAME +//#define BB_BUNZIP2 #define BB_CAT #define BB_CHGRP #define BB_CHMOD @@ -64,6 +64,9 @@ #ifdef BB_BASENAME APPLET(basename, basename_main, _BB_DIR_USR_BIN) #endif +#ifdef BB_BUNZIP2 + APPLET(bunzip2, bunzip2_main, _BB_DIR_USR_BIN) +#endif APPLET_NOUSAGE("busybox", busybox_main, _BB_DIR_BIN) #ifdef BB_CAT APPLET(cat, cat_main, _BB_DIR_BIN) diff --git a/applets/usage.h b/applets/usage.h index f504ac1b8..0b095a4da 100644 --- a/applets/usage.h +++ b/applets/usage.h @@ -51,6 +51,12 @@ "$ basename /foo/bar.txt .txt\n" \ "bar" +#define bunzip2_trivial_usage \ + "FILE" +#define bunzip2_full_usage \ + "Uncompress FILE to current directory, stripping its .bz2 extension.\n"\ + " -k is assumed" + #define cat_trivial_usage \ "[FILE]..." #define cat_full_usage \ diff --git a/archival/bunzip2.c b/archival/bunzip2.c new file mode 100644 index 000000000..757654dab --- /dev/null +++ b/archival/bunzip2.c @@ -0,0 +1,2340 @@ +/* Modified for busybox by Glenn McGrath <bug1@optushome.com.au> */ +/*-- + This file is a part of bzip2 and/or libbzip2, a program and + library for lossless, block-sorting data compression. + + Copyright (C) 1996-2000 Julian R Seward. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. The origin of this software must not be misrepresented; you must + not claim that you wrote the original software. If you use this + software in a product, an acknowledgment in the product + documentation would be appreciated but is not required. + + 3. Altered source versions must be plainly marked as such, and must + not be misrepresented as being the original software. + + 4. The name of the author may not be used to endorse or promote + products derived from this software without specific prior written + permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS + OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + Julian Seward, Cambridge, UK. + jseward@acm.org + bzip2/libbzip2 version 1.0 of 21 March 2000 + + This program is based on (at least) the work of: + Mike Burrows + David Wheeler + Peter Fenwick + Alistair Moffat + Radford Neal + Ian H. Witten + Robert Sedgewick + Jon L. Bentley + + For more information on these sources, see the manual. +--*/ + +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <busybox.h> + +//#define TRUE 1 +//#define FALSE 0 + +#define MTFA_SIZE 4096 +#define MTFL_SIZE 16 +#define BZ_N_GROUPS 6 +#define BZ_G_SIZE 50 +#define BZ_MAX_ALPHA_SIZE 258 + +#define BZ_OK 0 +#define BZ_RUN_OK 1 +#define BZ_FLUSH_OK 2 +#define BZ_FINISH_OK 3 +#define BZ_STREAM_END 4 +#define BZ_SEQUENCE_ERROR (-1) +#define BZ_PARAM_ERROR (-2) +#define BZ_MEM_ERROR (-3) +#define BZ_DATA_ERROR (-4) +#define BZ_DATA_ERROR_MAGIC (-5) +#define BZ_IO_ERROR (-6) +#define BZ_UNEXPECTED_EOF (-7) +#define BZ_OUTBUFF_FULL (-8) +#define BZ_CONFIG_ERROR (-9) + +#define BZ_RUNA 0 +#define BZ_RUNB 1 + +#define BZ_MAX_UNUSED 5000 +#define FILE_NAME_LEN 1034 +/*-- states for decompression. --*/ + +#define BZ_X_IDLE 1 +#define BZ_X_OUTPUT 2 + +#define BZ_X_MAGIC_1 10 +#define BZ_X_MAGIC_2 11 +#define BZ_X_MAGIC_3 12 +#define BZ_X_MAGIC_4 13 +#define BZ_X_BLKHDR_1 14 +#define BZ_X_BLKHDR_2 15 +#define BZ_X_BLKHDR_3 16 +#define BZ_X_BLKHDR_4 17 +#define BZ_X_BLKHDR_5 18 +#define BZ_X_BLKHDR_6 19 +#define BZ_X_BCRC_1 20 +#define BZ_X_BCRC_2 21 +#define BZ_X_BCRC_3 22 +#define BZ_X_BCRC_4 23 +#define BZ_X_RANDBIT 24 +#define BZ_X_ORIGPTR_1 25 +#define BZ_X_ORIGPTR_2 26 +#define BZ_X_ORIGPTR_3 27 +#define BZ_X_MAPPING_1 28 +#define BZ_X_MAPPING_2 29 +#define BZ_X_SELECTOR_1 30 +#define BZ_X_SELECTOR_2 31 +#define BZ_X_SELECTOR_3 32 +#define BZ_X_CODING_1 33 +#define BZ_X_CODING_2 34 +#define BZ_X_CODING_3 35 +#define BZ_X_MTF_1 36 +#define BZ_X_MTF_2 37 +#define BZ_X_MTF_3 38 +#define BZ_X_MTF_4 39 +#define BZ_X_MTF_5 40 +#define BZ_X_MTF_6 41 +#define BZ_X_ENDHDR_2 42 +#define BZ_X_ENDHDR_3 43 +#define BZ_X_ENDHDR_4 44 +#define BZ_X_ENDHDR_5 45 +#define BZ_X_ENDHDR_6 46 +#define BZ_X_CCRC_1 47 +#define BZ_X_CCRC_2 48 +#define BZ_X_CCRC_3 49 +#define BZ_X_CCRC_4 50 + +#define BZ_MAX_CODE_LEN 23 +#define BZ_VERSION "1.0.1, 23-June-2000" +#define OM_TEST 3 +#define SM_F2F 3 + +typedef struct { + char *next_in; + unsigned int avail_in; + unsigned int total_in_lo32; + unsigned int total_in_hi32; + + char *next_out; + unsigned int avail_out; + unsigned int total_out_lo32; + unsigned int total_out_hi32; + + void *state; + + void *(*bzalloc)(void *,int,int); + void (*bzfree)(void *,void *); + void *opaque; +} bz_stream; + +typedef struct { + bz_stream strm; + FILE *handle; + unsigned char initialisedOk; + unsigned char writing; + char buf[BZ_MAX_UNUSED]; + int lastErr; + int bufN; +} bzFile; + +/*-- Structure holding all the decompression-side stuff. --*/ +typedef struct { + /* pointer back to the struct bz_stream */ + bz_stream* strm; + + /* state indicator for this stream */ + int state; + + /* for doing the final run-length decoding */ + unsigned char state_out_ch; + int state_out_len; + unsigned char blockRandomised; + int rNToGo; + int rTPos; + + /* the buffer for bit stream reading */ + unsigned int bsBuff; + int bsLive; + + /* misc administratium */ + int blockSize100k; + unsigned char smallDecompress; + int currBlockNo; + int verbosity; + + /* for undoing the Burrows-Wheeler transform */ + int origPtr; + unsigned int tPos; + int k0; + int unzftab[256]; + int nblock_used; + int cftab[257]; + int cftabCopy[257]; + + /* for undoing the Burrows-Wheeler transform (FAST) */ + unsigned int *tt; + + /* for undoing the Burrows-Wheeler transform (SMALL) */ + unsigned short *ll16; + unsigned char *ll4; + + /* stored and calculated CRCs */ + unsigned int storedBlockCRC; + unsigned int storedCombinedCRC; + unsigned int calculatedBlockCRC; + unsigned int calculatedCombinedCRC; + + /* map of bytes used in block */ + int nInUse; + unsigned char inUse[256]; + unsigned char inUse16[16]; + unsigned char seqToUnseq[256]; + + /* for decoding the MTF values */ + unsigned char mtfa [MTFA_SIZE]; + unsigned char selector [2 + (900000 / BZ_G_SIZE)]; + unsigned char selectorMtf[2 + (900000 / BZ_G_SIZE)]; + unsigned char len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + int mtfbase[256 / MTFL_SIZE]; + + int limit [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + int base [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + int perm [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + int minLens[BZ_N_GROUPS]; + + /* save area for scalars in the main decompress code */ + int save_i; + int save_j; + int save_t; + int save_alphaSize; + int save_nGroups; + int save_nSelectors; + int save_EOB; + int save_groupNo; + int save_groupPos; + int save_nextSym; + int save_nblockMAX; + int save_nblock; + int save_es; + int save_N; + int save_curr; + int save_zt; + int save_zn; + int save_zvec; + int save_zj; + int save_gSel; + int save_gMinlen; + int *save_gLimit; + int *save_gBase; + int *save_gPerm; +} DState; + +int BZ2_rNums[512]; +//int verbosity_level; +unsigned char smallMode; +unsigned char noisy; +char *progName; +char inName[FILE_NAME_LEN]; +char outName[FILE_NAME_LEN]; +int srcMode; +int opMode; +unsigned char deleteOutputOnInterrupt; +FILE *outputHandleJustInCase; +int numFileNames; +int numFilesProcessed; +int exitValue; + +unsigned int BZ2_crc32Table[256] = { + + /*-- Ugly, innit? --*/ + + 0x00000000L, 0x04c11db7L, 0x09823b6eL, 0x0d4326d9L, + 0x130476dcL, 0x17c56b6bL, 0x1a864db2L, 0x1e475005L, + 0x2608edb8L, 0x22c9f00fL, 0x2f8ad6d6L, 0x2b4bcb61L, + 0x350c9b64L, 0x31cd86d3L, 0x3c8ea00aL, 0x384fbdbdL, + 0x4c11db70L, 0x48d0c6c7L, 0x4593e01eL, 0x4152fda9L, + 0x5f15adacL, 0x5bd4b01bL, 0x569796c2L, 0x52568b75L, + 0x6a1936c8L, 0x6ed82b7fL, 0x639b0da6L, 0x675a1011L, + 0x791d4014L, 0x7ddc5da3L, 0x709f7b7aL, 0x745e66cdL, + 0x9823b6e0L, 0x9ce2ab57L, 0x91a18d8eL, 0x95609039L, + 0x8b27c03cL, 0x8fe6dd8bL, 0x82a5fb52L, 0x8664e6e5L, + 0xbe2b5b58L, 0xbaea46efL, 0xb7a96036L, 0xb3687d81L, + 0xad2f2d84L, 0xa9ee3033L, 0xa4ad16eaL, 0xa06c0b5dL, + 0xd4326d90L, 0xd0f37027L, 0xddb056feL, 0xd9714b49L, + 0xc7361b4cL, 0xc3f706fbL, 0xceb42022L, 0xca753d95L, + 0xf23a8028L, 0xf6fb9d9fL, 0xfbb8bb46L, 0xff79a6f1L, + 0xe13ef6f4L, 0xe5ffeb43L, 0xe8bccd9aL, 0xec7dd02dL, + 0x34867077L, 0x30476dc0L, 0x3d044b19L, 0x39c556aeL, + 0x278206abL, 0x23431b1cL, 0x2e003dc5L, 0x2ac12072L, + 0x128e9dcfL, 0x164f8078L, 0x1b0ca6a1L, 0x1fcdbb16L, + 0x018aeb13L, 0x054bf6a4L, 0x0808d07dL, 0x0cc9cdcaL, + 0x7897ab07L, 0x7c56b6b0L, 0x71159069L, 0x75d48ddeL, + 0x6b93dddbL, 0x6f52c06cL, 0x6211e6b5L, 0x66d0fb02L, + 0x5e9f46bfL, 0x5a5e5b08L, 0x571d7dd1L, 0x53dc6066L, + 0x4d9b3063L, 0x495a2dd4L, 0x44190b0dL, 0x40d816baL, + 0xaca5c697L, 0xa864db20L, 0xa527fdf9L, 0xa1e6e04eL, + 0xbfa1b04bL, 0xbb60adfcL, 0xb6238b25L, 0xb2e29692L, + 0x8aad2b2fL, 0x8e6c3698L, 0x832f1041L, 0x87ee0df6L, + 0x99a95df3L, 0x9d684044L, 0x902b669dL, 0x94ea7b2aL, + 0xe0b41de7L, 0xe4750050L, 0xe9362689L, 0xedf73b3eL, + 0xf3b06b3bL, 0xf771768cL, 0xfa325055L, 0xfef34de2L, + 0xc6bcf05fL, 0xc27dede8L, 0xcf3ecb31L, 0xcbffd686L, + 0xd5b88683L, 0xd1799b34L, 0xdc3abdedL, 0xd8fba05aL, + 0x690ce0eeL, 0x6dcdfd59L, 0x608edb80L, 0x644fc637L, + 0x7a089632L, 0x7ec98b85L, 0x738aad5cL, 0x774bb0ebL, + 0x4f040d56L, 0x4bc510e1L, 0x46863638L, 0x42472b8fL, + 0x5c007b8aL, 0x58c1663dL, 0x558240e4L, 0x51435d53L, + 0x251d3b9eL, 0x21dc2629L, 0x2c9f00f0L, 0x285e1d47L, + 0x36194d42L, 0x32d850f5L, 0x3f9b762cL, 0x3b5a6b9bL, + 0x0315d626L, 0x07d4cb91L, 0x0a97ed48L, 0x0e56f0ffL, + 0x1011a0faL, 0x14d0bd4dL, 0x19939b94L, 0x1d528623L, + 0xf12f560eL, 0xf5ee4bb9L, 0xf8ad6d60L, 0xfc6c70d7L, + 0xe22b20d2L, 0xe6ea3d65L, 0xeba91bbcL, 0xef68060bL, + 0xd727bbb6L, 0xd3e6a601L, 0xdea580d8L, 0xda649d6fL, + 0xc423cd6aL, 0xc0e2d0ddL, 0xcda1f604L, 0xc960ebb3L, + 0xbd3e8d7eL, 0xb9ff90c9L, 0xb4bcb610L, 0xb07daba7L, + 0xae3afba2L, 0xaafbe615L, 0xa7b8c0ccL, 0xa379dd7bL, + 0x9b3660c6L, 0x9ff77d71L, 0x92b45ba8L, 0x9675461fL, + 0x8832161aL, 0x8cf30badL, 0x81b02d74L, 0x857130c3L, + 0x5d8a9099L, 0x594b8d2eL, 0x5408abf7L, 0x50c9b640L, + 0x4e8ee645L, 0x4a4ffbf2L, 0x470cdd2bL, 0x43cdc09cL, + 0x7b827d21L, 0x7f436096L, 0x7200464fL, 0x76c15bf8L, + 0x68860bfdL, 0x6c47164aL, 0x61043093L, 0x65c52d24L, + 0x119b4be9L, 0x155a565eL, 0x18197087L, 0x1cd86d30L, + 0x029f3d35L, 0x065e2082L, 0x0b1d065bL, 0x0fdc1becL, + 0x3793a651L, 0x3352bbe6L, 0x3e119d3fL, 0x3ad08088L, + 0x2497d08dL, 0x2056cd3aL, 0x2d15ebe3L, 0x29d4f654L, + 0xc5a92679L, 0xc1683bceL, 0xcc2b1d17L, 0xc8ea00a0L, + 0xd6ad50a5L, 0xd26c4d12L, 0xdf2f6bcbL, 0xdbee767cL, + 0xe3a1cbc1L, 0xe760d676L, 0xea23f0afL, 0xeee2ed18L, + 0xf0a5bd1dL, 0xf464a0aaL, 0xf9278673L, 0xfde69bc4L, + 0x89b8fd09L, 0x8d79e0beL, 0x803ac667L, 0x84fbdbd0L, + 0x9abc8bd5L, 0x9e7d9662L, 0x933eb0bbL, 0x97ffad0cL, + 0xafb010b1L, 0xab710d06L, 0xa6322bdfL, 0xa2f33668L, + 0xbcb4666dL, 0xb8757bdaL, 0xb5365d03L, 0xb1f740b4L +}; + +void bz_rand_udp_mask(DState *s) +{ + if (s->rNToGo == 0) { + s->rNToGo = BZ2_rNums[s->rTPos]; + s->rTPos++; + if (s->rTPos == 512) { + s->rTPos = 0; + } + } + s->rNToGo--; +} + +static unsigned char myfeof(FILE *f) +{ + int c = fgetc(f); + if (c == EOF) { + return(TRUE); + } + ungetc(c, f); + return(FALSE); +} + +static void cleanUpAndFail(int ec) +{ + int retVal; + + if ((srcMode == SM_F2F) && (opMode != OM_TEST) && deleteOutputOnInterrupt) { + if (noisy) { + error_msg("%s: Deleting output file %s, if it exists.\n", progName, outName); + } + if (outputHandleJustInCase != NULL) { + fclose(outputHandleJustInCase); + } + retVal = remove(outName); + if (retVal != 0) { + error_msg("%s: WARNING: deletion of output file (apparently) failed.\n", progName); + } + } + if (noisy && (numFileNames > 0) && (numFilesProcessed < numFileNames)) { + error_msg("%s: WARNING: some files have not been processed:\n" + "\t%d specified on command line, %d not processed yet.\n\n", + progName, numFileNames, numFileNames - numFilesProcessed ); + } + + exit(ec); +} + + +void panic(char *s) +{ + error_msg("\n%s: PANIC -- internal consistency error:\n" + "\t%s\n" + "\tThis is a BUG. Please report it to me at:\n" + "\tjseward@acm.org\n", + progName, s); + cleanUpAndFail( 3 ); +} + +void BZ2_hbCreateDecodeTables(int *limit, int *base, int *perm, unsigned char *length, int minLen, int maxLen, int alphaSize ) +{ + int pp, i, j, vec; + + pp = 0; + for (i = minLen; i <= maxLen; i++) { + for (j = 0; j < alphaSize; j++) { + if (length[j] == i) { + perm[pp] = j; + pp++; + } + } + } + + for (i = 0; i < BZ_MAX_CODE_LEN; i++) { + base[i] = 0; + } + + for (i = 0; i < alphaSize; i++) { + base[length[i]+1]++; + } + + for (i = 1; i < BZ_MAX_CODE_LEN; i++) { + base[i] += base[i-1]; + } + + for (i = 0; i < BZ_MAX_CODE_LEN; i++) { + limit[i] = 0; + } + vec = 0; + + for (i = minLen; i <= maxLen; i++) { + vec += (base[i+1] - base[i]); + limit[i] = vec-1; + vec <<= 1; + } + for (i = minLen + 1; i <= maxLen; i++) { + base[i] = ((limit[i-1] + 1) << 1) - base[i]; + } +} + +int bz_get_small(DState *s) +{ + int cccc; + int nb, na, mid; + nb = 0; + na = 256; + do { + mid = (nb + na) >> 1; + if (s->tPos >= s->cftab[mid]) { + nb = mid; + } else { + na = mid; + } + } + while (na - nb != 1); + cccc = nb; + s->tPos = (((unsigned int)s->ll16[s->tPos]) | + (((((unsigned int)(s->ll4[(s->tPos) >> 1])) >> + (((s->tPos) << 2) & 0x4)) & 0xF) << 16)); + return(cccc); +} + +void assert_h(int errcode) +{ + error_msg_and_die("\n\nbzip2/libbzip2: internal error number %d.\n" + "This is a bug in bzip2/libbzip2, %s.\n" + "Please report it to me at: jseward@acm.org. If this happened\n" + "when you were using some program which uses libbzip2 as a\n" + "component, you should also report this bug to the author(s)\n" + "of that program. Please make an effort to report this bug;\n" + "timely and accurate bug reports eventually lead to higher\n" + "quality software. Thanks. Julian Seward, 21 March 2000.\n\n", + errcode, BZ_VERSION); +} + +static int get_bits(DState *s, int *vvv, char nnn) +{ + while (1) { + if (s->bsLive >= nnn) { + *vvv = (s->bsBuff >> (s->bsLive-nnn)) & ((1 << nnn)-1); + s->bsLive -= nnn; + break; + } + if (s->strm->avail_in == 0) { + return(FALSE); + } + s->bsBuff = (s->bsBuff << 8) | ((unsigned int) (*((unsigned char*)(s->strm->next_in)))); + s->bsLive += 8; + s->strm->next_in++; + s->strm->avail_in--; + s->strm->total_in_lo32++; + if (s->strm->total_in_lo32 == 0) { + s->strm->total_in_hi32++; + } + } + return(TRUE); +} + +int bz_get_fast(DState *s) +{ + int cccc; + s->tPos = s->tt[s->tPos]; + cccc = (unsigned char)(s->tPos & 0xff); + s->tPos >>= 8; + return(cccc); +} + +/*---------------------------------------------------*/ +int BZ2_decompress(DState *s) +{ + int uc = 0; + int retVal; + int minLen, maxLen; + bz_stream *strm = s->strm; + + /* stuff that needs to be saved/restored */ + int i; + int j; + int t; + int alphaSize; + int nGroups; + int nSelectors; + int EOB; + int groupNo; + int groupPos; + int nextSym; + int nblockMAX; + int nblock; + int es; + int N; + int curr; + int zt; + int zn; + int zvec; + int zj; + int gSel; + int gMinlen; + int *gLimit; + int *gBase; + int *gPerm; + int switch_val; + + int get_mtf_val_init(void) + { + if (groupPos == 0) { + groupNo++; + if (groupNo >= nSelectors) { + retVal = BZ_DATA_ERROR; + return(FALSE); + } + groupPos = BZ_G_SIZE; + gSel = s->selector[groupNo]; + gMinlen = s->minLens[gSel]; + gLimit = &(s->limit[gSel][0]); + gPerm = &(s->perm[gSel][0]); + gBase = &(s->base[gSel][0]); + } + groupPos--; + zn = gMinlen; + return(TRUE); + } + + if (s->state == BZ_X_MAGIC_1) { + /*initialise the save area*/ + s->save_i = 0; + s->save_j = 0; + s->save_t = 0; + s->save_alphaSize = 0; + s->save_nGroups = 0; + s->save_nSelectors = 0; + s->save_EOB = 0; + s->save_groupNo = 0; + s->save_groupPos = 0; + s->save_nextSym = 0; + s->save_nblockMAX = 0; + s->save_nblock = 0; + s->save_es = 0; + s->save_N = 0; + s->save_curr = 0; + s->save_zt = 0; + s->save_zn = 0; + s->save_zvec = 0; + s->save_zj = 0; + s->save_gSel = 0; + s->save_gMinlen = 0; + s->save_gLimit = NULL; + s->save_gBase = NULL; + s->save_gPerm = NULL; + } + + /*restore from the save area*/ + i = s->save_i; + j = s->save_j; + t = s->save_t; + alphaSize = s->save_alphaSize; + nGroups = s->save_nGroups; + nSelectors = s->save_nSelectors; + EOB = s->save_EOB; + groupNo = s->save_groupNo; + groupPos = s->save_groupPos; + nextSym = s->save_nextSym; + nblockMAX = s->save_nblockMAX; + nblock = s->save_nblock; + es = s->save_es; + N = s->save_N; + curr = s->save_curr; + zt = s->save_zt; + zn = s->save_zn; + zvec = s->save_zvec; + zj = s->save_zj; + gSel = s->save_gSel; + gMinlen = s->save_gMinlen; + gLimit = s->save_gLimit; + gBase = s->save_gBase; + gPerm = s->save_gPerm; + + retVal = BZ_OK; + switch_val = s->state; + switch (switch_val) { + case BZ_X_MAGIC_1: + s->state = BZ_X_MAGIC_1; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 'B') { + retVal = BZ_DATA_ERROR_MAGIC; + goto save_state_and_return; + } + + case BZ_X_MAGIC_2: + s->state = BZ_X_MAGIC_2; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 'Z') { + retVal = BZ_DATA_ERROR_MAGIC; + goto save_state_and_return; + } + + case BZ_X_MAGIC_3: + s->state = BZ_X_MAGIC_3; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 'h') { + retVal = BZ_DATA_ERROR_MAGIC; + goto save_state_and_return; + } + + case BZ_X_MAGIC_4: + s->state = BZ_X_MAGIC_4; + if (get_bits(s, &s->blockSize100k, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if ((s->blockSize100k < '1') || (s->blockSize100k > '9')) { + retVal = BZ_DATA_ERROR_MAGIC; + goto save_state_and_return; + } + s->blockSize100k -= '0'; + + if (s->smallDecompress) { + s->ll16 = (strm->bzalloc)(strm->opaque, s->blockSize100k * 100000 * sizeof(unsigned short), 1); + s->ll4 = (strm->bzalloc)(strm->opaque, ((1 + s->blockSize100k * 100000) >> 1) * sizeof(unsigned char), 1); + + if (s->ll16 == NULL || s->ll4 == NULL) { + retVal = BZ_MEM_ERROR; + goto save_state_and_return; + } + } else { + s->tt = (strm->bzalloc)(strm->opaque, s->blockSize100k * 100000 * sizeof(int), 1); + if (s->tt == NULL) { + retVal = BZ_MEM_ERROR; + goto save_state_and_return; + } + } + + case BZ_X_BLKHDR_1: + s->state = BZ_X_BLKHDR_1; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + + if (uc == 0x17) { + goto endhdr_2; + } + if (uc != 0x31) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + case BZ_X_BLKHDR_2: + s->state = BZ_X_BLKHDR_2; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 0x41) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + case BZ_X_BLKHDR_3: + s->state = BZ_X_BLKHDR_3; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 0x59) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + case BZ_X_BLKHDR_4: + s->state = BZ_X_BLKHDR_4; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 0x26) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + case BZ_X_BLKHDR_5: + s->state = BZ_X_BLKHDR_5; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 0x53) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + case BZ_X_BLKHDR_6: + s->state = BZ_X_BLKHDR_6; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 0x59) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + s->currBlockNo++; + if (s->verbosity >= 2) { + error_msg("\n [%d: huff+mtf ", s->currBlockNo); + } + s->storedBlockCRC = 0; + + case BZ_X_BCRC_1: + s->state = BZ_X_BCRC_1; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc); + + case BZ_X_BCRC_2: + s->state = BZ_X_BCRC_2; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc); + + case BZ_X_BCRC_3: + s->state = BZ_X_BCRC_3; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc); + + case BZ_X_BCRC_4: + s->state = BZ_X_BCRC_4; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc); + + case BZ_X_RANDBIT: + s->state = BZ_X_RANDBIT; + { + int tmp = s->blockRandomised; + const int ret = get_bits(s, &tmp, 1); + s->blockRandomised = tmp; + if (ret == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + } + + s->origPtr = 0; + + case BZ_X_ORIGPTR_1: + s->state = BZ_X_ORIGPTR_1; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + s->origPtr = (s->origPtr << 8) | ((int)uc); + + case BZ_X_ORIGPTR_2: + s->state = BZ_X_ORIGPTR_2; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + s->origPtr = (s->origPtr << 8) | ((int)uc); + + case BZ_X_ORIGPTR_3: + s->state = BZ_X_ORIGPTR_3; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + s->origPtr = (s->origPtr << 8) | ((int)uc); + + if (s->origPtr < 0) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + if (s->origPtr > 10 + 100000*s->blockSize100k) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + /*--- Receive the mapping table ---*/ + case BZ_X_MAPPING_1: + for (i = 0; i < 16; i++) { + s->state = BZ_X_MAPPING_1; + if (get_bits(s, &uc, 1) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc == 1) { + s->inUse16[i] = TRUE; + } else { + s->inUse16[i] = FALSE; + } + } + + for (i = 0; i < 256; i++) { + s->inUse[i] = FALSE; + } + + for (i = 0; i < 16; i++) { + if (s->inUse16[i]) { + for (j = 0; j < 16; j++) { + case BZ_X_MAPPING_2: + s->state = BZ_X_MAPPING_2; + if (get_bits(s, &uc, 1) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc == 1) { + s->inUse[i * 16 + j] = TRUE; + } + } + } + } + + s->nInUse = 0; + for (i = 0; i < 256; i++) { + if (s->inUse[i]) { + s->seqToUnseq[s->nInUse] = i; + s->nInUse++; + } + } + if (s->nInUse == 0) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + alphaSize = s->nInUse+2; + + /*--- Now the selectors ---*/ + case BZ_X_SELECTOR_1: + s->state = BZ_X_SELECTOR_1; + if (get_bits(s, &nGroups, 3) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (nGroups < 2 || nGroups > 6) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + case BZ_X_SELECTOR_2: + s->state = BZ_X_SELECTOR_2; + if (get_bits(s, &nSelectors, 15) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (nSelectors < 1) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + + + for (i = 0; i < nSelectors; i++) { + j = 0; + while (1) { + case BZ_X_SELECTOR_3: + s->state = BZ_X_SELECTOR_3; + if (get_bits(s, &uc, 1) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc == 0) { + break; + } + j++; + if (j >= nGroups) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + } + s->selectorMtf[i] = j; + } + + /*--- Undo the MTF values for the selectors. ---*/ + { + unsigned char pos[BZ_N_GROUPS], tmp, v; + for (v = 0; v < nGroups; v++) { + pos[v] = v; + } + for (i = 0; i < nSelectors; i++) { + v = s->selectorMtf[i]; + tmp = pos[v]; + while (v > 0) { + pos[v] = pos[v-1]; + v--; + } + pos[0] = tmp; + s->selector[i] = tmp; + } + } + + /*--- Now the coding tables ---*/ + for (t = 0; t < nGroups; t++) { + case BZ_X_CODING_1: + s->state = BZ_X_CODING_1; + if (get_bits(s, &curr, 5) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + for (i = 0; i < alphaSize; i++) { + while (TRUE) { + if (curr < 1 || curr > 20) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + case BZ_X_CODING_2: + s->state = BZ_X_CODING_2; + if (get_bits(s, &uc, 1) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc == 0) { + break; + } + + case BZ_X_CODING_3: + s->state = BZ_X_CODING_3; + if (get_bits(s, &uc, 1) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc == 0) { + curr++; + } else { + curr--; + } + } + s->len[t][i] = curr; + } + } + + /*--- Create the Huffman decoding tables ---*/ + for (t = 0; t < nGroups; t++) { + minLen = 32; + maxLen = 0; + for (i = 0; i < alphaSize; i++) { + if (s->len[t][i] > maxLen) { + maxLen = s->len[t][i]; + } + if (s->len[t][i] < minLen) { + minLen = s->len[t][i]; + } + } + + BZ2_hbCreateDecodeTables ( + &(s->limit[t][0]), + &(s->base[t][0]), + &(s->perm[t][0]), + &(s->len[t][0]), + minLen, maxLen, alphaSize + ); + + + s->minLens[t] = minLen; + } + + /*--- Now the MTF values ---*/ + + EOB = s->nInUse+1; + nblockMAX = 100000 * s->blockSize100k; + groupNo = -1; + groupPos = 0; + + for (i = 0; i <= 255; i++) { + s->unzftab[i] = 0; + } + /*-- MTF init --*/ + { + int ii, jj, kk; + kk = MTFA_SIZE-1; + for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) { + for (jj = MTFL_SIZE-1; jj >= 0; jj--) { + s->mtfa[kk] = (unsigned char)(ii * MTFL_SIZE + jj); + kk--; + } + s->mtfbase[ii] = kk + 1; + } + } + /*-- end MTF init --*/ + + nblock = 0; + + if (get_mtf_val_init() == FALSE) { + goto save_state_and_return; + } + case BZ_X_MTF_1: + s->state = BZ_X_MTF_1; + if (get_bits(s, &zvec, zn) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + while (1) { + if (zn > 20 /* the longest code */) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + if (zvec <= gLimit[zn]) { + break; + } + zn++; + + case BZ_X_MTF_2: + s->state = BZ_X_MTF_2; + if (get_bits(s, &zj, 1) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + zvec = (zvec << 1) | zj; + } + if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + nextSym = gPerm[zvec - gBase[zn]]; + + while (1) { + if (nextSym == EOB) { + break; + } + + if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) { + es = -1; + N = 1; + do { + if (nextSym == BZ_RUNA) { + es = es + (0+1) * N; + } else { + if (nextSym == BZ_RUNB) { + es = es + (1+1) * N; + } + } + N = N * 2; + if (get_mtf_val_init() == FALSE) { + goto save_state_and_return; + } + case BZ_X_MTF_3: + s->state = BZ_X_MTF_3; + if (get_bits(s, &zvec, zn) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + while (1) { + if (zn > 20 /* the longest code */) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + if (zvec <= gLimit[zn]) { + break; + } + zn++; + + case BZ_X_MTF_4: + s->state = BZ_X_MTF_4; + if (get_bits(s, &zj, 1) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + zvec = (zvec << 1) | zj; + } + if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + + } + nextSym = gPerm[zvec - gBase[zn]]; + } + while (nextSym == BZ_RUNA || nextSym == BZ_RUNB); + + es++; + uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ]; + s->unzftab[uc] += es; + + if (s->smallDecompress) { + while (es > 0) { + if (nblock >= nblockMAX) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + s->ll16[nblock] = (unsigned short)uc; + nblock++; + es--; + } + } else { + while (es > 0) { + if (nblock >= nblockMAX) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + s->tt[nblock] = (unsigned int)uc; + nblock++; + es--; + } + } + continue; + } else { + if (nblock >= nblockMAX) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + /*-- uc = MTF ( nextSym-1 ) --*/ + { + int ii, jj, kk, pp, lno, off; + unsigned int nn; + nn = (unsigned int)(nextSym - 1); + + if (nn < MTFL_SIZE) { + /* avoid general-case expense */ + pp = s->mtfbase[0]; + uc = s->mtfa[pp+nn]; + while (nn > 3) { + int z = pp+nn; + s->mtfa[(z) ] = s->mtfa[(z)-1]; + s->mtfa[(z)-1] = s->mtfa[(z)-2]; + s->mtfa[(z)-2] = s->mtfa[(z)-3]; + s->mtfa[(z)-3] = s->mtfa[(z)-4]; + nn -= 4; + } + while (nn > 0) { + s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--; + } + s->mtfa[pp] = uc; + } else { + /* general case */ + lno = nn / MTFL_SIZE; + off = nn % MTFL_SIZE; + pp = s->mtfbase[lno] + off; + uc = s->mtfa[pp]; + while (pp > s->mtfbase[lno]) { + s->mtfa[pp] = s->mtfa[pp-1]; + pp--; + } + s->mtfbase[lno]++; + while (lno > 0) { + s->mtfbase[lno]--; + s->mtfa[s->mtfbase[lno]] = s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1]; + lno--; + } + s->mtfbase[0]--; + s->mtfa[s->mtfbase[0]] = uc; + if (s->mtfbase[0] == 0) { + kk = MTFA_SIZE-1; + for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) { + for (jj = MTFL_SIZE-1; jj >= 0; jj--) { + s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj]; + kk--; + } + s->mtfbase[ii] = kk + 1; + } + } + } + } + /*-- end uc = MTF ( nextSym-1 ) --*/ + + s->unzftab[s->seqToUnseq[uc]]++; + if (s->smallDecompress) { + s->ll16[nblock] = (unsigned short)(s->seqToUnseq[uc]); + } else { + s->tt[nblock] = (unsigned int)(s->seqToUnseq[uc]); + } + nblock++; + + if (get_mtf_val_init() == FALSE) { + goto save_state_and_return; + } + case BZ_X_MTF_5: + s->state = BZ_X_MTF_5; + if (get_bits(s, &zvec, zn) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + while (1) { + if (zn > 20 /* the longest code */) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + if (zvec <= gLimit[zn]) { + break; + } + zn++; + + case BZ_X_MTF_6: + s->state = BZ_X_MTF_6; + if (get_bits(s, &zj, 1) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + zvec = (zvec << 1) | zj; + } + if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + nextSym = gPerm[zvec - gBase[zn]]; + continue; + } + } + + /* Now we know what nblock is, we can do a better sanity + check on s->origPtr. + */ + if (s->origPtr < 0 || s->origPtr >= nblock) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + s->state_out_len = 0; + s->state_out_ch = 0; + s->calculatedBlockCRC = 0xffffffffL; + s->state = BZ_X_OUTPUT; + if (s->verbosity >= 2) { + error_msg("rt+rld"); + } + + /*-- Set up cftab to facilitate generation of T^(-1) --*/ + s->cftab[0] = 0; + for (i = 1; i <= 256; i++) { + s->cftab[i] = s->unzftab[i-1]; + } + for (i = 1; i <= 256; i++) { + s->cftab[i] += s->cftab[i-1]; + } + + if (s->smallDecompress) { + + /*-- Make a copy of cftab, used in generation of T --*/ + for (i = 0; i <= 256; i++) { + s->cftabCopy[i] = s->cftab[i]; + } + + /*-- compute the T vector --*/ + for (i = 0; i < nblock; i++) { + uc = (unsigned char)(s->ll16[i]); + s->ll16[i] = (unsigned short)(s->cftabCopy[uc] & 0x0000ffff); + if (((i) & 0x1) == 0) { + s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0xf0) | (s->cftabCopy[uc] >> 16); + } else { + s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0x0f) | ((s->cftabCopy[uc] >> 16) << 4); + } + s->cftabCopy[uc]++; + } + + /*-- Compute T^(-1) by pointer reversal on T --*/ + i = s->origPtr; + j = (((unsigned int)s->ll16[i]) | + (((((unsigned int)(s->ll4[(i) >> 1])) >> + (((i) << 2) & 0x4)) & 0xF) << 16)); + + do { + const int tmp = (((unsigned int)s->ll16[j]) | + (((((unsigned int)(s->ll4[(j) >> 1])) >> + (((j) << 2) & 0x4)) & 0xF) << 16)); + + s->ll16[j] = (unsigned short)(i & 0x0000ffff); + if (((j) & 0x1) == 0) { + s->ll4[(j) >> 1] = (s->ll4[(j) >> 1] & 0xf0) | (i >> 16); + } else { + s->ll4[(j) >> 1] = (s->ll4[(j) >> 1] & 0x0f) | ((i >> 16) << 4); + } + i = j; + j = tmp; + } + while (i != s->origPtr); + s->tPos = s->origPtr; + s->nblock_used = 0; + if (s->blockRandomised) { + s->rNToGo = 0; + s->rTPos = 0; + s->k0 = bz_get_small(s); + s->nblock_used++; + bz_rand_udp_mask(s); + s->k0 ^= ((s->rNToGo == 1) ? 1 : 0); + } else { + s->k0 = bz_get_small(s); + s->nblock_used++; + } + } else { + /*-- compute the T^(-1) vector --*/ + for (i = 0; i < nblock; i++) { + uc = (unsigned char)(s->tt[i] & 0xff); + s->tt[s->cftab[uc]] |= (i << 8); + s->cftab[uc]++; + } + + s->tPos = s->tt[s->origPtr] >> 8; + s->nblock_used = 0; + if (s->blockRandomised) { + s->rNToGo = 0; + s->rTPos = 0; + s->k0 = bz_get_fast(s); + + s->nblock_used++; + bz_rand_udp_mask(s); + s->k0 ^= ((s->rNToGo == 1) ? 1 : 0); + } else { + s->k0 = bz_get_fast(s); + s->nblock_used++; + } + } + + retVal = BZ_OK; + goto save_state_and_return; + +endhdr_2: + case BZ_X_ENDHDR_2: + s->state = BZ_X_ENDHDR_2; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 0x72) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + case BZ_X_ENDHDR_3: + s->state = BZ_X_ENDHDR_3; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 0x45) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + case BZ_X_ENDHDR_4: + s->state = BZ_X_ENDHDR_4; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 0x38) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + case BZ_X_ENDHDR_5: + s->state = BZ_X_ENDHDR_5; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 0x50) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + case BZ_X_ENDHDR_6: + s->state = BZ_X_ENDHDR_6; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 0x90) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + s->storedCombinedCRC = 0; + + case BZ_X_CCRC_1: + s->state = BZ_X_CCRC_1; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc); + case BZ_X_CCRC_2: + s->state = BZ_X_CCRC_2; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc); + + case BZ_X_CCRC_3: + s->state = BZ_X_CCRC_3; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc); + + case BZ_X_CCRC_4: + s->state = BZ_X_CCRC_4; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc); + + s->state = BZ_X_IDLE; + retVal = BZ_STREAM_END; + goto save_state_and_return; + +default: + printf("switch val is %d\n", switch_val); + assert_h(4001); + } + + assert_h(4002); + +save_state_and_return: + s->save_i = i; + s->save_j = j; + s->save_t = t; + s->save_alphaSize = alphaSize; + s->save_nGroups = nGroups; + s->save_nSelectors = nSelectors; + s->save_EOB = EOB; + s->save_groupNo = groupNo; + s->save_groupPos = groupPos; + s->save_nextSym = nextSym; + s->save_nblockMAX = nblockMAX; + s->save_nblock = nblock; + s->save_es = es; + s->save_N = N; + s->save_curr = curr; + s->save_zt = zt; + s->save_zn = zn; + s->save_zvec = zvec; + s->save_zj = zj; + s->save_gSel = gSel; + s->save_gMinlen = gMinlen; + s->save_gLimit = gLimit; + s->save_gBase = gBase; + s->save_gPerm = gPerm; + + return retVal; +} + +static void *default_bzalloc(void *opaque, int items, int size) +{ + void *v = xmalloc(items *size); + return v; +} + +static void default_bzfree(void *opaque, void *addr) +{ + if (addr != NULL) { + free(addr); + } +} + +//int BZ2_bzDecompressInit(bz_stream* strm, int verbosity_level, int small) +int BZ2_bzDecompressInit(bz_stream* strm, int small) +{ + DState* s; + + if (sizeof(int) != 4) { + return BZ_CONFIG_ERROR; + } + if (sizeof(short) != 2) { + return BZ_CONFIG_ERROR; + } + if (sizeof(char) != 1) { + return BZ_CONFIG_ERROR; + } + if (strm == NULL) { + return BZ_PARAM_ERROR; + } + if (small != 0 && small != 1) { + return BZ_PARAM_ERROR; + } +// if (verbosity_level < 0 || verbosity_level > 4) { +// return BZ_PARAM_ERROR; +// } + if (strm->bzalloc == NULL) { + strm->bzalloc = default_bzalloc; + } + if (strm->bzfree == NULL) { + strm->bzfree = default_bzfree; + } + s = (strm->bzalloc)(strm->opaque, sizeof(DState), 1); + if (s == NULL) { + return BZ_MEM_ERROR; + } + s->strm = strm; + strm->state = s; + s->state = BZ_X_MAGIC_1; + s->bsLive = 0; + s->bsBuff = 0; + s->calculatedCombinedCRC = 0; + strm->total_in_lo32 = 0; + strm->total_in_hi32 = 0; + strm->total_out_lo32 = 0; + strm->total_out_hi32 = 0; + s->smallDecompress = (unsigned char)small; + s->ll4 = NULL; + s->ll16 = NULL; + s->tt = NULL; + s->currBlockNo = 0; +// s->verbosity = verbosity_level; + + return BZ_OK; +} + +void bz_seterr(int eee, int *bzerror, bzFile **bzf) +{ + if (bzerror != NULL) { + *bzerror = eee; + } + if (*bzf != NULL) { + (*bzf)->lastErr = eee; + } +} + +void BZ2_bzReadClose(int *bzerror, void *b) +{ + bzFile* bzf = (bzFile*)b; + + bz_seterr(BZ_OK, bzerror, &bzf); + if (bzf == NULL) { + bz_seterr(BZ_OK, bzerror, &bzf); + return; + } + + if (bzf->writing) { + bz_seterr(BZ_SEQUENCE_ERROR, bzerror, &bzf); + return; + } + + if (bzf->initialisedOk) { + bz_stream *strm = &(bzf->strm); + DState *s; + if (strm == NULL) { + return; + } + s = strm->state; + if ((s == NULL) || (s->strm != strm)) { + return; + } + if (s->tt != NULL) { + (strm->bzfree)(strm->opaque,(s->tt)); + } + if (s->ll16 != NULL) { + (strm->bzfree)(strm->opaque,(s->ll16)); + } + if (s->ll4 != NULL) { + (strm->bzfree)(strm->opaque,(s->ll4)); + } + (strm->bzfree)(strm->opaque,(strm->state)); + strm->state = NULL; + return; + } + free(bzf); +} + +static void unRLE_obuf_to_output_FAST(DState *s) +{ + unsigned char k1; + + if (s->blockRandomised) { + while (1) { + /* try to finish existing run */ + while (1) { + if (s->strm->avail_out == 0) { + return; + } + if (s->state_out_len == 0) { + break; + } + *((unsigned char *)(s->strm->next_out)) = s->state_out_ch; + s->calculatedBlockCRC = (s->calculatedBlockCRC << 8) ^ + BZ2_crc32Table[(s->calculatedBlockCRC >> 24) ^ + ((unsigned char)s->state_out_ch)]; + s->state_out_len--; + s->strm->next_out++; + s->strm->avail_out--; + s->strm->total_out_lo32++; + if (s->strm->total_out_lo32 == 0) { + s->strm->total_out_hi32++; + } + } + + /* can a new run be started? */ + if (s->nblock_used == s->save_nblock+1) { + return; + } + s->state_out_len = 1; + s->state_out_ch = s->k0; + k1 = bz_get_fast(s); + bz_rand_udp_mask(s); + k1 ^= ((s->rNToGo == 1) ? 1 : 0); + s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) { + continue; + } + if (k1 != s->k0) { + s->k0 = k1; + continue; + } + + s->state_out_len = 2; + k1 = bz_get_fast(s); + bz_rand_udp_mask(s); + k1 ^= ((s->rNToGo == 1) ? 1 : 0); + s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) { + continue; + } + if (k1 != s->k0) { + s->k0 = k1; + continue; + } + s->state_out_len = 3; + k1 = bz_get_fast(s); + bz_rand_udp_mask(s); + k1 ^= ((s->rNToGo == 1) ? 1 : 0); + s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) { + continue; + } + if (k1 != s->k0) { + s->k0 = k1; + continue; + } + + k1 = bz_get_fast(s); + bz_rand_udp_mask(s); + k1 ^= ((s->rNToGo == 1) ? 1 : 0); + s->nblock_used++; + s->state_out_len = ((int)k1) + 4; + s->k0 = bz_get_fast(s); + bz_rand_udp_mask(s); + s->k0 ^= ((s->rNToGo == 1) ? 1 : 0); + s->nblock_used++; + } + } else { + /* restore */ + unsigned int c_calculatedBlockCRC = s->calculatedBlockCRC; + unsigned char c_state_out_ch = s->state_out_ch; + int c_state_out_len = s->state_out_len; + int c_nblock_used = s->nblock_used; + int c_k0 = s->k0; + unsigned int *c_tt = s->tt; + unsigned int c_tPos = s->tPos; + char *cs_next_out = s->strm->next_out; + unsigned int cs_avail_out = s->strm->avail_out; + /* end restore */ + + unsigned int avail_out_INIT = cs_avail_out; + int s_save_nblockPP = s->save_nblock+1; + unsigned int total_out_lo32_old; + + while (1) { + /* try to finish existing run */ + if (c_state_out_len > 0) { + while (TRUE) { + if (cs_avail_out == 0) { + goto return_notr; + } + if (c_state_out_len == 1) { + break; + } + *((unsigned char *)(cs_next_out)) = c_state_out_ch; + c_calculatedBlockCRC = (c_calculatedBlockCRC << 8) ^ + BZ2_crc32Table[(c_calculatedBlockCRC >> 24) ^ + ((unsigned char)c_state_out_ch)]; + c_state_out_len--; + cs_next_out++; + cs_avail_out--; + } +s_state_out_len_eq_one: + { + if (cs_avail_out == 0) { + c_state_out_len = 1; + goto return_notr; + } + *((unsigned char *)(cs_next_out)) = c_state_out_ch; + c_calculatedBlockCRC = (c_calculatedBlockCRC << 8) ^ + BZ2_crc32Table[(c_calculatedBlockCRC >> 24) ^ + ((unsigned char)c_state_out_ch)]; + cs_next_out++; + cs_avail_out--; + } + } + /* can a new run be started? */ + if (c_nblock_used == s_save_nblockPP) { + c_state_out_len = 0; goto return_notr; + } + c_state_out_ch = c_k0; + c_tPos = c_tt[c_tPos]; + k1 = (unsigned char)(c_tPos & 0xff); + c_tPos >>= 8; + + c_nblock_used++; + + if (k1 != c_k0) { + c_k0 = k1; + goto s_state_out_len_eq_one; + } + + if (c_nblock_used == s_save_nblockPP) { + goto s_state_out_len_eq_one; + } + + c_state_out_len = 2; + c_tPos = c_tt[c_tPos]; + k1 = (unsigned char)(c_tPos & 0xff); + c_tPos >>= 8; + + c_nblock_used++; + if (c_nblock_used == s_save_nblockPP) { + continue; + } + if (k1 != c_k0) { + c_k0 = k1; + continue; + } + + c_state_out_len = 3; + c_tPos = c_tt[c_tPos]; + k1 = (unsigned char)(c_tPos & 0xff); + c_tPos >>= 8; + + c_nblock_used++; + if (c_nblock_used == s_save_nblockPP) { + continue; + } + if (k1 != c_k0) { + c_k0 = k1; + continue; + } + + c_tPos = c_tt[c_tPos]; + k1 = (unsigned char)(c_tPos & 0xff); + c_tPos >>= 8; + + c_nblock_used++; + c_state_out_len = ((int)k1) + 4; + + c_tPos = c_tt[c_tPos]; + c_k0 = (unsigned char)(c_tPos & 0xff); + c_tPos >>= 8; + + c_nblock_used++; + } + +return_notr: + total_out_lo32_old = s->strm->total_out_lo32; + s->strm->total_out_lo32 += (avail_out_INIT - cs_avail_out); + if (s->strm->total_out_lo32 < total_out_lo32_old) { + s->strm->total_out_hi32++; + } + + /* save */ + s->calculatedBlockCRC = c_calculatedBlockCRC; + s->state_out_ch = c_state_out_ch; + s->state_out_len = c_state_out_len; + s->nblock_used = c_nblock_used; + s->k0 = c_k0; + s->tt = c_tt; + s->tPos = c_tPos; + s->strm->next_out = cs_next_out; + s->strm->avail_out = cs_avail_out; + /* end save */ + } +} + +static void unRLE_obuf_to_output_SMALL(DState *s) +{ + unsigned char k1; + + if (s->blockRandomised) { + while (1) { + /* try to finish existing run */ + while (1) { + if (s->strm->avail_out == 0) { + return; + } + if (s->state_out_len == 0) { + break; + } + *((unsigned char *)(s->strm->next_out)) = s->state_out_ch; + s->calculatedBlockCRC = (s->calculatedBlockCRC << 8) ^ + BZ2_crc32Table[(s->calculatedBlockCRC >> 24) ^ + ((unsigned char)s->state_out_ch)]; + s->state_out_len--; + s->strm->next_out++; + s->strm->avail_out--; + s->strm->total_out_lo32++; + if (s->strm->total_out_lo32 == 0) { + s->strm->total_out_hi32++; + } + } + + /* can a new run be started? */ + if (s->nblock_used == s->save_nblock+1) { + return; + } + + s->state_out_len = 1; + s->state_out_ch = s->k0; + k1 = bz_get_small(s); + bz_rand_udp_mask(s); + k1 ^= ((s->rNToGo == 1) ? 1 : 0); + s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) { + continue; + } + if (k1 != s->k0) { + s->k0 = k1; + continue; + } + + s->state_out_len = 2; + k1 = bz_get_small(s); + bz_rand_udp_mask(s); + k1 ^= ((s->rNToGo == 1) ? 1 : 0); + s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) { + continue; + } + if (k1 != s->k0) { + s->k0 = k1; + continue; + } + + s->state_out_len = 3; + k1 = bz_get_small(s); + bz_rand_udp_mask(s); + k1 ^= ((s->rNToGo == 1) ? 1 : 0); + s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) { + continue; + } + if (k1 != s->k0) { + s->k0 = k1; + continue; + } + k1 = bz_get_small(s); + bz_rand_udp_mask(s); + k1 ^= ((s->rNToGo == 1) ? 1 : 0); + s->nblock_used++; + s->state_out_len = ((int)k1) + 4; + s->k0 = bz_get_small(s); + bz_rand_udp_mask(s); + s->k0 ^= ((s->rNToGo == 1) ? 1 : 0); + s->nblock_used++; + } + } else { + while (1) { + /* try to finish existing run */ + while (1) { + if (s->strm->avail_out == 0) { + return; + } + if (s->state_out_len == 0) { + break; + } + *((unsigned char *)(s->strm->next_out)) = s->state_out_ch; + s->calculatedBlockCRC = (s->calculatedBlockCRC << 8) ^ + BZ2_crc32Table[(s->calculatedBlockCRC >> 24) ^ + ((unsigned char)s->state_out_ch)]; + s->state_out_len--; + s->strm->next_out++; + s->strm->avail_out--; + s->strm->total_out_lo32++; + if (s->strm->total_out_lo32 == 0) { + s->strm->total_out_hi32++; + } + } + + /* can a new run be started? */ + if (s->nblock_used == s->save_nblock+1) { + return; + } + + s->state_out_len = 1; + s->state_out_ch = s->k0; + k1 = bz_get_small(s); + s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) { + continue; + } + if (k1 != s->k0) { + s->k0 = k1; + continue; + } + + s->state_out_len = 2; + k1 = bz_get_small(s); + s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) { + continue; + } + if (k1 != s->k0) { + s->k0 = k1; + continue; + } + + s->state_out_len = 3; + k1 = bz_get_small(s); + s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) { + continue; + } + if (k1 != s->k0) { + s->k0 = k1; + continue; + } + + k1 = bz_get_small(s); + s->nblock_used++; + s->state_out_len = ((int)k1) + 4; + s->k0 = bz_get_small(s); + s->nblock_used++; + } + } +} + +int BZ2_bzDecompress(bz_stream *strm) +{ + DState* s; + if (strm == NULL) { + return BZ_PARAM_ERROR; + } + s = strm->state; + if (s == NULL) { + return BZ_PARAM_ERROR; + } + if (s->strm != strm) { + return BZ_PARAM_ERROR; + } + + while (1) { + if (s->state == BZ_X_IDLE) { + return BZ_SEQUENCE_ERROR; + } + if (s->state == BZ_X_OUTPUT) { + if (s->smallDecompress) { + unRLE_obuf_to_output_SMALL(s); + } else { + unRLE_obuf_to_output_FAST(s); + } + if (s->nblock_used == s->save_nblock+1 && s->state_out_len == 0) { + s->calculatedBlockCRC = ~(s->calculatedBlockCRC); + if (s->verbosity >= 3) { + error_msg("{0x%x, 0x%x}", s->storedBlockCRC, s->calculatedBlockCRC); + } + if (s->verbosity >= 2) { + error_msg("]"); + } + if (s->calculatedBlockCRC != s->storedBlockCRC) { + return BZ_DATA_ERROR; + } + s->calculatedCombinedCRC = (s->calculatedCombinedCRC << 1) | (s->calculatedCombinedCRC >> 31); + s->calculatedCombinedCRC ^= s->calculatedBlockCRC; + s->state = BZ_X_BLKHDR_1; + } else { + return BZ_OK; + } + } + if (s->state >= BZ_X_MAGIC_1) { + int r = BZ2_decompress(s); + if (r == BZ_STREAM_END) { + if (s->verbosity >= 3) { + error_msg("\n combined CRCs: stored = 0x%x, computed = 0x%x", + s->storedCombinedCRC, s->calculatedCombinedCRC ); + } + if (s->calculatedCombinedCRC != s->storedCombinedCRC) { + return BZ_DATA_ERROR; + } + return r; + } + if (s->state != BZ_X_OUTPUT) { + return r; + } + } + } + + assert_h(6001); + + return(0); /*NOTREACHED*/ +} + +int BZ2_bzRead(int *bzerror, void *b, void *buf, int len) +{ + int n, ret; + bzFile *bzf = (bzFile*)b; + + bz_seterr(BZ_OK, bzerror, &bzf); + + if (bzf == NULL || buf == NULL || len < 0) { + bz_seterr(BZ_PARAM_ERROR, bzerror, &bzf); + return 0; + } + + if (bzf->writing) { + bz_seterr(BZ_SEQUENCE_ERROR, bzerror, &bzf); + return 0; + } + + if (len == 0) { + bz_seterr(BZ_OK, bzerror, &bzf); + return 0; + } + + bzf->strm.avail_out = len; + bzf->strm.next_out = buf; + + while (1) { + if (ferror(bzf->handle)) { + bz_seterr(BZ_IO_ERROR, bzerror, &bzf); + return 0; + } + if ((bzf->strm.avail_in == 0) && !myfeof(bzf->handle)) { + n = fread(bzf->buf, sizeof(unsigned char), BZ_MAX_UNUSED, bzf->handle); + if (ferror(bzf->handle)) { + bz_seterr(BZ_IO_ERROR, bzerror, &bzf); + return 0; + } + bzf->bufN = n; + bzf->strm.avail_in = bzf->bufN; + bzf->strm.next_in = bzf->buf; + } + + ret = BZ2_bzDecompress(&(bzf->strm)); + + if ((ret != BZ_OK) && (ret != BZ_STREAM_END)) { + bz_seterr(ret, bzerror, &bzf); + return 0; + } + + if ((ret == BZ_OK) && myfeof(bzf->handle) && + (bzf->strm.avail_in == 0) && (bzf->strm.avail_out > 0)) { + bz_seterr(BZ_UNEXPECTED_EOF, bzerror, &bzf); + return(0); + } + + if (ret == BZ_STREAM_END) { + bz_seterr(BZ_STREAM_END, bzerror, &bzf); + return(len - bzf->strm.avail_out); + } + if (bzf->strm.avail_out == 0) { + bz_seterr(BZ_OK, bzerror, &bzf); + return(len); + } + } + return(0); /*not reached*/ +} + +void BZ2_bzReadGetUnused(int *bzerror, void *b, void **unused, int *nUnused) +{ + bzFile *bzf = (bzFile*)b; + if (bzf == NULL) { + bz_seterr(BZ_PARAM_ERROR, bzerror, &bzf); + return; + } + if (bzf->lastErr != BZ_STREAM_END) { + bz_seterr(BZ_SEQUENCE_ERROR, bzerror, &bzf); + return; + } + if (unused == NULL || nUnused == NULL) { + bz_seterr(BZ_PARAM_ERROR, bzerror, &bzf); + return; + } + + bz_seterr(BZ_OK, bzerror, &bzf); + *nUnused = bzf->strm.avail_in; + *unused = bzf->strm.next_in; +} + +void *BZ2_bzReadOpen(int *bzerror, FILE *f, int small, void *unused, int nUnused) +{ + bzFile *bzf = NULL; + int ret; + + bz_seterr(BZ_OK, bzerror, &bzf); + + if (f == NULL || (small != 0 && small != 1) || + (unused != NULL && (nUnused < 0 || nUnused > BZ_MAX_UNUSED)) || +// (verbosity_level < 0 || verbosity_level > 4) || + (unused == NULL && nUnused != 0)) { + bz_seterr(BZ_PARAM_ERROR, bzerror, &bzf); + return NULL; + } + + if (ferror(f)) { + bz_seterr(BZ_IO_ERROR, bzerror, &bzf); + return NULL; + } + + bzf = xmalloc(sizeof(bzFile)); + if (bzf == NULL) { + bz_seterr(BZ_MEM_ERROR, bzerror, &bzf); + return NULL; + } + bz_seterr(BZ_OK, bzerror, &bzf); + + bzf->initialisedOk = FALSE; + bzf->handle = f; + bzf->bufN = 0; + bzf->writing = FALSE; + bzf->strm.bzalloc = NULL; + bzf->strm.bzfree = NULL; + bzf->strm.opaque = NULL; + + while (nUnused > 0) { + bzf->buf[bzf->bufN] = *((unsigned char *)(unused)); bzf->bufN++; + unused = ((void *)( 1 + ((unsigned char *)(unused)) )); + nUnused--; + } + + ret = BZ2_bzDecompressInit(&(bzf->strm), small); + if (ret != BZ_OK) { + bz_seterr(ret, bzerror, &bzf); + free(bzf); + return NULL; + } + + bzf->strm.avail_in = bzf->bufN; + bzf->strm.next_in = bzf->buf; + + bzf->initialisedOk = TRUE; + return bzf; +} + +static unsigned char uncompressStream(FILE *zStream, FILE *stream) +{ + unsigned char unused[BZ_MAX_UNUSED]; + unsigned char *unusedTmp; + unsigned char obuf[5000]; + void *bzf = NULL; + int bzerr_dummy; + int bzerr; + int nread; + int nUnused; + int streamNo; + int ret; + int i; + + nUnused = 0; + streamNo = 0; + + if (ferror(stream)) { + goto errhandler_io; + } + if (ferror(zStream)) { + goto errhandler_io; + } + + while(1) { + bzf = BZ2_bzReadOpen(&bzerr, zStream, (int)smallMode, unused, nUnused); + if (bzf == NULL || bzerr != BZ_OK) { + goto errhandler; + } + streamNo++; + + while (bzerr == BZ_OK) { + nread = BZ2_bzRead(&bzerr, bzf, obuf, 5000); + if (bzerr == BZ_DATA_ERROR_MAGIC) { + goto errhandler; + } + if ((bzerr == BZ_OK || bzerr == BZ_STREAM_END) && nread > 0) { + fwrite(obuf, sizeof(unsigned char), nread, stream); + } + if (ferror(stream)) { + goto errhandler_io; + } + } + if (bzerr != BZ_STREAM_END) { + goto errhandler; + } + BZ2_bzReadGetUnused(&bzerr, bzf, (void **)(&unusedTmp), &nUnused); + if (bzerr != BZ_OK) { + panic("decompress:bzReadGetUnused"); + } + for (i = 0; i < nUnused; i++) { + unused[i] = unusedTmp[i]; + } + BZ2_bzReadClose(&bzerr, bzf); + if (bzerr != BZ_OK) { + panic("decompress:bzReadGetUnused"); + } + if ((nUnused == 0) && myfeof(zStream)) { + break; + } + } + + if (ferror(zStream)) { + goto errhandler_io; + } + ret = fclose(zStream); + if (ret == EOF) { + goto errhandler_io; + } + if (ferror(stream)) { + goto errhandler_io; + } + ret = fflush(stream); + if (ret != 0) { + goto errhandler_io; + } + if (stream != stdout) { + ret = fclose(stream); + if (ret == EOF) { + goto errhandler_io; + } + } +// if (verbosity_level >= 2) { +// fprintf(stderr,"\n "); +// } + return TRUE; + +errhandler: + BZ2_bzReadClose ( &bzerr_dummy, bzf ); + switch (bzerr) { + case BZ_CONFIG_ERROR: + error_msg("bzip2: I'm not configured correctly for this platform!\n" + "\tI require Int32, Int16 and Char to have sizes\n" + "\tof 4, 2 and 1 bytes to run properly, and they don't.\n" + "\tProbably you can fix this by defining them correctly,\n" + "\tand recompiling. Bye!\n" ); + exit(3); + case BZ_IO_ERROR: +errhandler_io: + error_msg("\n%s: I/O or other error, bailing out. " + "Possible reason follows.\n", progName); + perror(progName); + cleanUpAndFail(1); + case BZ_DATA_ERROR: + error_msg("\n%s: Data integrity error when decompressing.\n", progName); + cleanUpAndFail(2); + case BZ_MEM_ERROR: + error_msg("\n%s: couldn't allocate enough memory\n", progName); + cleanUpAndFail(1); + case BZ_UNEXPECTED_EOF: + error_msg("\n%s: Compressed file ends unexpectedly;\n\t" + "perhaps it is corrupted? *Possible* reason follows.\n", progName); + perror(progName); + cleanUpAndFail(2); + case BZ_DATA_ERROR_MAGIC: + if (zStream != stdin) { + fclose(zStream); + } + if (stream != stdout) { + fclose(stream); + } + if (streamNo == 1) { + return FALSE; + } else { + if (noisy) { + error_msg("\n%s: %s: trailing garbage after EOF ignored\n", progName, inName ); + } + return TRUE; + } + default: + panic ( "decompress:unexpected error" ); + } + + panic("decompress:end"); + return(TRUE); /*notreached*/ +} + +int bunzip2_main(int argc, char **argv) +{ + FILE *src_stream; + FILE *dst_stream; + char *save_name; + char *save_name_ptr; + if (argc != 2) { + show_usage(); + } + src_stream = xfopen(argv[1], "r"); + save_name = strdup(argv[1]); + save_name_ptr = strrchr(save_name, '.'); + if (save_name_ptr == NULL) { + return(FALSE); + } + if (strcmp(save_name_ptr, ".bz2") != 0) { + error_msg("Invalid extension, expected .bz2"); + } + *save_name_ptr = '\0'; + dst_stream = xfopen(save_name, "w"); + uncompressStream(src_stream, dst_stream); + + return(TRUE); +} diff --git a/bunzip2.c b/bunzip2.c new file mode 100644 index 000000000..757654dab --- /dev/null +++ b/bunzip2.c @@ -0,0 +1,2340 @@ +/* Modified for busybox by Glenn McGrath <bug1@optushome.com.au> */ +/*-- + This file is a part of bzip2 and/or libbzip2, a program and + library for lossless, block-sorting data compression. + + Copyright (C) 1996-2000 Julian R Seward. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. The origin of this software must not be misrepresented; you must + not claim that you wrote the original software. If you use this + software in a product, an acknowledgment in the product + documentation would be appreciated but is not required. + + 3. Altered source versions must be plainly marked as such, and must + not be misrepresented as being the original software. + + 4. The name of the author may not be used to endorse or promote + products derived from this software without specific prior written + permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS + OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + Julian Seward, Cambridge, UK. + jseward@acm.org + bzip2/libbzip2 version 1.0 of 21 March 2000 + + This program is based on (at least) the work of: + Mike Burrows + David Wheeler + Peter Fenwick + Alistair Moffat + Radford Neal + Ian H. Witten + Robert Sedgewick + Jon L. Bentley + + For more information on these sources, see the manual. +--*/ + +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <busybox.h> + +//#define TRUE 1 +//#define FALSE 0 + +#define MTFA_SIZE 4096 +#define MTFL_SIZE 16 +#define BZ_N_GROUPS 6 +#define BZ_G_SIZE 50 +#define BZ_MAX_ALPHA_SIZE 258 + +#define BZ_OK 0 +#define BZ_RUN_OK 1 +#define BZ_FLUSH_OK 2 +#define BZ_FINISH_OK 3 +#define BZ_STREAM_END 4 +#define BZ_SEQUENCE_ERROR (-1) +#define BZ_PARAM_ERROR (-2) +#define BZ_MEM_ERROR (-3) +#define BZ_DATA_ERROR (-4) +#define BZ_DATA_ERROR_MAGIC (-5) +#define BZ_IO_ERROR (-6) +#define BZ_UNEXPECTED_EOF (-7) +#define BZ_OUTBUFF_FULL (-8) +#define BZ_CONFIG_ERROR (-9) + +#define BZ_RUNA 0 +#define BZ_RUNB 1 + +#define BZ_MAX_UNUSED 5000 +#define FILE_NAME_LEN 1034 +/*-- states for decompression. --*/ + +#define BZ_X_IDLE 1 +#define BZ_X_OUTPUT 2 + +#define BZ_X_MAGIC_1 10 +#define BZ_X_MAGIC_2 11 +#define BZ_X_MAGIC_3 12 +#define BZ_X_MAGIC_4 13 +#define BZ_X_BLKHDR_1 14 +#define BZ_X_BLKHDR_2 15 +#define BZ_X_BLKHDR_3 16 +#define BZ_X_BLKHDR_4 17 +#define BZ_X_BLKHDR_5 18 +#define BZ_X_BLKHDR_6 19 +#define BZ_X_BCRC_1 20 +#define BZ_X_BCRC_2 21 +#define BZ_X_BCRC_3 22 +#define BZ_X_BCRC_4 23 +#define BZ_X_RANDBIT 24 +#define BZ_X_ORIGPTR_1 25 +#define BZ_X_ORIGPTR_2 26 +#define BZ_X_ORIGPTR_3 27 +#define BZ_X_MAPPING_1 28 +#define BZ_X_MAPPING_2 29 +#define BZ_X_SELECTOR_1 30 +#define BZ_X_SELECTOR_2 31 +#define BZ_X_SELECTOR_3 32 +#define BZ_X_CODING_1 33 +#define BZ_X_CODING_2 34 +#define BZ_X_CODING_3 35 +#define BZ_X_MTF_1 36 +#define BZ_X_MTF_2 37 +#define BZ_X_MTF_3 38 +#define BZ_X_MTF_4 39 +#define BZ_X_MTF_5 40 +#define BZ_X_MTF_6 41 +#define BZ_X_ENDHDR_2 42 +#define BZ_X_ENDHDR_3 43 +#define BZ_X_ENDHDR_4 44 +#define BZ_X_ENDHDR_5 45 +#define BZ_X_ENDHDR_6 46 +#define BZ_X_CCRC_1 47 +#define BZ_X_CCRC_2 48 +#define BZ_X_CCRC_3 49 +#define BZ_X_CCRC_4 50 + +#define BZ_MAX_CODE_LEN 23 +#define BZ_VERSION "1.0.1, 23-June-2000" +#define OM_TEST 3 +#define SM_F2F 3 + +typedef struct { + char *next_in; + unsigned int avail_in; + unsigned int total_in_lo32; + unsigned int total_in_hi32; + + char *next_out; + unsigned int avail_out; + unsigned int total_out_lo32; + unsigned int total_out_hi32; + + void *state; + + void *(*bzalloc)(void *,int,int); + void (*bzfree)(void *,void *); + void *opaque; +} bz_stream; + +typedef struct { + bz_stream strm; + FILE *handle; + unsigned char initialisedOk; + unsigned char writing; + char buf[BZ_MAX_UNUSED]; + int lastErr; + int bufN; +} bzFile; + +/*-- Structure holding all the decompression-side stuff. --*/ +typedef struct { + /* pointer back to the struct bz_stream */ + bz_stream* strm; + + /* state indicator for this stream */ + int state; + + /* for doing the final run-length decoding */ + unsigned char state_out_ch; + int state_out_len; + unsigned char blockRandomised; + int rNToGo; + int rTPos; + + /* the buffer for bit stream reading */ + unsigned int bsBuff; + int bsLive; + + /* misc administratium */ + int blockSize100k; + unsigned char smallDecompress; + int currBlockNo; + int verbosity; + + /* for undoing the Burrows-Wheeler transform */ + int origPtr; + unsigned int tPos; + int k0; + int unzftab[256]; + int nblock_used; + int cftab[257]; + int cftabCopy[257]; + + /* for undoing the Burrows-Wheeler transform (FAST) */ + unsigned int *tt; + + /* for undoing the Burrows-Wheeler transform (SMALL) */ + unsigned short *ll16; + unsigned char *ll4; + + /* stored and calculated CRCs */ + unsigned int storedBlockCRC; + unsigned int storedCombinedCRC; + unsigned int calculatedBlockCRC; + unsigned int calculatedCombinedCRC; + + /* map of bytes used in block */ + int nInUse; + unsigned char inUse[256]; + unsigned char inUse16[16]; + unsigned char seqToUnseq[256]; + + /* for decoding the MTF values */ + unsigned char mtfa [MTFA_SIZE]; + unsigned char selector [2 + (900000 / BZ_G_SIZE)]; + unsigned char selectorMtf[2 + (900000 / BZ_G_SIZE)]; + unsigned char len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + int mtfbase[256 / MTFL_SIZE]; + + int limit [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + int base [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + int perm [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + int minLens[BZ_N_GROUPS]; + + /* save area for scalars in the main decompress code */ + int save_i; + int save_j; + int save_t; + int save_alphaSize; + int save_nGroups; + int save_nSelectors; + int save_EOB; + int save_groupNo; + int save_groupPos; + int save_nextSym; + int save_nblockMAX; + int save_nblock; + int save_es; + int save_N; + int save_curr; + int save_zt; + int save_zn; + int save_zvec; + int save_zj; + int save_gSel; + int save_gMinlen; + int *save_gLimit; + int *save_gBase; + int *save_gPerm; +} DState; + +int BZ2_rNums[512]; +//int verbosity_level; +unsigned char smallMode; +unsigned char noisy; +char *progName; +char inName[FILE_NAME_LEN]; +char outName[FILE_NAME_LEN]; +int srcMode; +int opMode; +unsigned char deleteOutputOnInterrupt; +FILE *outputHandleJustInCase; +int numFileNames; +int numFilesProcessed; +int exitValue; + +unsigned int BZ2_crc32Table[256] = { + + /*-- Ugly, innit? --*/ + + 0x00000000L, 0x04c11db7L, 0x09823b6eL, 0x0d4326d9L, + 0x130476dcL, 0x17c56b6bL, 0x1a864db2L, 0x1e475005L, + 0x2608edb8L, 0x22c9f00fL, 0x2f8ad6d6L, 0x2b4bcb61L, + 0x350c9b64L, 0x31cd86d3L, 0x3c8ea00aL, 0x384fbdbdL, + 0x4c11db70L, 0x48d0c6c7L, 0x4593e01eL, 0x4152fda9L, + 0x5f15adacL, 0x5bd4b01bL, 0x569796c2L, 0x52568b75L, + 0x6a1936c8L, 0x6ed82b7fL, 0x639b0da6L, 0x675a1011L, + 0x791d4014L, 0x7ddc5da3L, 0x709f7b7aL, 0x745e66cdL, + 0x9823b6e0L, 0x9ce2ab57L, 0x91a18d8eL, 0x95609039L, + 0x8b27c03cL, 0x8fe6dd8bL, 0x82a5fb52L, 0x8664e6e5L, + 0xbe2b5b58L, 0xbaea46efL, 0xb7a96036L, 0xb3687d81L, + 0xad2f2d84L, 0xa9ee3033L, 0xa4ad16eaL, 0xa06c0b5dL, + 0xd4326d90L, 0xd0f37027L, 0xddb056feL, 0xd9714b49L, + 0xc7361b4cL, 0xc3f706fbL, 0xceb42022L, 0xca753d95L, + 0xf23a8028L, 0xf6fb9d9fL, 0xfbb8bb46L, 0xff79a6f1L, + 0xe13ef6f4L, 0xe5ffeb43L, 0xe8bccd9aL, 0xec7dd02dL, + 0x34867077L, 0x30476dc0L, 0x3d044b19L, 0x39c556aeL, + 0x278206abL, 0x23431b1cL, 0x2e003dc5L, 0x2ac12072L, + 0x128e9dcfL, 0x164f8078L, 0x1b0ca6a1L, 0x1fcdbb16L, + 0x018aeb13L, 0x054bf6a4L, 0x0808d07dL, 0x0cc9cdcaL, + 0x7897ab07L, 0x7c56b6b0L, 0x71159069L, 0x75d48ddeL, + 0x6b93dddbL, 0x6f52c06cL, 0x6211e6b5L, 0x66d0fb02L, + 0x5e9f46bfL, 0x5a5e5b08L, 0x571d7dd1L, 0x53dc6066L, + 0x4d9b3063L, 0x495a2dd4L, 0x44190b0dL, 0x40d816baL, + 0xaca5c697L, 0xa864db20L, 0xa527fdf9L, 0xa1e6e04eL, + 0xbfa1b04bL, 0xbb60adfcL, 0xb6238b25L, 0xb2e29692L, + 0x8aad2b2fL, 0x8e6c3698L, 0x832f1041L, 0x87ee0df6L, + 0x99a95df3L, 0x9d684044L, 0x902b669dL, 0x94ea7b2aL, + 0xe0b41de7L, 0xe4750050L, 0xe9362689L, 0xedf73b3eL, + 0xf3b06b3bL, 0xf771768cL, 0xfa325055L, 0xfef34de2L, + 0xc6bcf05fL, 0xc27dede8L, 0xcf3ecb31L, 0xcbffd686L, + 0xd5b88683L, 0xd1799b34L, 0xdc3abdedL, 0xd8fba05aL, + 0x690ce0eeL, 0x6dcdfd59L, 0x608edb80L, 0x644fc637L, + 0x7a089632L, 0x7ec98b85L, 0x738aad5cL, 0x774bb0ebL, + 0x4f040d56L, 0x4bc510e1L, 0x46863638L, 0x42472b8fL, + 0x5c007b8aL, 0x58c1663dL, 0x558240e4L, 0x51435d53L, + 0x251d3b9eL, 0x21dc2629L, 0x2c9f00f0L, 0x285e1d47L, + 0x36194d42L, 0x32d850f5L, 0x3f9b762cL, 0x3b5a6b9bL, + 0x0315d626L, 0x07d4cb91L, 0x0a97ed48L, 0x0e56f0ffL, + 0x1011a0faL, 0x14d0bd4dL, 0x19939b94L, 0x1d528623L, + 0xf12f560eL, 0xf5ee4bb9L, 0xf8ad6d60L, 0xfc6c70d7L, + 0xe22b20d2L, 0xe6ea3d65L, 0xeba91bbcL, 0xef68060bL, + 0xd727bbb6L, 0xd3e6a601L, 0xdea580d8L, 0xda649d6fL, + 0xc423cd6aL, 0xc0e2d0ddL, 0xcda1f604L, 0xc960ebb3L, + 0xbd3e8d7eL, 0xb9ff90c9L, 0xb4bcb610L, 0xb07daba7L, + 0xae3afba2L, 0xaafbe615L, 0xa7b8c0ccL, 0xa379dd7bL, + 0x9b3660c6L, 0x9ff77d71L, 0x92b45ba8L, 0x9675461fL, + 0x8832161aL, 0x8cf30badL, 0x81b02d74L, 0x857130c3L, + 0x5d8a9099L, 0x594b8d2eL, 0x5408abf7L, 0x50c9b640L, + 0x4e8ee645L, 0x4a4ffbf2L, 0x470cdd2bL, 0x43cdc09cL, + 0x7b827d21L, 0x7f436096L, 0x7200464fL, 0x76c15bf8L, + 0x68860bfdL, 0x6c47164aL, 0x61043093L, 0x65c52d24L, + 0x119b4be9L, 0x155a565eL, 0x18197087L, 0x1cd86d30L, + 0x029f3d35L, 0x065e2082L, 0x0b1d065bL, 0x0fdc1becL, + 0x3793a651L, 0x3352bbe6L, 0x3e119d3fL, 0x3ad08088L, + 0x2497d08dL, 0x2056cd3aL, 0x2d15ebe3L, 0x29d4f654L, + 0xc5a92679L, 0xc1683bceL, 0xcc2b1d17L, 0xc8ea00a0L, + 0xd6ad50a5L, 0xd26c4d12L, 0xdf2f6bcbL, 0xdbee767cL, + 0xe3a1cbc1L, 0xe760d676L, 0xea23f0afL, 0xeee2ed18L, + 0xf0a5bd1dL, 0xf464a0aaL, 0xf9278673L, 0xfde69bc4L, + 0x89b8fd09L, 0x8d79e0beL, 0x803ac667L, 0x84fbdbd0L, + 0x9abc8bd5L, 0x9e7d9662L, 0x933eb0bbL, 0x97ffad0cL, + 0xafb010b1L, 0xab710d06L, 0xa6322bdfL, 0xa2f33668L, + 0xbcb4666dL, 0xb8757bdaL, 0xb5365d03L, 0xb1f740b4L +}; + +void bz_rand_udp_mask(DState *s) +{ + if (s->rNToGo == 0) { + s->rNToGo = BZ2_rNums[s->rTPos]; + s->rTPos++; + if (s->rTPos == 512) { + s->rTPos = 0; + } + } + s->rNToGo--; +} + +static unsigned char myfeof(FILE *f) +{ + int c = fgetc(f); + if (c == EOF) { + return(TRUE); + } + ungetc(c, f); + return(FALSE); +} + +static void cleanUpAndFail(int ec) +{ + int retVal; + + if ((srcMode == SM_F2F) && (opMode != OM_TEST) && deleteOutputOnInterrupt) { + if (noisy) { + error_msg("%s: Deleting output file %s, if it exists.\n", progName, outName); + } + if (outputHandleJustInCase != NULL) { + fclose(outputHandleJustInCase); + } + retVal = remove(outName); + if (retVal != 0) { + error_msg("%s: WARNING: deletion of output file (apparently) failed.\n", progName); + } + } + if (noisy && (numFileNames > 0) && (numFilesProcessed < numFileNames)) { + error_msg("%s: WARNING: some files have not been processed:\n" + "\t%d specified on command line, %d not processed yet.\n\n", + progName, numFileNames, numFileNames - numFilesProcessed ); + } + + exit(ec); +} + + +void panic(char *s) +{ + error_msg("\n%s: PANIC -- internal consistency error:\n" + "\t%s\n" + "\tThis is a BUG. Please report it to me at:\n" + "\tjseward@acm.org\n", + progName, s); + cleanUpAndFail( 3 ); +} + +void BZ2_hbCreateDecodeTables(int *limit, int *base, int *perm, unsigned char *length, int minLen, int maxLen, int alphaSize ) +{ + int pp, i, j, vec; + + pp = 0; + for (i = minLen; i <= maxLen; i++) { + for (j = 0; j < alphaSize; j++) { + if (length[j] == i) { + perm[pp] = j; + pp++; + } + } + } + + for (i = 0; i < BZ_MAX_CODE_LEN; i++) { + base[i] = 0; + } + + for (i = 0; i < alphaSize; i++) { + base[length[i]+1]++; + } + + for (i = 1; i < BZ_MAX_CODE_LEN; i++) { + base[i] += base[i-1]; + } + + for (i = 0; i < BZ_MAX_CODE_LEN; i++) { + limit[i] = 0; + } + vec = 0; + + for (i = minLen; i <= maxLen; i++) { + vec += (base[i+1] - base[i]); + limit[i] = vec-1; + vec <<= 1; + } + for (i = minLen + 1; i <= maxLen; i++) { + base[i] = ((limit[i-1] + 1) << 1) - base[i]; + } +} + +int bz_get_small(DState *s) +{ + int cccc; + int nb, na, mid; + nb = 0; + na = 256; + do { + mid = (nb + na) >> 1; + if (s->tPos >= s->cftab[mid]) { + nb = mid; + } else { + na = mid; + } + } + while (na - nb != 1); + cccc = nb; + s->tPos = (((unsigned int)s->ll16[s->tPos]) | + (((((unsigned int)(s->ll4[(s->tPos) >> 1])) >> + (((s->tPos) << 2) & 0x4)) & 0xF) << 16)); + return(cccc); +} + +void assert_h(int errcode) +{ + error_msg_and_die("\n\nbzip2/libbzip2: internal error number %d.\n" + "This is a bug in bzip2/libbzip2, %s.\n" + "Please report it to me at: jseward@acm.org. If this happened\n" + "when you were using some program which uses libbzip2 as a\n" + "component, you should also report this bug to the author(s)\n" + "of that program. Please make an effort to report this bug;\n" + "timely and accurate bug reports eventually lead to higher\n" + "quality software. Thanks. Julian Seward, 21 March 2000.\n\n", + errcode, BZ_VERSION); +} + +static int get_bits(DState *s, int *vvv, char nnn) +{ + while (1) { + if (s->bsLive >= nnn) { + *vvv = (s->bsBuff >> (s->bsLive-nnn)) & ((1 << nnn)-1); + s->bsLive -= nnn; + break; + } + if (s->strm->avail_in == 0) { + return(FALSE); + } + s->bsBuff = (s->bsBuff << 8) | ((unsigned int) (*((unsigned char*)(s->strm->next_in)))); + s->bsLive += 8; + s->strm->next_in++; + s->strm->avail_in--; + s->strm->total_in_lo32++; + if (s->strm->total_in_lo32 == 0) { + s->strm->total_in_hi32++; + } + } + return(TRUE); +} + +int bz_get_fast(DState *s) +{ + int cccc; + s->tPos = s->tt[s->tPos]; + cccc = (unsigned char)(s->tPos & 0xff); + s->tPos >>= 8; + return(cccc); +} + +/*---------------------------------------------------*/ +int BZ2_decompress(DState *s) +{ + int uc = 0; + int retVal; + int minLen, maxLen; + bz_stream *strm = s->strm; + + /* stuff that needs to be saved/restored */ + int i; + int j; + int t; + int alphaSize; + int nGroups; + int nSelectors; + int EOB; + int groupNo; + int groupPos; + int nextSym; + int nblockMAX; + int nblock; + int es; + int N; + int curr; + int zt; + int zn; + int zvec; + int zj; + int gSel; + int gMinlen; + int *gLimit; + int *gBase; + int *gPerm; + int switch_val; + + int get_mtf_val_init(void) + { + if (groupPos == 0) { + groupNo++; + if (groupNo >= nSelectors) { + retVal = BZ_DATA_ERROR; + return(FALSE); + } + groupPos = BZ_G_SIZE; + gSel = s->selector[groupNo]; + gMinlen = s->minLens[gSel]; + gLimit = &(s->limit[gSel][0]); + gPerm = &(s->perm[gSel][0]); + gBase = &(s->base[gSel][0]); + } + groupPos--; + zn = gMinlen; + return(TRUE); + } + + if (s->state == BZ_X_MAGIC_1) { + /*initialise the save area*/ + s->save_i = 0; + s->save_j = 0; + s->save_t = 0; + s->save_alphaSize = 0; + s->save_nGroups = 0; + s->save_nSelectors = 0; + s->save_EOB = 0; + s->save_groupNo = 0; + s->save_groupPos = 0; + s->save_nextSym = 0; + s->save_nblockMAX = 0; + s->save_nblock = 0; + s->save_es = 0; + s->save_N = 0; + s->save_curr = 0; + s->save_zt = 0; + s->save_zn = 0; + s->save_zvec = 0; + s->save_zj = 0; + s->save_gSel = 0; + s->save_gMinlen = 0; + s->save_gLimit = NULL; + s->save_gBase = NULL; + s->save_gPerm = NULL; + } + + /*restore from the save area*/ + i = s->save_i; + j = s->save_j; + t = s->save_t; + alphaSize = s->save_alphaSize; + nGroups = s->save_nGroups; + nSelectors = s->save_nSelectors; + EOB = s->save_EOB; + groupNo = s->save_groupNo; + groupPos = s->save_groupPos; + nextSym = s->save_nextSym; + nblockMAX = s->save_nblockMAX; + nblock = s->save_nblock; + es = s->save_es; + N = s->save_N; + curr = s->save_curr; + zt = s->save_zt; + zn = s->save_zn; + zvec = s->save_zvec; + zj = s->save_zj; + gSel = s->save_gSel; + gMinlen = s->save_gMinlen; + gLimit = s->save_gLimit; + gBase = s->save_gBase; + gPerm = s->save_gPerm; + + retVal = BZ_OK; + switch_val = s->state; + switch (switch_val) { + case BZ_X_MAGIC_1: + s->state = BZ_X_MAGIC_1; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 'B') { + retVal = BZ_DATA_ERROR_MAGIC; + goto save_state_and_return; + } + + case BZ_X_MAGIC_2: + s->state = BZ_X_MAGIC_2; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 'Z') { + retVal = BZ_DATA_ERROR_MAGIC; + goto save_state_and_return; + } + + case BZ_X_MAGIC_3: + s->state = BZ_X_MAGIC_3; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 'h') { + retVal = BZ_DATA_ERROR_MAGIC; + goto save_state_and_return; + } + + case BZ_X_MAGIC_4: + s->state = BZ_X_MAGIC_4; + if (get_bits(s, &s->blockSize100k, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if ((s->blockSize100k < '1') || (s->blockSize100k > '9')) { + retVal = BZ_DATA_ERROR_MAGIC; + goto save_state_and_return; + } + s->blockSize100k -= '0'; + + if (s->smallDecompress) { + s->ll16 = (strm->bzalloc)(strm->opaque, s->blockSize100k * 100000 * sizeof(unsigned short), 1); + s->ll4 = (strm->bzalloc)(strm->opaque, ((1 + s->blockSize100k * 100000) >> 1) * sizeof(unsigned char), 1); + + if (s->ll16 == NULL || s->ll4 == NULL) { + retVal = BZ_MEM_ERROR; + goto save_state_and_return; + } + } else { + s->tt = (strm->bzalloc)(strm->opaque, s->blockSize100k * 100000 * sizeof(int), 1); + if (s->tt == NULL) { + retVal = BZ_MEM_ERROR; + goto save_state_and_return; + } + } + + case BZ_X_BLKHDR_1: + s->state = BZ_X_BLKHDR_1; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + + if (uc == 0x17) { + goto endhdr_2; + } + if (uc != 0x31) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + case BZ_X_BLKHDR_2: + s->state = BZ_X_BLKHDR_2; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 0x41) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + case BZ_X_BLKHDR_3: + s->state = BZ_X_BLKHDR_3; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 0x59) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + case BZ_X_BLKHDR_4: + s->state = BZ_X_BLKHDR_4; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 0x26) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + case BZ_X_BLKHDR_5: + s->state = BZ_X_BLKHDR_5; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 0x53) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + case BZ_X_BLKHDR_6: + s->state = BZ_X_BLKHDR_6; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 0x59) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + s->currBlockNo++; + if (s->verbosity >= 2) { + error_msg("\n [%d: huff+mtf ", s->currBlockNo); + } + s->storedBlockCRC = 0; + + case BZ_X_BCRC_1: + s->state = BZ_X_BCRC_1; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc); + + case BZ_X_BCRC_2: + s->state = BZ_X_BCRC_2; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc); + + case BZ_X_BCRC_3: + s->state = BZ_X_BCRC_3; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc); + + case BZ_X_BCRC_4: + s->state = BZ_X_BCRC_4; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc); + + case BZ_X_RANDBIT: + s->state = BZ_X_RANDBIT; + { + int tmp = s->blockRandomised; + const int ret = get_bits(s, &tmp, 1); + s->blockRandomised = tmp; + if (ret == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + } + + s->origPtr = 0; + + case BZ_X_ORIGPTR_1: + s->state = BZ_X_ORIGPTR_1; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + s->origPtr = (s->origPtr << 8) | ((int)uc); + + case BZ_X_ORIGPTR_2: + s->state = BZ_X_ORIGPTR_2; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + s->origPtr = (s->origPtr << 8) | ((int)uc); + + case BZ_X_ORIGPTR_3: + s->state = BZ_X_ORIGPTR_3; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + s->origPtr = (s->origPtr << 8) | ((int)uc); + + if (s->origPtr < 0) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + if (s->origPtr > 10 + 100000*s->blockSize100k) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + /*--- Receive the mapping table ---*/ + case BZ_X_MAPPING_1: + for (i = 0; i < 16; i++) { + s->state = BZ_X_MAPPING_1; + if (get_bits(s, &uc, 1) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc == 1) { + s->inUse16[i] = TRUE; + } else { + s->inUse16[i] = FALSE; + } + } + + for (i = 0; i < 256; i++) { + s->inUse[i] = FALSE; + } + + for (i = 0; i < 16; i++) { + if (s->inUse16[i]) { + for (j = 0; j < 16; j++) { + case BZ_X_MAPPING_2: + s->state = BZ_X_MAPPING_2; + if (get_bits(s, &uc, 1) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc == 1) { + s->inUse[i * 16 + j] = TRUE; + } + } + } + } + + s->nInUse = 0; + for (i = 0; i < 256; i++) { + if (s->inUse[i]) { + s->seqToUnseq[s->nInUse] = i; + s->nInUse++; + } + } + if (s->nInUse == 0) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + alphaSize = s->nInUse+2; + + /*--- Now the selectors ---*/ + case BZ_X_SELECTOR_1: + s->state = BZ_X_SELECTOR_1; + if (get_bits(s, &nGroups, 3) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (nGroups < 2 || nGroups > 6) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + case BZ_X_SELECTOR_2: + s->state = BZ_X_SELECTOR_2; + if (get_bits(s, &nSelectors, 15) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (nSelectors < 1) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + + + for (i = 0; i < nSelectors; i++) { + j = 0; + while (1) { + case BZ_X_SELECTOR_3: + s->state = BZ_X_SELECTOR_3; + if (get_bits(s, &uc, 1) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc == 0) { + break; + } + j++; + if (j >= nGroups) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + } + s->selectorMtf[i] = j; + } + + /*--- Undo the MTF values for the selectors. ---*/ + { + unsigned char pos[BZ_N_GROUPS], tmp, v; + for (v = 0; v < nGroups; v++) { + pos[v] = v; + } + for (i = 0; i < nSelectors; i++) { + v = s->selectorMtf[i]; + tmp = pos[v]; + while (v > 0) { + pos[v] = pos[v-1]; + v--; + } + pos[0] = tmp; + s->selector[i] = tmp; + } + } + + /*--- Now the coding tables ---*/ + for (t = 0; t < nGroups; t++) { + case BZ_X_CODING_1: + s->state = BZ_X_CODING_1; + if (get_bits(s, &curr, 5) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + for (i = 0; i < alphaSize; i++) { + while (TRUE) { + if (curr < 1 || curr > 20) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + case BZ_X_CODING_2: + s->state = BZ_X_CODING_2; + if (get_bits(s, &uc, 1) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc == 0) { + break; + } + + case BZ_X_CODING_3: + s->state = BZ_X_CODING_3; + if (get_bits(s, &uc, 1) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc == 0) { + curr++; + } else { + curr--; + } + } + s->len[t][i] = curr; + } + } + + /*--- Create the Huffman decoding tables ---*/ + for (t = 0; t < nGroups; t++) { + minLen = 32; + maxLen = 0; + for (i = 0; i < alphaSize; i++) { + if (s->len[t][i] > maxLen) { + maxLen = s->len[t][i]; + } + if (s->len[t][i] < minLen) { + minLen = s->len[t][i]; + } + } + + BZ2_hbCreateDecodeTables ( + &(s->limit[t][0]), + &(s->base[t][0]), + &(s->perm[t][0]), + &(s->len[t][0]), + minLen, maxLen, alphaSize + ); + + + s->minLens[t] = minLen; + } + + /*--- Now the MTF values ---*/ + + EOB = s->nInUse+1; + nblockMAX = 100000 * s->blockSize100k; + groupNo = -1; + groupPos = 0; + + for (i = 0; i <= 255; i++) { + s->unzftab[i] = 0; + } + /*-- MTF init --*/ + { + int ii, jj, kk; + kk = MTFA_SIZE-1; + for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) { + for (jj = MTFL_SIZE-1; jj >= 0; jj--) { + s->mtfa[kk] = (unsigned char)(ii * MTFL_SIZE + jj); + kk--; + } + s->mtfbase[ii] = kk + 1; + } + } + /*-- end MTF init --*/ + + nblock = 0; + + if (get_mtf_val_init() == FALSE) { + goto save_state_and_return; + } + case BZ_X_MTF_1: + s->state = BZ_X_MTF_1; + if (get_bits(s, &zvec, zn) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + while (1) { + if (zn > 20 /* the longest code */) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + if (zvec <= gLimit[zn]) { + break; + } + zn++; + + case BZ_X_MTF_2: + s->state = BZ_X_MTF_2; + if (get_bits(s, &zj, 1) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + zvec = (zvec << 1) | zj; + } + if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + nextSym = gPerm[zvec - gBase[zn]]; + + while (1) { + if (nextSym == EOB) { + break; + } + + if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) { + es = -1; + N = 1; + do { + if (nextSym == BZ_RUNA) { + es = es + (0+1) * N; + } else { + if (nextSym == BZ_RUNB) { + es = es + (1+1) * N; + } + } + N = N * 2; + if (get_mtf_val_init() == FALSE) { + goto save_state_and_return; + } + case BZ_X_MTF_3: + s->state = BZ_X_MTF_3; + if (get_bits(s, &zvec, zn) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + while (1) { + if (zn > 20 /* the longest code */) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + if (zvec <= gLimit[zn]) { + break; + } + zn++; + + case BZ_X_MTF_4: + s->state = BZ_X_MTF_4; + if (get_bits(s, &zj, 1) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + zvec = (zvec << 1) | zj; + } + if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + + } + nextSym = gPerm[zvec - gBase[zn]]; + } + while (nextSym == BZ_RUNA || nextSym == BZ_RUNB); + + es++; + uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ]; + s->unzftab[uc] += es; + + if (s->smallDecompress) { + while (es > 0) { + if (nblock >= nblockMAX) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + s->ll16[nblock] = (unsigned short)uc; + nblock++; + es--; + } + } else { + while (es > 0) { + if (nblock >= nblockMAX) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + s->tt[nblock] = (unsigned int)uc; + nblock++; + es--; + } + } + continue; + } else { + if (nblock >= nblockMAX) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + /*-- uc = MTF ( nextSym-1 ) --*/ + { + int ii, jj, kk, pp, lno, off; + unsigned int nn; + nn = (unsigned int)(nextSym - 1); + + if (nn < MTFL_SIZE) { + /* avoid general-case expense */ + pp = s->mtfbase[0]; + uc = s->mtfa[pp+nn]; + while (nn > 3) { + int z = pp+nn; + s->mtfa[(z) ] = s->mtfa[(z)-1]; + s->mtfa[(z)-1] = s->mtfa[(z)-2]; + s->mtfa[(z)-2] = s->mtfa[(z)-3]; + s->mtfa[(z)-3] = s->mtfa[(z)-4]; + nn -= 4; + } + while (nn > 0) { + s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--; + } + s->mtfa[pp] = uc; + } else { + /* general case */ + lno = nn / MTFL_SIZE; + off = nn % MTFL_SIZE; + pp = s->mtfbase[lno] + off; + uc = s->mtfa[pp]; + while (pp > s->mtfbase[lno]) { + s->mtfa[pp] = s->mtfa[pp-1]; + pp--; + } + s->mtfbase[lno]++; + while (lno > 0) { + s->mtfbase[lno]--; + s->mtfa[s->mtfbase[lno]] = s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1]; + lno--; + } + s->mtfbase[0]--; + s->mtfa[s->mtfbase[0]] = uc; + if (s->mtfbase[0] == 0) { + kk = MTFA_SIZE-1; + for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) { + for (jj = MTFL_SIZE-1; jj >= 0; jj--) { + s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj]; + kk--; + } + s->mtfbase[ii] = kk + 1; + } + } + } + } + /*-- end uc = MTF ( nextSym-1 ) --*/ + + s->unzftab[s->seqToUnseq[uc]]++; + if (s->smallDecompress) { + s->ll16[nblock] = (unsigned short)(s->seqToUnseq[uc]); + } else { + s->tt[nblock] = (unsigned int)(s->seqToUnseq[uc]); + } + nblock++; + + if (get_mtf_val_init() == FALSE) { + goto save_state_and_return; + } + case BZ_X_MTF_5: + s->state = BZ_X_MTF_5; + if (get_bits(s, &zvec, zn) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + while (1) { + if (zn > 20 /* the longest code */) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + if (zvec <= gLimit[zn]) { + break; + } + zn++; + + case BZ_X_MTF_6: + s->state = BZ_X_MTF_6; + if (get_bits(s, &zj, 1) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + zvec = (zvec << 1) | zj; + } + if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + nextSym = gPerm[zvec - gBase[zn]]; + continue; + } + } + + /* Now we know what nblock is, we can do a better sanity + check on s->origPtr. + */ + if (s->origPtr < 0 || s->origPtr >= nblock) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + s->state_out_len = 0; + s->state_out_ch = 0; + s->calculatedBlockCRC = 0xffffffffL; + s->state = BZ_X_OUTPUT; + if (s->verbosity >= 2) { + error_msg("rt+rld"); + } + + /*-- Set up cftab to facilitate generation of T^(-1) --*/ + s->cftab[0] = 0; + for (i = 1; i <= 256; i++) { + s->cftab[i] = s->unzftab[i-1]; + } + for (i = 1; i <= 256; i++) { + s->cftab[i] += s->cftab[i-1]; + } + + if (s->smallDecompress) { + + /*-- Make a copy of cftab, used in generation of T --*/ + for (i = 0; i <= 256; i++) { + s->cftabCopy[i] = s->cftab[i]; + } + + /*-- compute the T vector --*/ + for (i = 0; i < nblock; i++) { + uc = (unsigned char)(s->ll16[i]); + s->ll16[i] = (unsigned short)(s->cftabCopy[uc] & 0x0000ffff); + if (((i) & 0x1) == 0) { + s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0xf0) | (s->cftabCopy[uc] >> 16); + } else { + s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0x0f) | ((s->cftabCopy[uc] >> 16) << 4); + } + s->cftabCopy[uc]++; + } + + /*-- Compute T^(-1) by pointer reversal on T --*/ + i = s->origPtr; + j = (((unsigned int)s->ll16[i]) | + (((((unsigned int)(s->ll4[(i) >> 1])) >> + (((i) << 2) & 0x4)) & 0xF) << 16)); + + do { + const int tmp = (((unsigned int)s->ll16[j]) | + (((((unsigned int)(s->ll4[(j) >> 1])) >> + (((j) << 2) & 0x4)) & 0xF) << 16)); + + s->ll16[j] = (unsigned short)(i & 0x0000ffff); + if (((j) & 0x1) == 0) { + s->ll4[(j) >> 1] = (s->ll4[(j) >> 1] & 0xf0) | (i >> 16); + } else { + s->ll4[(j) >> 1] = (s->ll4[(j) >> 1] & 0x0f) | ((i >> 16) << 4); + } + i = j; + j = tmp; + } + while (i != s->origPtr); + s->tPos = s->origPtr; + s->nblock_used = 0; + if (s->blockRandomised) { + s->rNToGo = 0; + s->rTPos = 0; + s->k0 = bz_get_small(s); + s->nblock_used++; + bz_rand_udp_mask(s); + s->k0 ^= ((s->rNToGo == 1) ? 1 : 0); + } else { + s->k0 = bz_get_small(s); + s->nblock_used++; + } + } else { + /*-- compute the T^(-1) vector --*/ + for (i = 0; i < nblock; i++) { + uc = (unsigned char)(s->tt[i] & 0xff); + s->tt[s->cftab[uc]] |= (i << 8); + s->cftab[uc]++; + } + + s->tPos = s->tt[s->origPtr] >> 8; + s->nblock_used = 0; + if (s->blockRandomised) { + s->rNToGo = 0; + s->rTPos = 0; + s->k0 = bz_get_fast(s); + + s->nblock_used++; + bz_rand_udp_mask(s); + s->k0 ^= ((s->rNToGo == 1) ? 1 : 0); + } else { + s->k0 = bz_get_fast(s); + s->nblock_used++; + } + } + + retVal = BZ_OK; + goto save_state_and_return; + +endhdr_2: + case BZ_X_ENDHDR_2: + s->state = BZ_X_ENDHDR_2; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 0x72) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + case BZ_X_ENDHDR_3: + s->state = BZ_X_ENDHDR_3; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 0x45) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + case BZ_X_ENDHDR_4: + s->state = BZ_X_ENDHDR_4; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 0x38) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + case BZ_X_ENDHDR_5: + s->state = BZ_X_ENDHDR_5; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 0x50) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + + case BZ_X_ENDHDR_6: + s->state = BZ_X_ENDHDR_6; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + if (uc != 0x90) { + retVal = BZ_DATA_ERROR; + goto save_state_and_return; + } + s->storedCombinedCRC = 0; + + case BZ_X_CCRC_1: + s->state = BZ_X_CCRC_1; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc); + case BZ_X_CCRC_2: + s->state = BZ_X_CCRC_2; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc); + + case BZ_X_CCRC_3: + s->state = BZ_X_CCRC_3; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc); + + case BZ_X_CCRC_4: + s->state = BZ_X_CCRC_4; + if (get_bits(s, &uc, 8) == FALSE) { + retVal = BZ_OK; + goto save_state_and_return; + } + s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc); + + s->state = BZ_X_IDLE; + retVal = BZ_STREAM_END; + goto save_state_and_return; + +default: + printf("switch val is %d\n", switch_val); + assert_h(4001); + } + + assert_h(4002); + +save_state_and_return: + s->save_i = i; + s->save_j = j; + s->save_t = t; + s->save_alphaSize = alphaSize; + s->save_nGroups = nGroups; + s->save_nSelectors = nSelectors; + s->save_EOB = EOB; + s->save_groupNo = groupNo; + s->save_groupPos = groupPos; + s->save_nextSym = nextSym; + s->save_nblockMAX = nblockMAX; + s->save_nblock = nblock; + s->save_es = es; + s->save_N = N; + s->save_curr = curr; + s->save_zt = zt; + s->save_zn = zn; + s->save_zvec = zvec; + s->save_zj = zj; + s->save_gSel = gSel; + s->save_gMinlen = gMinlen; + s->save_gLimit = gLimit; + s->save_gBase = gBase; + s->save_gPerm = gPerm; + + return retVal; +} + +static void *default_bzalloc(void *opaque, int items, int size) +{ + void *v = xmalloc(items *size); + return v; +} + +static void default_bzfree(void *opaque, void *addr) +{ + if (addr != NULL) { + free(addr); + } +} + +//int BZ2_bzDecompressInit(bz_stream* strm, int verbosity_level, int small) +int BZ2_bzDecompressInit(bz_stream* strm, int small) +{ + DState* s; + + if (sizeof(int) != 4) { + return BZ_CONFIG_ERROR; + } + if (sizeof(short) != 2) { + return BZ_CONFIG_ERROR; + } + if (sizeof(char) != 1) { + return BZ_CONFIG_ERROR; + } + if (strm == NULL) { + return BZ_PARAM_ERROR; + } + if (small != 0 && small != 1) { + return BZ_PARAM_ERROR; + } +// if (verbosity_level < 0 || verbosity_level > 4) { +// return BZ_PARAM_ERROR; +// } + if (strm->bzalloc == NULL) { + strm->bzalloc = default_bzalloc; + } + if (strm->bzfree == NULL) { + strm->bzfree = default_bzfree; + } + s = (strm->bzalloc)(strm->opaque, sizeof(DState), 1); + if (s == NULL) { + return BZ_MEM_ERROR; + } + s->strm = strm; + strm->state = s; + s->state = BZ_X_MAGIC_1; + s->bsLive = 0; + s->bsBuff = 0; + s->calculatedCombinedCRC = 0; + strm->total_in_lo32 = 0; + strm->total_in_hi32 = 0; + strm->total_out_lo32 = 0; + strm->total_out_hi32 = 0; + s->smallDecompress = (unsigned char)small; + s->ll4 = NULL; + s->ll16 = NULL; + s->tt = NULL; + s->currBlockNo = 0; +// s->verbosity = verbosity_level; + + return BZ_OK; +} + +void bz_seterr(int eee, int *bzerror, bzFile **bzf) +{ + if (bzerror != NULL) { + *bzerror = eee; + } + if (*bzf != NULL) { + (*bzf)->lastErr = eee; + } +} + +void BZ2_bzReadClose(int *bzerror, void *b) +{ + bzFile* bzf = (bzFile*)b; + + bz_seterr(BZ_OK, bzerror, &bzf); + if (bzf == NULL) { + bz_seterr(BZ_OK, bzerror, &bzf); + return; + } + + if (bzf->writing) { + bz_seterr(BZ_SEQUENCE_ERROR, bzerror, &bzf); + return; + } + + if (bzf->initialisedOk) { + bz_stream *strm = &(bzf->strm); + DState *s; + if (strm == NULL) { + return; + } + s = strm->state; + if ((s == NULL) || (s->strm != strm)) { + return; + } + if (s->tt != NULL) { + (strm->bzfree)(strm->opaque,(s->tt)); + } + if (s->ll16 != NULL) { + (strm->bzfree)(strm->opaque,(s->ll16)); + } + if (s->ll4 != NULL) { + (strm->bzfree)(strm->opaque,(s->ll4)); + } + (strm->bzfree)(strm->opaque,(strm->state)); + strm->state = NULL; + return; + } + free(bzf); +} + +static void unRLE_obuf_to_output_FAST(DState *s) +{ + unsigned char k1; + + if (s->blockRandomised) { + while (1) { + /* try to finish existing run */ + while (1) { + if (s->strm->avail_out == 0) { + return; + } + if (s->state_out_len == 0) { + break; + } + *((unsigned char *)(s->strm->next_out)) = s->state_out_ch; + s->calculatedBlockCRC = (s->calculatedBlockCRC << 8) ^ + BZ2_crc32Table[(s->calculatedBlockCRC >> 24) ^ + ((unsigned char)s->state_out_ch)]; + s->state_out_len--; + s->strm->next_out++; + s->strm->avail_out--; + s->strm->total_out_lo32++; + if (s->strm->total_out_lo32 == 0) { + s->strm->total_out_hi32++; + } + } + + /* can a new run be started? */ + if (s->nblock_used == s->save_nblock+1) { + return; + } + s->state_out_len = 1; + s->state_out_ch = s->k0; + k1 = bz_get_fast(s); + bz_rand_udp_mask(s); + k1 ^= ((s->rNToGo == 1) ? 1 : 0); + s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) { + continue; + } + if (k1 != s->k0) { + s->k0 = k1; + continue; + } + + s->state_out_len = 2; + k1 = bz_get_fast(s); + bz_rand_udp_mask(s); + k1 ^= ((s->rNToGo == 1) ? 1 : 0); + s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) { + continue; + } + if (k1 != s->k0) { + s->k0 = k1; + continue; + } + s->state_out_len = 3; + k1 = bz_get_fast(s); + bz_rand_udp_mask(s); + k1 ^= ((s->rNToGo == 1) ? 1 : 0); + s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) { + continue; + } + if (k1 != s->k0) { + s->k0 = k1; + continue; + } + + k1 = bz_get_fast(s); + bz_rand_udp_mask(s); + k1 ^= ((s->rNToGo == 1) ? 1 : 0); + s->nblock_used++; + s->state_out_len = ((int)k1) + 4; + s->k0 = bz_get_fast(s); + bz_rand_udp_mask(s); + s->k0 ^= ((s->rNToGo == 1) ? 1 : 0); + s->nblock_used++; + } + } else { + /* restore */ + unsigned int c_calculatedBlockCRC = s->calculatedBlockCRC; + unsigned char c_state_out_ch = s->state_out_ch; + int c_state_out_len = s->state_out_len; + int c_nblock_used = s->nblock_used; + int c_k0 = s->k0; + unsigned int *c_tt = s->tt; + unsigned int c_tPos = s->tPos; + char *cs_next_out = s->strm->next_out; + unsigned int cs_avail_out = s->strm->avail_out; + /* end restore */ + + unsigned int avail_out_INIT = cs_avail_out; + int s_save_nblockPP = s->save_nblock+1; + unsigned int total_out_lo32_old; + + while (1) { + /* try to finish existing run */ + if (c_state_out_len > 0) { + while (TRUE) { + if (cs_avail_out == 0) { + goto return_notr; + } + if (c_state_out_len == 1) { + break; + } + *((unsigned char *)(cs_next_out)) = c_state_out_ch; + c_calculatedBlockCRC = (c_calculatedBlockCRC << 8) ^ + BZ2_crc32Table[(c_calculatedBlockCRC >> 24) ^ + ((unsigned char)c_state_out_ch)]; + c_state_out_len--; + cs_next_out++; + cs_avail_out--; + } +s_state_out_len_eq_one: + { + if (cs_avail_out == 0) { + c_state_out_len = 1; + goto return_notr; + } + *((unsigned char *)(cs_next_out)) = c_state_out_ch; + c_calculatedBlockCRC = (c_calculatedBlockCRC << 8) ^ + BZ2_crc32Table[(c_calculatedBlockCRC >> 24) ^ + ((unsigned char)c_state_out_ch)]; + cs_next_out++; + cs_avail_out--; + } + } + /* can a new run be started? */ + if (c_nblock_used == s_save_nblockPP) { + c_state_out_len = 0; goto return_notr; + } + c_state_out_ch = c_k0; + c_tPos = c_tt[c_tPos]; + k1 = (unsigned char)(c_tPos & 0xff); + c_tPos >>= 8; + + c_nblock_used++; + + if (k1 != c_k0) { + c_k0 = k1; + goto s_state_out_len_eq_one; + } + + if (c_nblock_used == s_save_nblockPP) { + goto s_state_out_len_eq_one; + } + + c_state_out_len = 2; + c_tPos = c_tt[c_tPos]; + k1 = (unsigned char)(c_tPos & 0xff); + c_tPos >>= 8; + + c_nblock_used++; + if (c_nblock_used == s_save_nblockPP) { + continue; + } + if (k1 != c_k0) { + c_k0 = k1; + continue; + } + + c_state_out_len = 3; + c_tPos = c_tt[c_tPos]; + k1 = (unsigned char)(c_tPos & 0xff); + c_tPos >>= 8; + + c_nblock_used++; + if (c_nblock_used == s_save_nblockPP) { + continue; + } + if (k1 != c_k0) { + c_k0 = k1; + continue; + } + + c_tPos = c_tt[c_tPos]; + k1 = (unsigned char)(c_tPos & 0xff); + c_tPos >>= 8; + + c_nblock_used++; + c_state_out_len = ((int)k1) + 4; + + c_tPos = c_tt[c_tPos]; + c_k0 = (unsigned char)(c_tPos & 0xff); + c_tPos >>= 8; + + c_nblock_used++; + } + +return_notr: + total_out_lo32_old = s->strm->total_out_lo32; + s->strm->total_out_lo32 += (avail_out_INIT - cs_avail_out); + if (s->strm->total_out_lo32 < total_out_lo32_old) { + s->strm->total_out_hi32++; + } + + /* save */ + s->calculatedBlockCRC = c_calculatedBlockCRC; + s->state_out_ch = c_state_out_ch; + s->state_out_len = c_state_out_len; + s->nblock_used = c_nblock_used; + s->k0 = c_k0; + s->tt = c_tt; + s->tPos = c_tPos; + s->strm->next_out = cs_next_out; + s->strm->avail_out = cs_avail_out; + /* end save */ + } +} + +static void unRLE_obuf_to_output_SMALL(DState *s) +{ + unsigned char k1; + + if (s->blockRandomised) { + while (1) { + /* try to finish existing run */ + while (1) { + if (s->strm->avail_out == 0) { + return; + } + if (s->state_out_len == 0) { + break; + } + *((unsigned char *)(s->strm->next_out)) = s->state_out_ch; + s->calculatedBlockCRC = (s->calculatedBlockCRC << 8) ^ + BZ2_crc32Table[(s->calculatedBlockCRC >> 24) ^ + ((unsigned char)s->state_out_ch)]; + s->state_out_len--; + s->strm->next_out++; + s->strm->avail_out--; + s->strm->total_out_lo32++; + if (s->strm->total_out_lo32 == 0) { + s->strm->total_out_hi32++; + } + } + + /* can a new run be started? */ + if (s->nblock_used == s->save_nblock+1) { + return; + } + + s->state_out_len = 1; + s->state_out_ch = s->k0; + k1 = bz_get_small(s); + bz_rand_udp_mask(s); + k1 ^= ((s->rNToGo == 1) ? 1 : 0); + s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) { + continue; + } + if (k1 != s->k0) { + s->k0 = k1; + continue; + } + + s->state_out_len = 2; + k1 = bz_get_small(s); + bz_rand_udp_mask(s); + k1 ^= ((s->rNToGo == 1) ? 1 : 0); + s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) { + continue; + } + if (k1 != s->k0) { + s->k0 = k1; + continue; + } + + s->state_out_len = 3; + k1 = bz_get_small(s); + bz_rand_udp_mask(s); + k1 ^= ((s->rNToGo == 1) ? 1 : 0); + s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) { + continue; + } + if (k1 != s->k0) { + s->k0 = k1; + continue; + } + k1 = bz_get_small(s); + bz_rand_udp_mask(s); + k1 ^= ((s->rNToGo == 1) ? 1 : 0); + s->nblock_used++; + s->state_out_len = ((int)k1) + 4; + s->k0 = bz_get_small(s); + bz_rand_udp_mask(s); + s->k0 ^= ((s->rNToGo == 1) ? 1 : 0); + s->nblock_used++; + } + } else { + while (1) { + /* try to finish existing run */ + while (1) { + if (s->strm->avail_out == 0) { + return; + } + if (s->state_out_len == 0) { + break; + } + *((unsigned char *)(s->strm->next_out)) = s->state_out_ch; + s->calculatedBlockCRC = (s->calculatedBlockCRC << 8) ^ + BZ2_crc32Table[(s->calculatedBlockCRC >> 24) ^ + ((unsigned char)s->state_out_ch)]; + s->state_out_len--; + s->strm->next_out++; + s->strm->avail_out--; + s->strm->total_out_lo32++; + if (s->strm->total_out_lo32 == 0) { + s->strm->total_out_hi32++; + } + } + + /* can a new run be started? */ + if (s->nblock_used == s->save_nblock+1) { + return; + } + + s->state_out_len = 1; + s->state_out_ch = s->k0; + k1 = bz_get_small(s); + s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) { + continue; + } + if (k1 != s->k0) { + s->k0 = k1; + continue; + } + + s->state_out_len = 2; + k1 = bz_get_small(s); + s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) { + continue; + } + if (k1 != s->k0) { + s->k0 = k1; + continue; + } + + s->state_out_len = 3; + k1 = bz_get_small(s); + s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) { + continue; + } + if (k1 != s->k0) { + s->k0 = k1; + continue; + } + + k1 = bz_get_small(s); + s->nblock_used++; + s->state_out_len = ((int)k1) + 4; + s->k0 = bz_get_small(s); + s->nblock_used++; + } + } +} + +int BZ2_bzDecompress(bz_stream *strm) +{ + DState* s; + if (strm == NULL) { + return BZ_PARAM_ERROR; + } + s = strm->state; + if (s == NULL) { + return BZ_PARAM_ERROR; + } + if (s->strm != strm) { + return BZ_PARAM_ERROR; + } + + while (1) { + if (s->state == BZ_X_IDLE) { + return BZ_SEQUENCE_ERROR; + } + if (s->state == BZ_X_OUTPUT) { + if (s->smallDecompress) { + unRLE_obuf_to_output_SMALL(s); + } else { + unRLE_obuf_to_output_FAST(s); + } + if (s->nblock_used == s->save_nblock+1 && s->state_out_len == 0) { + s->calculatedBlockCRC = ~(s->calculatedBlockCRC); + if (s->verbosity >= 3) { + error_msg("{0x%x, 0x%x}", s->storedBlockCRC, s->calculatedBlockCRC); + } + if (s->verbosity >= 2) { + error_msg("]"); + } + if (s->calculatedBlockCRC != s->storedBlockCRC) { + return BZ_DATA_ERROR; + } + s->calculatedCombinedCRC = (s->calculatedCombinedCRC << 1) | (s->calculatedCombinedCRC >> 31); + s->calculatedCombinedCRC ^= s->calculatedBlockCRC; + s->state = BZ_X_BLKHDR_1; + } else { + return BZ_OK; + } + } + if (s->state >= BZ_X_MAGIC_1) { + int r = BZ2_decompress(s); + if (r == BZ_STREAM_END) { + if (s->verbosity >= 3) { + error_msg("\n combined CRCs: stored = 0x%x, computed = 0x%x", + s->storedCombinedCRC, s->calculatedCombinedCRC ); + } + if (s->calculatedCombinedCRC != s->storedCombinedCRC) { + return BZ_DATA_ERROR; + } + return r; + } + if (s->state != BZ_X_OUTPUT) { + return r; + } + } + } + + assert_h(6001); + + return(0); /*NOTREACHED*/ +} + +int BZ2_bzRead(int *bzerror, void *b, void *buf, int len) +{ + int n, ret; + bzFile *bzf = (bzFile*)b; + + bz_seterr(BZ_OK, bzerror, &bzf); + + if (bzf == NULL || buf == NULL || len < 0) { + bz_seterr(BZ_PARAM_ERROR, bzerror, &bzf); + return 0; + } + + if (bzf->writing) { + bz_seterr(BZ_SEQUENCE_ERROR, bzerror, &bzf); + return 0; + } + + if (len == 0) { + bz_seterr(BZ_OK, bzerror, &bzf); + return 0; + } + + bzf->strm.avail_out = len; + bzf->strm.next_out = buf; + + while (1) { + if (ferror(bzf->handle)) { + bz_seterr(BZ_IO_ERROR, bzerror, &bzf); + return 0; + } + if ((bzf->strm.avail_in == 0) && !myfeof(bzf->handle)) { + n = fread(bzf->buf, sizeof(unsigned char), BZ_MAX_UNUSED, bzf->handle); + if (ferror(bzf->handle)) { + bz_seterr(BZ_IO_ERROR, bzerror, &bzf); + return 0; + } + bzf->bufN = n; + bzf->strm.avail_in = bzf->bufN; + bzf->strm.next_in = bzf->buf; + } + + ret = BZ2_bzDecompress(&(bzf->strm)); + + if ((ret != BZ_OK) && (ret != BZ_STREAM_END)) { + bz_seterr(ret, bzerror, &bzf); + return 0; + } + + if ((ret == BZ_OK) && myfeof(bzf->handle) && + (bzf->strm.avail_in == 0) && (bzf->strm.avail_out > 0)) { + bz_seterr(BZ_UNEXPECTED_EOF, bzerror, &bzf); + return(0); + } + + if (ret == BZ_STREAM_END) { + bz_seterr(BZ_STREAM_END, bzerror, &bzf); + return(len - bzf->strm.avail_out); + } + if (bzf->strm.avail_out == 0) { + bz_seterr(BZ_OK, bzerror, &bzf); + return(len); + } + } + return(0); /*not reached*/ +} + +void BZ2_bzReadGetUnused(int *bzerror, void *b, void **unused, int *nUnused) +{ + bzFile *bzf = (bzFile*)b; + if (bzf == NULL) { + bz_seterr(BZ_PARAM_ERROR, bzerror, &bzf); + return; + } + if (bzf->lastErr != BZ_STREAM_END) { + bz_seterr(BZ_SEQUENCE_ERROR, bzerror, &bzf); + return; + } + if (unused == NULL || nUnused == NULL) { + bz_seterr(BZ_PARAM_ERROR, bzerror, &bzf); + return; + } + + bz_seterr(BZ_OK, bzerror, &bzf); + *nUnused = bzf->strm.avail_in; + *unused = bzf->strm.next_in; +} + +void *BZ2_bzReadOpen(int *bzerror, FILE *f, int small, void *unused, int nUnused) +{ + bzFile *bzf = NULL; + int ret; + + bz_seterr(BZ_OK, bzerror, &bzf); + + if (f == NULL || (small != 0 && small != 1) || + (unused != NULL && (nUnused < 0 || nUnused > BZ_MAX_UNUSED)) || +// (verbosity_level < 0 || verbosity_level > 4) || + (unused == NULL && nUnused != 0)) { + bz_seterr(BZ_PARAM_ERROR, bzerror, &bzf); + return NULL; + } + + if (ferror(f)) { + bz_seterr(BZ_IO_ERROR, bzerror, &bzf); + return NULL; + } + + bzf = xmalloc(sizeof(bzFile)); + if (bzf == NULL) { + bz_seterr(BZ_MEM_ERROR, bzerror, &bzf); + return NULL; + } + bz_seterr(BZ_OK, bzerror, &bzf); + + bzf->initialisedOk = FALSE; + bzf->handle = f; + bzf->bufN = 0; + bzf->writing = FALSE; + bzf->strm.bzalloc = NULL; + bzf->strm.bzfree = NULL; + bzf->strm.opaque = NULL; + + while (nUnused > 0) { + bzf->buf[bzf->bufN] = *((unsigned char *)(unused)); bzf->bufN++; + unused = ((void *)( 1 + ((unsigned char *)(unused)) )); + nUnused--; + } + + ret = BZ2_bzDecompressInit(&(bzf->strm), small); + if (ret != BZ_OK) { + bz_seterr(ret, bzerror, &bzf); + free(bzf); + return NULL; + } + + bzf->strm.avail_in = bzf->bufN; + bzf->strm.next_in = bzf->buf; + + bzf->initialisedOk = TRUE; + return bzf; +} + +static unsigned char uncompressStream(FILE *zStream, FILE *stream) +{ + unsigned char unused[BZ_MAX_UNUSED]; + unsigned char *unusedTmp; + unsigned char obuf[5000]; + void *bzf = NULL; + int bzerr_dummy; + int bzerr; + int nread; + int nUnused; + int streamNo; + int ret; + int i; + + nUnused = 0; + streamNo = 0; + + if (ferror(stream)) { + goto errhandler_io; + } + if (ferror(zStream)) { + goto errhandler_io; + } + + while(1) { + bzf = BZ2_bzReadOpen(&bzerr, zStream, (int)smallMode, unused, nUnused); + if (bzf == NULL || bzerr != BZ_OK) { + goto errhandler; + } + streamNo++; + + while (bzerr == BZ_OK) { + nread = BZ2_bzRead(&bzerr, bzf, obuf, 5000); + if (bzerr == BZ_DATA_ERROR_MAGIC) { + goto errhandler; + } + if ((bzerr == BZ_OK || bzerr == BZ_STREAM_END) && nread > 0) { + fwrite(obuf, sizeof(unsigned char), nread, stream); + } + if (ferror(stream)) { + goto errhandler_io; + } + } + if (bzerr != BZ_STREAM_END) { + goto errhandler; + } + BZ2_bzReadGetUnused(&bzerr, bzf, (void **)(&unusedTmp), &nUnused); + if (bzerr != BZ_OK) { + panic("decompress:bzReadGetUnused"); + } + for (i = 0; i < nUnused; i++) { + unused[i] = unusedTmp[i]; + } + BZ2_bzReadClose(&bzerr, bzf); + if (bzerr != BZ_OK) { + panic("decompress:bzReadGetUnused"); + } + if ((nUnused == 0) && myfeof(zStream)) { + break; + } + } + + if (ferror(zStream)) { + goto errhandler_io; + } + ret = fclose(zStream); + if (ret == EOF) { + goto errhandler_io; + } + if (ferror(stream)) { + goto errhandler_io; + } + ret = fflush(stream); + if (ret != 0) { + goto errhandler_io; + } + if (stream != stdout) { + ret = fclose(stream); + if (ret == EOF) { + goto errhandler_io; + } + } +// if (verbosity_level >= 2) { +// fprintf(stderr,"\n "); +// } + return TRUE; + +errhandler: + BZ2_bzReadClose ( &bzerr_dummy, bzf ); + switch (bzerr) { + case BZ_CONFIG_ERROR: + error_msg("bzip2: I'm not configured correctly for this platform!\n" + "\tI require Int32, Int16 and Char to have sizes\n" + "\tof 4, 2 and 1 bytes to run properly, and they don't.\n" + "\tProbably you can fix this by defining them correctly,\n" + "\tand recompiling. Bye!\n" ); + exit(3); + case BZ_IO_ERROR: +errhandler_io: + error_msg("\n%s: I/O or other error, bailing out. " + "Possible reason follows.\n", progName); + perror(progName); + cleanUpAndFail(1); + case BZ_DATA_ERROR: + error_msg("\n%s: Data integrity error when decompressing.\n", progName); + cleanUpAndFail(2); + case BZ_MEM_ERROR: + error_msg("\n%s: couldn't allocate enough memory\n", progName); + cleanUpAndFail(1); + case BZ_UNEXPECTED_EOF: + error_msg("\n%s: Compressed file ends unexpectedly;\n\t" + "perhaps it is corrupted? *Possible* reason follows.\n", progName); + perror(progName); + cleanUpAndFail(2); + case BZ_DATA_ERROR_MAGIC: + if (zStream != stdin) { + fclose(zStream); + } + if (stream != stdout) { + fclose(stream); + } + if (streamNo == 1) { + return FALSE; + } else { + if (noisy) { + error_msg("\n%s: %s: trailing garbage after EOF ignored\n", progName, inName ); + } + return TRUE; + } + default: + panic ( "decompress:unexpected error" ); + } + + panic("decompress:end"); + return(TRUE); /*notreached*/ +} + +int bunzip2_main(int argc, char **argv) +{ + FILE *src_stream; + FILE *dst_stream; + char *save_name; + char *save_name_ptr; + if (argc != 2) { + show_usage(); + } + src_stream = xfopen(argv[1], "r"); + save_name = strdup(argv[1]); + save_name_ptr = strrchr(save_name, '.'); + if (save_name_ptr == NULL) { + return(FALSE); + } + if (strcmp(save_name_ptr, ".bz2") != 0) { + error_msg("Invalid extension, expected .bz2"); + } + *save_name_ptr = '\0'; + dst_stream = xfopen(save_name, "w"); + uncompressStream(src_stream, dst_stream); + + return(TRUE); +} diff --git a/include/applets.h b/include/applets.h index ab8727b71..461c878df 100644 --- a/include/applets.h +++ b/include/applets.h @@ -64,6 +64,9 @@ #ifdef BB_BASENAME APPLET(basename, basename_main, _BB_DIR_USR_BIN) #endif +#ifdef BB_BUNZIP2 + APPLET(bunzip2, bunzip2_main, _BB_DIR_USR_BIN) +#endif APPLET_NOUSAGE("busybox", busybox_main, _BB_DIR_BIN) #ifdef BB_CAT APPLET(cat, cat_main, _BB_DIR_BIN) diff --git a/include/usage.h b/include/usage.h index f504ac1b8..0b095a4da 100644 --- a/include/usage.h +++ b/include/usage.h @@ -51,6 +51,12 @@ "$ basename /foo/bar.txt .txt\n" \ "bar" +#define bunzip2_trivial_usage \ + "FILE" +#define bunzip2_full_usage \ + "Uncompress FILE to current directory, stripping its .bz2 extension.\n"\ + " -k is assumed" + #define cat_trivial_usage \ "[FILE]..." #define cat_full_usage \ @@ -51,6 +51,12 @@ "$ basename /foo/bar.txt .txt\n" \ "bar" +#define bunzip2_trivial_usage \ + "FILE" +#define bunzip2_full_usage \ + "Uncompress FILE to current directory, stripping its .bz2 extension.\n"\ + " -k is assumed" + #define cat_trivial_usage \ "[FILE]..." #define cat_full_usage \ |