Home | History | Annotate | Download | only in tests
      1 
      2 /* This is a very slightly modified version of perf/bz2.c, with a
      3    single change that causes it to overrun a global array by one byte.
      4    The change in question is a change of the size of myprintf_buf from
      5    1000 to 70, at line 1278.  ptrcheck should report exactly one
      6    error, resulting from an out of range access to this array. */
      7 
      8 // This benchmark is basically bzip2 (mashed to be a single file)
      9 // compressing and decompressing some data.  It tests Valgrind's handling of
     10 // realistic and "difficult" (ie. lots of branches and memory accesses)
     11 // integer code.  Execution is spread out over quite a few basic blocks;
     12 // --profile-flags indicates that to get to the top 90%th percentile of
     13 // dynamic BB counts requires considering the top 51 basic blocks
     14 
     15 // This program can be used both as part of the performance test
     16 // suite, in which case we want it to run for quite a while,
     17 // and as part of the regression (correctness) test suite, in
     18 // which case we want it to run quickly and be verbose.
     19 // So it does the latter iff given a command line arg.
     20 
     21 // Licensing: the code within is mostly taken from bzip2, which has a BSD
     22 // license.  There is a little code from VEX, which is licensed under GPLv2
     23 // And it's all written by Julian Seward.
     24 
     25 #define BZ_NO_STDIO
     26 
     27 
     28 /*-------------------------------------------------------------*/
     29 /*--- Private header file for the library.                  ---*/
     30 /*---                                       bzlib_private.h ---*/
     31 /*-------------------------------------------------------------*/
     32 
     33 /*--
     34   This file is a part of bzip2 and/or libbzip2, a program and
     35   library for lossless, block-sorting data compression.
     36 
     37   Copyright (C) 1996-2004 Julian R Seward.  All rights reserved.
     38 
     39   Redistribution and use in source and binary forms, with or without
     40   modification, are permitted provided that the following conditions
     41   are met:
     42 
     43   1. Redistributions of source code must retain the above copyright
     44      notice, this list of conditions and the following disclaimer.
     45 
     46   2. The origin of this software must not be misrepresented; you must
     47      not claim that you wrote the original software.  If you use this
     48      software in a product, an acknowledgment in the product
     49      documentation would be appreciated but is not required.
     50 
     51   3. Altered source versions must be plainly marked as such, and must
     52      not be misrepresented as being the original software.
     53 
     54   4. The name of the author may not be used to endorse or promote
     55      products derived from this software without specific prior written
     56      permission.
     57 
     58   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
     59   OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     60   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     61   ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
     62   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     63   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
     64   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     65   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     66   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
     67   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
     68   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     69 
     70   Julian Seward, Cambridge, UK.
     71   jseward (at) bzip.org
     72   bzip2/libbzip2 version 1.0 of 21 March 2000
     73 
     74   This program is based on (at least) the work of:
     75      Mike Burrows
     76      David Wheeler
     77      Peter Fenwick
     78      Alistair Moffat
     79      Radford Neal
     80      Ian H. Witten
     81      Robert Sedgewick
     82      Jon L. Bentley
     83 
     84   For more information on these sources, see the manual.
     85 --*/
     86 
     87 
     88 #ifndef _BZLIB_PRIVATE_H
     89 #define _BZLIB_PRIVATE_H
     90 
     91 #include <stdlib.h>
     92 
     93 #ifndef BZ_NO_STDIO
     94 #include <stdio.h>
     95 #include <ctype.h>
     96 #include <string.h>
     97 #endif
     98 
     99 
    100 /*-------------------------------------------------------------*/
    101 /*--- Public header file for the library.                   ---*/
    102 /*---                                               bzlib.h ---*/
    103 /*-------------------------------------------------------------*/
    104 
    105 /*--
    106   This file is a part of bzip2 and/or libbzip2, a program and
    107   library for lossless, block-sorting data compression.
    108 
    109   Copyright (C) 1996-2004 Julian R Seward.  All rights reserved.
    110 
    111   Redistribution and use in source and binary forms, with or without
    112   modification, are permitted provided that the following conditions
    113   are met:
    114 
    115   1. Redistributions of source code must retain the above copyright
    116      notice, this list of conditions and the following disclaimer.
    117 
    118   2. The origin of this software must not be misrepresented; you must
    119      not claim that you wrote the original software.  If you use this
    120      software in a product, an acknowledgment in the product
    121      documentation would be appreciated but is not required.
    122 
    123   3. Altered source versions must be plainly marked as such, and must
    124      not be misrepresented as being the original software.
    125 
    126   4. The name of the author may not be used to endorse or promote
    127      products derived from this software without specific prior written
    128      permission.
    129 
    130   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
    131   OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
    132   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    133   ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
    134   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    135   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
    136   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    137   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
    138   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
    139   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
    140   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    141 
    142   Julian Seward, Cambridge, UK.
    143   jseward (at) bzip.org
    144   bzip2/libbzip2 version 1.0 of 21 March 2000
    145 
    146   This program is based on (at least) the work of:
    147      Mike Burrows
    148      David Wheeler
    149      Peter Fenwick
    150      Alistair Moffat
    151      Radford Neal
    152      Ian H. Witten
    153      Robert Sedgewick
    154      Jon L. Bentley
    155 
    156   For more information on these sources, see the manual.
    157 --*/
    158 
    159 
    160 #ifndef _BZLIB_H
    161 #define _BZLIB_H
    162 
    163 #ifdef __cplusplus
    164 extern "C" {
    165 #endif
    166 
    167 #define BZ_RUN               0
    168 #define BZ_FLUSH             1
    169 #define BZ_FINISH            2
    170 
    171 #define BZ_OK                0
    172 #define BZ_RUN_OK            1
    173 #define BZ_FLUSH_OK          2
    174 #define BZ_FINISH_OK         3
    175 #define BZ_STREAM_END        4
    176 #define BZ_SEQUENCE_ERROR    (-1)
    177 #define BZ_PARAM_ERROR       (-2)
    178 #define BZ_MEM_ERROR         (-3)
    179 #define BZ_DATA_ERROR        (-4)
    180 #define BZ_DATA_ERROR_MAGIC  (-5)
    181 #define BZ_IO_ERROR          (-6)
    182 #define BZ_UNEXPECTED_EOF    (-7)
    183 #define BZ_OUTBUFF_FULL      (-8)
    184 #define BZ_CONFIG_ERROR      (-9)
    185 
    186 typedef
    187    struct {
    188       char *next_in;
    189       unsigned int avail_in;
    190       unsigned int total_in_lo32;
    191       unsigned int total_in_hi32;
    192 
    193       char *next_out;
    194       unsigned int avail_out;
    195       unsigned int total_out_lo32;
    196       unsigned int total_out_hi32;
    197 
    198       void *state;
    199 
    200       void *(*bzalloc)(void *,int,int);
    201       void (*bzfree)(void *,void *);
    202       void *opaque;
    203    }
    204    bz_stream;
    205 
    206 
    207 #ifndef BZ_IMPORT
    208 #define BZ_EXPORT
    209 #endif
    210 
    211 #ifndef BZ_NO_STDIO
    212 /* Need a definitition for FILE */
    213 #include <stdio.h>
    214 #endif
    215 
    216 #ifdef _WIN32
    217 #   include <windows.h>
    218 #   ifdef small
    219       /* windows.h define small to char */
    220 #      undef small
    221 #   endif
    222 #   ifdef BZ_EXPORT
    223 #   define BZ_API(func) WINAPI func
    224 #   define BZ_EXTERN extern
    225 #   else
    226    /* import windows dll dynamically */
    227 #   define BZ_API(func) (WINAPI * func)
    228 #   define BZ_EXTERN
    229 #   endif
    230 #else
    231 #   define BZ_API(func) func
    232 #   define BZ_EXTERN extern
    233 #endif
    234 
    235 
    236 /*-- Core (low-level) library functions --*/
    237 
    238 BZ_EXTERN int BZ_API(BZ2_bzCompressInit) (
    239       bz_stream* strm,
    240       int        blockSize100k,
    241       int        verbosity,
    242       int        workFactor
    243    );
    244 
    245 BZ_EXTERN int BZ_API(BZ2_bzCompress) (
    246       bz_stream* strm,
    247       int action
    248    );
    249 
    250 BZ_EXTERN int BZ_API(BZ2_bzCompressEnd) (
    251       bz_stream* strm
    252    );
    253 
    254 BZ_EXTERN int BZ_API(BZ2_bzDecompressInit) (
    255       bz_stream *strm,
    256       int       verbosity,
    257       int       small
    258    );
    259 
    260 BZ_EXTERN int BZ_API(BZ2_bzDecompress) (
    261       bz_stream* strm
    262    );
    263 
    264 BZ_EXTERN int BZ_API(BZ2_bzDecompressEnd) (
    265       bz_stream *strm
    266    );
    267 
    268 
    269 
    270 /*-- High(er) level library functions --*/
    271 
    272 #ifndef BZ_NO_STDIO
    273 #define BZ_MAX_UNUSED 5000
    274 
    275 typedef void BZFILE;
    276 
    277 BZ_EXTERN BZFILE* BZ_API(BZ2_bzReadOpen) (
    278       int*  bzerror,
    279       FILE* f,
    280       int   verbosity,
    281       int   small,
    282       void* unused,
    283       int   nUnused
    284    );
    285 
    286 BZ_EXTERN void BZ_API(BZ2_bzReadClose) (
    287       int*    bzerror,
    288       BZFILE* b
    289    );
    290 
    291 BZ_EXTERN void BZ_API(BZ2_bzReadGetUnused) (
    292       int*    bzerror,
    293       BZFILE* b,
    294       void**  unused,
    295       int*    nUnused
    296    );
    297 
    298 BZ_EXTERN int BZ_API(BZ2_bzRead) (
    299       int*    bzerror,
    300       BZFILE* b,
    301       void*   buf,
    302       int     len
    303    );
    304 
    305 BZ_EXTERN BZFILE* BZ_API(BZ2_bzWriteOpen) (
    306       int*  bzerror,
    307       FILE* f,
    308       int   blockSize100k,
    309       int   verbosity,
    310       int   workFactor
    311    );
    312 
    313 BZ_EXTERN void BZ_API(BZ2_bzWrite) (
    314       int*    bzerror,
    315       BZFILE* b,
    316       void*   buf,
    317       int     len
    318    );
    319 
    320 BZ_EXTERN void BZ_API(BZ2_bzWriteClose) (
    321       int*          bzerror,
    322       BZFILE*       b,
    323       int           abandon,
    324       unsigned int* nbytes_in,
    325       unsigned int* nbytes_out
    326    );
    327 
    328 BZ_EXTERN void BZ_API(BZ2_bzWriteClose64) (
    329       int*          bzerror,
    330       BZFILE*       b,
    331       int           abandon,
    332       unsigned int* nbytes_in_lo32,
    333       unsigned int* nbytes_in_hi32,
    334       unsigned int* nbytes_out_lo32,
    335       unsigned int* nbytes_out_hi32
    336    );
    337 #endif
    338 
    339 
    340 /*-- Utility functions --*/
    341 
    342 BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffCompress) (
    343       char*         dest,
    344       unsigned int* destLen,
    345       char*         source,
    346       unsigned int  sourceLen,
    347       int           blockSize100k,
    348       int           verbosity,
    349       int           workFactor
    350    );
    351 
    352 BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffDecompress) (
    353       char*         dest,
    354       unsigned int* destLen,
    355       char*         source,
    356       unsigned int  sourceLen,
    357       int           small,
    358       int           verbosity
    359    );
    360 
    361 
    362 /*--
    363    Code contributed by Yoshioka Tsuneo
    364    (QWF00133 (at) niftyserve.or.jp/tsuneo-y (at) is.aist-nara.ac.jp),
    365    to support better zlib compatibility.
    366    This code is not _officially_ part of libbzip2 (yet);
    367    I haven't tested it, documented it, or considered the
    368    threading-safeness of it.
    369    If this code breaks, please contact both Yoshioka and me.
    370 --*/
    371 
    372 BZ_EXTERN const char * BZ_API(BZ2_bzlibVersion) (
    373       void
    374    );
    375 
    376 #ifndef BZ_NO_STDIO
    377 BZ_EXTERN BZFILE * BZ_API(BZ2_bzopen) (
    378       const char *path,
    379       const char *mode
    380    );
    381 
    382 BZ_EXTERN BZFILE * BZ_API(BZ2_bzdopen) (
    383       int        fd,
    384       const char *mode
    385    );
    386 
    387 BZ_EXTERN int BZ_API(BZ2_bzread) (
    388       BZFILE* b,
    389       void* buf,
    390       int len
    391    );
    392 
    393 BZ_EXTERN int BZ_API(BZ2_bzwrite) (
    394       BZFILE* b,
    395       void*   buf,
    396       int     len
    397    );
    398 
    399 BZ_EXTERN int BZ_API(BZ2_bzflush) (
    400       BZFILE* b
    401    );
    402 
    403 BZ_EXTERN void BZ_API(BZ2_bzclose) (
    404       BZFILE* b
    405    );
    406 
    407 BZ_EXTERN const char * BZ_API(BZ2_bzerror) (
    408       BZFILE *b,
    409       int    *errnum
    410    );
    411 #endif
    412 
    413 #ifdef __cplusplus
    414 }
    415 #endif
    416 
    417 #endif
    418 
    419 /*-------------------------------------------------------------*/
    420 /*--- end                                           bzlib.h ---*/
    421 /*-------------------------------------------------------------*/
    422 
    423 
    424 
    425 
    426 /*-- General stuff. --*/
    427 
    428 #define BZ_VERSION  "1.0.3, 17-Oct-2004"
    429 
    430 typedef char            Char;
    431 typedef unsigned char   Bool;
    432 typedef unsigned char   UChar;
    433 typedef int             Int32;
    434 typedef unsigned int    UInt32;
    435 typedef short           Int16;
    436 typedef unsigned short  UInt16;
    437 
    438 #define True  ((Bool)1)
    439 #define False ((Bool)0)
    440 
    441 #ifndef __GNUC__
    442 #define __inline__  /* */
    443 #endif
    444 
    445 #ifndef BZ_NO_STDIO
    446 extern void BZ2_bz__AssertH__fail ( int errcode );
    447 #define AssertH(cond,errcode) \
    448    { if (!(cond)) BZ2_bz__AssertH__fail ( errcode ); }
    449 #if BZ_DEBUG
    450 #define AssertD(cond,msg) \
    451    { if (!(cond)) {       \
    452       fprintf ( stderr,   \
    453         "\n\nlibbzip2(debug build): internal error\n\t%s\n", msg );\
    454       exit(1); \
    455    }}
    456 #else
    457 #define AssertD(cond,msg) /* */
    458 #endif
    459 #define VPrintf0(zf) \
    460    fprintf(stderr,zf)
    461 #define VPrintf1(zf,za1) \
    462    fprintf(stderr,zf,za1)
    463 #define VPrintf2(zf,za1,za2) \
    464    fprintf(stderr,zf,za1,za2)
    465 #define VPrintf3(zf,za1,za2,za3) \
    466    fprintf(stderr,zf,za1,za2,za3)
    467 #define VPrintf4(zf,za1,za2,za3,za4) \
    468    fprintf(stderr,zf,za1,za2,za3,za4)
    469 #define VPrintf5(zf,za1,za2,za3,za4,za5) \
    470    fprintf(stderr,zf,za1,za2,za3,za4,za5)
    471 #else
    472 extern void bz_internal_error ( int errcode );
    473 #define AssertH(cond,errcode) \
    474    { if (!(cond)) bz_internal_error ( errcode ); }
    475 #define AssertD(cond,msg) /* */
    476 #define VPrintf0(zf) \
    477    vex_printf(zf)
    478 #define VPrintf1(zf,za1) \
    479    vex_printf(zf,za1)
    480 #define VPrintf2(zf,za1,za2) \
    481    vex_printf(zf,za1,za2)
    482 #define VPrintf3(zf,za1,za2,za3) \
    483    vex_printf(zf,za1,za2,za3)
    484 #define VPrintf4(zf,za1,za2,za3,za4) \
    485    vex_printf(zf,za1,za2,za3,za4)
    486 #define VPrintf5(zf,za1,za2,za3,za4,za5) \
    487    vex_printf(zf,za1,za2,za3,za4,za5)
    488 #endif
    489 
    490 
    491 #define BZALLOC(nnn) (strm->bzalloc)(strm->opaque,(nnn),1)
    492 #define BZFREE(ppp)  (strm->bzfree)(strm->opaque,(ppp))
    493 
    494 
    495 /*-- Header bytes. --*/
    496 
    497 #define BZ_HDR_B 0x42   /* 'B' */
    498 #define BZ_HDR_Z 0x5a   /* 'Z' */
    499 #define BZ_HDR_h 0x68   /* 'h' */
    500 #define BZ_HDR_0 0x30   /* '0' */
    501 
    502 /*-- Constants for the back end. --*/
    503 
    504 #define BZ_MAX_ALPHA_SIZE 258
    505 #define BZ_MAX_CODE_LEN    23
    506 
    507 #define BZ_RUNA 0
    508 #define BZ_RUNB 1
    509 
    510 #define BZ_N_GROUPS 6
    511 #define BZ_G_SIZE   50
    512 #define BZ_N_ITERS  4
    513 
    514 #define BZ_MAX_SELECTORS (2 + (900000 / BZ_G_SIZE))
    515 
    516 
    517 
    518 /*-- Stuff for randomising repetitive blocks. --*/
    519 
    520 extern Int32 BZ2_rNums[512];
    521 
    522 #define BZ_RAND_DECLS                          \
    523    Int32 rNToGo;                               \
    524    Int32 rTPos                                 \
    525 
    526 #define BZ_RAND_INIT_MASK                      \
    527    s->rNToGo = 0;                              \
    528    s->rTPos  = 0                               \
    529 
    530 #define BZ_RAND_MASK ((s->rNToGo == 1) ? 1 : 0)
    531 
    532 #define BZ_RAND_UPD_MASK                       \
    533    if (s->rNToGo == 0) {                       \
    534       s->rNToGo = BZ2_rNums[s->rTPos];         \
    535       s->rTPos++;                              \
    536       if (s->rTPos == 512) s->rTPos = 0;       \
    537    }                                           \
    538    s->rNToGo--;
    539 
    540 
    541 
    542 /*-- Stuff for doing CRCs. --*/
    543 
    544 extern UInt32 BZ2_crc32Table[256];
    545 
    546 #define BZ_INITIALISE_CRC(crcVar)              \
    547 {                                              \
    548    crcVar = 0xffffffffL;                       \
    549 }
    550 
    551 #define BZ_FINALISE_CRC(crcVar)                \
    552 {                                              \
    553    crcVar = ~(crcVar);                         \
    554 }
    555 
    556 #define BZ_UPDATE_CRC(crcVar,cha)              \
    557 {                                              \
    558    crcVar = (crcVar << 8) ^                    \
    559             BZ2_crc32Table[(crcVar >> 24) ^    \
    560                            ((UChar)cha)];      \
    561 }
    562 
    563 
    564 
    565 /*-- States and modes for compression. --*/
    566 
    567 #define BZ_M_IDLE      1
    568 #define BZ_M_RUNNING   2
    569 #define BZ_M_FLUSHING  3
    570 #define BZ_M_FINISHING 4
    571 
    572 #define BZ_S_OUTPUT    1
    573 #define BZ_S_INPUT     2
    574 
    575 #define BZ_N_RADIX 2
    576 #define BZ_N_QSORT 12
    577 #define BZ_N_SHELL 18
    578 #define BZ_N_OVERSHOOT (BZ_N_RADIX + BZ_N_QSORT + BZ_N_SHELL + 2)
    579 
    580 
    581 
    582 
    583 /*-- Structure holding all the compression-side stuff. --*/
    584 
    585 typedef
    586    struct {
    587       /* pointer back to the struct bz_stream */
    588       bz_stream* strm;
    589 
    590       /* mode this stream is in, and whether inputting */
    591       /* or outputting data */
    592       Int32    mode;
    593       Int32    state;
    594 
    595       /* remembers avail_in when flush/finish requested */
    596       UInt32   avail_in_expect;
    597 
    598       /* for doing the block sorting */
    599       UInt32*  arr1;
    600       UInt32*  arr2;
    601       UInt32*  ftab;
    602       Int32    origPtr;
    603 
    604       /* aliases for arr1 and arr2 */
    605       UInt32*  ptr;
    606       UChar*   block;
    607       UInt16*  mtfv;
    608       UChar*   zbits;
    609 
    610       /* for deciding when to use the fallback sorting algorithm */
    611       Int32    workFactor;
    612 
    613       /* run-length-encoding of the input */
    614       UInt32   state_in_ch;
    615       Int32    state_in_len;
    616       BZ_RAND_DECLS;
    617 
    618       /* input and output limits and current posns */
    619       Int32    nblock;
    620       Int32    nblockMAX;
    621       Int32    numZ;
    622       Int32    state_out_pos;
    623 
    624       /* map of bytes used in block */
    625       Int32    nInUse;
    626       Bool     inUse[256];
    627       UChar    unseqToSeq[256];
    628 
    629       /* the buffer for bit stream creation */
    630       UInt32   bsBuff;
    631       Int32    bsLive;
    632 
    633       /* block and combined CRCs */
    634       UInt32   blockCRC;
    635       UInt32   combinedCRC;
    636 
    637       /* misc administratium */
    638       Int32    verbosity;
    639       Int32    blockNo;
    640       Int32    blockSize100k;
    641 
    642       /* stuff for coding the MTF values */
    643       Int32    nMTF;
    644       Int32    mtfFreq    [BZ_MAX_ALPHA_SIZE];
    645       UChar    selector   [BZ_MAX_SELECTORS];
    646       UChar    selectorMtf[BZ_MAX_SELECTORS];
    647 
    648       UChar    len     [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
    649       Int32    code    [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
    650       Int32    rfreq   [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
    651       /* second dimension: only 3 needed; 4 makes index calculations faster */
    652       UInt32   len_pack[BZ_MAX_ALPHA_SIZE][4];
    653 
    654    }
    655    EState;
    656 
    657 
    658 
    659 /*-- externs for compression. --*/
    660 
    661 extern void
    662 BZ2_blockSort ( EState* );
    663 
    664 extern void
    665 BZ2_compressBlock ( EState*, Bool );
    666 
    667 extern void
    668 BZ2_bsInitWrite ( EState* );
    669 
    670 extern void
    671 BZ2_hbAssignCodes ( Int32*, UChar*, Int32, Int32, Int32 );
    672 
    673 extern void
    674 BZ2_hbMakeCodeLengths ( UChar*, Int32*, Int32, Int32 );
    675 
    676 
    677 
    678 /*-- states for decompression. --*/
    679 
    680 #define BZ_X_IDLE        1
    681 #define BZ_X_OUTPUT      2
    682 
    683 #define BZ_X_MAGIC_1     10
    684 #define BZ_X_MAGIC_2     11
    685 #define BZ_X_MAGIC_3     12
    686 #define BZ_X_MAGIC_4     13
    687 #define BZ_X_BLKHDR_1    14
    688 #define BZ_X_BLKHDR_2    15
    689 #define BZ_X_BLKHDR_3    16
    690 #define BZ_X_BLKHDR_4    17
    691 #define BZ_X_BLKHDR_5    18
    692 #define BZ_X_BLKHDR_6    19
    693 #define BZ_X_BCRC_1      20
    694 #define BZ_X_BCRC_2      21
    695 #define BZ_X_BCRC_3      22
    696 #define BZ_X_BCRC_4      23
    697 #define BZ_X_RANDBIT     24
    698 #define BZ_X_ORIGPTR_1   25
    699 #define BZ_X_ORIGPTR_2   26
    700 #define BZ_X_ORIGPTR_3   27
    701 #define BZ_X_MAPPING_1   28
    702 #define BZ_X_MAPPING_2   29
    703 #define BZ_X_SELECTOR_1  30
    704 #define BZ_X_SELECTOR_2  31
    705 #define BZ_X_SELECTOR_3  32
    706 #define BZ_X_CODING_1    33
    707 #define BZ_X_CODING_2    34
    708 #define BZ_X_CODING_3    35
    709 #define BZ_X_MTF_1       36
    710 #define BZ_X_MTF_2       37
    711 #define BZ_X_MTF_3       38
    712 #define BZ_X_MTF_4       39
    713 #define BZ_X_MTF_5       40
    714 #define BZ_X_MTF_6       41
    715 #define BZ_X_ENDHDR_2    42
    716 #define BZ_X_ENDHDR_3    43
    717 #define BZ_X_ENDHDR_4    44
    718 #define BZ_X_ENDHDR_5    45
    719 #define BZ_X_ENDHDR_6    46
    720 #define BZ_X_CCRC_1      47
    721 #define BZ_X_CCRC_2      48
    722 #define BZ_X_CCRC_3      49
    723 #define BZ_X_CCRC_4      50
    724 
    725 
    726 
    727 /*-- Constants for the fast MTF decoder. --*/
    728 
    729 #define MTFA_SIZE 4096
    730 #define MTFL_SIZE 16
    731 
    732 
    733 
    734 /*-- Structure holding all the decompression-side stuff. --*/
    735 
    736 typedef
    737    struct {
    738       /* pointer back to the struct bz_stream */
    739       bz_stream* strm;
    740 
    741       /* state indicator for this stream */
    742       Int32    state;
    743 
    744       /* for doing the final run-length decoding */
    745       UChar    state_out_ch;
    746       Int32    state_out_len;
    747       Bool     blockRandomised;
    748       BZ_RAND_DECLS;
    749 
    750       /* the buffer for bit stream reading */
    751       UInt32   bsBuff;
    752       Int32    bsLive;
    753 
    754       /* misc administratium */
    755       Int32    blockSize100k;
    756       Bool     smallDecompress;
    757       Int32    currBlockNo;
    758       Int32    verbosity;
    759 
    760       /* for undoing the Burrows-Wheeler transform */
    761       Int32    origPtr;
    762       UInt32   tPos;
    763       Int32    k0;
    764       Int32    unzftab[256];
    765       Int32    nblock_used;
    766       Int32    cftab[257];
    767       Int32    cftabCopy[257];
    768 
    769       /* for undoing the Burrows-Wheeler transform (FAST) */
    770       UInt32   *tt;
    771 
    772       /* for undoing the Burrows-Wheeler transform (SMALL) */
    773       UInt16   *ll16;
    774       UChar    *ll4;
    775 
    776       /* stored and calculated CRCs */
    777       UInt32   storedBlockCRC;
    778       UInt32   storedCombinedCRC;
    779       UInt32   calculatedBlockCRC;
    780       UInt32   calculatedCombinedCRC;
    781 
    782       /* map of bytes used in block */
    783       Int32    nInUse;
    784       Bool     inUse[256];
    785       Bool     inUse16[16];
    786       UChar    seqToUnseq[256];
    787 
    788       /* for decoding the MTF values */
    789       UChar    mtfa   [MTFA_SIZE];
    790       Int32    mtfbase[256 / MTFL_SIZE];
    791       UChar    selector   [BZ_MAX_SELECTORS];
    792       UChar    selectorMtf[BZ_MAX_SELECTORS];
    793       UChar    len  [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
    794 
    795       Int32    limit  [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
    796       Int32    base   [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
    797       Int32    perm   [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
    798       Int32    minLens[BZ_N_GROUPS];
    799 
    800       /* save area for scalars in the main decompress code */
    801       Int32    save_i;
    802       Int32    save_j;
    803       Int32    save_t;
    804       Int32    save_alphaSize;
    805       Int32    save_nGroups;
    806       Int32    save_nSelectors;
    807       Int32    save_EOB;
    808       Int32    save_groupNo;
    809       Int32    save_groupPos;
    810       Int32    save_nextSym;
    811       Int32    save_nblockMAX;
    812       Int32    save_nblock;
    813       Int32    save_es;
    814       Int32    save_N;
    815       Int32    save_curr;
    816       Int32    save_zt;
    817       Int32    save_zn;
    818       Int32    save_zvec;
    819       Int32    save_zj;
    820       Int32    save_gSel;
    821       Int32    save_gMinlen;
    822       Int32*   save_gLimit;
    823       Int32*   save_gBase;
    824       Int32*   save_gPerm;
    825 
    826    }
    827    DState;
    828 
    829 
    830 
    831 /*-- Macros for decompression. --*/
    832 
    833 #define BZ_GET_FAST(cccc)                     \
    834     s->tPos = s->tt[s->tPos];                 \
    835     cccc = (UChar)(s->tPos & 0xff);           \
    836     s->tPos >>= 8;
    837 
    838 #define BZ_GET_FAST_C(cccc)                   \
    839     c_tPos = c_tt[c_tPos];                    \
    840     cccc = (UChar)(c_tPos & 0xff);            \
    841     c_tPos >>= 8;
    842 
    843 #define SET_LL4(i,n)                                          \
    844    { if (((i) & 0x1) == 0)                                    \
    845         s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0xf0) | (n); else    \
    846         s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0x0f) | ((n) << 4);  \
    847    }
    848 
    849 #define GET_LL4(i)                             \
    850    ((((UInt32)(s->ll4[(i) >> 1])) >> (((i) << 2) & 0x4)) & 0xF)
    851 
    852 #define SET_LL(i,n)                          \
    853    { s->ll16[i] = (UInt16)(n & 0x0000ffff);  \
    854      SET_LL4(i, n >> 16);                    \
    855    }
    856 
    857 #define GET_LL(i) \
    858    (((UInt32)s->ll16[i]) | (GET_LL4(i) << 16))
    859 
    860 #define BZ_GET_SMALL(cccc)                            \
    861       cccc = BZ2_indexIntoF ( s->tPos, s->cftab );    \
    862       s->tPos = GET_LL(s->tPos);
    863 
    864 
    865 /*-- externs for decompression. --*/
    866 
    867 extern Int32
    868 BZ2_indexIntoF ( Int32, Int32* );
    869 
    870 extern Int32
    871 BZ2_decompress ( DState* );
    872 
    873 extern void
    874 BZ2_hbCreateDecodeTables ( Int32*, Int32*, Int32*, UChar*,
    875                            Int32,  Int32, Int32 );
    876 
    877 
    878 #endif
    879 
    880 
    881 /*-- BZ_NO_STDIO seems to make NULL disappear on some platforms. --*/
    882 
    883 #ifdef BZ_NO_STDIO
    884 #ifndef NULL
    885 #define NULL 0
    886 #endif
    887 #endif
    888 
    889 
    890 /*-------------------------------------------------------------*/
    891 /*--- end                                   bzlib_private.h ---*/
    892 /*-------------------------------------------------------------*/
    893 
    894 
    895 /* Something which has the same size as void* on the host.  That is,
    896    it is 32 bits on a 32-bit host and 64 bits on a 64-bit host, and so
    897    it can safely be coerced to and from a pointer type on the host
    898    machine. */
    899 typedef  unsigned long HWord;
    900 typedef  char          HChar;
    901 typedef  signed int    Int;
    902 typedef  unsigned int  UInt;
    903 
    904 typedef    signed long long int   Long;
    905 typedef  unsigned long long int   ULong;
    906 
    907 
    908 /////////////////////////////////////////////////////////////////////
    909 /////////////////////////////////////////////////////////////////////
    910 
    911 static HWord (*serviceFn)(HWord,HWord) = 0;
    912 
    913 #if 0
    914 static char* my_strcpy ( char* dest, const char* src )
    915 {
    916    char* dest_orig = dest;
    917    while (*src) *dest++ = *src++;
    918    *dest = 0;
    919    return dest_orig;
    920 }
    921 
    922 static void* my_memcpy ( void *dest, const void *src, int sz )
    923 {
    924    const char *s = (const char *)src;
    925    char *d = (char *)dest;
    926 
    927    while (sz--)
    928       *d++ = *s++;
    929 
    930    return dest;
    931 }
    932 
    933 static void* my_memmove( void *dst, const void *src, unsigned int len )
    934 {
    935     register char *d;
    936     register char *s;
    937     if ( dst > src ) {
    938         d = (char *)dst + len - 1;
    939         s = (char *)src + len - 1;
    940         while ( len >= 4 ) {
    941             *d-- = *s--;
    942             *d-- = *s--;
    943             *d-- = *s--;
    944             *d-- = *s--;
    945             len -= 4;
    946         }
    947         while ( len-- ) {
    948             *d-- = *s--;
    949         }
    950     } else if ( dst < src ) {
    951         d = (char *)dst;
    952         s = (char *)src;
    953         while ( len >= 4 ) {
    954             *d++ = *s++;
    955             *d++ = *s++;
    956             *d++ = *s++;
    957             *d++ = *s++;
    958             len -= 4;
    959         }
    960         while ( len-- ) {
    961             *d++ = *s++;
    962         }
    963     }
    964     return dst;
    965 }
    966 #endif
    967 
    968 char* my_strcat ( char* dest, const char* src )
    969 {
    970    char* dest_orig = dest;
    971    while (*dest) dest++;
    972    while (*src) *dest++ = *src++;
    973    *dest = 0;
    974    return dest_orig;
    975 }
    976 
    977 
    978 /////////////////////////////////////////////////////////////////////
    979 
    980 static void vex_log_bytes ( char* p, int n )
    981 {
    982    int i;
    983    for (i = 0; i < n; i++)
    984       (*serviceFn)( 1, (int)p[i] );
    985 }
    986 
    987 /*---------------------------------------------------------*/
    988 /*--- vex_printf                                        ---*/
    989 /*---------------------------------------------------------*/
    990 
    991 /* This should be the only <...> include in the entire VEX library.
    992    New code for vex_util.c should go above this point. */
    993 #include <stdarg.h>
    994 
    995 static HChar vex_toupper ( HChar c )
    996 {
    997    if (c >= 'a' && c <= 'z')
    998       return c + ('A' - 'a');
    999    else
   1000       return c;
   1001 }
   1002 
   1003 static Int vex_strlen ( const HChar* str )
   1004 {
   1005    Int i = 0;
   1006    while (str[i] != 0) i++;
   1007    return i;
   1008 }
   1009 
   1010 Bool vex_streq ( const HChar* s1, const HChar* s2 )
   1011 {
   1012    while (True) {
   1013       if (*s1 == 0 && *s2 == 0)
   1014          return True;
   1015       if (*s1 != *s2)
   1016          return False;
   1017       s1++;
   1018       s2++;
   1019    }
   1020 }
   1021 
   1022 /* Some flags.  */
   1023 #define VG_MSG_SIGNED    1 /* The value is signed. */
   1024 #define VG_MSG_ZJUSTIFY  2 /* Must justify with '0'. */
   1025 #define VG_MSG_LJUSTIFY  4 /* Must justify on the left. */
   1026 #define VG_MSG_PAREN     8 /* Parenthesize if present (for %y) */
   1027 #define VG_MSG_COMMA    16 /* Add commas to numbers (for %d, %u) */
   1028 
   1029 /* Copy a string into the buffer. */
   1030 static UInt
   1031 myvprintf_str ( void(*send)(HChar), Int flags, Int width, HChar* str,
   1032                 Bool capitalise )
   1033 {
   1034 #  define MAYBE_TOUPPER(ch) (capitalise ? vex_toupper(ch) : (ch))
   1035    UInt ret = 0;
   1036    Int i, extra;
   1037    Int len = vex_strlen(str);
   1038 
   1039    if (width == 0) {
   1040       ret += len;
   1041       for (i = 0; i < len; i++)
   1042          send(MAYBE_TOUPPER(str[i]));
   1043       return ret;
   1044    }
   1045 
   1046    if (len > width) {
   1047       ret += width;
   1048       for (i = 0; i < width; i++)
   1049          send(MAYBE_TOUPPER(str[i]));
   1050       return ret;
   1051    }
   1052 
   1053    extra = width - len;
   1054    if (flags & VG_MSG_LJUSTIFY) {
   1055       ret += extra;
   1056       for (i = 0; i < extra; i++)
   1057          send(' ');
   1058    }
   1059    ret += len;
   1060    for (i = 0; i < len; i++)
   1061       send(MAYBE_TOUPPER(str[i]));
   1062    if (!(flags & VG_MSG_LJUSTIFY)) {
   1063       ret += extra;
   1064       for (i = 0; i < extra; i++)
   1065          send(' ');
   1066    }
   1067 
   1068 #  undef MAYBE_TOUPPER
   1069 
   1070    return ret;
   1071 }
   1072 
   1073 /* Write P into the buffer according to these args:
   1074  *  If SIGN is true, p is a signed.
   1075  *  BASE is the base.
   1076  *  If WITH_ZERO is true, '0' must be added.
   1077  *  WIDTH is the width of the field.
   1078  */
   1079 static UInt
   1080 myvprintf_int64 ( void(*send)(HChar), Int flags, Int base, Int width, ULong pL)
   1081 {
   1082    HChar buf[40];
   1083    Int   ind = 0;
   1084    Int   i, nc = 0;
   1085    Bool  neg = False;
   1086    HChar *digits = "0123456789ABCDEF";
   1087    UInt  ret = 0;
   1088    UInt  p = (UInt)pL;
   1089 
   1090    if (base < 2 || base > 16)
   1091       return ret;
   1092 
   1093    if ((flags & VG_MSG_SIGNED) && (Int)p < 0) {
   1094       p   = - (Int)p;
   1095       neg = True;
   1096    }
   1097 
   1098    if (p == 0)
   1099       buf[ind++] = '0';
   1100    else {
   1101       while (p > 0) {
   1102          if ((flags & VG_MSG_COMMA) && 10 == base &&
   1103              0 == (ind-nc) % 3 && 0 != ind)
   1104          {
   1105             buf[ind++] = ',';
   1106             nc++;
   1107          }
   1108          buf[ind++] = digits[p % base];
   1109          p /= base;
   1110       }
   1111    }
   1112 
   1113    if (neg)
   1114       buf[ind++] = '-';
   1115 
   1116    if (width > 0 && !(flags & VG_MSG_LJUSTIFY)) {
   1117       for(; ind < width; ind++) {
   1118 	//vassert(ind < 39);
   1119          buf[ind] = ((flags & VG_MSG_ZJUSTIFY) ? '0': ' ');
   1120       }
   1121    }
   1122 
   1123    /* Reverse copy to buffer.  */
   1124    ret += ind;
   1125    for (i = ind -1; i >= 0; i--) {
   1126       send(buf[i]);
   1127    }
   1128    if (width > 0 && (flags & VG_MSG_LJUSTIFY)) {
   1129       for(; ind < width; ind++) {
   1130 	 ret++;
   1131          send(' ');  // Never pad with zeroes on RHS -- changes the value!
   1132       }
   1133    }
   1134    return ret;
   1135 }
   1136 
   1137 
   1138 /* A simple vprintf().  */
   1139 static
   1140 UInt vprintf_wrk ( void(*send)(HChar), const HChar *format, va_list vargs )
   1141 {
   1142    UInt ret = 0;
   1143    int i;
   1144    int flags;
   1145    int width;
   1146    Bool is_long;
   1147 
   1148    /* We assume that vargs has already been initialised by the
   1149       caller, using va_start, and that the caller will similarly
   1150       clean up with va_end.
   1151    */
   1152 
   1153    for (i = 0; format[i] != 0; i++) {
   1154       if (format[i] != '%') {
   1155          send(format[i]);
   1156 	 ret++;
   1157          continue;
   1158       }
   1159       i++;
   1160       /* A '%' has been found.  Ignore a trailing %. */
   1161       if (format[i] == 0)
   1162          break;
   1163       if (format[i] == '%') {
   1164          /* `%%' is replaced by `%'. */
   1165          send('%');
   1166 	 ret++;
   1167          continue;
   1168       }
   1169       flags = 0;
   1170       is_long = False;
   1171       width = 0; /* length of the field. */
   1172       if (format[i] == '(') {
   1173 	 flags |= VG_MSG_PAREN;
   1174 	 i++;
   1175       }
   1176       /* If ',' follows '%', commas will be inserted. */
   1177       if (format[i] == ',') {
   1178          flags |= VG_MSG_COMMA;
   1179          i++;
   1180       }
   1181       /* If '-' follows '%', justify on the left. */
   1182       if (format[i] == '-') {
   1183          flags |= VG_MSG_LJUSTIFY;
   1184          i++;
   1185       }
   1186       /* If '0' follows '%', pads will be inserted. */
   1187       if (format[i] == '0') {
   1188          flags |= VG_MSG_ZJUSTIFY;
   1189          i++;
   1190       }
   1191       /* Compute the field length. */
   1192       while (format[i] >= '0' && format[i] <= '9') {
   1193          width *= 10;
   1194          width += format[i++] - '0';
   1195       }
   1196       while (format[i] == 'l') {
   1197          i++;
   1198          is_long = True;
   1199       }
   1200 
   1201       switch (format[i]) {
   1202          case 'd': /* %d */
   1203             flags |= VG_MSG_SIGNED;
   1204             if (is_long)
   1205                ret += myvprintf_int64(send, flags, 10, width,
   1206 				      (ULong)(va_arg (vargs, Long)));
   1207             else
   1208                ret += myvprintf_int64(send, flags, 10, width,
   1209 				      (ULong)(va_arg (vargs, Int)));
   1210             break;
   1211          case 'u': /* %u */
   1212             if (is_long)
   1213                ret += myvprintf_int64(send, flags, 10, width,
   1214 				      (ULong)(va_arg (vargs, ULong)));
   1215             else
   1216                ret += myvprintf_int64(send, flags, 10, width,
   1217 				      (ULong)(va_arg (vargs, UInt)));
   1218             break;
   1219          case 'p': /* %p */
   1220 	    ret += 2;
   1221             send('0');
   1222             send('x');
   1223             ret += myvprintf_int64(send, flags, 16, width,
   1224 				   (ULong)((HWord)va_arg (vargs, void *)));
   1225             break;
   1226          case 'x': /* %x */
   1227             if (is_long)
   1228                ret += myvprintf_int64(send, flags, 16, width,
   1229 				      (ULong)(va_arg (vargs, ULong)));
   1230             else
   1231                ret += myvprintf_int64(send, flags, 16, width,
   1232 				      (ULong)(va_arg (vargs, UInt)));
   1233             break;
   1234          case 'c': /* %c */
   1235 	    ret++;
   1236             send((va_arg (vargs, int)));
   1237             break;
   1238          case 's': case 'S': { /* %s */
   1239             char *str = va_arg (vargs, char *);
   1240             if (str == (char*) 0) str = "(null)";
   1241             ret += myvprintf_str(send, flags, width, str,
   1242                                  (format[i]=='S'));
   1243             break;
   1244 	 }
   1245 #        if 0
   1246 	 case 'y': { /* %y - print symbol */
   1247 	    Char buf[100];
   1248 	    Char *cp = buf;
   1249 	    Addr a = va_arg(vargs, Addr);
   1250 
   1251 	    if (flags & VG_MSG_PAREN)
   1252 	       *cp++ = '(';
   1253 	    if (VG_(get_fnname_w_offset)(a, cp, sizeof(buf)-4)) {
   1254 	       if (flags & VG_MSG_PAREN) {
   1255 		  cp += VG_(strlen)(cp);
   1256 		  *cp++ = ')';
   1257 		  *cp = '\0';
   1258 	       }
   1259 	       ret += myvprintf_str(send, flags, width, buf, 0);
   1260 	    }
   1261 	    break;
   1262 	 }
   1263 #        endif
   1264          default:
   1265             break;
   1266       }
   1267    }
   1268    return ret;
   1269 }
   1270 
   1271 
   1272 /* A general replacement for printf().  Note that only low-level
   1273    debugging info should be sent via here.  The official route is to
   1274    to use vg_message().  This interface is deprecated.
   1275 */
   1276 /* XXX re 930: make the buffer just to small (by 1 byte) to be OK
   1277    for this particular run. */
   1278 static HChar myprintf_buf[1000   -930];
   1279 static Int   n_myprintf_buf;
   1280 
   1281 static void add_to_myprintf_buf ( HChar c )
   1282 {
   1283    if (c == '\n' || n_myprintf_buf >= 1000-10 /*paranoia*/ ) {
   1284       (*vex_log_bytes)( myprintf_buf, vex_strlen(myprintf_buf) );
   1285       n_myprintf_buf = 0;
   1286       myprintf_buf[n_myprintf_buf] = 0;
   1287    }
   1288    myprintf_buf[n_myprintf_buf++] = c;
   1289    myprintf_buf[n_myprintf_buf] = 0;
   1290 }
   1291 
   1292 static UInt vex_printf ( const char *format, ... )
   1293 {
   1294    UInt ret;
   1295    va_list vargs;
   1296    va_start(vargs,format);
   1297 
   1298    n_myprintf_buf = 0;
   1299    myprintf_buf[n_myprintf_buf] = 0;
   1300    ret = vprintf_wrk ( add_to_myprintf_buf, format, vargs );
   1301 
   1302    if (n_myprintf_buf > 0) {
   1303       (*vex_log_bytes)( myprintf_buf, n_myprintf_buf );
   1304    }
   1305 
   1306    va_end(vargs);
   1307 
   1308    return ret;
   1309 }
   1310 
   1311 /*---------------------------------------------------------------*/
   1312 /*--- end                                          vex_util.c ---*/
   1313 /*---------------------------------------------------------------*/
   1314 
   1315 
   1316 /////////////////////////////////////////////////////////////////////
   1317 /////////////////////////////////////////////////////////////////////
   1318 /////////////////////////////////////////////////////////////////////
   1319 /////////////////////////////////////////////////////////////////////
   1320 
   1321 
   1322 /*-------------------------------------------------------------*/
   1323 /*--- Decompression machinery                               ---*/
   1324 /*---                                          decompress.c ---*/
   1325 /*-------------------------------------------------------------*/
   1326 
   1327 /*--
   1328   This file is a part of bzip2 and/or libbzip2, a program and
   1329   library for lossless, block-sorting data compression.
   1330 
   1331   Copyright (C) 1996-2004 Julian R Seward.  All rights reserved.
   1332 
   1333   Redistribution and use in source and binary forms, with or without
   1334   modification, are permitted provided that the following conditions
   1335   are met:
   1336 
   1337   1. Redistributions of source code must retain the above copyright
   1338      notice, this list of conditions and the following disclaimer.
   1339 
   1340   2. The origin of this software must not be misrepresented; you must
   1341      not claim that you wrote the original software.  If you use this
   1342      software in a product, an acknowledgment in the product
   1343      documentation would be appreciated but is not required.
   1344 
   1345   3. Altered source versions must be plainly marked as such, and must
   1346      not be misrepresented as being the original software.
   1347 
   1348   4. The name of the author may not be used to endorse or promote
   1349      products derived from this software without specific prior written
   1350      permission.
   1351 
   1352   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
   1353   OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   1354   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   1355   ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
   1356   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   1357   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
   1358   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   1359   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   1360   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   1361   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   1362   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   1363 
   1364   Julian Seward, Cambridge, UK.
   1365   jseward (at) bzip.org
   1366   bzip2/libbzip2 version 1.0 of 21 March 2000
   1367 
   1368   This program is based on (at least) the work of:
   1369      Mike Burrows
   1370      David Wheeler
   1371      Peter Fenwick
   1372      Alistair Moffat
   1373      Radford Neal
   1374      Ian H. Witten
   1375      Robert Sedgewick
   1376      Jon L. Bentley
   1377 
   1378   For more information on these sources, see the manual.
   1379 --*/
   1380 
   1381 
   1382 
   1383 
   1384 /*---------------------------------------------------*/
   1385 static
   1386 void makeMaps_d ( DState* s )
   1387 {
   1388    Int32 i;
   1389    s->nInUse = 0;
   1390    for (i = 0; i < 256; i++)
   1391       if (s->inUse[i]) {
   1392          s->seqToUnseq[s->nInUse] = i;
   1393          s->nInUse++;
   1394       }
   1395 }
   1396 
   1397 
   1398 /*---------------------------------------------------*/
   1399 #define RETURN(rrr)                               \
   1400    { retVal = rrr; goto save_state_and_return; };
   1401 
   1402 #define GET_BITS(lll,vvv,nnn)                     \
   1403    case lll: s->state = lll;                      \
   1404    while (True) {                                 \
   1405       if (s->bsLive >= nnn) {                     \
   1406          UInt32 v;                                \
   1407          v = (s->bsBuff >>                        \
   1408              (s->bsLive-nnn)) & ((1 << nnn)-1);   \
   1409          s->bsLive -= nnn;                        \
   1410          vvv = v;                                 \
   1411          break;                                   \
   1412       }                                           \
   1413       if (s->strm->avail_in == 0) RETURN(BZ_OK);  \
   1414       s->bsBuff                                   \
   1415          = (s->bsBuff << 8) |                     \
   1416            ((UInt32)                              \
   1417               (*((UChar*)(s->strm->next_in))));   \
   1418       s->bsLive += 8;                             \
   1419       s->strm->next_in++;                         \
   1420       s->strm->avail_in--;                        \
   1421       s->strm->total_in_lo32++;                   \
   1422       if (s->strm->total_in_lo32 == 0)            \
   1423          s->strm->total_in_hi32++;                \
   1424    }
   1425 
   1426 #define GET_UCHAR(lll,uuu)                        \
   1427    GET_BITS(lll,uuu,8)
   1428 
   1429 #define GET_BIT(lll,uuu)                          \
   1430    GET_BITS(lll,uuu,1)
   1431 
   1432 /*---------------------------------------------------*/
   1433 #define GET_MTF_VAL(label1,label2,lval)           \
   1434 {                                                 \
   1435    if (groupPos == 0) {                           \
   1436       groupNo++;                                  \
   1437       if (groupNo >= nSelectors)                  \
   1438          RETURN(BZ_DATA_ERROR);                   \
   1439       groupPos = BZ_G_SIZE;                       \
   1440       gSel = s->selector[groupNo];                \
   1441       gMinlen = s->minLens[gSel];                 \
   1442       gLimit = &(s->limit[gSel][0]);              \
   1443       gPerm = &(s->perm[gSel][0]);                \
   1444       gBase = &(s->base[gSel][0]);                \
   1445    }                                              \
   1446    groupPos--;                                    \
   1447    zn = gMinlen;                                  \
   1448    GET_BITS(label1, zvec, zn);                    \
   1449    while (1) {                                    \
   1450       if (zn > 20 /* the longest code */)         \
   1451          RETURN(BZ_DATA_ERROR);                   \
   1452       if (zvec <= gLimit[zn]) break;              \
   1453       zn++;                                       \
   1454       GET_BIT(label2, zj);                        \
   1455       zvec = (zvec << 1) | zj;                    \
   1456    };                                             \
   1457    if (zvec - gBase[zn] < 0                       \
   1458        || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE)  \
   1459       RETURN(BZ_DATA_ERROR);                      \
   1460    lval = gPerm[zvec - gBase[zn]];                \
   1461 }
   1462 
   1463 
   1464 
   1465 /*---------------------------------------------------*/
   1466 __inline__ Int32 BZ2_indexIntoF ( Int32 indx, Int32 *cftab )
   1467 {
   1468    Int32 nb, na, mid;
   1469    nb = 0;
   1470    na = 256;
   1471    do {
   1472       mid = (nb + na) >> 1;
   1473       if (indx >= cftab[mid]) nb = mid; else na = mid;
   1474    }
   1475    while (na - nb != 1);
   1476    return nb;
   1477 }
   1478 
   1479 /*---------------------------------------------------*/
   1480 Int32 BZ2_decompress ( DState* s )
   1481 {
   1482    UChar      uc;
   1483    Int32      retVal;
   1484    Int32      minLen, maxLen;
   1485    bz_stream* strm = s->strm;
   1486 
   1487    /* stuff that needs to be saved/restored */
   1488    Int32  i;
   1489    Int32  j;
   1490    Int32  t;
   1491    Int32  alphaSize;
   1492    Int32  nGroups;
   1493    Int32  nSelectors;
   1494    Int32  EOB;
   1495    Int32  groupNo;
   1496    Int32  groupPos;
   1497    Int32  nextSym;
   1498    Int32  nblockMAX;
   1499    Int32  nblock;
   1500    Int32  es;
   1501    Int32  N;
   1502    Int32  curr;
   1503    Int32  zt;
   1504    Int32  zn;
   1505    Int32  zvec;
   1506    Int32  zj;
   1507    Int32  gSel;
   1508    Int32  gMinlen;
   1509    Int32* gLimit;
   1510    Int32* gBase;
   1511    Int32* gPerm;
   1512 
   1513    if (s->state == BZ_X_MAGIC_1) {
   1514       /*initialise the save area*/
   1515       s->save_i           = 0;
   1516       s->save_j           = 0;
   1517       s->save_t           = 0;
   1518       s->save_alphaSize   = 0;
   1519       s->save_nGroups     = 0;
   1520       s->save_nSelectors  = 0;
   1521       s->save_EOB         = 0;
   1522       s->save_groupNo     = 0;
   1523       s->save_groupPos    = 0;
   1524       s->save_nextSym     = 0;
   1525       s->save_nblockMAX   = 0;
   1526       s->save_nblock      = 0;
   1527       s->save_es          = 0;
   1528       s->save_N           = 0;
   1529       s->save_curr        = 0;
   1530       s->save_zt          = 0;
   1531       s->save_zn          = 0;
   1532       s->save_zvec        = 0;
   1533       s->save_zj          = 0;
   1534       s->save_gSel        = 0;
   1535       s->save_gMinlen     = 0;
   1536       s->save_gLimit      = NULL;
   1537       s->save_gBase       = NULL;
   1538       s->save_gPerm       = NULL;
   1539    }
   1540 
   1541    /*restore from the save area*/
   1542    i           = s->save_i;
   1543    j           = s->save_j;
   1544    t           = s->save_t;
   1545    alphaSize   = s->save_alphaSize;
   1546    nGroups     = s->save_nGroups;
   1547    nSelectors  = s->save_nSelectors;
   1548    EOB         = s->save_EOB;
   1549    groupNo     = s->save_groupNo;
   1550    groupPos    = s->save_groupPos;
   1551    nextSym     = s->save_nextSym;
   1552    nblockMAX   = s->save_nblockMAX;
   1553    nblock      = s->save_nblock;
   1554    es          = s->save_es;
   1555    N           = s->save_N;
   1556    curr        = s->save_curr;
   1557    zt          = s->save_zt;
   1558    zn          = s->save_zn;
   1559    zvec        = s->save_zvec;
   1560    zj          = s->save_zj;
   1561    gSel        = s->save_gSel;
   1562    gMinlen     = s->save_gMinlen;
   1563    gLimit      = s->save_gLimit;
   1564    gBase       = s->save_gBase;
   1565    gPerm       = s->save_gPerm;
   1566 
   1567    retVal = BZ_OK;
   1568 
   1569    switch (s->state) {
   1570 
   1571       GET_UCHAR(BZ_X_MAGIC_1, uc);
   1572       if (uc != BZ_HDR_B) RETURN(BZ_DATA_ERROR_MAGIC);
   1573 
   1574       GET_UCHAR(BZ_X_MAGIC_2, uc);
   1575       if (uc != BZ_HDR_Z) RETURN(BZ_DATA_ERROR_MAGIC);
   1576 
   1577       GET_UCHAR(BZ_X_MAGIC_3, uc)
   1578       if (uc != BZ_HDR_h) RETURN(BZ_DATA_ERROR_MAGIC);
   1579 
   1580       GET_BITS(BZ_X_MAGIC_4, s->blockSize100k, 8)
   1581       if (s->blockSize100k < (BZ_HDR_0 + 1) ||
   1582           s->blockSize100k > (BZ_HDR_0 + 9)) RETURN(BZ_DATA_ERROR_MAGIC);
   1583       s->blockSize100k -= BZ_HDR_0;
   1584 
   1585       if (s->smallDecompress) {
   1586          s->ll16 = BZALLOC( s->blockSize100k * 100000 * sizeof(UInt16) );
   1587          s->ll4  = BZALLOC(
   1588                       ((1 + s->blockSize100k * 100000) >> 1) * sizeof(UChar)
   1589                    );
   1590          if (s->ll16 == NULL || s->ll4 == NULL) RETURN(BZ_MEM_ERROR);
   1591       } else {
   1592          s->tt  = BZALLOC( s->blockSize100k * 100000 * sizeof(Int32) );
   1593          if (s->tt == NULL) RETURN(BZ_MEM_ERROR);
   1594       }
   1595 
   1596       GET_UCHAR(BZ_X_BLKHDR_1, uc);
   1597 
   1598       if (uc == 0x17) goto endhdr_2;
   1599       if (uc != 0x31) RETURN(BZ_DATA_ERROR);
   1600       GET_UCHAR(BZ_X_BLKHDR_2, uc);
   1601       if (uc != 0x41) RETURN(BZ_DATA_ERROR);
   1602       GET_UCHAR(BZ_X_BLKHDR_3, uc);
   1603       if (uc != 0x59) RETURN(BZ_DATA_ERROR);
   1604       GET_UCHAR(BZ_X_BLKHDR_4, uc);
   1605       if (uc != 0x26) RETURN(BZ_DATA_ERROR);
   1606       GET_UCHAR(BZ_X_BLKHDR_5, uc);
   1607       if (uc != 0x53) RETURN(BZ_DATA_ERROR);
   1608       GET_UCHAR(BZ_X_BLKHDR_6, uc);
   1609       if (uc != 0x59) RETURN(BZ_DATA_ERROR);
   1610 
   1611       s->currBlockNo++;
   1612       if (s->verbosity >= 2)
   1613          VPrintf1 ( "\n    [%d: huff+mtf ", s->currBlockNo );
   1614 
   1615       s->storedBlockCRC = 0;
   1616       GET_UCHAR(BZ_X_BCRC_1, uc);
   1617       s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
   1618       GET_UCHAR(BZ_X_BCRC_2, uc);
   1619       s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
   1620       GET_UCHAR(BZ_X_BCRC_3, uc);
   1621       s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
   1622       GET_UCHAR(BZ_X_BCRC_4, uc);
   1623       s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
   1624 
   1625       GET_BITS(BZ_X_RANDBIT, s->blockRandomised, 1);
   1626 
   1627       s->origPtr = 0;
   1628       GET_UCHAR(BZ_X_ORIGPTR_1, uc);
   1629       s->origPtr = (s->origPtr << 8) | ((Int32)uc);
   1630       GET_UCHAR(BZ_X_ORIGPTR_2, uc);
   1631       s->origPtr = (s->origPtr << 8) | ((Int32)uc);
   1632       GET_UCHAR(BZ_X_ORIGPTR_3, uc);
   1633       s->origPtr = (s->origPtr << 8) | ((Int32)uc);
   1634 
   1635       if (s->origPtr < 0)
   1636          RETURN(BZ_DATA_ERROR);
   1637       if (s->origPtr > 10 + 100000*s->blockSize100k)
   1638          RETURN(BZ_DATA_ERROR);
   1639 
   1640       /*--- Receive the mapping table ---*/
   1641       for (i = 0; i < 16; i++) {
   1642          GET_BIT(BZ_X_MAPPING_1, uc);
   1643          if (uc == 1)
   1644             s->inUse16[i] = True; else
   1645             s->inUse16[i] = False;
   1646       }
   1647 
   1648       for (i = 0; i < 256; i++) s->inUse[i] = False;
   1649 
   1650       for (i = 0; i < 16; i++)
   1651          if (s->inUse16[i])
   1652             for (j = 0; j < 16; j++) {
   1653                GET_BIT(BZ_X_MAPPING_2, uc);
   1654                if (uc == 1) s->inUse[i * 16 + j] = True;
   1655             }
   1656       makeMaps_d ( s );
   1657       if (s->nInUse == 0) RETURN(BZ_DATA_ERROR);
   1658       alphaSize = s->nInUse+2;
   1659 
   1660       /*--- Now the selectors ---*/
   1661       GET_BITS(BZ_X_SELECTOR_1, nGroups, 3);
   1662       if (nGroups < 2 || nGroups > 6) RETURN(BZ_DATA_ERROR);
   1663       GET_BITS(BZ_X_SELECTOR_2, nSelectors, 15);
   1664       if (nSelectors < 1) RETURN(BZ_DATA_ERROR);
   1665       for (i = 0; i < nSelectors; i++) {
   1666          j = 0;
   1667          while (True) {
   1668             GET_BIT(BZ_X_SELECTOR_3, uc);
   1669             if (uc == 0) break;
   1670             j++;
   1671             if (j >= nGroups) RETURN(BZ_DATA_ERROR);
   1672          }
   1673          s->selectorMtf[i] = j;
   1674       }
   1675 
   1676       /*--- Undo the MTF values for the selectors. ---*/
   1677       {
   1678          UChar pos[BZ_N_GROUPS], tmp, v;
   1679          for (v = 0; v < nGroups; v++) pos[v] = v;
   1680 
   1681          for (i = 0; i < nSelectors; i++) {
   1682             v = s->selectorMtf[i];
   1683             tmp = pos[v];
   1684             while (v > 0) { pos[v] = pos[v-1]; v--; }
   1685             pos[0] = tmp;
   1686             s->selector[i] = tmp;
   1687          }
   1688       }
   1689 
   1690       /*--- Now the coding tables ---*/
   1691       for (t = 0; t < nGroups; t++) {
   1692          GET_BITS(BZ_X_CODING_1, curr, 5);
   1693          for (i = 0; i < alphaSize; i++) {
   1694             while (True) {
   1695                if (curr < 1 || curr > 20) RETURN(BZ_DATA_ERROR);
   1696                GET_BIT(BZ_X_CODING_2, uc);
   1697                if (uc == 0) break;
   1698                GET_BIT(BZ_X_CODING_3, uc);
   1699                if (uc == 0) curr++; else curr--;
   1700             }
   1701             s->len[t][i] = curr;
   1702          }
   1703       }
   1704 
   1705       /*--- Create the Huffman decoding tables ---*/
   1706       for (t = 0; t < nGroups; t++) {
   1707          minLen = 32;
   1708          maxLen = 0;
   1709          for (i = 0; i < alphaSize; i++) {
   1710             if (s->len[t][i] > maxLen) maxLen = s->len[t][i];
   1711             if (s->len[t][i] < minLen) minLen = s->len[t][i];
   1712          }
   1713          BZ2_hbCreateDecodeTables (
   1714             &(s->limit[t][0]),
   1715             &(s->base[t][0]),
   1716             &(s->perm[t][0]),
   1717             &(s->len[t][0]),
   1718             minLen, maxLen, alphaSize
   1719          );
   1720          s->minLens[t] = minLen;
   1721       }
   1722 
   1723       /*--- Now the MTF values ---*/
   1724 
   1725       EOB      = s->nInUse+1;
   1726       nblockMAX = 100000 * s->blockSize100k;
   1727       groupNo  = -1;
   1728       groupPos = 0;
   1729 
   1730       for (i = 0; i <= 255; i++) s->unzftab[i] = 0;
   1731 
   1732       /*-- MTF init --*/
   1733       {
   1734          Int32 ii, jj, kk;
   1735          kk = MTFA_SIZE-1;
   1736          for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) {
   1737             for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
   1738                s->mtfa[kk] = (UChar)(ii * MTFL_SIZE + jj);
   1739                kk--;
   1740             }
   1741             s->mtfbase[ii] = kk + 1;
   1742          }
   1743       }
   1744       /*-- end MTF init --*/
   1745 
   1746       nblock = 0;
   1747       GET_MTF_VAL(BZ_X_MTF_1, BZ_X_MTF_2, nextSym);
   1748 
   1749       while (True) {
   1750 
   1751          if (nextSym == EOB) break;
   1752 
   1753          if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) {
   1754 
   1755             es = -1;
   1756             N = 1;
   1757             do {
   1758                if (nextSym == BZ_RUNA) es = es + (0+1) * N; else
   1759                if (nextSym == BZ_RUNB) es = es + (1+1) * N;
   1760                N = N * 2;
   1761                GET_MTF_VAL(BZ_X_MTF_3, BZ_X_MTF_4, nextSym);
   1762             }
   1763                while (nextSym == BZ_RUNA || nextSym == BZ_RUNB);
   1764 
   1765             es++;
   1766             uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ];
   1767             s->unzftab[uc] += es;
   1768 
   1769             if (s->smallDecompress)
   1770                while (es > 0) {
   1771                   if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
   1772                   s->ll16[nblock] = (UInt16)uc;
   1773                   nblock++;
   1774                   es--;
   1775                }
   1776             else
   1777                while (es > 0) {
   1778                   if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
   1779                   s->tt[nblock] = (UInt32)uc;
   1780                   nblock++;
   1781                   es--;
   1782                };
   1783 
   1784             continue;
   1785 
   1786          } else {
   1787 
   1788             if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
   1789 
   1790             /*-- uc = MTF ( nextSym-1 ) --*/
   1791             {
   1792                Int32 ii, jj, kk, pp, lno, off;
   1793                UInt32 nn;
   1794                nn = (UInt32)(nextSym - 1);
   1795 
   1796                if (nn < MTFL_SIZE) {
   1797                   /* avoid general-case expense */
   1798                   pp = s->mtfbase[0];
   1799                   uc = s->mtfa[pp+nn];
   1800                   while (nn > 3) {
   1801                      Int32 z = pp+nn;
   1802                      s->mtfa[(z)  ] = s->mtfa[(z)-1];
   1803                      s->mtfa[(z)-1] = s->mtfa[(z)-2];
   1804                      s->mtfa[(z)-2] = s->mtfa[(z)-3];
   1805                      s->mtfa[(z)-3] = s->mtfa[(z)-4];
   1806                      nn -= 4;
   1807                   }
   1808                   while (nn > 0) {
   1809                      s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--;
   1810                   };
   1811                   s->mtfa[pp] = uc;
   1812                } else {
   1813                   /* general case */
   1814                   lno = nn / MTFL_SIZE;
   1815                   off = nn % MTFL_SIZE;
   1816                   pp = s->mtfbase[lno] + off;
   1817                   uc = s->mtfa[pp];
   1818                   while (pp > s->mtfbase[lno]) {
   1819                      s->mtfa[pp] = s->mtfa[pp-1]; pp--;
   1820                   };
   1821                   s->mtfbase[lno]++;
   1822                   while (lno > 0) {
   1823                      s->mtfbase[lno]--;
   1824                      s->mtfa[s->mtfbase[lno]]
   1825                         = s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1];
   1826                      lno--;
   1827                   }
   1828                   s->mtfbase[0]--;
   1829                   s->mtfa[s->mtfbase[0]] = uc;
   1830                   if (s->mtfbase[0] == 0) {
   1831                      kk = MTFA_SIZE-1;
   1832                      for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) {
   1833                         for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
   1834                            s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj];
   1835                            kk--;
   1836                         }
   1837                         s->mtfbase[ii] = kk + 1;
   1838                      }
   1839                   }
   1840                }
   1841             }
   1842             /*-- end uc = MTF ( nextSym-1 ) --*/
   1843 
   1844             s->unzftab[s->seqToUnseq[uc]]++;
   1845             if (s->smallDecompress)
   1846                s->ll16[nblock] = (UInt16)(s->seqToUnseq[uc]); else
   1847                s->tt[nblock]   = (UInt32)(s->seqToUnseq[uc]);
   1848             nblock++;
   1849 
   1850             GET_MTF_VAL(BZ_X_MTF_5, BZ_X_MTF_6, nextSym);
   1851             continue;
   1852          }
   1853       }
   1854 
   1855       /* Now we know what nblock is, we can do a better sanity
   1856          check on s->origPtr.
   1857       */
   1858       if (s->origPtr < 0 || s->origPtr >= nblock)
   1859          RETURN(BZ_DATA_ERROR);
   1860 
   1861       /*-- Set up cftab to facilitate generation of T^(-1) --*/
   1862       s->cftab[0] = 0;
   1863       for (i = 1; i <= 256; i++) s->cftab[i] = s->unzftab[i-1];
   1864       for (i = 1; i <= 256; i++) s->cftab[i] += s->cftab[i-1];
   1865       for (i = 0; i <= 256; i++) {
   1866          if (s->cftab[i] < 0 || s->cftab[i] > nblock) {
   1867             /* s->cftab[i] can legitimately be == nblock */
   1868             RETURN(BZ_DATA_ERROR);
   1869          }
   1870       }
   1871 
   1872       s->state_out_len = 0;
   1873       s->state_out_ch  = 0;
   1874       BZ_INITIALISE_CRC ( s->calculatedBlockCRC );
   1875       s->state = BZ_X_OUTPUT;
   1876       if (s->verbosity >= 2) VPrintf0 ( "rt+rld" );
   1877 
   1878       if (s->smallDecompress) {
   1879 
   1880          /*-- Make a copy of cftab, used in generation of T --*/
   1881          for (i = 0; i <= 256; i++) s->cftabCopy[i] = s->cftab[i];
   1882 
   1883          /*-- compute the T vector --*/
   1884          for (i = 0; i < nblock; i++) {
   1885             uc = (UChar)(s->ll16[i]);
   1886             SET_LL(i, s->cftabCopy[uc]);
   1887             s->cftabCopy[uc]++;
   1888          }
   1889 
   1890          /*-- Compute T^(-1) by pointer reversal on T --*/
   1891          i = s->origPtr;
   1892          j = GET_LL(i);
   1893          do {
   1894             Int32 tmp = GET_LL(j);
   1895             SET_LL(j, i);
   1896             i = j;
   1897             j = tmp;
   1898          }
   1899             while (i != s->origPtr);
   1900 
   1901          s->tPos = s->origPtr;
   1902          s->nblock_used = 0;
   1903          if (s->blockRandomised) {
   1904             BZ_RAND_INIT_MASK;
   1905             BZ_GET_SMALL(s->k0); s->nblock_used++;
   1906             BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK;
   1907          } else {
   1908             BZ_GET_SMALL(s->k0); s->nblock_used++;
   1909          }
   1910 
   1911       } else {
   1912 
   1913          /*-- compute the T^(-1) vector --*/
   1914          for (i = 0; i < nblock; i++) {
   1915             uc = (UChar)(s->tt[i] & 0xff);
   1916             s->tt[s->cftab[uc]] |= (i << 8);
   1917             s->cftab[uc]++;
   1918          }
   1919 
   1920          s->tPos = s->tt[s->origPtr] >> 8;
   1921          s->nblock_used = 0;
   1922          if (s->blockRandomised) {
   1923             BZ_RAND_INIT_MASK;
   1924             BZ_GET_FAST(s->k0); s->nblock_used++;
   1925             BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK;
   1926          } else {
   1927             BZ_GET_FAST(s->k0); s->nblock_used++;
   1928          }
   1929 
   1930       }
   1931 
   1932       RETURN(BZ_OK);
   1933 
   1934 
   1935 
   1936     endhdr_2:
   1937 
   1938       GET_UCHAR(BZ_X_ENDHDR_2, uc);
   1939       if (uc != 0x72) RETURN(BZ_DATA_ERROR);
   1940       GET_UCHAR(BZ_X_ENDHDR_3, uc);
   1941       if (uc != 0x45) RETURN(BZ_DATA_ERROR);
   1942       GET_UCHAR(BZ_X_ENDHDR_4, uc);
   1943       if (uc != 0x38) RETURN(BZ_DATA_ERROR);
   1944       GET_UCHAR(BZ_X_ENDHDR_5, uc);
   1945       if (uc != 0x50) RETURN(BZ_DATA_ERROR);
   1946       GET_UCHAR(BZ_X_ENDHDR_6, uc);
   1947       if (uc != 0x90) RETURN(BZ_DATA_ERROR);
   1948 
   1949       s->storedCombinedCRC = 0;
   1950       GET_UCHAR(BZ_X_CCRC_1, uc);
   1951       s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
   1952       GET_UCHAR(BZ_X_CCRC_2, uc);
   1953       s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
   1954       GET_UCHAR(BZ_X_CCRC_3, uc);
   1955       s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
   1956       GET_UCHAR(BZ_X_CCRC_4, uc);
   1957       s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
   1958 
   1959       s->state = BZ_X_IDLE;
   1960       RETURN(BZ_STREAM_END);
   1961 
   1962       default: AssertH ( False, 4001 );
   1963    }
   1964 
   1965    AssertH ( False, 4002 );
   1966 
   1967    save_state_and_return:
   1968 
   1969    s->save_i           = i;
   1970    s->save_j           = j;
   1971    s->save_t           = t;
   1972    s->save_alphaSize   = alphaSize;
   1973    s->save_nGroups     = nGroups;
   1974    s->save_nSelectors  = nSelectors;
   1975    s->save_EOB         = EOB;
   1976    s->save_groupNo     = groupNo;
   1977    s->save_groupPos    = groupPos;
   1978    s->save_nextSym     = nextSym;
   1979    s->save_nblockMAX   = nblockMAX;
   1980    s->save_nblock      = nblock;
   1981    s->save_es          = es;
   1982    s->save_N           = N;
   1983    s->save_curr        = curr;
   1984    s->save_zt          = zt;
   1985    s->save_zn          = zn;
   1986    s->save_zvec        = zvec;
   1987    s->save_zj          = zj;
   1988    s->save_gSel        = gSel;
   1989    s->save_gMinlen     = gMinlen;
   1990    s->save_gLimit      = gLimit;
   1991    s->save_gBase       = gBase;
   1992    s->save_gPerm       = gPerm;
   1993 
   1994    return retVal;
   1995 }
   1996 
   1997 
   1998 /*-------------------------------------------------------------*/
   1999 /*--- end                                      decompress.c ---*/
   2000 /*-------------------------------------------------------------*/
   2001 
   2002 /*-------------------------------------------------------------*/
   2003 /*--- Block sorting machinery                               ---*/
   2004 /*---                                           blocksort.c ---*/
   2005 /*-------------------------------------------------------------*/
   2006 
   2007 /*--
   2008   This file is a part of bzip2 and/or libbzip2, a program and
   2009   library for lossless, block-sorting data compression.
   2010 
   2011   Copyright (C) 1996-2004 Julian R Seward.  All rights reserved.
   2012 
   2013   Redistribution and use in source and binary forms, with or without
   2014   modification, are permitted provided that the following conditions
   2015   are met:
   2016 
   2017   1. Redistributions of source code must retain the above copyright
   2018      notice, this list of conditions and the following disclaimer.
   2019 
   2020   2. The origin of this software must not be misrepresented; you must
   2021      not claim that you wrote the original software.  If you use this
   2022      software in a product, an acknowledgment in the product
   2023      documentation would be appreciated but is not required.
   2024 
   2025   3. Altered source versions must be plainly marked as such, and must
   2026      not be misrepresented as being the original software.
   2027 
   2028   4. The name of the author may not be used to endorse or promote
   2029      products derived from this software without specific prior written
   2030      permission.
   2031 
   2032   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
   2033   OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   2034   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   2035   ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
   2036   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   2037   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
   2038   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   2039   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   2040   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   2041   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   2042   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   2043 
   2044   Julian Seward, Cambridge, UK.
   2045   jseward (at) bzip.org
   2046   bzip2/libbzip2 version 1.0 of 21 March 2000
   2047 
   2048   This program is based on (at least) the work of:
   2049      Mike Burrows
   2050      David Wheeler
   2051      Peter Fenwick
   2052      Alistair Moffat
   2053      Radford Neal
   2054      Ian H. Witten
   2055      Robert Sedgewick
   2056      Jon L. Bentley
   2057 
   2058   For more information on these sources, see the manual.
   2059 
   2060   To get some idea how the block sorting algorithms in this file
   2061   work, read my paper
   2062      On the Performance of BWT Sorting Algorithms
   2063   in Proceedings of the IEEE Data Compression Conference 2000,
   2064   Snowbird, Utah, USA, 27-30 March 2000.  The main sort in this
   2065   file implements the algorithm called  cache  in the paper.
   2066 --*/
   2067 
   2068 
   2069 
   2070 /*---------------------------------------------*/
   2071 /*--- Fallback O(N log(N)^2) sorting        ---*/
   2072 /*--- algorithm, for repetitive blocks      ---*/
   2073 /*---------------------------------------------*/
   2074 
   2075 /*---------------------------------------------*/
   2076 static
   2077 __inline__
   2078 void fallbackSimpleSort ( UInt32* fmap,
   2079                           UInt32* eclass,
   2080                           Int32   lo,
   2081                           Int32   hi )
   2082 {
   2083    Int32 i, j, tmp;
   2084    UInt32 ec_tmp;
   2085 
   2086    if (lo == hi) return;
   2087 
   2088    if (hi - lo > 3) {
   2089       for ( i = hi-4; i >= lo; i-- ) {
   2090          tmp = fmap[i];
   2091          ec_tmp = eclass[tmp];
   2092          for ( j = i+4; j <= hi && ec_tmp > eclass[fmap[j]]; j += 4 )
   2093             fmap[j-4] = fmap[j];
   2094          fmap[j-4] = tmp;
   2095       }
   2096    }
   2097 
   2098    for ( i = hi-1; i >= lo; i-- ) {
   2099       tmp = fmap[i];
   2100       ec_tmp = eclass[tmp];
   2101       for ( j = i+1; j <= hi && ec_tmp > eclass[fmap[j]]; j++ )
   2102          fmap[j-1] = fmap[j];
   2103       fmap[j-1] = tmp;
   2104    }
   2105 }
   2106 
   2107 
   2108 /*---------------------------------------------*/
   2109 #define fswap(zz1, zz2) \
   2110    { Int32 zztmp = zz1; zz1 = zz2; zz2 = zztmp; }
   2111 
   2112 #define fvswap(zzp1, zzp2, zzn)       \
   2113 {                                     \
   2114    Int32 yyp1 = (zzp1);               \
   2115    Int32 yyp2 = (zzp2);               \
   2116    Int32 yyn  = (zzn);                \
   2117    while (yyn > 0) {                  \
   2118       fswap(fmap[yyp1], fmap[yyp2]);  \
   2119       yyp1++; yyp2++; yyn--;          \
   2120    }                                  \
   2121 }
   2122 
   2123 
   2124 #define fmin(a,b) ((a) < (b)) ? (a) : (b)
   2125 
   2126 #define fpush(lz,hz) { stackLo[sp] = lz; \
   2127                        stackHi[sp] = hz; \
   2128                        sp++; }
   2129 
   2130 #define fpop(lz,hz) { sp--;              \
   2131                       lz = stackLo[sp];  \
   2132                       hz = stackHi[sp]; }
   2133 
   2134 #define FALLBACK_QSORT_SMALL_THRESH 10
   2135 #define FALLBACK_QSORT_STACK_SIZE   100
   2136 
   2137 
   2138 static
   2139 void fallbackQSort3 ( UInt32* fmap,
   2140                       UInt32* eclass,
   2141                       Int32   loSt,
   2142                       Int32   hiSt )
   2143 {
   2144    Int32 unLo, unHi, ltLo, gtHi, n, m;
   2145    Int32 sp, lo, hi;
   2146    UInt32 med, r, r3;
   2147    Int32 stackLo[FALLBACK_QSORT_STACK_SIZE];
   2148    Int32 stackHi[FALLBACK_QSORT_STACK_SIZE];
   2149 
   2150    r = 0;
   2151 
   2152    sp = 0;
   2153    fpush ( loSt, hiSt );
   2154 
   2155    while (sp > 0) {
   2156 
   2157       AssertH ( sp < FALLBACK_QSORT_STACK_SIZE, 1004 );
   2158 
   2159       fpop ( lo, hi );
   2160       if (hi - lo < FALLBACK_QSORT_SMALL_THRESH) {
   2161          fallbackSimpleSort ( fmap, eclass, lo, hi );
   2162          continue;
   2163       }
   2164 
   2165       /* Random partitioning.  Median of 3 sometimes fails to
   2166          avoid bad cases.  Median of 9 seems to help but
   2167          looks rather expensive.  This too seems to work but
   2168          is cheaper.  Guidance for the magic constants
   2169          7621 and 32768 is taken from Sedgewick's algorithms
   2170          book, chapter 35.
   2171       */
   2172       r = ((r * 7621) + 1) % 32768;
   2173       r3 = r % 3;
   2174       if (r3 == 0) med = eclass[fmap[lo]]; else
   2175       if (r3 == 1) med = eclass[fmap[(lo+hi)>>1]]; else
   2176                    med = eclass[fmap[hi]];
   2177 
   2178       unLo = ltLo = lo;
   2179       unHi = gtHi = hi;
   2180 
   2181       while (1) {
   2182          while (1) {
   2183             if (unLo > unHi) break;
   2184             n = (Int32)eclass[fmap[unLo]] - (Int32)med;
   2185             if (n == 0) {
   2186                fswap(fmap[unLo], fmap[ltLo]);
   2187                ltLo++; unLo++;
   2188                continue;
   2189             };
   2190             if (n > 0) break;
   2191             unLo++;
   2192          }
   2193          while (1) {
   2194             if (unLo > unHi) break;
   2195             n = (Int32)eclass[fmap[unHi]] - (Int32)med;
   2196             if (n == 0) {
   2197                fswap(fmap[unHi], fmap[gtHi]);
   2198                gtHi--; unHi--;
   2199                continue;
   2200             };
   2201             if (n < 0) break;
   2202             unHi--;
   2203          }
   2204          if (unLo > unHi) break;
   2205          fswap(fmap[unLo], fmap[unHi]); unLo++; unHi--;
   2206       }
   2207 
   2208       AssertD ( unHi == unLo-1, "fallbackQSort3(2)" );
   2209 
   2210       if (gtHi < ltLo) continue;
   2211 
   2212       n = fmin(ltLo-lo, unLo-ltLo); fvswap(lo, unLo-n, n);
   2213       m = fmin(hi-gtHi, gtHi-unHi); fvswap(unLo, hi-m+1, m);
   2214 
   2215       n = lo + unLo - ltLo - 1;
   2216       m = hi - (gtHi - unHi) + 1;
   2217 
   2218       if (n - lo > hi - m) {
   2219          fpush ( lo, n );
   2220          fpush ( m, hi );
   2221       } else {
   2222          fpush ( m, hi );
   2223          fpush ( lo, n );
   2224       }
   2225    }
   2226 }
   2227 
   2228 #undef fmin
   2229 #undef fpush
   2230 #undef fpop
   2231 #undef fswap
   2232 #undef fvswap
   2233 #undef FALLBACK_QSORT_SMALL_THRESH
   2234 #undef FALLBACK_QSORT_STACK_SIZE
   2235 
   2236 
   2237 /*---------------------------------------------*/
   2238 /* Pre:
   2239       nblock > 0
   2240       eclass exists for [0 .. nblock-1]
   2241       ((UChar*)eclass) [0 .. nblock-1] holds block
   2242       ptr exists for [0 .. nblock-1]
   2243 
   2244    Post:
   2245       ((UChar*)eclass) [0 .. nblock-1] holds block
   2246       All other areas of eclass destroyed
   2247       fmap [0 .. nblock-1] holds sorted order
   2248       bhtab [ 0 .. 2+(nblock/32) ] destroyed
   2249 */
   2250 
   2251 #define       SET_BH(zz)  bhtab[(zz) >> 5] |= (1 << ((zz) & 31))
   2252 #define     CLEAR_BH(zz)  bhtab[(zz) >> 5] &= ~(1 << ((zz) & 31))
   2253 #define     ISSET_BH(zz)  (bhtab[(zz) >> 5] & (1 << ((zz) & 31)))
   2254 #define      WORD_BH(zz)  bhtab[(zz) >> 5]
   2255 #define UNALIGNED_BH(zz)  ((zz) & 0x01f)
   2256 
   2257 static
   2258 void fallbackSort ( UInt32* fmap,
   2259                     UInt32* eclass,
   2260                     UInt32* bhtab,
   2261                     Int32   nblock,
   2262                     Int32   verb )
   2263 {
   2264    Int32 ftab[257];
   2265    Int32 ftabCopy[256];
   2266    Int32 H, i, j, k, l, r, cc, cc1;
   2267    Int32 nNotDone;
   2268    Int32 nBhtab;
   2269    UChar* eclass8 = (UChar*)eclass;
   2270 
   2271    /*--
   2272       Initial 1-char radix sort to generate
   2273       initial fmap and initial BH bits.
   2274    --*/
   2275    if (verb >= 4)
   2276       VPrintf0 ( "        bucket sorting ...\n" );
   2277    for (i = 0; i < 257;    i++) ftab[i] = 0;
   2278    for (i = 0; i < nblock; i++) ftab[eclass8[i]]++;
   2279    for (i = 0; i < 256;    i++) ftabCopy[i] = ftab[i];
   2280    for (i = 1; i < 257;    i++) ftab[i] += ftab[i-1];
   2281 
   2282    for (i = 0; i < nblock; i++) {
   2283       j = eclass8[i];
   2284       k = ftab[j] - 1;
   2285       ftab[j] = k;
   2286       fmap[k] = i;
   2287    }
   2288 
   2289    nBhtab = 2 + (nblock / 32);
   2290    for (i = 0; i < nBhtab; i++) bhtab[i] = 0;
   2291    for (i = 0; i < 256; i++) SET_BH(ftab[i]);
   2292 
   2293    /*--
   2294       Inductively refine the buckets.  Kind-of an
   2295       "exponential radix sort" (!), inspired by the
   2296       Manber-Myers suffix array construction algorithm.
   2297    --*/
   2298 
   2299    /*-- set sentinel bits for block-end detection --*/
   2300    for (i = 0; i < 32; i++) {
   2301       SET_BH(nblock + 2*i);
   2302       CLEAR_BH(nblock + 2*i + 1);
   2303    }
   2304 
   2305    /*-- the log(N) loop --*/
   2306    H = 1;
   2307    while (1) {
   2308 
   2309       if (verb >= 4)
   2310          VPrintf1 ( "        depth %6d has ", H );
   2311 
   2312       j = 0;
   2313       for (i = 0; i < nblock; i++) {
   2314          if (ISSET_BH(i)) j = i;
   2315          k = fmap[i] - H; if (k < 0) k += nblock;
   2316          eclass[k] = j;
   2317       }
   2318 
   2319       nNotDone = 0;
   2320       r = -1;
   2321       while (1) {
   2322 
   2323 	 /*-- find the next non-singleton bucket --*/
   2324          k = r + 1;
   2325          while (ISSET_BH(k) && UNALIGNED_BH(k)) k++;
   2326          if (ISSET_BH(k)) {
   2327             while (WORD_BH(k) == 0xffffffff) k += 32;
   2328             while (ISSET_BH(k)) k++;
   2329          }
   2330          l = k - 1;
   2331          if (l >= nblock) break;
   2332          while (!ISSET_BH(k) && UNALIGNED_BH(k)) k++;
   2333          if (!ISSET_BH(k)) {
   2334             while (WORD_BH(k) == 0x00000000) k += 32;
   2335             while (!ISSET_BH(k)) k++;
   2336          }
   2337          r = k - 1;
   2338          if (r >= nblock) break;
   2339 
   2340          /*-- now [l, r] bracket current bucket --*/
   2341          if (r > l) {
   2342             nNotDone += (r - l + 1);
   2343             fallbackQSort3 ( fmap, eclass, l, r );
   2344 
   2345             /*-- scan bucket and generate header bits-- */
   2346             cc = -1;
   2347             for (i = l; i <= r; i++) {
   2348                cc1 = eclass[fmap[i]];
   2349                if (cc != cc1) { SET_BH(i); cc = cc1; };
   2350             }
   2351          }
   2352       }
   2353 
   2354       if (verb >= 4)
   2355          VPrintf1 ( "%6d unresolved strings\n", nNotDone );
   2356 
   2357       H *= 2;
   2358       if (H > nblock || nNotDone == 0) break;
   2359    }
   2360 
   2361    /*--
   2362       Reconstruct the original block in
   2363       eclass8 [0 .. nblock-1], since the
   2364       previous phase destroyed it.
   2365    --*/
   2366    if (verb >= 4)
   2367       VPrintf0 ( "        reconstructing block ...\n" );
   2368    j = 0;
   2369    for (i = 0; i < nblock; i++) {
   2370       while (ftabCopy[j] == 0) j++;
   2371       ftabCopy[j]--;
   2372       eclass8[fmap[i]] = (UChar)j;
   2373    }
   2374    AssertH ( j < 256, 1005 );
   2375 }
   2376 
   2377 #undef       SET_BH
   2378 #undef     CLEAR_BH
   2379 #undef     ISSET_BH
   2380 #undef      WORD_BH
   2381 #undef UNALIGNED_BH
   2382 
   2383 
   2384 /*---------------------------------------------*/
   2385 /*--- The main, O(N^2 log(N)) sorting       ---*/
   2386 /*--- algorithm.  Faster for "normal"       ---*/
   2387 /*--- non-repetitive blocks.                ---*/
   2388 /*---------------------------------------------*/
   2389 
   2390 /*---------------------------------------------*/
   2391 static
   2392 __inline__
   2393 Bool mainGtU ( UInt32  i1,
   2394                UInt32  i2,
   2395                UChar*  block,
   2396                UInt16* quadrant,
   2397                UInt32  nblock,
   2398                Int32*  budget )
   2399 {
   2400    Int32  k;
   2401    UChar  c1, c2;
   2402    UInt16 s1, s2;
   2403 
   2404    AssertD ( i1 != i2, "mainGtU" );
   2405    /* 1 */
   2406    c1 = block[i1]; c2 = block[i2];
   2407    if (c1 != c2) return (c1 > c2);
   2408    i1++; i2++;
   2409    /* 2 */
   2410    c1 = block[i1]; c2 = block[i2];
   2411    if (c1 != c2) return (c1 > c2);
   2412    i1++; i2++;
   2413    /* 3 */
   2414    c1 = block[i1]; c2 = block[i2];
   2415    if (c1 != c2) return (c1 > c2);
   2416    i1++; i2++;
   2417    /* 4 */
   2418    c1 = block[i1]; c2 = block[i2];
   2419    if (c1 != c2) return (c1 > c2);
   2420    i1++; i2++;
   2421    /* 5 */
   2422    c1 = block[i1]; c2 = block[i2];
   2423    if (c1 != c2) return (c1 > c2);
   2424    i1++; i2++;
   2425    /* 6 */
   2426    c1 = block[i1]; c2 = block[i2];
   2427    if (c1 != c2) return (c1 > c2);
   2428    i1++; i2++;
   2429    /* 7 */
   2430    c1 = block[i1]; c2 = block[i2];
   2431    if (c1 != c2) return (c1 > c2);
   2432    i1++; i2++;
   2433    /* 8 */
   2434    c1 = block[i1]; c2 = block[i2];
   2435    if (c1 != c2) return (c1 > c2);
   2436    i1++; i2++;
   2437    /* 9 */
   2438    c1 = block[i1]; c2 = block[i2];
   2439    if (c1 != c2) return (c1 > c2);
   2440    i1++; i2++;
   2441    /* 10 */
   2442    c1 = block[i1]; c2 = block[i2];
   2443    if (c1 != c2) return (c1 > c2);
   2444    i1++; i2++;
   2445    /* 11 */
   2446    c1 = block[i1]; c2 = block[i2];
   2447    if (c1 != c2) return (c1 > c2);
   2448    i1++; i2++;
   2449    /* 12 */
   2450    c1 = block[i1]; c2 = block[i2];
   2451    if (c1 != c2) return (c1 > c2);
   2452    i1++; i2++;
   2453 
   2454    k = nblock + 8;
   2455 
   2456    do {
   2457       /* 1 */
   2458       c1 = block[i1]; c2 = block[i2];
   2459       if (c1 != c2) return (c1 > c2);
   2460       s1 = quadrant[i1]; s2 = quadrant[i2];
   2461       if (s1 != s2) return (s1 > s2);
   2462       i1++; i2++;
   2463       /* 2 */
   2464       c1 = block[i1]; c2 = block[i2];
   2465       if (c1 != c2) return (c1 > c2);
   2466       s1 = quadrant[i1]; s2 = quadrant[i2];
   2467       if (s1 != s2) return (s1 > s2);
   2468       i1++; i2++;
   2469       /* 3 */
   2470       c1 = block[i1]; c2 = block[i2];
   2471       if (c1 != c2) return (c1 > c2);
   2472       s1 = quadrant[i1]; s2 = quadrant[i2];
   2473       if (s1 != s2) return (s1 > s2);
   2474       i1++; i2++;
   2475       /* 4 */
   2476       c1 = block[i1]; c2 = block[i2];
   2477       if (c1 != c2) return (c1 > c2);
   2478       s1 = quadrant[i1]; s2 = quadrant[i2];
   2479       if (s1 != s2) return (s1 > s2);
   2480       i1++; i2++;
   2481       /* 5 */
   2482       c1 = block[i1]; c2 = block[i2];
   2483       if (c1 != c2) return (c1 > c2);
   2484       s1 = quadrant[i1]; s2 = quadrant[i2];
   2485       if (s1 != s2) return (s1 > s2);
   2486       i1++; i2++;
   2487       /* 6 */
   2488       c1 = block[i1]; c2 = block[i2];
   2489       if (c1 != c2) return (c1 > c2);
   2490       s1 = quadrant[i1]; s2 = quadrant[i2];
   2491       if (s1 != s2) return (s1 > s2);
   2492       i1++; i2++;
   2493       /* 7 */
   2494       c1 = block[i1]; c2 = block[i2];
   2495       if (c1 != c2) return (c1 > c2);
   2496       s1 = quadrant[i1]; s2 = quadrant[i2];
   2497       if (s1 != s2) return (s1 > s2);
   2498       i1++; i2++;
   2499       /* 8 */
   2500       c1 = block[i1]; c2 = block[i2];
   2501       if (c1 != c2) return (c1 > c2);
   2502       s1 = quadrant[i1]; s2 = quadrant[i2];
   2503       if (s1 != s2) return (s1 > s2);
   2504       i1++; i2++;
   2505 
   2506       if (i1 >= nblock) i1 -= nblock;
   2507       if (i2 >= nblock) i2 -= nblock;
   2508 
   2509       k -= 8;
   2510       (*budget)--;
   2511    }
   2512       while (k >= 0);
   2513 
   2514    return False;
   2515 }
   2516 
   2517 
   2518 /*---------------------------------------------*/
   2519 /*--
   2520    Knuth's increments seem to work better
   2521    than Incerpi-Sedgewick here.  Possibly
   2522    because the number of elems to sort is
   2523    usually small, typically <= 20.
   2524 --*/
   2525 static
   2526 Int32 incs[14] = { 1, 4, 13, 40, 121, 364, 1093, 3280,
   2527                    9841, 29524, 88573, 265720,
   2528                    797161, 2391484 };
   2529 
   2530 static
   2531 void mainSimpleSort ( UInt32* ptr,
   2532                       UChar*  block,
   2533                       UInt16* quadrant,
   2534                       Int32   nblock,
   2535                       Int32   lo,
   2536                       Int32   hi,
   2537                       Int32   d,
   2538                       Int32*  budget )
   2539 {
   2540    Int32 i, j, h, bigN, hp;
   2541    UInt32 v;
   2542 
   2543    bigN = hi - lo + 1;
   2544    if (bigN < 2) return;
   2545 
   2546    hp = 0;
   2547    while (incs[hp] < bigN) hp++;
   2548    hp--;
   2549 
   2550    for (; hp >= 0; hp--) {
   2551       h = incs[hp];
   2552 
   2553       i = lo + h;
   2554       while (True) {
   2555 
   2556          /*-- copy 1 --*/
   2557          if (i > hi) break;
   2558          v = ptr[i];
   2559          j = i;
   2560          while ( mainGtU (
   2561                     ptr[j-h]+d, v+d, block, quadrant, nblock, budget
   2562                  ) ) {
   2563             ptr[j] = ptr[j-h];
   2564             j = j - h;
   2565             if (j <= (lo + h - 1)) break;
   2566          }
   2567          ptr[j] = v;
   2568          i++;
   2569 
   2570          /*-- copy 2 --*/
   2571          if (i > hi) break;
   2572          v = ptr[i];
   2573          j = i;
   2574          while ( mainGtU (
   2575                     ptr[j-h]+d, v+d, block, quadrant, nblock, budget
   2576                  ) ) {
   2577             ptr[j] = ptr[j-h];
   2578             j = j - h;
   2579             if (j <= (lo + h - 1)) break;
   2580          }
   2581          ptr[j] = v;
   2582          i++;
   2583 
   2584          /*-- copy 3 --*/
   2585          if (i > hi) break;
   2586          v = ptr[i];
   2587          j = i;
   2588          while ( mainGtU (
   2589                     ptr[j-h]+d, v+d, block, quadrant, nblock, budget
   2590                  ) ) {
   2591             ptr[j] = ptr[j-h];
   2592             j = j - h;
   2593             if (j <= (lo + h - 1)) break;
   2594          }
   2595          ptr[j] = v;
   2596          i++;
   2597 
   2598          if (*budget < 0) return;
   2599       }
   2600    }
   2601 }
   2602 
   2603 
   2604 /*---------------------------------------------*/
   2605 /*--
   2606    The following is an implementation of
   2607    an elegant 3-way quicksort for strings,
   2608    described in a paper "Fast Algorithms for
   2609    Sorting and Searching Strings", by Robert
   2610    Sedgewick and Jon L. Bentley.
   2611 --*/
   2612 
   2613 #define mswap(zz1, zz2) \
   2614    { Int32 zztmp = zz1; zz1 = zz2; zz2 = zztmp; }
   2615 
   2616 #define mvswap(zzp1, zzp2, zzn)       \
   2617 {                                     \
   2618    Int32 yyp1 = (zzp1);               \
   2619    Int32 yyp2 = (zzp2);               \
   2620    Int32 yyn  = (zzn);                \
   2621    while (yyn > 0) {                  \
   2622       mswap(ptr[yyp1], ptr[yyp2]);    \
   2623       yyp1++; yyp2++; yyn--;          \
   2624    }                                  \
   2625 }
   2626 
   2627 static
   2628 __inline__
   2629 UChar mmed3 ( UChar a, UChar b, UChar c )
   2630 {
   2631    UChar t;
   2632    if (a > b) { t = a; a = b; b = t; };
   2633    if (b > c) {
   2634       b = c;
   2635       if (a > b) b = a;
   2636    }
   2637    return b;
   2638 }
   2639 
   2640 #define mmin(a,b) ((a) < (b)) ? (a) : (b)
   2641 
   2642 #define mpush(lz,hz,dz) { stackLo[sp] = lz; \
   2643                           stackHi[sp] = hz; \
   2644                           stackD [sp] = dz; \
   2645                           sp++; }
   2646 
   2647 #define mpop(lz,hz,dz) { sp--;             \
   2648                          lz = stackLo[sp]; \
   2649                          hz = stackHi[sp]; \
   2650                          dz = stackD [sp]; }
   2651 
   2652 
   2653 #define mnextsize(az) (nextHi[az]-nextLo[az])
   2654 
   2655 #define mnextswap(az,bz)                                        \
   2656    { Int32 tz;                                                  \
   2657      tz = nextLo[az]; nextLo[az] = nextLo[bz]; nextLo[bz] = tz; \
   2658      tz = nextHi[az]; nextHi[az] = nextHi[bz]; nextHi[bz] = tz; \
   2659      tz = nextD [az]; nextD [az] = nextD [bz]; nextD [bz] = tz; }
   2660 
   2661 
   2662 #define MAIN_QSORT_SMALL_THRESH 20
   2663 #define MAIN_QSORT_DEPTH_THRESH (BZ_N_RADIX + BZ_N_QSORT)
   2664 #define MAIN_QSORT_STACK_SIZE 100
   2665 
   2666 static
   2667 void mainQSort3 ( UInt32* ptr,
   2668                   UChar*  block,
   2669                   UInt16* quadrant,
   2670                   Int32   nblock,
   2671                   Int32   loSt,
   2672                   Int32   hiSt,
   2673                   Int32   dSt,
   2674                   Int32*  budget )
   2675 {
   2676    Int32 unLo, unHi, ltLo, gtHi, n, m, med;
   2677    Int32 sp, lo, hi, d;
   2678 
   2679    Int32 stackLo[MAIN_QSORT_STACK_SIZE];
   2680    Int32 stackHi[MAIN_QSORT_STACK_SIZE];
   2681    Int32 stackD [MAIN_QSORT_STACK_SIZE];
   2682 
   2683    Int32 nextLo[3];
   2684    Int32 nextHi[3];
   2685    Int32 nextD [3];
   2686 
   2687    sp = 0;
   2688    mpush ( loSt, hiSt, dSt );
   2689 
   2690    while (sp > 0) {
   2691 
   2692       AssertH ( sp < MAIN_QSORT_STACK_SIZE, 1001 );
   2693 
   2694       mpop ( lo, hi, d );
   2695       if (hi - lo < MAIN_QSORT_SMALL_THRESH ||
   2696           d > MAIN_QSORT_DEPTH_THRESH) {
   2697          mainSimpleSort ( ptr, block, quadrant, nblock, lo, hi, d, budget );
   2698          if (*budget < 0) return;
   2699          continue;
   2700       }
   2701 
   2702       med = (Int32)
   2703             mmed3 ( block[ptr[ lo         ]+d],
   2704                     block[ptr[ hi         ]+d],
   2705                     block[ptr[ (lo+hi)>>1 ]+d] );
   2706 
   2707       unLo = ltLo = lo;
   2708       unHi = gtHi = hi;
   2709 
   2710       while (True) {
   2711          while (True) {
   2712             if (unLo > unHi) break;
   2713             n = ((Int32)block[ptr[unLo]+d]) - med;
   2714             if (n == 0) {
   2715                mswap(ptr[unLo], ptr[ltLo]);
   2716                ltLo++; unLo++; continue;
   2717             };
   2718             if (n >  0) break;
   2719             unLo++;
   2720          }
   2721          while (True) {
   2722             if (unLo > unHi) break;
   2723             n = ((Int32)block[ptr[unHi]+d]) - med;
   2724             if (n == 0) {
   2725                mswap(ptr[unHi], ptr[gtHi]);
   2726                gtHi--; unHi--; continue;
   2727             };
   2728             if (n <  0) break;
   2729             unHi--;
   2730          }
   2731          if (unLo > unHi) break;
   2732          mswap(ptr[unLo], ptr[unHi]); unLo++; unHi--;
   2733       }
   2734 
   2735       AssertD ( unHi == unLo-1, "mainQSort3(2)" );
   2736 
   2737       if (gtHi < ltLo) {
   2738          mpush(lo, hi, d+1 );
   2739          continue;
   2740       }
   2741 
   2742       n = mmin(ltLo-lo, unLo-ltLo); mvswap(lo, unLo-n, n);
   2743       m = mmin(hi-gtHi, gtHi-unHi); mvswap(unLo, hi-m+1, m);
   2744 
   2745       n = lo + unLo - ltLo - 1;
   2746       m = hi - (gtHi - unHi) + 1;
   2747 
   2748       nextLo[0] = lo;  nextHi[0] = n;   nextD[0] = d;
   2749       nextLo[1] = m;   nextHi[1] = hi;  nextD[1] = d;
   2750       nextLo[2] = n+1; nextHi[2] = m-1; nextD[2] = d+1;
   2751 
   2752       if (mnextsize(0) < mnextsize(1)) mnextswap(0,1);
   2753       if (mnextsize(1) < mnextsize(2)) mnextswap(1,2);
   2754       if (mnextsize(0) < mnextsize(1)) mnextswap(0,1);
   2755 
   2756       AssertD (mnextsize(0) >= mnextsize(1), "mainQSort3(8)" );
   2757       AssertD (mnextsize(1) >= mnextsize(2), "mainQSort3(9)" );
   2758 
   2759       mpush (nextLo[0], nextHi[0], nextD[0]);
   2760       mpush (nextLo[1], nextHi[1], nextD[1]);
   2761       mpush (nextLo[2], nextHi[2], nextD[2]);
   2762    }
   2763 }
   2764 
   2765 #undef mswap
   2766 #undef mvswap
   2767 #undef mpush
   2768 #undef mpop
   2769 #undef mmin
   2770 #undef mnextsize
   2771 #undef mnextswap
   2772 #undef MAIN_QSORT_SMALL_THRESH
   2773 #undef MAIN_QSORT_DEPTH_THRESH
   2774 #undef MAIN_QSORT_STACK_SIZE
   2775 
   2776 
   2777 /*---------------------------------------------*/
   2778 /* Pre:
   2779       nblock > N_OVERSHOOT
   2780       block32 exists for [0 .. nblock-1 +N_OVERSHOOT]
   2781       ((UChar*)block32) [0 .. nblock-1] holds block
   2782       ptr exists for [0 .. nblock-1]
   2783 
   2784    Post:
   2785       ((UChar*)block32) [0 .. nblock-1] holds block
   2786       All other areas of block32 destroyed
   2787       ftab [0 .. 65536 ] destroyed
   2788       ptr [0 .. nblock-1] holds sorted order
   2789       if (*budget < 0), sorting was abandoned
   2790 */
   2791 
   2792 #define BIGFREQ(b) (ftab[((b)+1) << 8] - ftab[(b) << 8])
   2793 #define SETMASK (1 << 21)
   2794 #define CLEARMASK (~(SETMASK))
   2795 
   2796 static
   2797 void mainSort ( UInt32* ptr,
   2798                 UChar*  block,
   2799                 UInt16* quadrant,
   2800                 UInt32* ftab,
   2801                 Int32   nblock,
   2802                 Int32   verb,
   2803                 Int32*  budget )
   2804 {
   2805    Int32  i, j, k, ss, sb;
   2806    Int32  runningOrder[256];
   2807    Bool   bigDone[256];
   2808    Int32  copyStart[256];
   2809    Int32  copyEnd  [256];
   2810    UChar  c1;
   2811    Int32  numQSorted;
   2812    UInt16 s;
   2813    if (verb >= 4) VPrintf0 ( "        main sort initialise ...\n" );
   2814 
   2815    /*-- set up the 2-byte frequency table --*/
   2816    for (i = 65536; i >= 0; i--) ftab[i] = 0;
   2817 
   2818    j = block[0] << 8;
   2819    i = nblock-1;
   2820    for (; i >= 3; i -= 4) {
   2821       quadrant[i] = 0;
   2822       j = (j >> 8) | ( ((UInt16)block[i]) << 8);
   2823       ftab[j]++;
   2824       quadrant[i-1] = 0;
   2825       j = (j >> 8) | ( ((UInt16)block[i-1]) << 8);
   2826       ftab[j]++;
   2827       quadrant[i-2] = 0;
   2828       j = (j >> 8) | ( ((UInt16)block[i-2]) << 8);
   2829       ftab[j]++;
   2830       quadrant[i-3] = 0;
   2831       j = (j >> 8) | ( ((UInt16)block[i-3]) << 8);
   2832       ftab[j]++;
   2833    }
   2834    for (; i >= 0; i--) {
   2835       quadrant[i] = 0;
   2836       j = (j >> 8) | ( ((UInt16)block[i]) << 8);
   2837       ftab[j]++;
   2838    }
   2839 
   2840    /*-- (emphasises close relationship of block & quadrant) --*/
   2841    for (i = 0; i < BZ_N_OVERSHOOT; i++) {
   2842       block   [nblock+i] = block[i];
   2843       quadrant[nblock+i] = 0;
   2844    }
   2845 
   2846    if (verb >= 4) VPrintf0 ( "        bucket sorting ...\n" );
   2847 
   2848    /*-- Complete the initial radix sort --*/
   2849    for (i = 1; i <= 65536; i++) ftab[i] += ftab[i-1];
   2850 
   2851    s = block[0] << 8;
   2852    i = nblock-1;
   2853    for (; i >= 3; i -= 4) {
   2854       s = (s >> 8) | (block[i] << 8);
   2855       j = ftab[s] -1;
   2856       ftab[s] = j;
   2857       ptr[j] = i;
   2858       s = (s >> 8) | (block[i-1] << 8);
   2859       j = ftab[s] -1;
   2860       ftab[s] = j;
   2861       ptr[j] = i-1;
   2862       s = (s >> 8) | (block[i-2] << 8);
   2863       j = ftab[s] -1;
   2864       ftab[s] = j;
   2865       ptr[j] = i-2;
   2866       s = (s >> 8) | (block[i-3] << 8);
   2867       j = ftab[s] -1;
   2868       ftab[s] = j;
   2869       ptr[j] = i-3;
   2870    }
   2871    for (; i >= 0; i--) {
   2872       s = (s >> 8) | (block[i] << 8);
   2873       j = ftab[s] -1;
   2874       ftab[s] = j;
   2875       ptr[j] = i;
   2876    }
   2877 
   2878    /*--
   2879       Now ftab contains the first loc of every small bucket.
   2880       Calculate the running order, from smallest to largest
   2881       big bucket.
   2882    --*/
   2883    for (i = 0; i <= 255; i++) {
   2884       bigDone     [i] = False;
   2885       runningOrder[i] = i;
   2886    }
   2887 
   2888    {
   2889       Int32 vv;
   2890       Int32 h = 1;
   2891       do h = 3 * h + 1; while (h <= 256);
   2892       do {
   2893          h = h / 3;
   2894          for (i = h; i <= 255; i++) {
   2895             vv = runningOrder[i];
   2896             j = i;
   2897             while ( BIGFREQ(runningOrder[j-h]) > BIGFREQ(vv) ) {
   2898                runningOrder[j] = runningOrder[j-h];
   2899                j = j - h;
   2900                if (j <= (h - 1)) goto zero;
   2901             }
   2902             zero:
   2903             runningOrder[j] = vv;
   2904          }
   2905       } while (h != 1);
   2906    }
   2907 
   2908    /*--
   2909       The main sorting loop.
   2910    --*/
   2911 
   2912    numQSorted = 0;
   2913 
   2914    for (i = 0; i <= 255; i++) {
   2915 
   2916       /*--
   2917          Process big buckets, starting with the least full.
   2918          Basically this is a 3-step process in which we call
   2919          mainQSort3 to sort the small buckets [ss, j], but
   2920          also make a big effort to avoid the calls if we can.
   2921       --*/
   2922       ss = runningOrder[i];
   2923 
   2924       /*--
   2925          Step 1:
   2926          Complete the big bucket [ss] by quicksorting
   2927          any unsorted small buckets [ss, j], for j != ss.
   2928          Hopefully previous pointer-scanning phases have already
   2929          completed many of the small buckets [ss, j], so
   2930          we don't have to sort them at all.
   2931       --*/
   2932       for (j = 0; j <= 255; j++) {
   2933          if (j != ss) {
   2934             sb = (ss << 8) + j;
   2935             if ( ! (ftab[sb] & SETMASK) ) {
   2936                Int32 lo = ftab[sb]   & CLEARMASK;
   2937                Int32 hi = (ftab[sb+1] & CLEARMASK) - 1;
   2938                if (hi > lo) {
   2939                   if (verb >= 4)
   2940                      VPrintf4 ( "        qsort [0x%x, 0x%x]   "
   2941                                 "done %d   this %d\n",
   2942                                 ss, j, numQSorted, hi - lo + 1 );
   2943                   mainQSort3 (
   2944                      ptr, block, quadrant, nblock,
   2945                      lo, hi, BZ_N_RADIX, budget
   2946                   );
   2947                   numQSorted += (hi - lo + 1);
   2948                   if (*budget < 0) return;
   2949                }
   2950             }
   2951             ftab[sb] |= SETMASK;
   2952          }
   2953       }
   2954 
   2955       AssertH ( !bigDone[ss], 1006 );
   2956 
   2957       /*--
   2958          Step 2:
   2959          Now scan this big bucket [ss] so as to synthesise the
   2960          sorted order for small buckets [t, ss] for all t,
   2961          including, magically, the bucket [ss,ss] too.
   2962          This will avoid doing Real Work in subsequent Step 1's.
   2963       --*/
   2964       {
   2965          for (j = 0; j <= 255; j++) {
   2966             copyStart[j] =  ftab[(j << 8) + ss]     & CLEARMASK;
   2967             copyEnd  [j] = (ftab[(j << 8) + ss + 1] & CLEARMASK) - 1;
   2968          }
   2969          for (j = ftab[ss << 8] & CLEARMASK; j < copyStart[ss]; j++) {
   2970             k = ptr[j]-1; if (k < 0) k += nblock;
   2971             c1 = block[k];
   2972             if (!bigDone[c1])
   2973                ptr[ copyStart[c1]++ ] = k;
   2974          }
   2975          for (j = (ftab[(ss+1) << 8] & CLEARMASK) - 1; j > copyEnd[ss]; j--) {
   2976             k = ptr[j]-1; if (k < 0) k += nblock;
   2977             c1 = block[k];
   2978             if (!bigDone[c1])
   2979                ptr[ copyEnd[c1]-- ] = k;
   2980          }
   2981       }
   2982 
   2983       AssertH ( (copyStart[ss]-1 == copyEnd[ss])
   2984                 ||
   2985                 /* Extremely rare case missing in bzip2-1.0.0 and 1.0.1.
   2986                    Necessity for this case is demonstrated by compressing
   2987                    a sequence of approximately 48.5 million of character
   2988                    251; 1.0.0/1.0.1 will then die here. */
   2989                 (copyStart[ss] == 0 && copyEnd[ss] == nblock-1),
   2990                 1007 )
   2991 
   2992       for (j = 0; j <= 255; j++) ftab[(j << 8) + ss] |= SETMASK;
   2993 
   2994       /*--
   2995          Step 3:
   2996          The [ss] big bucket is now done.  Record this fact,
   2997          and update the quadrant descriptors.  Remember to
   2998          update quadrants in the overshoot area too, if
   2999          necessary.  The "if (i < 255)" test merely skips
   3000          this updating for the last bucket processed, since
   3001          updating for the last bucket is pointless.
   3002 
   3003          The quadrant array provides a way to incrementally
   3004          cache sort orderings, as they appear, so as to
   3005          make subsequent comparisons in fullGtU() complete
   3006          faster.  For repetitive blocks this makes a big
   3007          difference (but not big enough to be able to avoid
   3008          the fallback sorting mechanism, exponential radix sort).
   3009 
   3010          The precise meaning is: at all times:
   3011 
   3012             for 0 <= i < nblock and 0 <= j <= nblock
   3013 
   3014             if block[i] != block[j],
   3015 
   3016                then the relative values of quadrant[i] and
   3017                     quadrant[j] are meaningless.
   3018 
   3019                else {
   3020                   if quadrant[i] < quadrant[j]
   3021                      then the string starting at i lexicographically
   3022                      precedes the string starting at j
   3023 
   3024                   else if quadrant[i] > quadrant[j]
   3025                      then the string starting at j lexicographically
   3026                      precedes the string starting at i
   3027 
   3028                   else
   3029                      the relative ordering of the strings starting
   3030                      at i and j has not yet been determined.
   3031                }
   3032       --*/
   3033       bigDone[ss] = True;
   3034 
   3035       if (i < 255) {
   3036          Int32 bbStart  = ftab[ss << 8] & CLEARMASK;
   3037          Int32 bbSize   = (ftab[(ss+1) << 8] & CLEARMASK) - bbStart;
   3038          Int32 shifts   = 0;
   3039 
   3040          while ((bbSize >> shifts) > 65534) shifts++;
   3041 
   3042          for (j = bbSize-1; j >= 0; j--) {
   3043             Int32 a2update     = ptr[bbStart + j];
   3044             UInt16 qVal        = (UInt16)(j >> shifts);
   3045             quadrant[a2update] = qVal;
   3046             if (a2update < BZ_N_OVERSHOOT)
   3047                quadrant[a2update + nblock] = qVal;
   3048          }
   3049          AssertH ( ((bbSize-1) >> shifts) <= 65535, 1002 );
   3050       }
   3051 
   3052    }
   3053 
   3054    if (verb >= 4)
   3055       VPrintf3 ( "        %d pointers, %d sorted, %d scanned\n",
   3056                  nblock, numQSorted, nblock - numQSorted );
   3057 }
   3058 
   3059 #undef BIGFREQ
   3060 #undef SETMASK
   3061 #undef CLEARMASK
   3062 
   3063 
   3064 /*---------------------------------------------*/
   3065 /* Pre:
   3066       nblock > 0
   3067       arr2 exists for [0 .. nblock-1 +N_OVERSHOOT]
   3068       ((UChar*)arr2)  [0 .. nblock-1] holds block
   3069       arr1 exists for [0 .. nblock-1]
   3070 
   3071    Post:
   3072       ((UChar*)arr2) [0 .. nblock-1] holds block
   3073       All other areas of block destroyed
   3074       ftab [ 0 .. 65536 ] destroyed
   3075       arr1 [0 .. nblock-1] holds sorted order
   3076 */
   3077 void BZ2_blockSort ( EState* s )
   3078 {
   3079    UInt32* ptr    = s->ptr;
   3080    UChar*  block  = s->block;
   3081    UInt32* ftab   = s->ftab;
   3082    Int32   nblock = s->nblock;
   3083    Int32   verb   = s->verbosity;
   3084    Int32   wfact  = s->workFactor;
   3085    UInt16* quadrant;
   3086    Int32   budget;
   3087    Int32   budgetInit;
   3088    Int32   i;
   3089 
   3090    if (nblock < /* 10000 */1000 ) {
   3091       fallbackSort ( s->arr1, s->arr2, ftab, nblock, verb );
   3092    } else {
   3093       /* Calculate the location for quadrant, remembering to get
   3094          the alignment right.  Assumes that &(block[0]) is at least
   3095          2-byte aligned -- this should be ok since block is really
   3096          the first section of arr2.
   3097       */
   3098       i = nblock+BZ_N_OVERSHOOT;
   3099       if (i & 1) i++;
   3100       quadrant = (UInt16*)(&(block[i]));
   3101 
   3102       /* (wfact-1) / 3 puts the default-factor-30
   3103          transition point at very roughly the same place as
   3104          with v0.1 and v0.9.0.
   3105          Not that it particularly matters any more, since the
   3106          resulting compressed stream is now the same regardless
   3107          of whether or not we use the main sort or fallback sort.
   3108       */
   3109       if (wfact < 1  ) wfact = 1;
   3110       if (wfact > 100) wfact = 100;
   3111       budgetInit = nblock * ((wfact-1) / 3);
   3112       budget = budgetInit;
   3113 
   3114       mainSort ( ptr, block, quadrant, ftab, nblock, verb, &budget );
   3115       if (0 && verb >= 3)
   3116          VPrintf3 ( "      %d work, %d block, ratio %5.2f\n",
   3117                     budgetInit - budget,
   3118                     nblock,
   3119                     (float)(budgetInit - budget) /
   3120                     (float)(nblock==0 ? 1 : nblock) );
   3121       if (budget < 0) {
   3122          if (verb >= 2)
   3123             VPrintf0 ( "    too repetitive; using fallback"
   3124                        " sorting algorithm\n" );
   3125          fallbackSort ( s->arr1, s->arr2, ftab, nblock, verb );
   3126       }
   3127    }
   3128 
   3129    s->origPtr = -1;
   3130    for (i = 0; i < s->nblock; i++)
   3131       if (ptr[i] == 0)
   3132          { s->origPtr = i; break; };
   3133 
   3134    AssertH( s->origPtr != -1, 1003 );
   3135 }
   3136 
   3137 
   3138 /*-------------------------------------------------------------*/
   3139 /*--- end                                       blocksort.c ---*/
   3140 /*-------------------------------------------------------------*/
   3141 
   3142 /*-------------------------------------------------------------*/
   3143 /*--- Huffman coding low-level stuff                        ---*/
   3144 /*---                                             huffman.c ---*/
   3145 /*-------------------------------------------------------------*/
   3146 
   3147 /*--
   3148   This file is a part of bzip2 and/or libbzip2, a program and
   3149   library for lossless, block-sorting data compression.
   3150 
   3151   Copyright (C) 1996-2004 Julian R Seward.  All rights reserved.
   3152 
   3153   Redistribution and use in source and binary forms, with or without
   3154   modification, are permitted provided that the following conditions
   3155   are met:
   3156 
   3157   1. Redistributions of source code must retain the above copyright
   3158      notice, this list of conditions and the following disclaimer.
   3159 
   3160   2. The origin of this software must not be misrepresented; you must
   3161      not claim that you wrote the original software.  If you use this
   3162      software in a product, an acknowledgment in the product
   3163      documentation would be appreciated but is not required.
   3164 
   3165   3. Altered source versions must be plainly marked as such, and must
   3166      not be misrepresented as being the original software.
   3167 
   3168   4. The name of the author may not be used to endorse or promote
   3169      products derived from this software without specific prior written
   3170      permission.
   3171 
   3172   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
   3173   OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   3174   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   3175   ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
   3176   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   3177   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
   3178   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   3179   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   3180   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   3181   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   3182   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   3183 
   3184   Julian Seward, Cambridge, UK.
   3185   jseward (at) bzip.org
   3186   bzip2/libbzip2 version 1.0 of 21 March 2000
   3187 
   3188   This program is based on (at least) the work of:
   3189      Mike Burrows
   3190      David Wheeler
   3191      Peter Fenwick
   3192      Alistair Moffat
   3193      Radford Neal
   3194      Ian H. Witten
   3195      Robert Sedgewick
   3196      Jon L. Bentley
   3197 
   3198   For more information on these sources, see the manual.
   3199 --*/
   3200 
   3201 
   3202 
   3203 /*---------------------------------------------------*/
   3204 #define WEIGHTOF(zz0)  ((zz0) & 0xffffff00)
   3205 #define DEPTHOF(zz1)   ((zz1) & 0x000000ff)
   3206 #define MYMAX(zz2,zz3) ((zz2) > (zz3) ? (zz2) : (zz3))
   3207 
   3208 #define ADDWEIGHTS(zw1,zw2)                           \
   3209    (WEIGHTOF(zw1)+WEIGHTOF(zw2)) |                    \
   3210    (1 + MYMAX(DEPTHOF(zw1),DEPTHOF(zw2)))
   3211 
   3212 #define UPHEAP(z)                                     \
   3213 {                                                     \
   3214    Int32 zz, tmp;                                     \
   3215    zz = z; tmp = heap[zz];                            \
   3216    while (weight[tmp] < weight[heap[zz >> 1]]) {      \
   3217       heap[zz] = heap[zz >> 1];                       \
   3218       zz >>= 1;                                       \
   3219    }                                                  \
   3220    heap[zz] = tmp;                                    \
   3221 }
   3222 
   3223 #define DOWNHEAP(z)                                   \
   3224 {                                                     \
   3225    Int32 zz, yy, tmp;                                 \
   3226    zz = z; tmp = heap[zz];                            \
   3227    while (True) {                                     \
   3228       yy = zz << 1;                                   \
   3229       if (yy > nHeap) break;                          \
   3230       if (yy < nHeap &&                               \
   3231           weight[heap[yy+1]] < weight[heap[yy]])      \
   3232          yy++;                                        \
   3233       if (weight[tmp] < weight[heap[yy]]) break;      \
   3234       heap[zz] = heap[yy];                            \
   3235       zz = yy;                                        \
   3236    }                                                  \
   3237    heap[zz] = tmp;                                    \
   3238 }
   3239 
   3240 
   3241 /*---------------------------------------------------*/
   3242 void BZ2_hbMakeCodeLengths ( UChar *len,
   3243                              Int32 *freq,
   3244                              Int32 alphaSize,
   3245                              Int32 maxLen )
   3246 {
   3247    /*--
   3248       Nodes and heap entries run from 1.  Entry 0
   3249       for both the heap and nodes is a sentinel.
   3250    --*/
   3251    Int32 nNodes, nHeap, n1, n2, i, j, k;
   3252    Bool  tooLong;
   3253 
   3254    Int32 heap   [ BZ_MAX_ALPHA_SIZE + 2 ];
   3255    Int32 weight [ BZ_MAX_ALPHA_SIZE * 2 ];
   3256    Int32 parent [ BZ_MAX_ALPHA_SIZE * 2 ];
   3257 
   3258    for (i = 0; i < alphaSize; i++)
   3259       weight[i+1] = (freq[i] == 0 ? 1 : freq[i]) << 8;
   3260 
   3261    while (True) {
   3262 
   3263       nNodes = alphaSize;
   3264       nHeap = 0;
   3265 
   3266       heap[0] = 0;
   3267       weight[0] = 0;
   3268       parent[0] = -2;
   3269 
   3270       for (i = 1; i <= alphaSize; i++) {
   3271          parent[i] = -1;
   3272          nHeap++;
   3273          heap[nHeap] = i;
   3274          UPHEAP(nHeap);
   3275       }
   3276 
   3277       AssertH( nHeap < (BZ_MAX_ALPHA_SIZE+2), 2001 );
   3278 
   3279       while (nHeap > 1) {
   3280          n1 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1);
   3281          n2 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1);
   3282          nNodes++;
   3283          parent[n1] = parent[n2] = nNodes;
   3284          weight[nNodes] = ADDWEIGHTS(weight[n1], weight[n2]);
   3285          parent[nNodes] = -1;
   3286          nHeap++;
   3287          heap[nHeap] = nNodes;
   3288          UPHEAP(nHeap);
   3289       }
   3290 
   3291       AssertH( nNodes < (BZ_MAX_ALPHA_SIZE * 2), 2002 );
   3292 
   3293       tooLong = False;
   3294       for (i = 1; i <= alphaSize; i++) {
   3295          j = 0;
   3296          k = i;
   3297          while (parent[k] >= 0) { k = parent[k]; j++; }
   3298          len[i-1] = j;
   3299          if (j > maxLen) tooLong = True;
   3300       }
   3301 
   3302       if (! tooLong) break;
   3303 
   3304       /* 17 Oct 04: keep-going condition for the following loop used
   3305          to be 'i < alphaSize', which missed the last element,
   3306          theoretically leading to the possibility of the compressor
   3307          looping.  However, this count-scaling step is only needed if
   3308          one of the generated Huffman code words is longer than
   3309          maxLen, which up to and including version 1.0.2 was 20 bits,
   3310          which is extremely unlikely.  In version 1.0.3 maxLen was
   3311          changed to 17 bits, which has minimal effect on compression
   3312          ratio, but does mean this scaling step is used from time to
   3313          time, enough to verify that it works.
   3314 
   3315          This means that bzip2-1.0.3 and later will only produce
   3316          Huffman codes with a maximum length of 17 bits.  However, in
   3317          order to preserve backwards compatibility with bitstreams
   3318          produced by versions pre-1.0.3, the decompressor must still
   3319          handle lengths of up to 20. */
   3320 
   3321       for (i = 1; i <= alphaSize; i++) {
   3322          j = weight[i] >> 8;
   3323          j = 1 + (j / 2);
   3324          weight[i] = j << 8;
   3325       }
   3326    }
   3327 }
   3328 
   3329 
   3330 /*---------------------------------------------------*/
   3331 void BZ2_hbAssignCodes ( Int32 *code,
   3332                          UChar *length,
   3333                          Int32 minLen,
   3334                          Int32 maxLen,
   3335                          Int32 alphaSize )
   3336 {
   3337    Int32 n, vec, i;
   3338 
   3339    vec = 0;
   3340    for (n = minLen; n <= maxLen; n++) {
   3341       for (i = 0; i < alphaSize; i++)
   3342          if (length[i] == n) { code[i] = vec; vec++; };
   3343       vec <<= 1;
   3344    }
   3345 }
   3346 
   3347 
   3348 /*---------------------------------------------------*/
   3349 void BZ2_hbCreateDecodeTables ( Int32 *limit,
   3350                                 Int32 *base,
   3351                                 Int32 *perm,
   3352                                 UChar *length,
   3353                                 Int32 minLen,
   3354                                 Int32 maxLen,
   3355                                 Int32 alphaSize )
   3356 {
   3357    Int32 pp, i, j, vec;
   3358 
   3359    pp = 0;
   3360    for (i = minLen; i <= maxLen; i++)
   3361       for (j = 0; j < alphaSize; j++)
   3362          if (length[j] == i) { perm[pp] = j; pp++; };
   3363 
   3364    for (i = 0; i < BZ_MAX_CODE_LEN; i++) base[i] = 0;
   3365    for (i = 0; i < alphaSize; i++) base[length[i]+1]++;
   3366 
   3367    for (i = 1; i < BZ_MAX_CODE_LEN; i++) base[i] += base[i-1];
   3368 
   3369    for (i = 0; i < BZ_MAX_CODE_LEN; i++) limit[i] = 0;
   3370    vec = 0;
   3371 
   3372    for (i = minLen; i <= maxLen; i++) {
   3373       vec += (base[i+1] - base[i]);
   3374       limit[i] = vec-1;
   3375       vec <<= 1;
   3376    }
   3377    for (i = minLen + 1; i <= maxLen; i++)
   3378       base[i] = ((limit[i-1] + 1) << 1) - base[i];
   3379 }
   3380 
   3381 
   3382 /*-------------------------------------------------------------*/
   3383 /*--- end                                         huffman.c ---*/
   3384 /*-------------------------------------------------------------*/
   3385 
   3386 /*-------------------------------------------------------------*/
   3387 /*--- Compression machinery (not incl block sorting)        ---*/
   3388 /*---                                            compress.c ---*/
   3389 /*-------------------------------------------------------------*/
   3390 
   3391 /*--
   3392   This file is a part of bzip2 and/or libbzip2, a program and
   3393   library for lossless, block-sorting data compression.
   3394 
   3395   Copyright (C) 1996-2004 Julian R Seward.  All rights reserved.
   3396 
   3397   Redistribution and use in source and binary forms, with or without
   3398   modification, are permitted provided that the following conditions
   3399   are met:
   3400 
   3401   1. Redistributions of source code must retain the above copyright
   3402      notice, this list of conditions and the following disclaimer.
   3403 
   3404   2. The origin of this software must not be misrepresented; you must
   3405      not claim that you wrote the original software.  If you use this
   3406      software in a product, an acknowledgment in the product
   3407      documentation would be appreciated but is not required.
   3408 
   3409   3. Altered source versions must be plainly marked as such, and must
   3410      not be misrepresented as being the original software.
   3411 
   3412   4. The name of the author may not be used to endorse or promote
   3413      products derived from this software without specific prior written
   3414      permission.
   3415 
   3416   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
   3417   OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   3418   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   3419   ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
   3420   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   3421   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
   3422   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   3423   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   3424   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   3425   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   3426   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   3427 
   3428   Julian Seward, Cambridge, UK.
   3429   jseward (at) bzip.org
   3430   bzip2/libbzip2 version 1.0 of 21 March 2000
   3431 
   3432   This program is based on (at least) the work of:
   3433      Mike Burrows
   3434      David Wheeler
   3435      Peter Fenwick
   3436      Alistair Moffat
   3437      Radford Neal
   3438      Ian H. Witten
   3439      Robert Sedgewick
   3440      Jon L. Bentley
   3441 
   3442   For more information on these sources, see the manual.
   3443 --*/
   3444 
   3445 /*--
   3446    CHANGES
   3447    ~~~~~~~
   3448    0.9.0 -- original version.
   3449 
   3450    0.9.0a/b -- no changes in this file.
   3451 
   3452    0.9.0c
   3453       * changed setting of nGroups in sendMTFValues() so as to
   3454         do a bit better on small files
   3455 --*/
   3456 
   3457 
   3458 
   3459 /*---------------------------------------------------*/
   3460 /*--- Bit stream I/O                              ---*/
   3461 /*---------------------------------------------------*/
   3462 
   3463 /*---------------------------------------------------*/
   3464 void BZ2_bsInitWrite ( EState* s )
   3465 {
   3466    s->bsLive = 0;
   3467    s->bsBuff = 0;
   3468 }
   3469 
   3470 
   3471 /*---------------------------------------------------*/
   3472 static
   3473 void bsFinishWrite ( EState* s )
   3474 {
   3475    while (s->bsLive > 0) {
   3476       s->zbits[s->numZ] = (UChar)(s->bsBuff >> 24);
   3477       s->numZ++;
   3478       s->bsBuff <<= 8;
   3479       s->bsLive -= 8;
   3480    }
   3481 }
   3482 
   3483 
   3484 /*---------------------------------------------------*/
   3485 #define bsNEEDW(nz)                           \
   3486 {                                             \
   3487    while (s->bsLive >= 8) {                   \
   3488       s->zbits[s->numZ]                       \
   3489          = (UChar)(s->bsBuff >> 24);          \
   3490       s->numZ++;                              \
   3491       s->bsBuff <<= 8;                        \
   3492       s->bsLive -= 8;                         \
   3493    }                                          \
   3494 }
   3495 
   3496 
   3497 /*---------------------------------------------------*/
   3498 static
   3499 __inline__
   3500 void bsW ( EState* s, Int32 n, UInt32 v )
   3501 {
   3502    bsNEEDW ( n );
   3503    s->bsBuff |= (v << (32 - s->bsLive - n));
   3504    s->bsLive += n;
   3505 }
   3506 
   3507 
   3508 /*---------------------------------------------------*/
   3509 static
   3510 void bsPutUInt32 ( EState* s, UInt32 u )
   3511 {
   3512    bsW ( s, 8, (u >> 24) & 0xffL );
   3513    bsW ( s, 8, (u >> 16) & 0xffL );
   3514    bsW ( s, 8, (u >>  8) & 0xffL );
   3515    bsW ( s, 8,  u        & 0xffL );
   3516 }
   3517 
   3518 
   3519 /*---------------------------------------------------*/
   3520 static
   3521 void bsPutUChar ( EState* s, UChar c )
   3522 {
   3523    bsW( s, 8, (UInt32)c );
   3524 }
   3525 
   3526 
   3527 /*---------------------------------------------------*/
   3528 /*--- The back end proper                         ---*/
   3529 /*---------------------------------------------------*/
   3530 
   3531 /*---------------------------------------------------*/
   3532 static
   3533 void makeMaps_e ( EState* s )
   3534 {
   3535    Int32 i;
   3536    s->nInUse = 0;
   3537    for (i = 0; i < 256; i++)
   3538       if (s->inUse[i]) {
   3539          s->unseqToSeq[i] = s->nInUse;
   3540          s->nInUse++;
   3541       }
   3542 }
   3543 
   3544 
   3545 /*---------------------------------------------------*/
   3546 static
   3547 void generateMTFValues ( EState* s )
   3548 {
   3549    UChar   yy[256];
   3550    Int32   i, j;
   3551    Int32   zPend;
   3552    Int32   wr;
   3553    Int32   EOB;
   3554 
   3555    /*
   3556       After sorting (eg, here),
   3557          s->arr1 [ 0 .. s->nblock-1 ] holds sorted order,
   3558          and
   3559          ((UChar*)s->arr2) [ 0 .. s->nblock-1 ]
   3560          holds the original block data.
   3561 
   3562       The first thing to do is generate the MTF values,
   3563       and put them in
   3564          ((UInt16*)s->arr1) [ 0 .. s->nblock-1 ].
   3565       Because there are strictly fewer or equal MTF values
   3566       than block values, ptr values in this area are overwritten
   3567       with MTF values only when they are no longer needed.
   3568 
   3569       The final compressed bitstream is generated into the
   3570       area starting at
   3571          (UChar*) (&((UChar*)s->arr2)[s->nblock])
   3572 
   3573       These storage aliases are set up in bzCompressInit(),
   3574       except for the last one, which is arranged in
   3575       compressBlock().
   3576    */
   3577    UInt32* ptr   = s->ptr;
   3578    UChar* block  = s->block;
   3579    UInt16* mtfv  = s->mtfv;
   3580 
   3581    makeMaps_e ( s );
   3582    EOB = s->nInUse+1;
   3583 
   3584    for (i = 0; i <= EOB; i++) s->mtfFreq[i] = 0;
   3585 
   3586    wr = 0;
   3587    zPend = 0;
   3588    for (i = 0; i < s->nInUse; i++) yy[i] = (UChar) i;
   3589 
   3590    for (i = 0; i < s->nblock; i++) {
   3591       UChar ll_i;
   3592       AssertD ( wr <= i, "generateMTFValues(1)" );
   3593       j = ptr[i]-1; if (j < 0) j += s->nblock;
   3594       ll_i = s->unseqToSeq[block[j]];
   3595       AssertD ( ll_i < s->nInUse, "generateMTFValues(2a)" );
   3596 
   3597       if (yy[0] == ll_i) {
   3598          zPend++;
   3599       } else {
   3600 
   3601          if (zPend > 0) {
   3602             zPend--;
   3603             while (True) {
   3604                if (zPend & 1) {
   3605                   mtfv[wr] = BZ_RUNB; wr++;
   3606                   s->mtfFreq[BZ_RUNB]++;
   3607                } else {
   3608                   mtfv[wr] = BZ_RUNA; wr++;
   3609                   s->mtfFreq[BZ_RUNA]++;
   3610                }
   3611                if (zPend < 2) break;
   3612                zPend = (zPend - 2) / 2;
   3613             };
   3614             zPend = 0;
   3615          }
   3616          {
   3617             register UChar  rtmp;
   3618             register UChar* ryy_j;
   3619             register UChar  rll_i;
   3620             rtmp  = yy[1];
   3621             yy[1] = yy[0];
   3622             ryy_j = &(yy[1]);
   3623             rll_i = ll_i;
   3624             while ( rll_i != rtmp ) {
   3625                register UChar rtmp2;
   3626                ryy_j++;
   3627                rtmp2  = rtmp;
   3628                rtmp   = *ryy_j;
   3629                *ryy_j = rtmp2;
   3630             };
   3631             yy[0] = rtmp;
   3632             j = ryy_j - &(yy[0]);
   3633             mtfv[wr] = j+1; wr++; s->mtfFreq[j+1]++;
   3634          }
   3635 
   3636       }
   3637    }
   3638 
   3639    if (zPend > 0) {
   3640       zPend--;
   3641       while (True) {
   3642          if (zPend & 1) {
   3643             mtfv[wr] = BZ_RUNB; wr++;
   3644             s->mtfFreq[BZ_RUNB]++;
   3645          } else {
   3646             mtfv[wr] = BZ_RUNA; wr++;
   3647             s->mtfFreq[BZ_RUNA]++;
   3648          }
   3649          if (zPend < 2) break;
   3650          zPend = (zPend - 2) / 2;
   3651       };
   3652       zPend = 0;
   3653    }
   3654 
   3655    mtfv[wr] = EOB; wr++; s->mtfFreq[EOB]++;
   3656 
   3657    s->nMTF = wr;
   3658 }
   3659 
   3660 
   3661 /*---------------------------------------------------*/
   3662 #define BZ_LESSER_ICOST  0
   3663 #define BZ_GREATER_ICOST 15
   3664 
   3665 static
   3666 void sendMTFValues ( EState* s )
   3667 {
   3668    Int32 v, t, i, j, gs, ge, totc, bt, bc, iter;
   3669    Int32 nSelectors, alphaSize, minLen, maxLen, selCtr;
   3670    Int32 nGroups, nBytes;
   3671 
   3672    /*--
   3673    UChar  len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
   3674    is a global since the decoder also needs it.
   3675 
   3676    Int32  code[BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
   3677    Int32  rfreq[BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
   3678    are also globals only used in this proc.
   3679    Made global to keep stack frame size small.
   3680    --*/
   3681 
   3682 
   3683    UInt16 cost[BZ_N_GROUPS];
   3684    Int32  fave[BZ_N_GROUPS];
   3685 
   3686    UInt16* mtfv = s->mtfv;
   3687 
   3688    if (s->verbosity >= 3)
   3689       VPrintf3( "      %d in block, %d after MTF & 1-2 coding, "
   3690                 "%d+2 syms in use\n",
   3691                 s->nblock, s->nMTF, s->nInUse );
   3692 
   3693    alphaSize = s->nInUse+2;
   3694    for (t = 0; t < BZ_N_GROUPS; t++)
   3695       for (v = 0; v < alphaSize; v++)
   3696          s->len[t][v] = BZ_GREATER_ICOST;
   3697 
   3698    /*--- Decide how many coding tables to use ---*/
   3699    AssertH ( s->nMTF > 0, 3001 );
   3700    if (s->nMTF < 200)  nGroups = 2; else
   3701    if (s->nMTF < 600)  nGroups = 3; else
   3702    if (s->nMTF < 1200) nGroups = 4; else
   3703    if (s->nMTF < 2400) nGroups = 5; else
   3704                        nGroups = 6;
   3705 
   3706    /*--- Generate an initial set of coding tables ---*/
   3707    {
   3708       Int32 nPart, remF, tFreq, aFreq;
   3709 
   3710       nPart = nGroups;
   3711       remF  = s->nMTF;
   3712       gs = 0;
   3713       while (nPart > 0) {
   3714          tFreq = remF / nPart;
   3715          ge = gs-1;
   3716          aFreq = 0;
   3717          while (aFreq < tFreq && ge < alphaSize-1) {
   3718             ge++;
   3719             aFreq += s->mtfFreq[ge];
   3720          }
   3721 
   3722          if (ge > gs
   3723              && nPart != nGroups && nPart != 1
   3724              && ((nGroups-nPart) % 2 == 1)) {
   3725             aFreq -= s->mtfFreq[ge];
   3726             ge--;
   3727          }
   3728 
   3729          if (0 && s->verbosity >= 3)
   3730             VPrintf5( "      initial group %d, [%d .. %d], "
   3731                       "has %d syms (%4.1f%%)\n",
   3732                       nPart, gs, ge, aFreq,
   3733                       (100.0 * (float)aFreq) / (float)(s->nMTF) );
   3734 
   3735          for (v = 0; v < alphaSize; v++)
   3736             if (v >= gs && v <= ge)
   3737                s->len[nPart-1][v] = BZ_LESSER_ICOST; else
   3738                s->len[nPart-1][v] = BZ_GREATER_ICOST;
   3739 
   3740          nPart--;
   3741          gs = ge+1;
   3742          remF -= aFreq;
   3743       }
   3744    }
   3745 
   3746    /*---
   3747       Iterate up to BZ_N_ITERS times to improve the tables.
   3748    ---*/
   3749    for (iter = 0; iter < BZ_N_ITERS; iter++) {
   3750 
   3751       for (t = 0; t < nGroups; t++) fave[t] = 0;
   3752 
   3753       for (t = 0; t < nGroups; t++)
   3754          for (v = 0; v < alphaSize; v++)
   3755             s->rfreq[t][v] = 0;
   3756 
   3757       /*---
   3758         Set up an auxiliary length table which is used to fast-track
   3759 	the common case (nGroups == 6).
   3760       ---*/
   3761       if (nGroups == 6) {
   3762          for (v = 0; v < alphaSize; v++) {
   3763             s->len_pack[v][0] = (s->len[1][v] << 16) | s->len[0][v];
   3764             s->len_pack[v][1] = (s->len[3][v] << 16) | s->len[2][v];
   3765             s->len_pack[v][2] = (s->len[5][v] << 16) | s->len[4][v];
   3766 	 }
   3767       }
   3768 
   3769       nSelectors = 0;
   3770       totc = 0;
   3771       gs = 0;
   3772       while (True) {
   3773 
   3774          /*--- Set group start & end marks. --*/
   3775          if (gs >= s->nMTF) break;
   3776          ge = gs + BZ_G_SIZE - 1;
   3777          if (ge >= s->nMTF) ge = s->nMTF-1;
   3778 
   3779          /*--
   3780             Calculate the cost of this group as coded
   3781             by each of the coding tables.
   3782          --*/
   3783          for (t = 0; t < nGroups; t++) cost[t] = 0;
   3784 
   3785          if (nGroups == 6 && 50 == ge-gs+1) {
   3786             /*--- fast track the common case ---*/
   3787             register UInt32 cost01, cost23, cost45;
   3788             register UInt16 icv;
   3789             cost01 = cost23 = cost45 = 0;
   3790 
   3791 #           define BZ_ITER(nn)                \
   3792                icv = mtfv[gs+(nn)];           \
   3793                cost01 += s->len_pack[icv][0]; \
   3794                cost23 += s->len_pack[icv][1]; \
   3795                cost45 += s->len_pack[icv][2]; \
   3796 
   3797             BZ_ITER(0);  BZ_ITER(1);  BZ_ITER(2);  BZ_ITER(3);  BZ_ITER(4);
   3798             BZ_ITER(5);  BZ_ITER(6);  BZ_ITER(7);  BZ_ITER(8);  BZ_ITER(9);
   3799             BZ_ITER(10); BZ_ITER(11); BZ_ITER(12); BZ_ITER(13); BZ_ITER(14);
   3800             BZ_ITER(15); BZ_ITER(16); BZ_ITER(17); BZ_ITER(18); BZ_ITER(19);
   3801             BZ_ITER(20); BZ_ITER(21); BZ_ITER(22); BZ_ITER(23); BZ_ITER(24);
   3802             BZ_ITER(25); BZ_ITER(26); BZ_ITER(27); BZ_ITER(28); BZ_ITER(29);
   3803             BZ_ITER(30); BZ_ITER(31); BZ_ITER(32); BZ_ITER(33); BZ_ITER(34);
   3804             BZ_ITER(35); BZ_ITER(36); BZ_ITER(37); BZ_ITER(38); BZ_ITER(39);
   3805             BZ_ITER(40); BZ_ITER(41); BZ_ITER(42); BZ_ITER(43); BZ_ITER(44);
   3806             BZ_ITER(45); BZ_ITER(46); BZ_ITER(47); BZ_ITER(48); BZ_ITER(49);
   3807 
   3808 #           undef BZ_ITER
   3809 
   3810             cost[0] = cost01 & 0xffff; cost[1] = cost01 >> 16;
   3811             cost[2] = cost23 & 0xffff; cost[3] = cost23 >> 16;
   3812             cost[4] = cost45 & 0xffff; cost[5] = cost45 >> 16;
   3813 
   3814          } else {
   3815 	    /*--- slow version which correctly handles all situations ---*/
   3816             for (i = gs; i <= ge; i++) {
   3817                UInt16 icv = mtfv[i];
   3818                for (t = 0; t < nGroups; t++) cost[t] += s->len[t][icv];
   3819             }
   3820          }
   3821 
   3822          /*--
   3823             Find the coding table which is best for this group,
   3824             and record its identity in the selector table.
   3825          --*/
   3826          bc = 999999999; bt = -1;
   3827          for (t = 0; t < nGroups; t++)
   3828             if (cost[t] < bc) { bc = cost[t]; bt = t; };
   3829          totc += bc;
   3830          fave[bt]++;
   3831          s->selector[nSelectors] = bt;
   3832          nSelectors++;
   3833 
   3834          /*--
   3835             Increment the symbol frequencies for the selected table.
   3836           --*/
   3837          if (nGroups == 6 && 50 == ge-gs+1) {
   3838             /*--- fast track the common case ---*/
   3839 
   3840 #           define BZ_ITUR(nn) s->rfreq[bt][ mtfv[gs+(nn)] ]++
   3841 
   3842             BZ_ITUR(0);  BZ_ITUR(1);  BZ_ITUR(2);  BZ_ITUR(3);  BZ_ITUR(4);
   3843             BZ_ITUR(5);  BZ_ITUR(6);  BZ_ITUR(7);  BZ_ITUR(8);  BZ_ITUR(9);
   3844             BZ_ITUR(10); BZ_ITUR(11); BZ_ITUR(12); BZ_ITUR(13); BZ_ITUR(14);
   3845             BZ_ITUR(15); BZ_ITUR(16); BZ_ITUR(17); BZ_ITUR(18); BZ_ITUR(19);
   3846             BZ_ITUR(20); BZ_ITUR(21); BZ_ITUR(22); BZ_ITUR(23); BZ_ITUR(24);
   3847             BZ_ITUR(25); BZ_ITUR(26); BZ_ITUR(27); BZ_ITUR(28); BZ_ITUR(29);
   3848             BZ_ITUR(30); BZ_ITUR(31); BZ_ITUR(32); BZ_ITUR(33); BZ_ITUR(34);
   3849             BZ_ITUR(35); BZ_ITUR(36); BZ_ITUR(37); BZ_ITUR(38); BZ_ITUR(39);
   3850             BZ_ITUR(40); BZ_ITUR(41); BZ_ITUR(42); BZ_ITUR(43); BZ_ITUR(44);
   3851             BZ_ITUR(45); BZ_ITUR(46); BZ_ITUR(47); BZ_ITUR(48); BZ_ITUR(49);
   3852 
   3853 #           undef BZ_ITUR
   3854 
   3855          } else {
   3856 	    /*--- slow version which correctly handles all situations ---*/
   3857             for (i = gs; i <= ge; i++)
   3858                s->rfreq[bt][ mtfv[i] ]++;
   3859          }
   3860 
   3861          gs = ge+1;
   3862       }
   3863       if (s->verbosity >= 3) {
   3864          VPrintf2 ( "      pass %d: size is %d, grp uses are ",
   3865                    iter+1, totc/8 );
   3866          for (t = 0; t < nGroups; t++)
   3867             VPrintf1 ( "%d ", fave[t] );
   3868          VPrintf0 ( "\n" );
   3869       }
   3870 
   3871       /*--
   3872         Recompute the tables based on the accumulated frequencies.
   3873       --*/
   3874       /* maxLen was changed from 20 to 17 in bzip2-1.0.3.  See
   3875          comment in huffman.c for details. */
   3876       for (t = 0; t < nGroups; t++)
   3877          BZ2_hbMakeCodeLengths ( &(s->len[t][0]), &(s->rfreq[t][0]),
   3878                                  alphaSize, 17 /*20*/ );
   3879    }
   3880 
   3881 
   3882    AssertH( nGroups < 8, 3002 );
   3883    AssertH( nSelectors < 32768 &&
   3884             nSelectors <= (2 + (900000 / BZ_G_SIZE)),
   3885             3003 );
   3886 
   3887 
   3888    /*--- Compute MTF values for the selectors. ---*/
   3889    {
   3890       UChar pos[BZ_N_GROUPS], ll_i, tmp2, tmp;
   3891       for (i = 0; i < nGroups; i++) pos[i] = i;
   3892       for (i = 0; i < nSelectors; i++) {
   3893          ll_i = s->selector[i];
   3894          j = 0;
   3895          tmp = pos[j];
   3896          while ( ll_i != tmp ) {
   3897             j++;
   3898             tmp2 = tmp;
   3899             tmp = pos[j];
   3900             pos[j] = tmp2;
   3901          };
   3902          pos[0] = tmp;
   3903          s->selectorMtf[i] = j;
   3904       }
   3905    };
   3906 
   3907    /*--- Assign actual codes for the tables. --*/
   3908    for (t = 0; t < nGroups; t++) {
   3909       minLen = 32;
   3910       maxLen = 0;
   3911       for (i = 0; i < alphaSize; i++) {
   3912          if (s->len[t][i] > maxLen) maxLen = s->len[t][i];
   3913          if (s->len[t][i] < minLen) minLen = s->len[t][i];
   3914       }
   3915       AssertH ( !(maxLen > 17 /*20*/ ), 3004 );
   3916       AssertH ( !(minLen < 1),  3005 );
   3917       BZ2_hbAssignCodes ( &(s->code[t][0]), &(s->len[t][0]),
   3918                           minLen, maxLen, alphaSize );
   3919    }
   3920 
   3921    /*--- Transmit the mapping table. ---*/
   3922    {
   3923       Bool inUse16[16];
   3924       for (i = 0; i < 16; i++) {
   3925           inUse16[i] = False;
   3926           for (j = 0; j < 16; j++)
   3927              if (s->inUse[i * 16 + j]) inUse16[i] = True;
   3928       }
   3929 
   3930       nBytes = s->numZ;
   3931       for (i = 0; i < 16; i++)
   3932          if (inUse16[i]) bsW(s,1,1); else bsW(s,1,0);
   3933 
   3934       for (i = 0; i < 16; i++)
   3935          if (inUse16[i])
   3936             for (j = 0; j < 16; j++) {
   3937                if (s->inUse[i * 16 + j]) bsW(s,1,1); else bsW(s,1,0);
   3938             }
   3939 
   3940       if (s->verbosity >= 3)
   3941          VPrintf1( "      bytes: mapping %d, ", s->numZ-nBytes );
   3942    }
   3943 
   3944    /*--- Now the selectors. ---*/
   3945    nBytes = s->numZ;
   3946    bsW ( s, 3, nGroups );
   3947    bsW ( s, 15, nSelectors );
   3948    for (i = 0; i < nSelectors; i++) {
   3949       for (j = 0; j < s->selectorMtf[i]; j++) bsW(s,1,1);
   3950       bsW(s,1,0);
   3951    }
   3952    if (s->verbosity >= 3)
   3953       VPrintf1( "selectors %d, ", s->numZ-nBytes );
   3954 
   3955    /*--- Now the coding tables. ---*/
   3956    nBytes = s->numZ;
   3957 
   3958    for (t = 0; t < nGroups; t++) {
   3959       Int32 curr = s->len[t][0];
   3960       bsW ( s, 5, curr );
   3961       for (i = 0; i < alphaSize; i++) {
   3962          while (curr < s->len[t][i]) { bsW(s,2,2); curr++; /* 10 */ };
   3963          while (curr > s->len[t][i]) { bsW(s,2,3); curr--; /* 11 */ };
   3964          bsW ( s, 1, 0 );
   3965       }
   3966    }
   3967 
   3968    if (s->verbosity >= 3)
   3969       VPrintf1 ( "code lengths %d, ", s->numZ-nBytes );
   3970 
   3971    /*--- And finally, the block data proper ---*/
   3972    nBytes = s->numZ;
   3973    selCtr = 0;
   3974    gs = 0;
   3975    while (True) {
   3976       if (gs >= s->nMTF) break;
   3977       ge = gs + BZ_G_SIZE - 1;
   3978       if (ge >= s->nMTF) ge = s->nMTF-1;
   3979       AssertH ( s->selector[selCtr] < nGroups, 3006 );
   3980 
   3981       if (nGroups == 6 && 50 == ge-gs+1) {
   3982             /*--- fast track the common case ---*/
   3983             UInt16 mtfv_i;
   3984             UChar* s_len_sel_selCtr
   3985                = &(s->len[s->selector[selCtr]][0]);
   3986             Int32* s_code_sel_selCtr
   3987                = &(s->code[s->selector[selCtr]][0]);
   3988 
   3989 #           define BZ_ITAH(nn)                      \
   3990                mtfv_i = mtfv[gs+(nn)];              \
   3991                bsW ( s,                             \
   3992                      s_len_sel_selCtr[mtfv_i],      \
   3993                      s_code_sel_selCtr[mtfv_i] )
   3994 
   3995             BZ_ITAH(0);  BZ_ITAH(1);  BZ_ITAH(2);  BZ_ITAH(3);  BZ_ITAH(4);
   3996             BZ_ITAH(5);  BZ_ITAH(6);  BZ_ITAH(7);  BZ_ITAH(8);  BZ_ITAH(9);
   3997             BZ_ITAH(10); BZ_ITAH(11); BZ_ITAH(12); BZ_ITAH(13); BZ_ITAH(14);
   3998             BZ_ITAH(15); BZ_ITAH(16); BZ_ITAH(17); BZ_ITAH(18); BZ_ITAH(19);
   3999             BZ_ITAH(20); BZ_ITAH(21); BZ_ITAH(22); BZ_ITAH(23); BZ_ITAH(24);
   4000             BZ_ITAH(25); BZ_ITAH(26); BZ_ITAH(27); BZ_ITAH(28); BZ_ITAH(29);
   4001             BZ_ITAH(30); BZ_ITAH(31); BZ_ITAH(32); BZ_ITAH(33); BZ_ITAH(34);
   4002             BZ_ITAH(35); BZ_ITAH(36); BZ_ITAH(37); BZ_ITAH(38); BZ_ITAH(39);
   4003             BZ_ITAH(40); BZ_ITAH(41); BZ_ITAH(42); BZ_ITAH(43); BZ_ITAH(44);
   4004             BZ_ITAH(45); BZ_ITAH(46); BZ_ITAH(47); BZ_ITAH(48); BZ_ITAH(49);
   4005 
   4006 #           undef BZ_ITAH
   4007 
   4008       } else {
   4009 	 /*--- slow version which correctly handles all situations ---*/
   4010          for (i = gs; i <= ge; i++) {
   4011             bsW ( s,
   4012                   s->len  [s->selector[selCtr]] [mtfv[i]],
   4013                   s->code [s->selector[selCtr]] [mtfv[i]] );
   4014          }
   4015       }
   4016 
   4017 
   4018       gs = ge+1;
   4019       selCtr++;
   4020    }
   4021    AssertH( selCtr == nSelectors, 3007 );
   4022 
   4023    if (s->verbosity >= 3)
   4024       VPrintf1( "codes %d\n", s->numZ-nBytes );
   4025 }
   4026 
   4027 
   4028 /*---------------------------------------------------*/
   4029 void BZ2_compressBlock ( EState* s, Bool is_last_block )
   4030 {
   4031    if (s->nblock > 0) {
   4032 
   4033       BZ_FINALISE_CRC ( s->blockCRC );
   4034       s->combinedCRC = (s->combinedCRC << 1) | (s->combinedCRC >> 31);
   4035       s->combinedCRC ^= s->blockCRC;
   4036       if (s->blockNo > 1) s->numZ = 0;
   4037 
   4038       if (s->verbosity >= 2)
   4039          VPrintf4( "    block %d: crc = 0x%08x, "
   4040                    "combined CRC = 0x%08x, size = %d\n",
   4041                    s->blockNo, s->blockCRC, s->combinedCRC, s->nblock );
   4042 
   4043       BZ2_blockSort ( s );
   4044    }
   4045 
   4046    s->zbits = (UChar*) (&((UChar*)s->arr2)[s->nblock]);
   4047 
   4048    /*-- If this is the first block, create the stream header. --*/
   4049    if (s->blockNo == 1) {
   4050       BZ2_bsInitWrite ( s );
   4051       bsPutUChar ( s, BZ_HDR_B );
   4052       bsPutUChar ( s, BZ_HDR_Z );
   4053       bsPutUChar ( s, BZ_HDR_h );
   4054       bsPutUChar ( s, (UChar)(BZ_HDR_0 + s->blockSize100k) );
   4055    }
   4056 
   4057    if (s->nblock > 0) {
   4058 
   4059       bsPutUChar ( s, 0x31 ); bsPutUChar ( s, 0x41 );
   4060       bsPutUChar ( s, 0x59 ); bsPutUChar ( s, 0x26 );
   4061       bsPutUChar ( s, 0x53 ); bsPutUChar ( s, 0x59 );
   4062 
   4063       /*-- Now the block's CRC, so it is in a known place. --*/
   4064       bsPutUInt32 ( s, s->blockCRC );
   4065 
   4066       /*--
   4067          Now a single bit indicating (non-)randomisation.
   4068          As of version 0.9.5, we use a better sorting algorithm
   4069          which makes randomisation unnecessary.  So always set
   4070          the randomised bit to 'no'.  Of course, the decoder
   4071          still needs to be able to handle randomised blocks
   4072          so as to maintain backwards compatibility with
   4073          older versions of bzip2.
   4074       --*/
   4075       bsW(s,1,0);
   4076 
   4077       bsW ( s, 24, s->origPtr );
   4078       generateMTFValues ( s );
   4079       sendMTFValues ( s );
   4080    }
   4081 
   4082 
   4083    /*-- If this is the last block, add the stream trailer. --*/
   4084    if (is_last_block) {
   4085 
   4086       bsPutUChar ( s, 0x17 ); bsPutUChar ( s, 0x72 );
   4087       bsPutUChar ( s, 0x45 ); bsPutUChar ( s, 0x38 );
   4088       bsPutUChar ( s, 0x50 ); bsPutUChar ( s, 0x90 );
   4089       bsPutUInt32 ( s, s->combinedCRC );
   4090       if (s->verbosity >= 2)
   4091          VPrintf1( "    final combined CRC = 0x%08x\n   ", s->combinedCRC );
   4092       bsFinishWrite ( s );
   4093    }
   4094 }
   4095 
   4096 
   4097 /*-------------------------------------------------------------*/
   4098 /*--- end                                        compress.c ---*/
   4099 /*-------------------------------------------------------------*/
   4100 
   4101 
   4102 /*-------------------------------------------------------------*/
   4103 /*--- Table for randomising repetitive blocks               ---*/
   4104 /*---                                           randtable.c ---*/
   4105 /*-------------------------------------------------------------*/
   4106 
   4107 /*--
   4108   This file is a part of bzip2 and/or libbzip2, a program and
   4109   library for lossless, block-sorting data compression.
   4110 
   4111   Copyright (C) 1996-2004 Julian R Seward.  All rights reserved.
   4112 
   4113   Redistribution and use in source and binary forms, with or without
   4114   modification, are permitted provided that the following conditions
   4115   are met:
   4116 
   4117   1. Redistributions of source code must retain the above copyright
   4118      notice, this list of conditions and the following disclaimer.
   4119 
   4120   2. The origin of this software must not be misrepresented; you must
   4121      not claim that you wrote the original software.  If you use this
   4122      software in a product, an acknowledgment in the product
   4123      documentation would be appreciated but is not required.
   4124 
   4125   3. Altered source versions must be plainly marked as such, and must
   4126      not be misrepresented as being the original software.
   4127 
   4128   4. The name of the author may not be used to endorse or promote
   4129      products derived from this software without specific prior written
   4130      permission.
   4131 
   4132   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
   4133   OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   4134   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   4135   ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
   4136   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   4137   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
   4138   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   4139   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   4140   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   4141   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   4142   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   4143 
   4144   Julian Seward, Cambridge, UK.
   4145   jseward (at) bzip.org
   4146   bzip2/libbzip2 version 1.0 of 21 March 2000
   4147 
   4148   This program is based on (at least) the work of:
   4149      Mike Burrows
   4150      David Wheeler
   4151      Peter Fenwick
   4152      Alistair Moffat
   4153      Radford Neal
   4154      Ian H. Witten
   4155      Robert Sedgewick
   4156      Jon L. Bentley
   4157 
   4158   For more information on these sources, see the manual.
   4159 --*/
   4160 
   4161 
   4162 
   4163 
   4164 /*---------------------------------------------*/
   4165 Int32 BZ2_rNums[512] = {
   4166    619, 720, 127, 481, 931, 816, 813, 233, 566, 247,
   4167    985, 724, 205, 454, 863, 491, 741, 242, 949, 214,
   4168    733, 859, 335, 708, 621, 574, 73, 654, 730, 472,
   4169    419, 436, 278, 496, 867, 210, 399, 680, 480, 51,
   4170    878, 465, 811, 169, 869, 675, 611, 697, 867, 561,
   4171    862, 687, 507, 283, 482, 129, 807, 591, 733, 623,
   4172    150, 238, 59, 379, 684, 877, 625, 169, 643, 105,
   4173    170, 607, 520, 932, 727, 476, 693, 425, 174, 647,
   4174    73, 122, 335, 530, 442, 853, 695, 249, 445, 515,
   4175    909, 545, 703, 919, 874, 474, 882, 500, 594, 612,
   4176    641, 801, 220, 162, 819, 984, 589, 513, 495, 799,
   4177    161, 604, 958, 533, 221, 400, 386, 867, 600, 782,
   4178    382, 596, 414, 171, 516, 375, 682, 485, 911, 276,
   4179    98, 553, 163, 354, 666, 933, 424, 341, 533, 870,
   4180    227, 730, 475, 186, 263, 647, 537, 686, 600, 224,
   4181    469, 68, 770, 919, 190, 373, 294, 822, 808, 206,
   4182    184, 943, 795, 384, 383, 461, 404, 758, 839, 887,
   4183    715, 67, 618, 276, 204, 918, 873, 777, 604, 560,
   4184    951, 160, 578, 722, 79, 804, 96, 409, 713, 940,
   4185    652, 934, 970, 447, 318, 353, 859, 672, 112, 785,
   4186    645, 863, 803, 350, 139, 93, 354, 99, 820, 908,
   4187    609, 772, 154, 274, 580, 184, 79, 626, 630, 742,
   4188    653, 282, 762, 623, 680, 81, 927, 626, 789, 125,
   4189    411, 521, 938, 300, 821, 78, 343, 175, 128, 250,
   4190    170, 774, 972, 275, 999, 639, 495, 78, 352, 126,
   4191    857, 956, 358, 619, 580, 124, 737, 594, 701, 612,
   4192    669, 112, 134, 694, 363, 992, 809, 743, 168, 974,
   4193    944, 375, 748, 52, 600, 747, 642, 182, 862, 81,
   4194    344, 805, 988, 739, 511, 655, 814, 334, 249, 515,
   4195    897, 955, 664, 981, 649, 113, 974, 459, 893, 228,
   4196    433, 837, 553, 268, 926, 240, 102, 654, 459, 51,
   4197    686, 754, 806, 760, 493, 403, 415, 394, 687, 700,
   4198    946, 670, 656, 610, 738, 392, 760, 799, 887, 653,
   4199    978, 321, 576, 617, 626, 502, 894, 679, 243, 440,
   4200    680, 879, 194, 572, 640, 724, 926, 56, 204, 700,
   4201    707, 151, 457, 449, 797, 195, 791, 558, 945, 679,
   4202    297, 59, 87, 824, 713, 663, 412, 693, 342, 606,
   4203    134, 108, 571, 364, 631, 212, 174, 643, 304, 329,
   4204    343, 97, 430, 751, 497, 314, 983, 374, 822, 928,
   4205    140, 206, 73, 263, 980, 736, 876, 478, 430, 305,
   4206    170, 514, 364, 692, 829, 82, 855, 953, 676, 246,
   4207    369, 970, 294, 750, 807, 827, 150, 790, 288, 923,
   4208    804, 378, 215, 828, 592, 281, 565, 555, 710, 82,
   4209    896, 831, 547, 261, 524, 462, 293, 465, 502, 56,
   4210    661, 821, 976, 991, 658, 869, 905, 758, 745, 193,
   4211    768, 550, 608, 933, 378, 286, 215, 979, 792, 961,
   4212    61, 688, 793, 644, 986, 403, 106, 366, 905, 644,
   4213    372, 567, 466, 434, 645, 210, 389, 550, 919, 135,
   4214    780, 773, 635, 389, 707, 100, 626, 958, 165, 504,
   4215    920, 176, 193, 713, 857, 265, 203, 50, 668, 108,
   4216    645, 990, 626, 197, 510, 357, 358, 850, 858, 364,
   4217    936, 638
   4218 };
   4219 
   4220 
   4221 /*-------------------------------------------------------------*/
   4222 /*--- end                                       randtable.c ---*/
   4223 /*-------------------------------------------------------------*/
   4224 
   4225 /*-------------------------------------------------------------*/
   4226 /*--- Table for doing CRCs                                  ---*/
   4227 /*---                                            crctable.c ---*/
   4228 /*-------------------------------------------------------------*/
   4229 
   4230 /*--
   4231   This file is a part of bzip2 and/or libbzip2, a program and
   4232   library for lossless, block-sorting data compression.
   4233 
   4234   Copyright (C) 1996-2004 Julian R Seward.  All rights reserved.
   4235 
   4236   Redistribution and use in source and binary forms, with or without
   4237   modification, are permitted provided that the following conditions
   4238   are met:
   4239 
   4240   1. Redistributions of source code must retain the above copyright
   4241      notice, this list of conditions and the following disclaimer.
   4242 
   4243   2. The origin of this software must not be misrepresented; you must
   4244      not claim that you wrote the original software.  If you use this
   4245      software in a product, an acknowledgment in the product
   4246      documentation would be appreciated but is not required.
   4247 
   4248   3. Altered source versions must be plainly marked as such, and must
   4249      not be misrepresented as being the original software.
   4250 
   4251   4. The name of the author may not be used to endorse or promote
   4252      products derived from this software without specific prior written
   4253      permission.
   4254 
   4255   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
   4256   OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   4257   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   4258   ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
   4259   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   4260   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
   4261   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   4262   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   4263   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   4264   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   4265   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   4266 
   4267   Julian Seward, Cambridge, UK.
   4268   jseward (at) bzip.org
   4269   bzip2/libbzip2 version 1.0 of 21 March 2000
   4270 
   4271   This program is based on (at least) the work of:
   4272      Mike Burrows
   4273      David Wheeler
   4274      Peter Fenwick
   4275      Alistair Moffat
   4276      Radford Neal
   4277      Ian H. Witten
   4278      Robert Sedgewick
   4279      Jon L. Bentley
   4280 
   4281   For more information on these sources, see the manual.
   4282 --*/
   4283 
   4284 
   4285 
   4286 
   4287 
   4288 /*--
   4289   I think this is an implementation of the AUTODIN-II,
   4290   Ethernet & FDDI 32-bit CRC standard.  Vaguely derived
   4291   from code by Rob Warnock, in Section 51 of the
   4292   comp.compression FAQ.
   4293 --*/
   4294 
   4295 UInt32 BZ2_crc32Table[256] = {
   4296 
   4297    /*-- Ugly, innit? --*/
   4298 
   4299    0x00000000L, 0x04c11db7L, 0x09823b6eL, 0x0d4326d9L,
   4300    0x130476dcL, 0x17c56b6bL, 0x1a864db2L, 0x1e475005L,
   4301    0x2608edb8L, 0x22c9f00fL, 0x2f8ad6d6L, 0x2b4bcb61L,
   4302    0x350c9b64L, 0x31cd86d3L, 0x3c8ea00aL, 0x384fbdbdL,
   4303    0x4c11db70L, 0x48d0c6c7L, 0x4593e01eL, 0x4152fda9L,
   4304    0x5f15adacL, 0x5bd4b01bL, 0x569796c2L, 0x52568b75L,
   4305    0x6a1936c8L, 0x6ed82b7fL, 0x639b0da6L, 0x675a1011L,
   4306    0x791d4014L, 0x7ddc5da3L, 0x709f7b7aL, 0x745e66cdL,
   4307    0x9823b6e0L, 0x9ce2ab57L, 0x91a18d8eL, 0x95609039L,
   4308    0x8b27c03cL, 0x8fe6dd8bL, 0x82a5fb52L, 0x8664e6e5L,
   4309    0xbe2b5b58L, 0xbaea46efL, 0xb7a96036L, 0xb3687d81L,
   4310    0xad2f2d84L, 0xa9ee3033L, 0xa4ad16eaL, 0xa06c0b5dL,
   4311    0xd4326d90L, 0xd0f37027L, 0xddb056feL, 0xd9714b49L,
   4312    0xc7361b4cL, 0xc3f706fbL, 0xceb42022L, 0xca753d95L,
   4313    0xf23a8028L, 0xf6fb9d9fL, 0xfbb8bb46L, 0xff79a6f1L,
   4314    0xe13ef6f4L, 0xe5ffeb43L, 0xe8bccd9aL, 0xec7dd02dL,
   4315    0x34867077L, 0x30476dc0L, 0x3d044b19L, 0x39c556aeL,
   4316    0x278206abL, 0x23431b1cL, 0x2e003dc5L, 0x2ac12072L,
   4317    0x128e9dcfL, 0x164f8078L, 0x1b0ca6a1L, 0x1fcdbb16L,
   4318    0x018aeb13L, 0x054bf6a4L, 0x0808d07dL, 0x0cc9cdcaL,
   4319    0x7897ab07L, 0x7c56b6b0L, 0x71159069L, 0x75d48ddeL,
   4320    0x6b93dddbL, 0x6f52c06cL, 0x6211e6b5L, 0x66d0fb02L,
   4321    0x5e9f46bfL, 0x5a5e5b08L, 0x571d7dd1L, 0x53dc6066L,
   4322    0x4d9b3063L, 0x495a2dd4L, 0x44190b0dL, 0x40d816baL,
   4323    0xaca5c697L, 0xa864db20L, 0xa527fdf9L, 0xa1e6e04eL,
   4324    0xbfa1b04bL, 0xbb60adfcL, 0xb6238b25L, 0xb2e29692L,
   4325    0x8aad2b2fL, 0x8e6c3698L, 0x832f1041L, 0x87ee0df6L,
   4326    0x99a95df3L, 0x9d684044L, 0x902b669dL, 0x94ea7b2aL,
   4327    0xe0b41de7L, 0xe4750050L, 0xe9362689L, 0xedf73b3eL,
   4328    0xf3b06b3bL, 0xf771768cL, 0xfa325055L, 0xfef34de2L,
   4329    0xc6bcf05fL, 0xc27dede8L, 0xcf3ecb31L, 0xcbffd686L,
   4330    0xd5b88683L, 0xd1799b34L, 0xdc3abdedL, 0xd8fba05aL,
   4331    0x690ce0eeL, 0x6dcdfd59L, 0x608edb80L, 0x644fc637L,
   4332    0x7a089632L, 0x7ec98b85L, 0x738aad5cL, 0x774bb0ebL,
   4333    0x4f040d56L, 0x4bc510e1L, 0x46863638L, 0x42472b8fL,
   4334    0x5c007b8aL, 0x58c1663dL, 0x558240e4L, 0x51435d53L,
   4335    0x251d3b9eL, 0x21dc2629L, 0x2c9f00f0L, 0x285e1d47L,
   4336    0x36194d42L, 0x32d850f5L, 0x3f9b762cL, 0x3b5a6b9bL,
   4337    0x0315d626L, 0x07d4cb91L, 0x0a97ed48L, 0x0e56f0ffL,
   4338    0x1011a0faL, 0x14d0bd4dL, 0x19939b94L, 0x1d528623L,
   4339    0xf12f560eL, 0xf5ee4bb9L, 0xf8ad6d60L, 0xfc6c70d7L,
   4340    0xe22b20d2L, 0xe6ea3d65L, 0xeba91bbcL, 0xef68060bL,
   4341    0xd727bbb6L, 0xd3e6a601L, 0xdea580d8L, 0xda649d6fL,
   4342    0xc423cd6aL, 0xc0e2d0ddL, 0xcda1f604L, 0xc960ebb3L,
   4343    0xbd3e8d7eL, 0xb9ff90c9L, 0xb4bcb610L, 0xb07daba7L,
   4344    0xae3afba2L, 0xaafbe615L, 0xa7b8c0ccL, 0xa379dd7bL,
   4345    0x9b3660c6L, 0x9ff77d71L, 0x92b45ba8L, 0x9675461fL,
   4346    0x8832161aL, 0x8cf30badL, 0x81b02d74L, 0x857130c3L,
   4347    0x5d8a9099L, 0x594b8d2eL, 0x5408abf7L, 0x50c9b640L,
   4348    0x4e8ee645L, 0x4a4ffbf2L, 0x470cdd2bL, 0x43cdc09cL,
   4349    0x7b827d21L, 0x7f436096L, 0x7200464fL, 0x76c15bf8L,
   4350    0x68860bfdL, 0x6c47164aL, 0x61043093L, 0x65c52d24L,
   4351    0x119b4be9L, 0x155a565eL, 0x18197087L, 0x1cd86d30L,
   4352    0x029f3d35L, 0x065e2082L, 0x0b1d065bL, 0x0fdc1becL,
   4353    0x3793a651L, 0x3352bbe6L, 0x3e119d3fL, 0x3ad08088L,
   4354    0x2497d08dL, 0x2056cd3aL, 0x2d15ebe3L, 0x29d4f654L,
   4355    0xc5a92679L, 0xc1683bceL, 0xcc2b1d17L, 0xc8ea00a0L,
   4356    0xd6ad50a5L, 0xd26c4d12L, 0xdf2f6bcbL, 0xdbee767cL,
   4357    0xe3a1cbc1L, 0xe760d676L, 0xea23f0afL, 0xeee2ed18L,
   4358    0xf0a5bd1dL, 0xf464a0aaL, 0xf9278673L, 0xfde69bc4L,
   4359    0x89b8fd09L, 0x8d79e0beL, 0x803ac667L, 0x84fbdbd0L,
   4360    0x9abc8bd5L, 0x9e7d9662L, 0x933eb0bbL, 0x97ffad0cL,
   4361    0xafb010b1L, 0xab710d06L, 0xa6322bdfL, 0xa2f33668L,
   4362    0xbcb4666dL, 0xb8757bdaL, 0xb5365d03L, 0xb1f740b4L
   4363 };
   4364 
   4365 
   4366 /*-------------------------------------------------------------*/
   4367 /*--- end                                        crctable.c ---*/
   4368 /*-------------------------------------------------------------*/
   4369 
   4370 /*-------------------------------------------------------------*/
   4371 /*--- Library top-level functions.                          ---*/
   4372 /*---                                               bzlib.c ---*/
   4373 /*-------------------------------------------------------------*/
   4374 
   4375 /*--
   4376   This file is a part of bzip2 and/or libbzip2, a program and
   4377   library for lossless, block-sorting data compression.
   4378 
   4379   Copyright (C) 1996-2004 Julian R Seward.  All rights reserved.
   4380 
   4381   Redistribution and use in source and binary forms, with or without
   4382   modification, are permitted provided that the following conditions
   4383   are met:
   4384 
   4385   1. Redistributions of source code must retain the above copyright
   4386      notice, this list of conditions and the following disclaimer.
   4387 
   4388   2. The origin of this software must not be misrepresented; you must
   4389      not claim that you wrote the original software.  If you use this
   4390      software in a product, an acknowledgment in the product
   4391      documentation would be appreciated but is not required.
   4392 
   4393   3. Altered source versions must be plainly marked as such, and must
   4394      not be misrepresented as being the original software.
   4395 
   4396   4. The name of the author may not be used to endorse or promote
   4397      products derived from this software without specific prior written
   4398      permission.
   4399 
   4400   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
   4401   OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   4402   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   4403   ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
   4404   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   4405   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
   4406   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   4407   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   4408   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   4409   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   4410   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   4411 
   4412   Julian Seward, Cambridge, UK.
   4413   jseward (at) bzip.org
   4414   bzip2/libbzip2 version 1.0 of 21 March 2000
   4415 
   4416   This program is based on (at least) the work of:
   4417      Mike Burrows
   4418      David Wheeler
   4419      Peter Fenwick
   4420      Alistair Moffat
   4421      Radford Neal
   4422      Ian H. Witten
   4423      Robert Sedgewick
   4424      Jon L. Bentley
   4425 
   4426   For more information on these sources, see the manual.
   4427 --*/
   4428 
   4429 /*--
   4430    CHANGES
   4431    ~~~~~~~
   4432    0.9.0 -- original version.
   4433 
   4434    0.9.0a/b -- no changes in this file.
   4435 
   4436    0.9.0c
   4437       * made zero-length BZ_FLUSH work correctly in bzCompress().
   4438       * fixed bzWrite/bzRead to ignore zero-length requests.
   4439       * fixed bzread to correctly handle read requests after EOF.
   4440       * wrong parameter order in call to bzDecompressInit in
   4441         bzBuffToBuffDecompress.  Fixed.
   4442 --*/
   4443 
   4444 
   4445 
   4446 /*---------------------------------------------------*/
   4447 /*--- Compression stuff                           ---*/
   4448 /*---------------------------------------------------*/
   4449 
   4450 
   4451 /*---------------------------------------------------*/
   4452 void BZ2_bz__AssertH__fail ( int errcode )
   4453 {
   4454    vex_printf("BZ2_bz__AssertH__fail(%d) called, exiting\n", errcode);
   4455    (*serviceFn)(0,0);
   4456 }
   4457 
   4458 void bz_internal_error ( int errcode )
   4459 {
   4460    vex_printf("bz_internal_error called, exiting\n", errcode);
   4461    (*serviceFn)(0,0);
   4462 }
   4463 
   4464 /*---------------------------------------------------*/
   4465 static
   4466 int bz_config_ok ( void )
   4467 {
   4468    if (sizeof(int)   != 4) return 0;
   4469    if (sizeof(short) != 2) return 0;
   4470    if (sizeof(char)  != 1) return 0;
   4471    return 1;
   4472 }
   4473 
   4474 
   4475 /*---------------------------------------------------*/
   4476 static
   4477 void* default_bzalloc ( void* opaque, Int32 items, Int32 size )
   4478 {
   4479    void* v = (void*) (*serviceFn)(2, items * size );
   4480    return v;
   4481 }
   4482 
   4483 static
   4484 void default_bzfree ( void* opaque, void* addr )
   4485 {
   4486    if (addr != NULL) (*serviceFn)( 3, (HWord)addr );
   4487 }
   4488 
   4489 
   4490 /*---------------------------------------------------*/
   4491 static
   4492 void prepare_new_block ( EState* s )
   4493 {
   4494    Int32 i;
   4495    s->nblock = 0;
   4496    s->numZ = 0;
   4497    s->state_out_pos = 0;
   4498    BZ_INITIALISE_CRC ( s->blockCRC );
   4499    for (i = 0; i < 256; i++) s->inUse[i] = False;
   4500    s->blockNo++;
   4501 }
   4502 
   4503 
   4504 /*---------------------------------------------------*/
   4505 static
   4506 void init_RL ( EState* s )
   4507 {
   4508    s->state_in_ch  = 256;
   4509    s->state_in_len = 0;
   4510 }
   4511 
   4512 
   4513 static
   4514 Bool isempty_RL ( EState* s )
   4515 {
   4516    if (s->state_in_ch < 256 && s->state_in_len > 0)
   4517       return False; else
   4518       return True;
   4519 }
   4520 
   4521 
   4522 /*---------------------------------------------------*/
   4523 int BZ_API(BZ2_bzCompressInit)
   4524                     ( bz_stream* strm,
   4525                      int        blockSize100k,
   4526                      int        verbosity,
   4527                      int        workFactor )
   4528 {
   4529    Int32   n;
   4530    EState* s;
   4531 
   4532    if (!bz_config_ok()) return BZ_CONFIG_ERROR;
   4533 
   4534    if (strm == NULL ||
   4535        blockSize100k < 1 || blockSize100k > 9 ||
   4536        workFactor < 0 || workFactor > 250)
   4537      return BZ_PARAM_ERROR;
   4538 
   4539    if (workFactor == 0) workFactor = 30;
   4540    if (strm->bzalloc == NULL) strm->bzalloc = default_bzalloc;
   4541    if (strm->bzfree == NULL) strm->bzfree = default_bzfree;
   4542 
   4543    s = BZALLOC( sizeof(EState) );
   4544    if (s == NULL) return BZ_MEM_ERROR;
   4545    s->strm = strm;
   4546 
   4547    s->arr1 = NULL;
   4548    s->arr2 = NULL;
   4549    s->ftab = NULL;
   4550 
   4551    n       = 100000 * blockSize100k;
   4552    s->arr1 = BZALLOC( n                  * sizeof(UInt32) );
   4553    s->arr2 = BZALLOC( (n+BZ_N_OVERSHOOT) * sizeof(UInt32) );
   4554    s->ftab = BZALLOC( 65537              * sizeof(UInt32) );
   4555 
   4556    if (s->arr1 == NULL || s->arr2 == NULL || s->ftab == NULL) {
   4557       if (s->arr1 != NULL) BZFREE(s->arr1);
   4558       if (s->arr2 != NULL) BZFREE(s->arr2);
   4559       if (s->ftab != NULL) BZFREE(s->ftab);
   4560       if (s       != NULL) BZFREE(s);
   4561       return BZ_MEM_ERROR;
   4562    }
   4563 
   4564    s->blockNo           = 0;
   4565    s->state             = BZ_S_INPUT;
   4566    s->mode              = BZ_M_RUNNING;
   4567    s->combinedCRC       = 0;
   4568    s->blockSize100k     = blockSize100k;
   4569    s->nblockMAX         = 100000 * blockSize100k - 19;
   4570    s->verbosity         = verbosity;
   4571    s->workFactor        = workFactor;
   4572 
   4573    s->block             = (UChar*)s->arr2;
   4574    s->mtfv              = (UInt16*)s->arr1;
   4575    s->zbits             = NULL;
   4576    s->ptr               = (UInt32*)s->arr1;
   4577 
   4578    strm->state          = s;
   4579    strm->total_in_lo32  = 0;
   4580    strm->total_in_hi32  = 0;
   4581    strm->total_out_lo32 = 0;
   4582    strm->total_out_hi32 = 0;
   4583    init_RL ( s );
   4584    prepare_new_block ( s );
   4585    return BZ_OK;
   4586 }
   4587 
   4588 
   4589 /*---------------------------------------------------*/
   4590 static
   4591 void add_pair_to_block ( EState* s )
   4592 {
   4593    Int32 i;
   4594    UChar ch = (UChar)(s->state_in_ch);
   4595    for (i = 0; i < s->state_in_len; i++) {
   4596       BZ_UPDATE_CRC( s->blockCRC, ch );
   4597    }
   4598    s->inUse[s->state_in_ch] = True;
   4599    switch (s->state_in_len) {
   4600       case 1:
   4601          s->block[s->nblock] = (UChar)ch; s->nblock++;
   4602          break;
   4603       case 2:
   4604          s->block[s->nblock] = (UChar)ch; s->nblock++;
   4605          s->block[s->nblock] = (UChar)ch; s->nblock++;
   4606          break;
   4607       case 3:
   4608          s->block[s->nblock] = (UChar)ch; s->nblock++;
   4609          s->block[s->nblock] = (UChar)ch; s->nblock++;
   4610          s->block[s->nblock] = (UChar)ch; s->nblock++;
   4611          break;
   4612       default:
   4613          s->inUse[s->state_in_len-4] = True;
   4614          s->block[s->nblock] = (UChar)ch; s->nblock++;
   4615          s->block[s->nblock] = (UChar)ch; s->nblock++;
   4616          s->block[s->nblock] = (UChar)ch; s->nblock++;
   4617          s->block[s->nblock] = (UChar)ch; s->nblock++;
   4618          s->block[s->nblock] = ((UChar)(s->state_in_len-4));
   4619          s->nblock++;
   4620          break;
   4621    }
   4622 }
   4623 
   4624 
   4625 /*---------------------------------------------------*/
   4626 static
   4627 void flush_RL ( EState* s )
   4628 {
   4629    if (s->state_in_ch < 256) add_pair_to_block ( s );
   4630    init_RL ( s );
   4631 }
   4632 
   4633 
   4634 /*---------------------------------------------------*/
   4635 #define ADD_CHAR_TO_BLOCK(zs,zchh0)               \
   4636 {                                                 \
   4637    UInt32 zchh = (UInt32)(zchh0);                 \
   4638    /*-- fast track the common case --*/           \
   4639    if (zchh != zs->state_in_ch &&                 \
   4640        zs->state_in_len == 1) {                   \
   4641       UChar ch = (UChar)(zs->state_in_ch);        \
   4642       BZ_UPDATE_CRC( zs->blockCRC, ch );          \
   4643       zs->inUse[zs->state_in_ch] = True;          \
   4644       zs->block[zs->nblock] = (UChar)ch;          \
   4645       zs->nblock++;                               \
   4646       zs->state_in_ch = zchh;                     \
   4647    }                                              \
   4648    else                                           \
   4649    /*-- general, uncommon cases --*/              \
   4650    if (zchh != zs->state_in_ch ||                 \
   4651       zs->state_in_len == 255) {                  \
   4652       if (zs->state_in_ch < 256)                  \
   4653          add_pair_to_block ( zs );                \
   4654       zs->state_in_ch = zchh;                     \
   4655       zs->state_in_len = 1;                       \
   4656    } else {                                       \
   4657       zs->state_in_len++;                         \
   4658    }                                              \
   4659 }
   4660 
   4661 
   4662 /*---------------------------------------------------*/
   4663 static
   4664 Bool copy_input_until_stop ( EState* s )
   4665 {
   4666    Bool progress_in = False;
   4667 
   4668    if (s->mode == BZ_M_RUNNING) {
   4669 
   4670       /*-- fast track the common case --*/
   4671       while (True) {
   4672          /*-- block full? --*/
   4673          if (s->nblock >= s->nblockMAX) break;
   4674          /*-- no input? --*/
   4675          if (s->strm->avail_in == 0) break;
   4676          progress_in = True;
   4677          ADD_CHAR_TO_BLOCK ( s, (UInt32)(*((UChar*)(s->strm->next_in))) );
   4678          s->strm->next_in++;
   4679          s->strm->avail_in--;
   4680          s->strm->total_in_lo32++;
   4681          if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++;
   4682       }
   4683 
   4684    } else {
   4685 
   4686       /*-- general, uncommon case --*/
   4687       while (True) {
   4688          /*-- block full? --*/
   4689          if (s->nblock >= s->nblockMAX) break;
   4690          /*-- no input? --*/
   4691          if (s->strm->avail_in == 0) break;
   4692          /*-- flush/finish end? --*/
   4693          if (s->avail_in_expect == 0) break;
   4694          progress_in = True;
   4695          ADD_CHAR_TO_BLOCK ( s, (UInt32)(*((UChar*)(s->strm->next_in))) );
   4696          s->strm->next_in++;
   4697          s->strm->avail_in--;
   4698          s->strm->total_in_lo32++;
   4699          if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++;
   4700          s->avail_in_expect--;
   4701       }
   4702    }
   4703    return progress_in;
   4704 }
   4705 
   4706 
   4707 /*---------------------------------------------------*/
   4708 static
   4709 Bool copy_output_until_stop ( EState* s )
   4710 {
   4711    Bool progress_out = False;
   4712 
   4713    while (True) {
   4714 
   4715       /*-- no output space? --*/
   4716       if (s->strm->avail_out == 0) break;
   4717 
   4718       /*-- block done? --*/
   4719       if (s->state_out_pos >= s->numZ) break;
   4720 
   4721       progress_out = True;
   4722       *(s->strm->next_out) = s->zbits[s->state_out_pos];
   4723       s->state_out_pos++;
   4724       s->strm->avail_out--;
   4725       s->strm->next_out++;
   4726       s->strm->total_out_lo32++;
   4727       if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
   4728    }
   4729 
   4730    return progress_out;
   4731 }
   4732 
   4733 
   4734 /*---------------------------------------------------*/
   4735 static
   4736 Bool handle_compress ( bz_stream* strm )
   4737 {
   4738    Bool progress_in  = False;
   4739    Bool progress_out = False;
   4740    EState* s = strm->state;
   4741 
   4742    while (True) {
   4743 
   4744       if (s->state == BZ_S_OUTPUT) {
   4745          progress_out |= copy_output_until_stop ( s );
   4746          if (s->state_out_pos < s->numZ) break;
   4747          if (s->mode == BZ_M_FINISHING &&
   4748              s->avail_in_expect == 0 &&
   4749              isempty_RL(s)) break;
   4750          prepare_new_block ( s );
   4751          s->state = BZ_S_INPUT;
   4752          if (s->mode == BZ_M_FLUSHING &&
   4753              s->avail_in_expect == 0 &&
   4754              isempty_RL(s)) break;
   4755       }
   4756 
   4757       if (s->state == BZ_S_INPUT) {
   4758          progress_in |= copy_input_until_stop ( s );
   4759          if (s->mode != BZ_M_RUNNING && s->avail_in_expect == 0) {
   4760             flush_RL ( s );
   4761             BZ2_compressBlock ( s, (Bool)(s->mode == BZ_M_FINISHING) );
   4762             s->state = BZ_S_OUTPUT;
   4763          }
   4764          else
   4765          if (s->nblock >= s->nblockMAX) {
   4766             BZ2_compressBlock ( s, False );
   4767             s->state = BZ_S_OUTPUT;
   4768          }
   4769          else
   4770          if (s->strm->avail_in == 0) {
   4771             break;
   4772          }
   4773       }
   4774 
   4775    }
   4776 
   4777    return progress_in || progress_out;
   4778 }
   4779 
   4780 
   4781 /*---------------------------------------------------*/
   4782 int BZ_API(BZ2_bzCompress) ( bz_stream *strm, int action )
   4783 {
   4784    Bool progress;
   4785    EState* s;
   4786    if (strm == NULL) return BZ_PARAM_ERROR;
   4787    s = strm->state;
   4788    if (s == NULL) return BZ_PARAM_ERROR;
   4789    if (s->strm != strm) return BZ_PARAM_ERROR;
   4790 
   4791    preswitch:
   4792    switch (s->mode) {
   4793 
   4794       case BZ_M_IDLE:
   4795          return BZ_SEQUENCE_ERROR;
   4796 
   4797       case BZ_M_RUNNING:
   4798          if (action == BZ_RUN) {
   4799             progress = handle_compress ( strm );
   4800             return progress ? BZ_RUN_OK : BZ_PARAM_ERROR;
   4801          }
   4802          else
   4803 	 if (action == BZ_FLUSH) {
   4804             s->avail_in_expect = strm->avail_in;
   4805             s->mode = BZ_M_FLUSHING;
   4806             goto preswitch;
   4807          }
   4808          else
   4809          if (action == BZ_FINISH) {
   4810             s->avail_in_expect = strm->avail_in;
   4811             s->mode = BZ_M_FINISHING;
   4812             goto preswitch;
   4813          }
   4814          else
   4815             return BZ_PARAM_ERROR;
   4816 
   4817       case BZ_M_FLUSHING:
   4818          if (action != BZ_FLUSH) return BZ_SEQUENCE_ERROR;
   4819          if (s->avail_in_expect != s->strm->avail_in)
   4820             return BZ_SEQUENCE_ERROR;
   4821          progress = handle_compress ( strm );
   4822          if (s->avail_in_expect > 0 || !isempty_RL(s) ||
   4823              s->state_out_pos < s->numZ) return BZ_FLUSH_OK;
   4824          s->mode = BZ_M_RUNNING;
   4825          return BZ_RUN_OK;
   4826 
   4827       case BZ_M_FINISHING:
   4828          if (action != BZ_FINISH) return BZ_SEQUENCE_ERROR;
   4829          if (s->avail_in_expect != s->strm->avail_in)
   4830             return BZ_SEQUENCE_ERROR;
   4831          progress = handle_compress ( strm );
   4832          if (!progress) return BZ_SEQUENCE_ERROR;
   4833          if (s->avail_in_expect > 0 || !isempty_RL(s) ||
   4834              s->state_out_pos < s->numZ) return BZ_FINISH_OK;
   4835          s->mode = BZ_M_IDLE;
   4836          return BZ_STREAM_END;
   4837    }
   4838    return BZ_OK; /*--not reached--*/
   4839 }
   4840 
   4841 
   4842 /*---------------------------------------------------*/
   4843 int BZ_API(BZ2_bzCompressEnd)  ( bz_stream *strm )
   4844 {
   4845    EState* s;
   4846    if (strm == NULL) return BZ_PARAM_ERROR;
   4847    s = strm->state;
   4848    if (s == NULL) return BZ_PARAM_ERROR;
   4849    if (s->strm != strm) return BZ_PARAM_ERROR;
   4850 
   4851    if (s->arr1 != NULL) BZFREE(s->arr1);
   4852    if (s->arr2 != NULL) BZFREE(s->arr2);
   4853    if (s->ftab != NULL) BZFREE(s->ftab);
   4854    BZFREE(strm->state);
   4855 
   4856    strm->state = NULL;
   4857 
   4858    return BZ_OK;
   4859 }
   4860 
   4861 
   4862 /*---------------------------------------------------*/
   4863 /*--- Decompression stuff                         ---*/
   4864 /*---------------------------------------------------*/
   4865 
   4866 /*---------------------------------------------------*/
   4867 int BZ_API(BZ2_bzDecompressInit)
   4868                      ( bz_stream* strm,
   4869                        int        verbosity,
   4870                        int        small )
   4871 {
   4872    DState* s;
   4873 
   4874    if (!bz_config_ok()) return BZ_CONFIG_ERROR;
   4875 
   4876    if (strm == NULL) return BZ_PARAM_ERROR;
   4877    if (small != 0 && small != 1) return BZ_PARAM_ERROR;
   4878    if (verbosity < 0 || verbosity > 4) return BZ_PARAM_ERROR;
   4879 
   4880    if (strm->bzalloc == NULL) strm->bzalloc = default_bzalloc;
   4881    if (strm->bzfree == NULL) strm->bzfree = default_bzfree;
   4882 
   4883    s = BZALLOC( sizeof(DState) );
   4884    if (s == NULL) return BZ_MEM_ERROR;
   4885    s->strm                  = strm;
   4886    strm->state              = s;
   4887    s->state                 = BZ_X_MAGIC_1;
   4888    s->bsLive                = 0;
   4889    s->bsBuff                = 0;
   4890    s->calculatedCombinedCRC = 0;
   4891    strm->total_in_lo32      = 0;
   4892    strm->total_in_hi32      = 0;
   4893    strm->total_out_lo32     = 0;
   4894    strm->total_out_hi32     = 0;
   4895    s->smallDecompress       = (Bool)small;
   4896    s->ll4                   = NULL;
   4897    s->ll16                  = NULL;
   4898    s->tt                    = NULL;
   4899    s->currBlockNo           = 0;
   4900    s->verbosity             = verbosity;
   4901 
   4902    return BZ_OK;
   4903 }
   4904 
   4905 
   4906 /*---------------------------------------------------*/
   4907 /* Return  True iff data corruption is discovered.
   4908    Returns False if there is no problem.
   4909 */
   4910 static
   4911 Bool unRLE_obuf_to_output_FAST ( DState* s )
   4912 {
   4913    UChar k1;
   4914 
   4915    if (s->blockRandomised) {
   4916 
   4917       while (True) {
   4918          /* try to finish existing run */
   4919          while (True) {
   4920             if (s->strm->avail_out == 0) return False;
   4921             if (s->state_out_len == 0) break;
   4922             *( (UChar*)(s->strm->next_out) ) = s->state_out_ch;
   4923             BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch );
   4924             s->state_out_len--;
   4925             s->strm->next_out++;
   4926             s->strm->avail_out--;
   4927             s->strm->total_out_lo32++;
   4928             if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
   4929          }
   4930 
   4931          /* can a new run be started? */
   4932          if (s->nblock_used == s->save_nblock+1) return False;
   4933 
   4934          /* Only caused by corrupt data stream? */
   4935          if (s->nblock_used > s->save_nblock+1)
   4936             return True;
   4937 
   4938          s->state_out_len = 1;
   4939          s->state_out_ch = s->k0;
   4940          BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
   4941          k1 ^= BZ_RAND_MASK; s->nblock_used++;
   4942          if (s->nblock_used == s->save_nblock+1) continue;
   4943          if (k1 != s->k0) { s->k0 = k1; continue; };
   4944 
   4945          s->state_out_len = 2;
   4946          BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
   4947          k1 ^= BZ_RAND_MASK; s->nblock_used++;
   4948          if (s->nblock_used == s->save_nblock+1) continue;
   4949          if (k1 != s->k0) { s->k0 = k1; continue; };
   4950 
   4951          s->state_out_len = 3;
   4952          BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
   4953          k1 ^= BZ_RAND_MASK; s->nblock_used++;
   4954          if (s->nblock_used == s->save_nblock+1) continue;
   4955          if (k1 != s->k0) { s->k0 = k1; continue; };
   4956 
   4957          BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
   4958          k1 ^= BZ_RAND_MASK; s->nblock_used++;
   4959          s->state_out_len = ((Int32)k1) + 4;
   4960          BZ_GET_FAST(s->k0); BZ_RAND_UPD_MASK;
   4961          s->k0 ^= BZ_RAND_MASK; s->nblock_used++;
   4962       }
   4963 
   4964    } else {
   4965 
   4966       /* restore */
   4967       UInt32        c_calculatedBlockCRC = s->calculatedBlockCRC;
   4968       UChar         c_state_out_ch       = s->state_out_ch;
   4969       Int32         c_state_out_len      = s->state_out_len;
   4970       Int32         c_nblock_used        = s->nblock_used;
   4971       Int32         c_k0                 = s->k0;
   4972       UInt32*       c_tt                 = s->tt;
   4973       UInt32        c_tPos               = s->tPos;
   4974       char*         cs_next_out          = s->strm->next_out;
   4975       unsigned int  cs_avail_out         = s->strm->avail_out;
   4976       /* end restore */
   4977 
   4978       UInt32       avail_out_INIT = cs_avail_out;
   4979       Int32        s_save_nblockPP = s->save_nblock+1;
   4980       unsigned int total_out_lo32_old;
   4981 
   4982       while (True) {
   4983 
   4984          /* try to finish existing run */
   4985          if (c_state_out_len > 0) {
   4986             while (True) {
   4987                if (cs_avail_out == 0) goto return_notr;
   4988                if (c_state_out_len == 1) break;
   4989                *( (UChar*)(cs_next_out) ) = c_state_out_ch;
   4990                BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch );
   4991                c_state_out_len--;
   4992                cs_next_out++;
   4993                cs_avail_out--;
   4994             }
   4995             s_state_out_len_eq_one:
   4996             {
   4997                if (cs_avail_out == 0) {
   4998                   c_state_out_len = 1; goto return_notr;
   4999                };
   5000                *( (UChar*)(cs_next_out) ) = c_state_out_ch;
   5001                BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch );
   5002                cs_next_out++;
   5003                cs_avail_out--;
   5004             }
   5005          }
   5006          /* Only caused by corrupt data stream? */
   5007          if (c_nblock_used > s_save_nblockPP)
   5008             return True;
   5009 
   5010          /* can a new run be started? */
   5011          if (c_nblock_used == s_save_nblockPP) {
   5012             c_state_out_len = 0; goto return_notr;
   5013          };
   5014          c_state_out_ch = c_k0;
   5015          BZ_GET_FAST_C(k1); c_nblock_used++;
   5016          if (k1 != c_k0) {
   5017             c_k0 = k1; goto s_state_out_len_eq_one;
   5018          };
   5019          if (c_nblock_used == s_save_nblockPP)
   5020             goto s_state_out_len_eq_one;
   5021 
   5022          c_state_out_len = 2;
   5023          BZ_GET_FAST_C(k1); c_nblock_used++;
   5024          if (c_nblock_used == s_save_nblockPP) continue;
   5025          if (k1 != c_k0) { c_k0 = k1; continue; };
   5026 
   5027          c_state_out_len = 3;
   5028          BZ_GET_FAST_C(k1); c_nblock_used++;
   5029          if (c_nblock_used == s_save_nblockPP) continue;
   5030          if (k1 != c_k0) { c_k0 = k1; continue; };
   5031 
   5032          BZ_GET_FAST_C(k1); c_nblock_used++;
   5033          c_state_out_len = ((Int32)k1) + 4;
   5034          BZ_GET_FAST_C(c_k0); c_nblock_used++;
   5035       }
   5036 
   5037       return_notr:
   5038       total_out_lo32_old = s->strm->total_out_lo32;
   5039       s->strm->total_out_lo32 += (avail_out_INIT - cs_avail_out);
   5040       if (s->strm->total_out_lo32 < total_out_lo32_old)
   5041          s->strm->total_out_hi32++;
   5042 
   5043       /* save */
   5044       s->calculatedBlockCRC = c_calculatedBlockCRC;
   5045       s->state_out_ch       = c_state_out_ch;
   5046       s->state_out_len      = c_state_out_len;
   5047       s->nblock_used        = c_nblock_used;
   5048       s->k0                 = c_k0;
   5049       s->tt                 = c_tt;
   5050       s->tPos               = c_tPos;
   5051       s->strm->next_out     = cs_next_out;
   5052       s->strm->avail_out    = cs_avail_out;
   5053       /* end save */
   5054    }
   5055    return False;
   5056 }
   5057 
   5058 
   5059 
   5060 /*---------------------------------------------------*/
   5061 /* Return  True iff data corruption is discovered.
   5062    Returns False if there is no problem.
   5063 */
   5064 static
   5065 Bool unRLE_obuf_to_output_SMALL ( DState* s )
   5066 {
   5067    UChar k1;
   5068 
   5069    if (s->blockRandomised) {
   5070 
   5071       while (True) {
   5072          /* try to finish existing run */
   5073          while (True) {
   5074             if (s->strm->avail_out == 0) return False;
   5075             if (s->state_out_len == 0) break;
   5076             *( (UChar*)(s->strm->next_out) ) = s->state_out_ch;
   5077             BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch );
   5078             s->state_out_len--;
   5079             s->strm->next_out++;
   5080             s->strm->avail_out--;
   5081             s->strm->total_out_lo32++;
   5082             if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
   5083          }
   5084 
   5085          /* can a new run be started? */
   5086          if (s->nblock_used == s->save_nblock+1) return False;
   5087 
   5088          /* Only caused by corrupt data stream? */
   5089          if (s->nblock_used > s->save_nblock+1)
   5090             return True;
   5091 
   5092          s->state_out_len = 1;
   5093          s->state_out_ch = s->k0;
   5094          BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
   5095          k1 ^= BZ_RAND_MASK; s->nblock_used++;
   5096          if (s->nblock_used == s->save_nblock+1) continue;
   5097          if (k1 != s->k0) { s->k0 = k1; continue; };
   5098 
   5099          s->state_out_len = 2;
   5100          BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
   5101          k1 ^= BZ_RAND_MASK; s->nblock_used++;
   5102          if (s->nblock_used == s->save_nblock+1) continue;
   5103          if (k1 != s->k0) { s->k0 = k1; continue; };
   5104 
   5105          s->state_out_len = 3;
   5106          BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
   5107          k1 ^= BZ_RAND_MASK; s->nblock_used++;
   5108          if (s->nblock_used == s->save_nblock+1) continue;
   5109          if (k1 != s->k0) { s->k0 = k1; continue; };
   5110 
   5111          BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
   5112          k1 ^= BZ_RAND_MASK; s->nblock_used++;
   5113          s->state_out_len = ((Int32)k1) + 4;
   5114          BZ_GET_SMALL(s->k0); BZ_RAND_UPD_MASK;
   5115          s->k0 ^= BZ_RAND_MASK; s->nblock_used++;
   5116       }
   5117 
   5118    } else {
   5119 
   5120       while (True) {
   5121          /* try to finish existing run */
   5122          while (True) {
   5123             if (s->strm->avail_out == 0) return False;
   5124             if (s->state_out_len == 0) break;
   5125             *( (UChar*)(s->strm->next_out) ) = s->state_out_ch;
   5126             BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch );
   5127             s->state_out_len--;
   5128             s->strm->next_out++;
   5129             s->strm->avail_out--;
   5130             s->strm->total_out_lo32++;
   5131             if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
   5132          }
   5133 
   5134          /* can a new run be started? */
   5135          if (s->nblock_used == s->save_nblock+1) return False;
   5136 
   5137          /* Only caused by corrupt data stream? */
   5138          if (s->nblock_used > s->save_nblock+1)
   5139             return True;
   5140 
   5141          s->state_out_len = 1;
   5142          s->state_out_ch = s->k0;
   5143          BZ_GET_SMALL(k1); s->nblock_used++;
   5144          if (s->nblock_used == s->save_nblock+1) continue;
   5145          if (k1 != s->k0) { s->k0 = k1; continue; };
   5146 
   5147          s->state_out_len = 2;
   5148          BZ_GET_SMALL(k1); s->nblock_used++;
   5149          if (s->nblock_used == s->save_nblock+1) continue;
   5150          if (k1 != s->k0) { s->k0 = k1; continue; };
   5151 
   5152          s->state_out_len = 3;
   5153          BZ_GET_SMALL(k1); s->nblock_used++;
   5154          if (s->nblock_used == s->save_nblock+1) continue;
   5155          if (k1 != s->k0) { s->k0 = k1; continue; };
   5156 
   5157          BZ_GET_SMALL(k1); s->nblock_used++;
   5158          s->state_out_len = ((Int32)k1) + 4;
   5159          BZ_GET_SMALL(s->k0); s->nblock_used++;
   5160       }
   5161 
   5162    }
   5163 }
   5164 
   5165 
   5166 /*---------------------------------------------------*/
   5167 int BZ_API(BZ2_bzDecompress) ( bz_stream *strm )
   5168 {
   5169    Bool    corrupt;
   5170    DState* s;
   5171    if (strm == NULL) return BZ_PARAM_ERROR;
   5172    s = strm->state;
   5173    if (s == NULL) return BZ_PARAM_ERROR;
   5174    if (s->strm != strm) return BZ_PARAM_ERROR;
   5175 
   5176    while (True) {
   5177       if (s->state == BZ_X_IDLE) return BZ_SEQUENCE_ERROR;
   5178       if (s->state == BZ_X_OUTPUT) {
   5179          if (s->smallDecompress)
   5180             corrupt = unRLE_obuf_to_output_SMALL ( s ); else
   5181             corrupt = unRLE_obuf_to_output_FAST  ( s );
   5182          if (corrupt) return BZ_DATA_ERROR;
   5183          if (s->nblock_used == s->save_nblock+1 && s->state_out_len == 0) {
   5184             BZ_FINALISE_CRC ( s->calculatedBlockCRC );
   5185             if (s->verbosity >= 3)
   5186                VPrintf2 ( " {0x%08x, 0x%08x}", s->storedBlockCRC,
   5187                           s->calculatedBlockCRC );
   5188             if (s->verbosity >= 2) VPrintf0 ( "]" );
   5189             if (s->calculatedBlockCRC != s->storedBlockCRC)
   5190                return BZ_DATA_ERROR;
   5191             s->calculatedCombinedCRC
   5192                = (s->calculatedCombinedCRC << 1) |
   5193                     (s->calculatedCombinedCRC >> 31);
   5194             s->calculatedCombinedCRC ^= s->calculatedBlockCRC;
   5195             s->state = BZ_X_BLKHDR_1;
   5196          } else {
   5197             return BZ_OK;
   5198          }
   5199       }
   5200       if (s->state >= BZ_X_MAGIC_1) {
   5201          Int32 r = BZ2_decompress ( s );
   5202          if (r == BZ_STREAM_END) {
   5203             if (s->verbosity >= 3)
   5204                VPrintf2 ( "\n    combined CRCs: stored = 0x%08x, computed = 0x%08x",
   5205                           s->storedCombinedCRC, s->calculatedCombinedCRC );
   5206             if (s->calculatedCombinedCRC != s->storedCombinedCRC)
   5207                return BZ_DATA_ERROR;
   5208             return r;
   5209          }
   5210          if (s->state != BZ_X_OUTPUT) return r;
   5211       }
   5212    }
   5213 
   5214    AssertH ( 0, 6001 );
   5215 
   5216    return 0;  /*NOTREACHED*/
   5217 }
   5218 
   5219 
   5220 /*---------------------------------------------------*/
   5221 int BZ_API(BZ2_bzDecompressEnd)  ( bz_stream *strm )
   5222 {
   5223    DState* s;
   5224    if (strm == NULL) return BZ_PARAM_ERROR;
   5225    s = strm->state;
   5226    if (s == NULL) return BZ_PARAM_ERROR;
   5227    if (s->strm != strm) return BZ_PARAM_ERROR;
   5228 
   5229    if (s->tt   != NULL) BZFREE(s->tt);
   5230    if (s->ll16 != NULL) BZFREE(s->ll16);
   5231    if (s->ll4  != NULL) BZFREE(s->ll4);
   5232 
   5233    BZFREE(strm->state);
   5234    strm->state = NULL;
   5235 
   5236    return BZ_OK;
   5237 }
   5238 
   5239 
   5240 #ifndef BZ_NO_STDIO
   5241 /*---------------------------------------------------*/
   5242 /*--- File I/O stuff                              ---*/
   5243 /*---------------------------------------------------*/
   5244 
   5245 #define BZ_SETERR(eee)                    \
   5246 {                                         \
   5247    if (bzerror != NULL) *bzerror = eee;   \
   5248    if (bzf != NULL) bzf->lastErr = eee;   \
   5249 }
   5250 
   5251 typedef
   5252    struct {
   5253       FILE*     handle;
   5254       Char      buf[BZ_MAX_UNUSED];
   5255       Int32     bufN;
   5256       Bool      writing;
   5257       bz_stream strm;
   5258       Int32     lastErr;
   5259       Bool      initialisedOk;
   5260    }
   5261    bzFile;
   5262 
   5263 
   5264 /*---------------------------------------------*/
   5265 static Bool myfeof ( FILE* f )
   5266 {
   5267    Int32 c = fgetc ( f );
   5268    if (c == EOF) return True;
   5269    ungetc ( c, f );
   5270    return False;
   5271 }
   5272 
   5273 
   5274 /*---------------------------------------------------*/
   5275 BZFILE* BZ_API(BZ2_bzWriteOpen)
   5276                     ( int*  bzerror,
   5277                       FILE* f,
   5278                       int   blockSize100k,
   5279                       int   verbosity,
   5280                       int   workFactor )
   5281 {
   5282    Int32   ret;
   5283    bzFile* bzf = NULL;
   5284 
   5285    BZ_SETERR(BZ_OK);
   5286 
   5287    if (f == NULL ||
   5288        (blockSize100k < 1 || blockSize100k > 9) ||
   5289        (workFactor < 0 || workFactor > 250) ||
   5290        (verbosity < 0 || verbosity > 4))
   5291       { BZ_SETERR(BZ_PARAM_ERROR); return NULL; };
   5292 
   5293    if (ferror(f))
   5294       { BZ_SETERR(BZ_IO_ERROR); return NULL; };
   5295 
   5296    bzf = malloc ( sizeof(bzFile) );
   5297    if (bzf == NULL)
   5298       { BZ_SETERR(BZ_MEM_ERROR); return NULL; };
   5299 
   5300    BZ_SETERR(BZ_OK);
   5301    bzf->initialisedOk = False;
   5302    bzf->bufN          = 0;
   5303    bzf->handle        = f;
   5304    bzf->writing       = True;
   5305    bzf->strm.bzalloc  = NULL;
   5306    bzf->strm.bzfree   = NULL;
   5307    bzf->strm.opaque   = NULL;
   5308 
   5309    if (workFactor == 0) workFactor = 30;
   5310    ret = BZ2_bzCompressInit ( &(bzf->strm), blockSize100k,
   5311                               verbosity, workFactor );
   5312    if (ret != BZ_OK)
   5313       { BZ_SETERR(ret); free(bzf); return NULL; };
   5314 
   5315    bzf->strm.avail_in = 0;
   5316    bzf->initialisedOk = True;
   5317    return bzf;
   5318 }
   5319 
   5320 
   5321 
   5322 /*---------------------------------------------------*/
   5323 void BZ_API(BZ2_bzWrite)
   5324              ( int*    bzerror,
   5325                BZFILE* b,
   5326                void*   buf,
   5327                int     len )
   5328 {
   5329    Int32 n, n2, ret;
   5330    bzFile* bzf = (bzFile*)b;
   5331 
   5332    BZ_SETERR(BZ_OK);
   5333    if (bzf == NULL || buf == NULL || len < 0)
   5334       { BZ_SETERR(BZ_PARAM_ERROR); return; };
   5335    if (!(bzf->writing))
   5336       { BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
   5337    if (ferror(bzf->handle))
   5338       { BZ_SETERR(BZ_IO_ERROR); return; };
   5339 
   5340    if (len == 0)
   5341       { BZ_SETERR(BZ_OK); return; };
   5342 
   5343    bzf->strm.avail_in = len;
   5344    bzf->strm.next_in  = buf;
   5345 
   5346    while (True) {
   5347       bzf->strm.avail_out = BZ_MAX_UNUSED;
   5348       bzf->strm.next_out = bzf->buf;
   5349       ret = BZ2_bzCompress ( &(bzf->strm), BZ_RUN );
   5350       if (ret != BZ_RUN_OK)
   5351          { BZ_SETERR(ret); return; };
   5352 
   5353       if (bzf->strm.avail_out < BZ_MAX_UNUSED) {
   5354          n = BZ_MAX_UNUSED - bzf->strm.avail_out;
   5355          n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar),
   5356                        n, bzf->handle );
   5357          if (n != n2 || ferror(bzf->handle))
   5358             { BZ_SETERR(BZ_IO_ERROR); return; };
   5359       }
   5360 
   5361       if (bzf->strm.avail_in == 0)
   5362          { BZ_SETERR(BZ_OK); return; };
   5363    }
   5364 }
   5365 
   5366 
   5367 /*---------------------------------------------------*/
   5368 void BZ_API(BZ2_bzWriteClose)
   5369                   ( int*          bzerror,
   5370                     BZFILE*       b,
   5371                     int           abandon,
   5372                     unsigned int* nbytes_in,
   5373                     unsigned int* nbytes_out )
   5374 {
   5375    BZ2_bzWriteClose64 ( bzerror, b, abandon,
   5376                         nbytes_in, NULL, nbytes_out, NULL );
   5377 }
   5378 
   5379 
   5380 void BZ_API(BZ2_bzWriteClose64)
   5381                   ( int*          bzerror,
   5382                     BZFILE*       b,
   5383                     int           abandon,
   5384                     unsigned int* nbytes_in_lo32,
   5385                     unsigned int* nbytes_in_hi32,
   5386                     unsigned int* nbytes_out_lo32,
   5387                     unsigned int* nbytes_out_hi32 )
   5388 {
   5389    Int32   n, n2, ret;
   5390    bzFile* bzf = (bzFile*)b;
   5391 
   5392    if (bzf == NULL)
   5393       { BZ_SETERR(BZ_OK); return; };
   5394    if (!(bzf->writing))
   5395       { BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
   5396    if (ferror(bzf->handle))
   5397       { BZ_SETERR(BZ_IO_ERROR); return; };
   5398 
   5399    if (nbytes_in_lo32 != NULL) *nbytes_in_lo32 = 0;
   5400    if (nbytes_in_hi32 != NULL) *nbytes_in_hi32 = 0;
   5401    if (nbytes_out_lo32 != NULL) *nbytes_out_lo32 = 0;
   5402    if (nbytes_out_hi32 != NULL) *nbytes_out_hi32 = 0;
   5403 
   5404    if ((!abandon) && bzf->lastErr == BZ_OK) {
   5405       while (True) {
   5406          bzf->strm.avail_out = BZ_MAX_UNUSED;
   5407          bzf->strm.next_out = bzf->buf;
   5408          ret = BZ2_bzCompress ( &(bzf->strm), BZ_FINISH );
   5409          if (ret != BZ_FINISH_OK && ret != BZ_STREAM_END)
   5410             { BZ_SETERR(ret); return; };
   5411 
   5412          if (bzf->strm.avail_out < BZ_MAX_UNUSED) {
   5413             n = BZ_MAX_UNUSED - bzf->strm.avail_out;
   5414             n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar),
   5415                           n, bzf->handle );
   5416             if (n != n2 || ferror(bzf->handle))
   5417                { BZ_SETERR(BZ_IO_ERROR); return; };
   5418          }
   5419 
   5420          if (ret == BZ_STREAM_END) break;
   5421       }
   5422    }
   5423 
   5424    if ( !abandon && !ferror ( bzf->handle ) ) {
   5425       fflush ( bzf->handle );
   5426       if (ferror(bzf->handle))
   5427          { BZ_SETERR(BZ_IO_ERROR); return; };
   5428    }
   5429 
   5430    if (nbytes_in_lo32 != NULL)
   5431       *nbytes_in_lo32 = bzf->strm.total_in_lo32;
   5432    if (nbytes_in_hi32 != NULL)
   5433       *nbytes_in_hi32 = bzf->strm.total_in_hi32;
   5434    if (nbytes_out_lo32 != NULL)
   5435       *nbytes_out_lo32 = bzf->strm.total_out_lo32;
   5436    if (nbytes_out_hi32 != NULL)
   5437       *nbytes_out_hi32 = bzf->strm.total_out_hi32;
   5438 
   5439    BZ_SETERR(BZ_OK);
   5440    BZ2_bzCompressEnd ( &(bzf->strm) );
   5441    free ( bzf );
   5442 }
   5443 
   5444 
   5445 /*---------------------------------------------------*/
   5446 BZFILE* BZ_API(BZ2_bzReadOpen)
   5447                    ( int*  bzerror,
   5448                      FILE* f,
   5449                      int   verbosity,
   5450                      int   small,
   5451                      void* unused,
   5452                      int   nUnused )
   5453 {
   5454    bzFile* bzf = NULL;
   5455    int     ret;
   5456 
   5457    BZ_SETERR(BZ_OK);
   5458 
   5459    if (f == NULL ||
   5460        (small != 0 && small != 1) ||
   5461        (verbosity < 0 || verbosity > 4) ||
   5462        (unused == NULL && nUnused != 0) ||
   5463        (unused != NULL && (nUnused < 0 || nUnused > BZ_MAX_UNUSED)))
   5464       { BZ_SETERR(BZ_PARAM_ERROR); return NULL; };
   5465 
   5466    if (ferror(f))
   5467       { BZ_SETERR(BZ_IO_ERROR); return NULL; };
   5468 
   5469    bzf = malloc ( sizeof(bzFile) );
   5470    if (bzf == NULL)
   5471       { BZ_SETERR(BZ_MEM_ERROR); return NULL; };
   5472 
   5473    BZ_SETERR(BZ_OK);
   5474 
   5475    bzf->initialisedOk = False;
   5476    bzf->handle        = f;
   5477    bzf->bufN          = 0;
   5478    bzf->writing       = False;
   5479    bzf->strm.bzalloc  = NULL;
   5480    bzf->strm.bzfree   = NULL;
   5481    bzf->strm.opaque   = NULL;
   5482 
   5483    while (nUnused > 0) {
   5484       bzf->buf[bzf->bufN] = *((UChar*)(unused)); bzf->bufN++;
   5485       unused = ((void*)( 1 + ((UChar*)(unused))  ));
   5486       nUnused--;
   5487    }
   5488 
   5489    ret = BZ2_bzDecompressInit ( &(bzf->strm), verbosity, small );
   5490    if (ret != BZ_OK)
   5491       { BZ_SETERR(ret); free(bzf); return NULL; };
   5492 
   5493    bzf->strm.avail_in = bzf->bufN;
   5494    bzf->strm.next_in  = bzf->buf;
   5495 
   5496    bzf->initialisedOk = True;
   5497    return bzf;
   5498 }
   5499 
   5500 
   5501 /*---------------------------------------------------*/
   5502 void BZ_API(BZ2_bzReadClose) ( int *bzerror, BZFILE *b )
   5503 {
   5504    bzFile* bzf = (bzFile*)b;
   5505 
   5506    BZ_SETERR(BZ_OK);
   5507    if (bzf == NULL)
   5508       { BZ_SETERR(BZ_OK); return; };
   5509 
   5510    if (bzf->writing)
   5511       { BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
   5512 
   5513    if (bzf->initialisedOk)
   5514       (void)BZ2_bzDecompressEnd ( &(bzf->strm) );
   5515    free ( bzf );
   5516 }
   5517 
   5518 
   5519 /*---------------------------------------------------*/
   5520 int BZ_API(BZ2_bzRead)
   5521            ( int*    bzerror,
   5522              BZFILE* b,
   5523              void*   buf,
   5524              int     len )
   5525 {
   5526    Int32   n, ret;
   5527    bzFile* bzf = (bzFile*)b;
   5528 
   5529    BZ_SETERR(BZ_OK);
   5530 
   5531    if (bzf == NULL || buf == NULL || len < 0)
   5532       { BZ_SETERR(BZ_PARAM_ERROR); return 0; };
   5533 
   5534    if (bzf->writing)
   5535       { BZ_SETERR(BZ_SEQUENCE_ERROR); return 0; };
   5536 
   5537    if (len == 0)
   5538       { BZ_SETERR(BZ_OK); return 0; };
   5539 
   5540    bzf->strm.avail_out = len;
   5541    bzf->strm.next_out = buf;
   5542 
   5543    while (True) {
   5544 
   5545       if (ferror(bzf->handle))
   5546          { BZ_SETERR(BZ_IO_ERROR); return 0; };
   5547 
   5548       if (bzf->strm.avail_in == 0 && !myfeof(bzf->handle)) {
   5549          n = fread ( bzf->buf, sizeof(UChar),
   5550                      BZ_MAX_UNUSED, bzf->handle );
   5551          if (ferror(bzf->handle))
   5552             { BZ_SETERR(BZ_IO_ERROR); return 0; };
   5553          bzf->bufN = n;
   5554          bzf->strm.avail_in = bzf->bufN;
   5555          bzf->strm.next_in = bzf->buf;
   5556       }
   5557 
   5558       ret = BZ2_bzDecompress ( &(bzf->strm) );
   5559 
   5560       if (ret != BZ_OK && ret != BZ_STREAM_END)
   5561          { BZ_SETERR(ret); return 0; };
   5562 
   5563       if (ret == BZ_OK && myfeof(bzf->handle) &&
   5564           bzf->strm.avail_in == 0 && bzf->strm.avail_out > 0)
   5565          { BZ_SETERR(BZ_UNEXPECTED_EOF); return 0; };
   5566 
   5567       if (ret == BZ_STREAM_END)
   5568          { BZ_SETERR(BZ_STREAM_END);
   5569            return len - bzf->strm.avail_out; };
   5570       if (bzf->strm.avail_out == 0)
   5571          { BZ_SETERR(BZ_OK); return len; };
   5572 
   5573    }
   5574 
   5575    return 0; /*not reached*/
   5576 }
   5577 
   5578 
   5579 /*---------------------------------------------------*/
   5580 void BZ_API(BZ2_bzReadGetUnused)
   5581                      ( int*    bzerror,
   5582                        BZFILE* b,
   5583                        void**  unused,
   5584                        int*    nUnused )
   5585 {
   5586    bzFile* bzf = (bzFile*)b;
   5587    if (bzf == NULL)
   5588       { BZ_SETERR(BZ_PARAM_ERROR); return; };
   5589    if (bzf->lastErr != BZ_STREAM_END)
   5590       { BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
   5591    if (unused == NULL || nUnused == NULL)
   5592       { BZ_SETERR(BZ_PARAM_ERROR); return; };
   5593 
   5594    BZ_SETERR(BZ_OK);
   5595    *nUnused = bzf->strm.avail_in;
   5596    *unused = bzf->strm.next_in;
   5597 }
   5598 #endif
   5599 
   5600 
   5601 /*---------------------------------------------------*/
   5602 /*--- Misc convenience stuff                      ---*/
   5603 /*---------------------------------------------------*/
   5604 
   5605 /*---------------------------------------------------*/
   5606 int BZ_API(BZ2_bzBuffToBuffCompress)
   5607                          ( char*         dest,
   5608                            unsigned int* destLen,
   5609                            char*         source,
   5610                            unsigned int  sourceLen,
   5611                            int           blockSize100k,
   5612                            int           verbosity,
   5613                            int           workFactor )
   5614 {
   5615    bz_stream strm;
   5616    int ret;
   5617 
   5618    if (dest == NULL || destLen == NULL ||
   5619        source == NULL ||
   5620        blockSize100k < 1 || blockSize100k > 9 ||
   5621        verbosity < 0 || verbosity > 4 ||
   5622        workFactor < 0 || workFactor > 250)
   5623       return BZ_PARAM_ERROR;
   5624 
   5625    if (workFactor == 0) workFactor = 30;
   5626    strm.bzalloc = NULL;
   5627    strm.bzfree = NULL;
   5628    strm.opaque = NULL;
   5629    ret = BZ2_bzCompressInit ( &strm, blockSize100k,
   5630                               verbosity, workFactor );
   5631    if (ret != BZ_OK) return ret;
   5632 
   5633    strm.next_in = source;
   5634    strm.next_out = dest;
   5635    strm.avail_in = sourceLen;
   5636    strm.avail_out = *destLen;
   5637 
   5638    ret = BZ2_bzCompress ( &strm, BZ_FINISH );
   5639    if (ret == BZ_FINISH_OK) goto output_overflow;
   5640    if (ret != BZ_STREAM_END) goto errhandler;
   5641 
   5642    /* normal termination */
   5643    *destLen -= strm.avail_out;
   5644    BZ2_bzCompressEnd ( &strm );
   5645    return BZ_OK;
   5646 
   5647    output_overflow:
   5648    BZ2_bzCompressEnd ( &strm );
   5649    return BZ_OUTBUFF_FULL;
   5650 
   5651    errhandler:
   5652    BZ2_bzCompressEnd ( &strm );
   5653    return ret;
   5654 }
   5655 
   5656 
   5657 /*---------------------------------------------------*/
   5658 int BZ_API(BZ2_bzBuffToBuffDecompress)
   5659                            ( char*         dest,
   5660                              unsigned int* destLen,
   5661                              char*         source,
   5662                              unsigned int  sourceLen,
   5663                              int           small,
   5664                              int           verbosity )
   5665 {
   5666    bz_stream strm;
   5667    int ret;
   5668 
   5669    if (dest == NULL || destLen == NULL ||
   5670        source == NULL ||
   5671        (small != 0 && small != 1) ||
   5672        verbosity < 0 || verbosity > 4)
   5673           return BZ_PARAM_ERROR;
   5674 
   5675    strm.bzalloc = NULL;
   5676    strm.bzfree = NULL;
   5677    strm.opaque = NULL;
   5678    ret = BZ2_bzDecompressInit ( &strm, verbosity, small );
   5679    if (ret != BZ_OK) return ret;
   5680 
   5681    strm.next_in = source;
   5682    strm.next_out = dest;
   5683    strm.avail_in = sourceLen;
   5684    strm.avail_out = *destLen;
   5685 
   5686    ret = BZ2_bzDecompress ( &strm );
   5687    if (ret == BZ_OK) goto output_overflow_or_eof;
   5688    if (ret != BZ_STREAM_END) goto errhandler;
   5689 
   5690    /* normal termination */
   5691    *destLen -= strm.avail_out;
   5692    BZ2_bzDecompressEnd ( &strm );
   5693    return BZ_OK;
   5694 
   5695    output_overflow_or_eof:
   5696    if (strm.avail_out > 0) {
   5697       BZ2_bzDecompressEnd ( &strm );
   5698       return BZ_UNEXPECTED_EOF;
   5699    } else {
   5700       BZ2_bzDecompressEnd ( &strm );
   5701       return BZ_OUTBUFF_FULL;
   5702    };
   5703 
   5704    errhandler:
   5705    BZ2_bzDecompressEnd ( &strm );
   5706    return ret;
   5707 }
   5708 
   5709 
   5710 /*---------------------------------------------------*/
   5711 /*--
   5712    Code contributed by Yoshioka Tsuneo
   5713    (QWF00133 (at) niftyserve.or.jp/tsuneo-y (at) is.aist-nara.ac.jp),
   5714    to support better zlib compatibility.
   5715    This code is not _officially_ part of libbzip2 (yet);
   5716    I haven't tested it, documented it, or considered the
   5717    threading-safeness of it.
   5718    If this code breaks, please contact both Yoshioka and me.
   5719 --*/
   5720 /*---------------------------------------------------*/
   5721 
   5722 /*---------------------------------------------------*/
   5723 /*--
   5724    return version like "0.9.0c".
   5725 --*/
   5726 const char * BZ_API(BZ2_bzlibVersion)(void)
   5727 {
   5728    return BZ_VERSION;
   5729 }
   5730 
   5731 
   5732 #ifndef BZ_NO_STDIO
   5733 /*---------------------------------------------------*/
   5734 
   5735 #if defined(_WIN32) || defined(OS2) || defined(MSDOS)
   5736 #   include <fcntl.h>
   5737 #   include <io.h>
   5738 #   define SET_BINARY_MODE(file) setmode(fileno(file),O_BINARY)
   5739 #else
   5740 #   define SET_BINARY_MODE(file)
   5741 #endif
   5742 static
   5743 BZFILE * bzopen_or_bzdopen
   5744                ( const char *path,   /* no use when bzdopen */
   5745                  int fd,             /* no use when bzdopen */
   5746                  const char *mode,
   5747                  int open_mode)      /* bzopen: 0, bzdopen:1 */
   5748 {
   5749    int    bzerr;
   5750    char   unused[BZ_MAX_UNUSED];
   5751    int    blockSize100k = 9;
   5752    int    writing       = 0;
   5753    char   mode2[10]     = "";
   5754    FILE   *fp           = NULL;
   5755    BZFILE *bzfp         = NULL;
   5756    int    verbosity     = 0;
   5757    int    workFactor    = 30;
   5758    int    smallMode     = 0;
   5759    int    nUnused       = 0;
   5760 
   5761    if (mode == NULL) return NULL;
   5762    while (*mode) {
   5763       switch (*mode) {
   5764       case 'r':
   5765          writing = 0; break;
   5766       case 'w':
   5767          writing = 1; break;
   5768       case 's':
   5769          smallMode = 1; break;
   5770       default:
   5771          if (isdigit((int)(*mode))) {
   5772             blockSize100k = *mode-BZ_HDR_0;
   5773          }
   5774       }
   5775       mode++;
   5776    }
   5777    strcat(mode2, writing ? "w" : "r" );
   5778    strcat(mode2,"b");   /* binary mode */
   5779 
   5780    if (open_mode==0) {
   5781       if (path==NULL || strcmp(path,"")==0) {
   5782         fp = (writing ? stdout : stdin);
   5783         SET_BINARY_MODE(fp);
   5784       } else {
   5785         fp = fopen(path,mode2);
   5786       }
   5787    } else {
   5788 #ifdef BZ_STRICT_ANSI
   5789       fp = NULL;
   5790 #else
   5791       fp = fdopen(fd,mode2);
   5792 #endif
   5793    }
   5794    if (fp == NULL) return NULL;
   5795 
   5796    if (writing) {
   5797       /* Guard against total chaos and anarchy -- JRS */
   5798       if (blockSize100k < 1) blockSize100k = 1;
   5799       if (blockSize100k > 9) blockSize100k = 9;
   5800       bzfp = BZ2_bzWriteOpen(&bzerr,fp,blockSize100k,
   5801                              verbosity,workFactor);
   5802    } else {
   5803       bzfp = BZ2_bzReadOpen(&bzerr,fp,verbosity,smallMode,
   5804                             unused,nUnused);
   5805    }
   5806    if (bzfp == NULL) {
   5807       if (fp != stdin && fp != stdout) fclose(fp);
   5808       return NULL;
   5809    }
   5810    return bzfp;
   5811 }
   5812 
   5813 
   5814 /*---------------------------------------------------*/
   5815 /*--
   5816    open file for read or write.
   5817       ex) bzopen("file","w9")
   5818       case path="" or NULL => use stdin or stdout.
   5819 --*/
   5820 BZFILE * BZ_API(BZ2_bzopen)
   5821                ( const char *path,
   5822                  const char *mode )
   5823 {
   5824    return bzopen_or_bzdopen(path,-1,mode,/*bzopen*/0);
   5825 }
   5826 
   5827 
   5828 /*---------------------------------------------------*/
   5829 BZFILE * BZ_API(BZ2_bzdopen)
   5830                ( int fd,
   5831                  const char *mode )
   5832 {
   5833    return bzopen_or_bzdopen(NULL,fd,mode,/*bzdopen*/1);
   5834 }
   5835 
   5836 
   5837 /*---------------------------------------------------*/
   5838 int BZ_API(BZ2_bzread) (BZFILE* b, void* buf, int len )
   5839 {
   5840    int bzerr, nread;
   5841    if (((bzFile*)b)->lastErr == BZ_STREAM_END) return 0;
   5842    nread = BZ2_bzRead(&bzerr,b,buf,len);
   5843    if (bzerr == BZ_OK || bzerr == BZ_STREAM_END) {
   5844       return nread;
   5845    } else {
   5846       return -1;
   5847    }
   5848 }
   5849 
   5850 
   5851 /*---------------------------------------------------*/
   5852 int BZ_API(BZ2_bzwrite) (BZFILE* b, void* buf, int len )
   5853 {
   5854    int bzerr;
   5855 
   5856    BZ2_bzWrite(&bzerr,b,buf,len);
   5857    if(bzerr == BZ_OK){
   5858       return len;
   5859    }else{
   5860       return -1;
   5861    }
   5862 }
   5863 
   5864 
   5865 /*---------------------------------------------------*/
   5866 int BZ_API(BZ2_bzflush) (BZFILE *b)
   5867 {
   5868    /* do nothing now... */
   5869    return 0;
   5870 }
   5871 
   5872 
   5873 /*---------------------------------------------------*/
   5874 void BZ_API(BZ2_bzclose) (BZFILE* b)
   5875 {
   5876    int bzerr;
   5877    FILE *fp = ((bzFile *)b)->handle;
   5878 
   5879    if (b==NULL) {return;}
   5880    if(((bzFile*)b)->writing){
   5881       BZ2_bzWriteClose(&bzerr,b,0,NULL,NULL);
   5882       if(bzerr != BZ_OK){
   5883          BZ2_bzWriteClose(NULL,b,1,NULL,NULL);
   5884       }
   5885    }else{
   5886       BZ2_bzReadClose(&bzerr,b);
   5887    }
   5888    if(fp!=stdin && fp!=stdout){
   5889       fclose(fp);
   5890    }
   5891 }
   5892 
   5893 
   5894 /*---------------------------------------------------*/
   5895 /*--
   5896    return last error code
   5897 --*/
   5898 static char *bzerrorstrings[] = {
   5899        "OK"
   5900       ,"SEQUENCE_ERROR"
   5901       ,"PARAM_ERROR"
   5902       ,"MEM_ERROR"
   5903       ,"DATA_ERROR"
   5904       ,"DATA_ERROR_MAGIC"
   5905       ,"IO_ERROR"
   5906       ,"UNEXPECTED_EOF"
   5907       ,"OUTBUFF_FULL"
   5908       ,"CONFIG_ERROR"
   5909       ,"???"   /* for future */
   5910       ,"???"   /* for future */
   5911       ,"???"   /* for future */
   5912       ,"???"   /* for future */
   5913       ,"???"   /* for future */
   5914       ,"???"   /* for future */
   5915 };
   5916 
   5917 
   5918 const char * BZ_API(BZ2_bzerror) (BZFILE *b, int *errnum)
   5919 {
   5920    int err = ((bzFile *)b)->lastErr;
   5921 
   5922    if(err>0) err = 0;
   5923    *errnum = err;
   5924    return bzerrorstrings[err*-1];
   5925 }
   5926 #endif
   5927 
   5928 
   5929 /*-------------------------------------------------------------*/
   5930 /*--- end                                           bzlib.c ---*/
   5931 /*-------------------------------------------------------------*/
   5932 
   5933 
   5934 /////////////////////////////////////////////////////////////////////
   5935 /////////////////////////////////////////////////////////////////////
   5936 
   5937 
   5938 /* A test program written to test robustness to decompression of
   5939    corrupted data.  Usage is
   5940        unzcrash filename
   5941    and the program will read the specified file, compress it (in memory),
   5942    and then repeatedly decompress it, each time with a different bit of
   5943    the compressed data inverted, so as to test all possible one-bit errors.
   5944    This should not cause any invalid memory accesses.  If it does,
   5945    I want to know about it!
   5946 
   5947    p.s.  As you can see from the above description, the process is
   5948    incredibly slow.  A file of size eg 5KB will cause it to run for
   5949    many hours.
   5950 */
   5951 
   5952 //#include <stdio.h>
   5953 //#include <assert.h>
   5954 //#include "bzlib.h"
   5955 
   5956 #define M_BLOCK 1000000
   5957 
   5958 
   5959 #define M_BLOCK_OUT (M_BLOCK + 1000000)
   5960  char inbuf[M_BLOCK];
   5961  char outbuf[M_BLOCK_OUT];
   5962  char zbuf[M_BLOCK + 600 + (M_BLOCK / 100)];
   5963 
   5964 int nIn;
   5965 unsigned int nOut;
   5966 unsigned int nZ;
   5967 
   5968 #if 0
   5969 static char *bzerrorstrings[] = {
   5970        "OK"
   5971       ,"SEQUENCE_ERROR"
   5972       ,"PARAM_ERROR"
   5973       ,"MEM_ERROR"
   5974       ,"DATA_ERROR"
   5975       ,"DATA_ERROR_MAGIC"
   5976       ,"IO_ERROR"
   5977       ,"UNEXPECTED_EOF"
   5978       ,"OUTBUFF_FULL"
   5979       ,"???"   /* for future */
   5980       ,"???"   /* for future */
   5981       ,"???"   /* for future */
   5982       ,"???"   /* for future */
   5983       ,"???"   /* for future */
   5984       ,"???"   /* for future */
   5985 };
   5986 #endif
   5987 
   5988 void flip_bit ( int bit )
   5989 {
   5990    int byteno = bit / 8;
   5991    int bitno  = bit % 8;
   5992    UChar mask = 1 << bitno;
   5993    //fprintf ( stderr, "(byte %d  bit %d  mask %d)",
   5994    //          byteno, bitno, (int)mask );
   5995    zbuf[byteno] ^= mask;
   5996 }
   5997 
   5998 void set_inbuf ( void )
   5999 {
   6000   inbuf[0] = 0;
   6001   my_strcat(inbuf, "At her sixtieth birthday party, Margaret Thatcher ");
   6002   my_strcat(inbuf, "blew on the cake to light the candles.\n");
   6003   my_strcat(inbuf, "This program, bzip2, the associated library libbzip2, and all\n");
   6004   my_strcat(inbuf, "documentation, are copyright (C) 1996-2004 Julian R Seward.  All\n");
   6005   my_strcat(inbuf, "rights reserved.\n");
   6006   my_strcat(inbuf, "\n");
   6007   my_strcat(inbuf, "Redistribution and use in source and binary forms, with or without\n");
   6008   my_strcat(inbuf, "modification, are permitted provided that the following conditions\n");
   6009   my_strcat(inbuf, "are met:\n");
   6010   my_strcat(inbuf, "\n");
   6011   my_strcat(inbuf, "1. Redistributions of source code must retain the above copyright\n");
   6012   my_strcat(inbuf, "   notice, this list of conditions and the following disclaimer.\n");
   6013   my_strcat(inbuf, "\n");
   6014   my_strcat(inbuf, "2. The origin of this software must not be misrepresented; you must\n");
   6015   my_strcat(inbuf, "   not claim that you wrote the original software.  If you use this\n");
   6016   my_strcat(inbuf, "   software in a product, an acknowledgment in the product\n");
   6017   my_strcat(inbuf, "   documentation would be appreciated but is not required.\n");
   6018   my_strcat(inbuf, "\n");
   6019   my_strcat(inbuf, "3. Altered source versions must be plainly marked as such, and must\n");
   6020   my_strcat(inbuf, "   not be misrepresented as being the original software.\n");
   6021   my_strcat(inbuf, "\n");
   6022   my_strcat(inbuf, "4. The name of the author may not be used to endorse or promote\n");
   6023   my_strcat(inbuf, "   products derived from this software without specific prior written\n");
   6024   my_strcat(inbuf, "   permission.\n");
   6025   my_strcat(inbuf, "\n");
   6026   my_strcat(inbuf, "THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS\n");
   6027   my_strcat(inbuf, "OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n");
   6028   my_strcat(inbuf, "WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n");
   6029   my_strcat(inbuf, "ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY\n");
   6030   my_strcat(inbuf, "DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n");
   6031   my_strcat(inbuf, "DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE\n");
   6032   my_strcat(inbuf, "GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n");
   6033   my_strcat(inbuf, "INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,\n");
   6034   my_strcat(inbuf, "WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\n");
   6035   my_strcat(inbuf, "NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\n");
   6036   my_strcat(inbuf, "SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n");
   6037   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6038   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6039   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6040   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6041   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6042   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6043   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6044   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6045   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6046   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6047   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6048   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6049   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6050   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6051   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6052   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6053   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6054   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6055   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6056   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6057   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6058   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6059   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6060   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6061   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6062   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6063   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6064   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6065   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6066   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6067   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6068   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6069   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6070   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6071   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6072   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6073   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6074   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6075   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6076   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6077   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6078   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
   6079   my_strcat(inbuf, "		    GNU GENERAL PUBLIC LICENSE\n");
   6080   my_strcat(inbuf, "		       Version 2, June 1991\n");
   6081   my_strcat(inbuf, "\n");
   6082   my_strcat(inbuf, " Copyright (C) 1989, 1991 Free Software Foundation, Inc.\n");
   6083   my_strcat(inbuf, "     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n");
   6084   my_strcat(inbuf, " Everyone is permitted to copy and distribute verbatim copies\n");
   6085   my_strcat(inbuf, " of this license document, but changing it is not allowed.\n");
   6086   my_strcat(inbuf, "\n");
   6087   my_strcat(inbuf, "			    Preamble\n");
   6088   my_strcat(inbuf, "\n");
   6089   my_strcat(inbuf, "  The licenses for most software are designed to take away your\n");
   6090   my_strcat(inbuf, "freedom to share and change it.  By contrast, the GNU General Public\n");
   6091   my_strcat(inbuf, "License is intended to guarantee your freedom to share and change free\n");
   6092   my_strcat(inbuf, "software--to make sure the software is free for all its users.  This\n");
   6093   my_strcat(inbuf, "General Public License applies to most of the Free Software\n");
   6094   my_strcat(inbuf, "Foundation's software and to any other program whose authors commit to\n");
   6095   my_strcat(inbuf, "using it.  (Some other Free Software Foundation software is covered by\n");
   6096   my_strcat(inbuf, "the GNU Library General Public License instead.)  You can apply it to\n");
   6097   my_strcat(inbuf, "your programs, too.\n");
   6098   my_strcat(inbuf, "\n");
   6099   my_strcat(inbuf, "  When we speak of free software, we are referring to freedom, not\n");
   6100   my_strcat(inbuf, "price.  Our General Public Licenses are designed to make sure that you\n");
   6101   my_strcat(inbuf, "have the freedom to distribute copies of free software (and charge for\n");
   6102   my_strcat(inbuf, "this service if you wish), that you receive source code or can get it\n");
   6103   my_strcat(inbuf, "if you want it, that you can change the software or use pieces of it\n");
   6104   my_strcat(inbuf, "in new free programs; and that you know you can do these things.\n");
   6105   my_strcat(inbuf, "\n");
   6106   my_strcat(inbuf, "  To protect your rights, we need to make restrictions that forbid\n");
   6107   my_strcat(inbuf, "anyone to deny you these rights or to ask you to surrender the rights.\n");
   6108   my_strcat(inbuf, "These restrictions translate to certain responsibilities for you if you\n");
   6109   my_strcat(inbuf, "distribute copies of the software, or if you modify it.\n");
   6110   my_strcat(inbuf, "\n");
   6111   my_strcat(inbuf, "  For example, if you distribute copies of such a program, whether\n");
   6112   my_strcat(inbuf, "gratis or for a fee, you must give the recipients all the rights that\n");
   6113   my_strcat(inbuf, "you have.  You must make sure that they, too, receive or can get the\n");
   6114   my_strcat(inbuf, "source code.  And you must show them these terms so they know their\n");
   6115   my_strcat(inbuf, "rights.\n");
   6116   my_strcat(inbuf, "\n");
   6117   my_strcat(inbuf, "  We protect your rights with two steps: (1) copyright the software, and\n");
   6118   my_strcat(inbuf, "(2) offer you this license which gives you legal permission to copy,\n");
   6119   my_strcat(inbuf, "distribute and/or modify the software.\n");
   6120   my_strcat(inbuf, "\n");
   6121   my_strcat(inbuf, "  Also, for each author's protection and ours, we want to make certain\n");
   6122   my_strcat(inbuf, "that everyone understands that there is no warranty for this free\n");
   6123   my_strcat(inbuf, "software.  If the software is modified by someone else and passed on, we\n");
   6124   my_strcat(inbuf, "want its recipients to know that what they have is not the original, so\n");
   6125   my_strcat(inbuf, "that any problems introduced by others will not reflect on the original\n");
   6126   my_strcat(inbuf, "authors' reputations.\n");
   6127   my_strcat(inbuf, "\n");
   6128   my_strcat(inbuf, "  Finally, any free program is threatened constantly by software\n");
   6129   my_strcat(inbuf, "patents.  We wish to avoid the danger that redistributors of a free\n");
   6130   my_strcat(inbuf, "program will individually obtain patent licenses, in effect making the\n");
   6131   my_strcat(inbuf, "program proprietary.  To prevent this, we have made it clear that any\n");
   6132   my_strcat(inbuf, "patent must be licensed for everyone's free use or not licensed at all.\n");
   6133   my_strcat(inbuf, "\n");
   6134   my_strcat(inbuf, "  The precise terms and conditions for copying, distribution and\n");
   6135   my_strcat(inbuf, "modification follow.\n");
   6136   my_strcat(inbuf, "\n");
   6137   my_strcat(inbuf, "		    GNU GENERAL PUBLIC LICENSE\n");
   6138   my_strcat(inbuf, "   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n");
   6139   my_strcat(inbuf, "\n");
   6140   my_strcat(inbuf, "  0. This License applies to any program or other work which contains\n");
   6141   my_strcat(inbuf, "a notice placed by the copyright holder saying it may be distributed\n");
   6142   my_strcat(inbuf, "under the terms of this General Public License.  The Program, below,\n");
   6143   my_strcat(inbuf, "refers to any such program or work, and a work based on the Program\n");
   6144   my_strcat(inbuf, "means either the Program or any derivative work under copyright law:\n");
   6145   my_strcat(inbuf, "that is to say, a work containing the Program or a portion of it,\n");
   6146   my_strcat(inbuf, "either verbatim or with modifications and/or translated into another\n");
   6147   my_strcat(inbuf, "language.  (Hereinafter, translation is included without limitation in\n");
   6148   my_strcat(inbuf, "the term modification.)  Each licensee is addressed as you.\n");
   6149   my_strcat(inbuf, "\n");
   6150   my_strcat(inbuf, "Activities other than copying, distribution and modification are not\n");
   6151   my_strcat(inbuf, "covered by this License; they are outside its scope.  The act of\n");
   6152   my_strcat(inbuf, "running the Program is not restricted, and the output from the Program\n");
   6153   my_strcat(inbuf, "is covered only if its contents constitute a work based on the\n");
   6154   my_strcat(inbuf, "Program (independent of having been made by running the Program).\n");
   6155   my_strcat(inbuf, "Whether that is true depends on what the Program does.\n");
   6156   my_strcat(inbuf, "\n");
   6157   my_strcat(inbuf, "  1. You may copy and distribute verbatim copies of the Program's\n");
   6158   my_strcat(inbuf, "source code as you receive it, in any medium, provided that you\n");
   6159   my_strcat(inbuf, "conspicuously and appropriately publish on each copy an appropriate\n");
   6160   my_strcat(inbuf, "copyright notice and disclaimer of warranty; keep intact all the\n");
   6161   my_strcat(inbuf, "notices that refer to this License and to the absence of any warranty;\n");
   6162   my_strcat(inbuf, "and give any other recipients of the Program a copy of this License\n");
   6163   my_strcat(inbuf, "along with the Program.\n");
   6164   my_strcat(inbuf, "\n");
   6165   my_strcat(inbuf, "You may charge a fee for the physical act of transferring a copy, and\n");
   6166   my_strcat(inbuf, "you may at your option offer warranty protection in exchange for a fee.\n");
   6167   my_strcat(inbuf, "\n");
   6168   my_strcat(inbuf, "  2. You may modify your copy or copies of the Program or any portion\n");
   6169   my_strcat(inbuf, "of it, thus forming a work based on the Program, and copy and\n");
   6170   my_strcat(inbuf, "distribute such modifications or work under the terms of Section 1\n");
   6171   my_strcat(inbuf, "above, provided that you also meet all of these conditions:\n");
   6172   my_strcat(inbuf, "\n");
   6173   my_strcat(inbuf, "    a) You must cause the modified files to carry prominent notices\n");
   6174   my_strcat(inbuf, "    stating that you changed the files and the date of any change.\n");
   6175   my_strcat(inbuf, "\n");
   6176   my_strcat(inbuf, "    b) You must cause any work that you distribute or publish, that in\n");
   6177   my_strcat(inbuf, "    whole or in part contains or is derived from the Program or any\n");
   6178   my_strcat(inbuf, "    part thereof, to be licensed as a whole at no charge to all third\n");
   6179   my_strcat(inbuf, "    parties under the terms of this License.\n");
   6180   my_strcat(inbuf, "\n");
   6181   my_strcat(inbuf, "    c) If the modified program normally reads commands interactively\n");
   6182   my_strcat(inbuf, "    when run, you must cause it, when started running for such\n");
   6183   my_strcat(inbuf, "    interactive use in the most ordinary way, to print or display an\n");
   6184   my_strcat(inbuf, "    announcement including an appropriate copyright notice and a\n");
   6185   my_strcat(inbuf, "    notice that there is no warranty (or else, saying that you provide\n");
   6186   my_strcat(inbuf, "    a warranty) and that users may redistribute the program under\n");
   6187   my_strcat(inbuf, "    these conditions, and telling the user how to view a copy of this\n");
   6188   my_strcat(inbuf, "    License.  (Exception: if the Program itself is interactive but\n");
   6189   my_strcat(inbuf, "    does not normally print such an announcement, your work based on\n");
   6190   my_strcat(inbuf, "    the Program is not required to print an announcement.)\n");
   6191   my_strcat(inbuf, "\n");
   6192   my_strcat(inbuf, "These requirements apply to the modified work as a whole.  If\n");
   6193   my_strcat(inbuf, "identifiable sections of that work are not derived from the Program,\n");
   6194   my_strcat(inbuf, "and can be reasonably considered independent and separate works in\n");
   6195   my_strcat(inbuf, "themselves, then this License, and its terms, do not apply to those\n");
   6196   my_strcat(inbuf, "sections when you distribute them as separate works.  But when you\n");
   6197   my_strcat(inbuf, "distribute the same sections as part of a whole which is a work based\n");
   6198   my_strcat(inbuf, "on the Program, the distribution of the whole must be on the terms of\n");
   6199   my_strcat(inbuf, "this License, whose permissions for other licensees extend to the\n");
   6200   my_strcat(inbuf, "entire whole, and thus to each and every part regardless of who wrote it.\n");
   6201   my_strcat(inbuf, "\n");
   6202   my_strcat(inbuf, "Thus, it is not the intent of this section to claim rights or contest\n");
   6203   my_strcat(inbuf, "your rights to work written entirely by you; rather, the intent is to\n");
   6204   my_strcat(inbuf, "exercise the right to control the distribution of derivative or\n");
   6205   my_strcat(inbuf, "collective works based on the Program.\n");
   6206   my_strcat(inbuf, "\n");
   6207   my_strcat(inbuf, "In addition, mere aggregation of another work not based on the Program\n");
   6208   my_strcat(inbuf, "with the Program (or with a work based on the Program) on a volume of\n");
   6209   my_strcat(inbuf, "a storage or distribution medium does not bring the other work under\n");
   6210   my_strcat(inbuf, "the scope of this License.\n");
   6211   my_strcat(inbuf, "\n");
   6212   my_strcat(inbuf, "  3. You may copy and distribute the Program (or a work based on it,\n");
   6213   my_strcat(inbuf, "under Section 2) in object code or executable form under the terms of\n");
   6214   my_strcat(inbuf, "Sections 1 and 2 above provided that you also do one of the following:\n");
   6215   my_strcat(inbuf, "\n");
   6216   my_strcat(inbuf, "    a) Accompany it with the complete corresponding machine-readable\n");
   6217   my_strcat(inbuf, "    source code, which must be distributed under the terms of Sections\n");
   6218   my_strcat(inbuf, "    1 and 2 above on a medium customarily used for software interchange; or,\n");
   6219   my_strcat(inbuf, "\n");
   6220   my_strcat(inbuf, "    b) Accompany it with a written offer, valid for at least three\n");
   6221   my_strcat(inbuf, "    years, to give any third party, for a charge no more than your\n");
   6222   my_strcat(inbuf, "    cost of physically performing source distribution, a complete\n");
   6223   my_strcat(inbuf, "    machine-readable copy of the corresponding source code, to be\n");
   6224   my_strcat(inbuf, "    distributed under the terms of Sections 1 and 2 above on a medium\n");
   6225   my_strcat(inbuf, "    customarily used for software interchange; or,\n");
   6226   my_strcat(inbuf, "\n");
   6227   my_strcat(inbuf, "    c) Accompany it with the information you received as to the offer\n");
   6228   my_strcat(inbuf, "    to distribute corresponding source code.  (This alternative is\n");
   6229   my_strcat(inbuf, "    allowed only for noncommercial distribution and only if you\n");
   6230   my_strcat(inbuf, "    received the program in object code or executable form with such\n");
   6231   my_strcat(inbuf, "    an offer, in accord with Subsection b above.)\n");
   6232   my_strcat(inbuf, "\n");
   6233   my_strcat(inbuf, "The source code for a work means the preferred form of the work for\n");
   6234   my_strcat(inbuf, "making modifications to it.  For an executable work, complete source\n");
   6235   my_strcat(inbuf, "code means all the source code for all modules it contains, plus any\n");
   6236   my_strcat(inbuf, "associated interface definition files, plus the scripts used to\n");
   6237   my_strcat(inbuf, "control compilation and installation of the executable.  However, as a\n");
   6238   my_strcat(inbuf, "special exception, the source code distributed need not include\n");
   6239   my_strcat(inbuf, "anything that is normally distributed (in either source or binary\n");
   6240   my_strcat(inbuf, "form) with the major components (compiler, kernel, and so on) of the\n");
   6241   my_strcat(inbuf, "operating system on which the executable runs, unless that component\n");
   6242   my_strcat(inbuf, "itself accompanies the executable.\n");
   6243   my_strcat(inbuf, "\n");
   6244   my_strcat(inbuf, "If distribution of executable or object code is made by offering\n");
   6245   my_strcat(inbuf, "access to copy from a designated place, then offering equivalent\n");
   6246   my_strcat(inbuf, "access to copy the source code from the same place counts as\n");
   6247   my_strcat(inbuf, "distribution of the source code, even though third parties are not\n");
   6248   my_strcat(inbuf, "compelled to copy the source along with the object code.\n");
   6249   my_strcat(inbuf, "\n");
   6250   my_strcat(inbuf, "  4. You may not copy, modify, sublicense, or distribute the Program\n");
   6251   my_strcat(inbuf, "except as expressly provided under this License.  Any attempt\n");
   6252   my_strcat(inbuf, "otherwise to copy, modify, sublicense or distribute the Program is\n");
   6253   my_strcat(inbuf, "void, and will automatically terminate your rights under this License.\n");
   6254   my_strcat(inbuf, "However, parties who have received copies, or rights, from you under\n");
   6255   my_strcat(inbuf, "this License will not have their licenses terminated so long as such\n");
   6256   my_strcat(inbuf, "parties remain in full compliance.\n");
   6257   my_strcat(inbuf, "\n");
   6258   my_strcat(inbuf, "  5. You are not required to accept this License, since you have not\n");
   6259   my_strcat(inbuf, "signed it.  However, nothing else grants you permission to modify or\n");
   6260   my_strcat(inbuf, "distribute the Program or its derivative works.  These actions are\n");
   6261   my_strcat(inbuf, "prohibited by law if you do not accept this License.  Therefore, by\n");
   6262   my_strcat(inbuf, "modifying or distributing the Program (or any work based on the\n");
   6263   my_strcat(inbuf, "Program), you indicate your acceptance of this License to do so, and\n");
   6264   my_strcat(inbuf, "all its terms and conditions for copying, distributing or modifying\n");
   6265   my_strcat(inbuf, "the Program or works based on it.\n");
   6266   my_strcat(inbuf, "\n");
   6267   my_strcat(inbuf, "  6. Each time you redistribute the Program (or any work based on the\n");
   6268   my_strcat(inbuf, "Program), the recipient automatically receives a license from the\n");
   6269   my_strcat(inbuf, "original licensor to copy, distribute or modify the Program subject to\n");
   6270   my_strcat(inbuf, "these terms and conditions.  You may not impose any further\n");
   6271   my_strcat(inbuf, "restrictions on the recipients' exercise of the rights granted herein.\n");
   6272   my_strcat(inbuf, "You are not responsible for enforcing compliance by third parties to\n");
   6273   my_strcat(inbuf, "this License.\n");
   6274   my_strcat(inbuf, "\n");
   6275   my_strcat(inbuf, "  7. If, as a consequence of a court judgment or allegation of patent\n");
   6276   my_strcat(inbuf, "infringement or for any other reason (not limited to patent issues),\n");
   6277   my_strcat(inbuf, "conditions are imposed on you (whether by court order, agreement or\n");
   6278   my_strcat(inbuf, "otherwise) that contradict the conditions of this License, they do not\n");
   6279   my_strcat(inbuf, "excuse you from the conditions of this License.  If you cannot\n");
   6280   my_strcat(inbuf, "distribute so as to satisfy simultaneously your obligations under this\n");
   6281   my_strcat(inbuf, "License and any other pertinent obligations, then as a consequence you\n");
   6282   my_strcat(inbuf, "may not distribute the Program at all.  For example, if a patent\n");
   6283   my_strcat(inbuf, "license would not permit royalty-free redistribution of the Program by\n");
   6284   my_strcat(inbuf, "all those who receive copies directly or indirectly through you, then\n");
   6285   my_strcat(inbuf, "the only way you could satisfy both it and this License would be to\n");
   6286   my_strcat(inbuf, "refrain entirely from distribution of the Program.\n");
   6287   my_strcat(inbuf, "\n");
   6288   my_strcat(inbuf, "If any portion of this section is held invalid or unenforceable under\n");
   6289   my_strcat(inbuf, "any particular circumstance, the balance of the section is intended to\n");
   6290   my_strcat(inbuf, "apply and the section as a whole is intended to apply in other\n");
   6291   my_strcat(inbuf, "circumstances.\n");
   6292   my_strcat(inbuf, "\n");
   6293   my_strcat(inbuf, "It is not the purpose of this section to induce you to infringe any\n");
   6294   my_strcat(inbuf, "patents or other property right claims or to contest validity of any\n");
   6295   my_strcat(inbuf, "such claims; this section has the sole purpose of protecting the\n");
   6296   my_strcat(inbuf, "integrity of the free software distribution system, which is\n");
   6297   my_strcat(inbuf, "implemented by public license practices.  Many people have made\n");
   6298   my_strcat(inbuf, "generous contributions to the wide range of software distributed\n");
   6299   my_strcat(inbuf, "through that system in reliance on consistent application of that\n");
   6300   my_strcat(inbuf, "system; it is up to the author/donor to decide if he or she is willing\n");
   6301   my_strcat(inbuf, "to distribute software through any other system and a licensee cannot\n");
   6302   my_strcat(inbuf, "impose that choice.\n");
   6303   my_strcat(inbuf, "\n");
   6304   my_strcat(inbuf, "This section is intended to make thoroughly clear what is believed to\n");
   6305   my_strcat(inbuf, "be a consequence of the rest of this License.\n");
   6306   my_strcat(inbuf, "\n");
   6307   my_strcat(inbuf, "  8. If the distribution and/or use of the Program is restricted in\n");
   6308   my_strcat(inbuf, "certain countries either by patents or by copyrighted interfaces, the\n");
   6309   my_strcat(inbuf, "original copyright holder who places the Program under this License\n");
   6310   my_strcat(inbuf, "may add an explicit geographical distribution limitation excluding\n");
   6311   my_strcat(inbuf, "those countries, so that distribution is permitted only in or among\n");
   6312   my_strcat(inbuf, "countries not thus excluded.  In such case, this License incorporates\n");
   6313   my_strcat(inbuf, "the limitation as if written in the body of this License.\n");
   6314   my_strcat(inbuf, "\n");
   6315   my_strcat(inbuf, "  9. The Free Software Foundation may publish revised and/or new versions\n");
   6316   my_strcat(inbuf, "of the General Public License from time to time.  Such new versions will\n");
   6317   my_strcat(inbuf, "be similar in spirit to the present version, but may differ in detail to\n");
   6318   my_strcat(inbuf, "address new problems or concerns.\n");
   6319   my_strcat(inbuf, "\n");
   6320   my_strcat(inbuf, "Each version is given a distinguishing version number.  If the Program\n");
   6321   my_strcat(inbuf, "specifies a version number of this License which applies to it and any\n");
   6322   my_strcat(inbuf, "later version, you have the option of following the terms and conditions\n");
   6323   my_strcat(inbuf, "either of that version or of any later version published by the Free\n");
   6324   my_strcat(inbuf, "Software Foundation.  If the Program does not specify a version number of\n");
   6325   my_strcat(inbuf, "this License, you may choose any version ever published by the Free Software\n");
   6326   my_strcat(inbuf, "Foundation.\n");
   6327   my_strcat(inbuf, "\n");
   6328   my_strcat(inbuf, "  10. If you wish to incorporate parts of the Program into other free\n");
   6329   my_strcat(inbuf, "programs whose distribution conditions are different, write to the author\n");
   6330   my_strcat(inbuf, "to ask for permission.  For software which is copyrighted by the Free\n");
   6331   my_strcat(inbuf, "Software Foundation, write to the Free Software Foundation; we sometimes\n");
   6332   my_strcat(inbuf, "make exceptions for this.  Our decision will be guided by the two goals\n");
   6333   my_strcat(inbuf, "of preserving the free status of all derivatives of our free software and\n");
   6334   my_strcat(inbuf, "of promoting the sharing and reuse of software generally.\n");
   6335   my_strcat(inbuf, "\n");
   6336   my_strcat(inbuf, "			    NO WARRANTY\n");
   6337   my_strcat(inbuf, "\n");
   6338   my_strcat(inbuf, "  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY\n");
   6339   my_strcat(inbuf, "FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN\n");
   6340   my_strcat(inbuf, "OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES\n");
   6341   my_strcat(inbuf, "PROVIDE THE PROGRAM AS IS WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED\n");
   6342   my_strcat(inbuf, "OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\n");
   6343   my_strcat(inbuf, "MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS\n");
   6344   my_strcat(inbuf, "TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE\n");
   6345   my_strcat(inbuf, "PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,\n");
   6346   my_strcat(inbuf, "REPAIR OR CORRECTION.\n");
   6347   my_strcat(inbuf, "\n");
   6348   my_strcat(inbuf, "  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING\n");
   6349   my_strcat(inbuf, "WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR\n");
   6350   my_strcat(inbuf, "REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,\n");
   6351   my_strcat(inbuf, "INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING\n");
   6352   my_strcat(inbuf, "OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED\n");
   6353   my_strcat(inbuf, "TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY\n");
   6354   my_strcat(inbuf, "YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER\n");
   6355   my_strcat(inbuf, "PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\n");
   6356   my_strcat(inbuf, "POSSIBILITY OF SUCH DAMAGES.\n");
   6357   my_strcat(inbuf, "\n");
   6358   my_strcat(inbuf, "		     END OF TERMS AND CONDITIONS\n");
   6359   my_strcat(inbuf, "\n");
   6360   my_strcat(inbuf, "	    How to Apply These Terms to Your New Programs\n");
   6361   my_strcat(inbuf, "\n");
   6362   my_strcat(inbuf, "  If you develop a new program, and you want it to be of the greatest\n");
   6363   my_strcat(inbuf, "possible use to the public, the best way to achieve this is to make it\n");
   6364   my_strcat(inbuf, "free software which everyone can redistribute and change under these terms.\n");
   6365   my_strcat(inbuf, "\n");
   6366   my_strcat(inbuf, "  To do so, attach the following notices to the program.  It is safest\n");
   6367   my_strcat(inbuf, "to attach them to the start of each source file to most effectively\n");
   6368   my_strcat(inbuf, "convey the exclusion of warranty; and each file should have at least\n");
   6369   my_strcat(inbuf, "the copyright line and a pointer to where the full notice is found.\n");
   6370   my_strcat(inbuf, "\n");
   6371   my_strcat(inbuf, "    <one line to give the program's name and a brief idea of what it does.>\n");
   6372   my_strcat(inbuf, "    Copyright (C) <year>  <name of author>\n");
   6373   my_strcat(inbuf, "\n");
   6374   my_strcat(inbuf, "    This program is free software; you can redistribute it and/or modify\n");
   6375   my_strcat(inbuf, "    it under the terms of the GNU General Public License as published by\n");
   6376   my_strcat(inbuf, "    the Free Software Foundation; either version 2 of the License, or\n");
   6377   my_strcat(inbuf, "    (at your option) any later version.\n");
   6378   my_strcat(inbuf, "\n");
   6379   my_strcat(inbuf, "    This program is distributed in the hope that it will be useful,\n");
   6380   my_strcat(inbuf, "    but WITHOUT ANY WARRANTY; without even the implied warranty of\n");
   6381   my_strcat(inbuf, "    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n");
   6382   my_strcat(inbuf, "    GNU General Public License for more details.\n");
   6383   my_strcat(inbuf, "\n");
   6384   my_strcat(inbuf, "    You should have received a copy of the GNU General Public License\n");
   6385   my_strcat(inbuf, "    along with this program; if not, write to the Free Software\n");
   6386   my_strcat(inbuf, "    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n");
   6387   my_strcat(inbuf, "\n");
   6388   my_strcat(inbuf, "\n");
   6389   my_strcat(inbuf, "Also add information on how to contact you by electronic and paper mail.\n");
   6390   my_strcat(inbuf, "\n");
   6391   my_strcat(inbuf, "If the program is interactive, make it output a short notice like this\n");
   6392   my_strcat(inbuf, "when it starts in an interactive mode:\n");
   6393   my_strcat(inbuf, "\n");
   6394   my_strcat(inbuf, "    Gnomovision version 69, Copyright (C) year  name of author\n");
   6395   my_strcat(inbuf, "    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.\n");
   6396   my_strcat(inbuf, "    This is free software, and you are welcome to redistribute it\n");
   6397   my_strcat(inbuf, "    under certain conditions; type `show c' for details.\n");
   6398   my_strcat(inbuf, "\n");
   6399   my_strcat(inbuf, "The hypothetical commands `show w' and `show c' should show the appropriate\n");
   6400   my_strcat(inbuf, "parts of the General Public License.  Of course, the commands you use may\n");
   6401   my_strcat(inbuf, "be called something other than `show w' and `show c'; they could even be\n");
   6402   my_strcat(inbuf, "mouse-clicks or menu items--whatever suits your program.\n");
   6403   my_strcat(inbuf, "\n");
   6404   my_strcat(inbuf, "You should also get your employer (if you work as a programmer) or your\n");
   6405   my_strcat(inbuf, "school, if any, to sign a copyright disclaimer for the program, if\n");
   6406   my_strcat(inbuf, "necessary.  Here is a sample; alter the names:\n");
   6407   my_strcat(inbuf, "\n");
   6408   my_strcat(inbuf, "  Yoyodyne, Inc., hereby disclaims all copyright interest in the program\n");
   6409   my_strcat(inbuf, "  `Gnomovision' (which makes passes at compilers) written by James Hacker.\n");
   6410   my_strcat(inbuf, "\n");
   6411   my_strcat(inbuf, "  <signature of Ty Coon>, 1 April 1989\n");
   6412   my_strcat(inbuf, "  Ty Coon, President of Vice\n");
   6413   my_strcat(inbuf, "\n");
   6414   my_strcat(inbuf, "This General Public License does not permit incorporating your program into\n");
   6415   my_strcat(inbuf, "proprietary programs.  If your program is a subroutine library, you may\n");
   6416   my_strcat(inbuf, "consider it more useful to permit linking proprietary applications with the\n");
   6417   my_strcat(inbuf, "library.  If this is what you want to do, use the GNU Library General\n");
   6418   my_strcat(inbuf, "Public License instead of this License.\n");
   6419 
   6420   my_strcat(inbuf, "\n");
   6421 }
   6422 
   6423 #include <stdio.h>
   6424 #include <assert.h>
   6425 
   6426 /* For providing services. */
   6427 static HWord g_serviceFn ( HWord arg1, HWord arg2 )
   6428 {
   6429    switch (arg1) {
   6430       case 0: /* EXIT */
   6431          exit(0);
   6432       case 1: /* PUTC */
   6433          putchar(arg2);
   6434          return 0;
   6435       case 2: /* MALLOC */
   6436          return (HWord)malloc(arg2);
   6437       case 3: /* FREE */
   6438          free((void*)arg2);
   6439          return 0;
   6440       default:
   6441          assert(0);
   6442    }
   6443 }
   6444 
   6445 static char *bzerrorstrings[] = {
   6446        "OK"
   6447        ,"SEQUENCE_ERROR"
   6448        ,"PARAM_ERROR"
   6449        ,"MEM_ERROR"
   6450        ,"DATA_ERROR"
   6451        ,"DATA_ERROR_MAGIC"
   6452        ,"IO_ERROR"
   6453        ,"UNEXPECTED_EOF"
   6454        ,"OUTBUFF_FULL"
   6455        ,"CONFIG_ERROR"
   6456        ,"???"   /* for future */
   6457        ,"???"   /* for future */
   6458        ,"???"   /* for future */
   6459        ,"???"   /* for future */
   6460        ,"???"   /* for future */
   6461        ,"???"   /* for future */
   6462 };
   6463 
   6464 // If given a cmd line arg, behave as a correctness regtest
   6465 // (run fast and be verbose).  If not, run for a long time
   6466 // which is what is needed for the performance suite.
   6467 int main ( int argc, char** argv )
   6468 {
   6469    int   r;
   6470    int   bit;
   6471    int   i;
   6472 
   6473    int regtest;
   6474    assert(argc == 1 || argc == 2);
   6475    regtest = argc==2;
   6476    regtest = 1;
   6477    serviceFn = g_serviceFn;
   6478 
   6479    set_inbuf();
   6480    nIn = vex_strlen(inbuf)+1;
   6481    vex_printf( "%d bytes read\n", nIn );
   6482 
   6483    nZ = M_BLOCK;
   6484    r = BZ2_bzBuffToBuffCompress (
   6485           zbuf, &nZ, inbuf, nIn, 9, 3/*verb*/, 30 );
   6486 
   6487    if (r != BZ_OK) {
   6488      vex_printf("initial compress failed!\n");
   6489      (*serviceFn)(0,0);
   6490    }
   6491    vex_printf( "%d after compression\n", nZ );
   6492 
   6493    for (bit = 0; bit < nZ*8; bit += (bit < 35 ? 1 : (regtest?2377:137))) {
   6494       if (regtest)
   6495          vex_printf( "bit %d  ", bit );
   6496       flip_bit ( bit );
   6497       nOut = M_BLOCK_OUT;
   6498       r = BZ2_bzBuffToBuffDecompress (
   6499              outbuf, &nOut, zbuf, nZ, 1/*small*/, 0 );
   6500       if (regtest)
   6501          vex_printf( " %d  %s ", r, bzerrorstrings[-r] );
   6502 
   6503       if (r != BZ_OK) {
   6504 	 if (regtest)
   6505             vex_printf( "\n" );
   6506       } else {
   6507          if (nOut != nIn) {
   6508            vex_printf(  "nIn/nOut mismatch %d %d\n", nIn, nOut );
   6509            (*serviceFn)(0,0);
   6510          } else {
   6511            for (i = 0; i < nOut; i++)
   6512              if (inbuf[i] != outbuf[i]) {
   6513                 vex_printf(  "mismatch at %d\n", i );
   6514                 (*serviceFn)(0,0);
   6515            }
   6516            if (i == nOut) vex_printf( "really ok!\n" );
   6517          }
   6518       }
   6519 
   6520       flip_bit ( bit );
   6521    }
   6522 
   6523 #if 0
   6524    assert (nOut == nIn);
   6525    for (i = 0; i < nOut; i++) {
   6526      if (inbuf[i] != outbuf[i]) {
   6527         vex_printf( "difference at %d !\n", i );
   6528         return 1;
   6529      }
   6530    }
   6531 #endif
   6532 
   6533    vex_printf( "all ok\n" );
   6534    (*serviceFn)(0,0);
   6535    /*NOTREACHED*/
   6536    return 0;
   6537 }
   6538