lib_generic/bzlib.c

   1 #include <config.h>
   2 #include <common.h>
   3 #include <watchdog.h>
   4 #ifdef CONFIG_BZIP2
   5
   6 /*
   7  * This file is a modified version of bzlib.c from the bzip2-1.0.2
   8  * distribution which can be found at http://sources.redhat.com/bzip2/
   9  */
  10
  11 /*-------------------------------------------------------------*/
  12 /*--- Library top-level functions.                          ---*/
  13 /*---                                               bzlib.c ---*/
  14 /*-------------------------------------------------------------*/
  15
  16 /*--
  17   This file is a part of bzip2 and/or libbzip2, a program and
  18   library for lossless, block-sorting data compression.
  19
  20   Copyright (C) 1996-2002 Julian R Seward.  All rights reserved.
  21
  22   Redistribution and use in source and binary forms, with or without
  23   modification, are permitted provided that the following conditions
  24   are met:
  25
  26   1. Redistributions of source code must retain the above copyright
  27      notice, this list of conditions and the following disclaimer.
  28
  29   2. The origin of this software must not be misrepresented; you must
  30      not claim that you wrote the original software.  If you use this
  31      software in a product, an acknowledgment in the product
  32      documentation would be appreciated but is not required.
  33
  34   3. Altered source versions must be plainly marked as such, and must
  35      not be misrepresented as being the original software.
  36
  37   4. The name of the author may not be used to endorse or promote
  38      products derived from this software without specific prior written
  39      permission.
  40
  41   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
  42   OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  43   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44   ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  45   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  47   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  48   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  49   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  50   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  51   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  52
  53   Julian Seward, Cambridge, UK.
  54   jseward@acm.org
  55   bzip2/libbzip2 version 1.0 of 21 March 2000
  56
  57   This program is based on (at least) the work of:
  58      Mike Burrows
  59      David Wheeler
  60      Peter Fenwick
  61      Alistair Moffat
  62      Radford Neal
  63      Ian H. Witten
  64      Robert Sedgewick
  65      Jon L. Bentley
  66
  67   For more information on these sources, see the manual.
  68 --*/
  69
  70 /*--
  71    CHANGES
  72    ~~~~~~~
  73    0.9.0 -- original version.
  74
  75    0.9.0a/b -- no changes in this file.
  76
  77    0.9.0c
  78       * made zero-length BZ_FLUSH work correctly in bzCompress().
  79       * fixed bzWrite/bzRead to ignore zero-length requests.
  80       * fixed bzread to correctly handle read requests after EOF.
  81       * wrong parameter order in call to bzDecompressInit in
  82         bzBuffToBuffDecompress.  Fixed.
  83 --*/
  84
  85 #include "bzlib_private.h"
  86
  87 /*---------------------------------------------------*/
  88 /*--- Compression stuff                           ---*/
  89 /*---------------------------------------------------*/
  90
  91
  92 /*---------------------------------------------------*/
  93 #ifndef BZ_NO_STDIO
  94 void BZ2_bz__AssertH__fail ( int errcode )
  95 {
  96    fprintf(stderr,
  97       "\n\nbzip2/libbzip2: internal error number %d.\n"
  98       "This is a bug in bzip2/libbzip2, %s.\n"
  99       "Please report it to me at: jseward@acm.org.  If this happened\n"
 100       "when you were using some program which uses libbzip2 as a\n"
 101       "component, you should also report this bug to the author(s)\n"
 102       "of that program.  Please make an effort to report this bug;\n"
 103       "timely and accurate bug reports eventually lead to higher\n"
 104       "quality software.  Thanks.  Julian Seward, 30 December 2001.\n\n",
 105       errcode,
 106       BZ2_bzlibVersion()
 107    );
 108
 109    if (errcode == 1007) {
 110    fprintf(stderr,
 111       "\n*** A special note about internal error number 1007 ***\n"
 112       "\n"
 113       "Experience suggests that a common cause of i.e. 1007\n"
 114       "is unreliable memory or other hardware.  The 1007 assertion\n"
 115       "just happens to cross-check the results of huge numbers of\n"
 116       "memory reads/writes, and so acts (unintendedly) as a stress\n"
 117       "test of your memory system.\n"
 118       "\n"
 119       "I suggest the following: try compressing the file again,\n"
 120       "possibly monitoring progress in detail with the -vv flag.\n"
 121       "\n"
 122       "* If the error cannot be reproduced, and/or happens at different\n"
 123       "  points in compression, you may have a flaky memory system.\n"
 124       "  Try a memory-test program.  I have used Memtest86\n"
 125       "  (www.memtest86.com).  At the time of writing it is free (GPLd).\n"
 126       "  Memtest86 tests memory much more thorougly than your BIOSs\n"
 127       "  power-on test, and may find failures that the BIOS doesn't.\n"
 128       "\n"
 129       "* If the error can be repeatably reproduced, this is a bug in\n"
 130       "  bzip2, and I would very much like to hear about it.  Please\n"
 131       "  let me know, and, ideally, save a copy of the file causing the\n"
 132       "  problem -- without which I will be unable to investigate it.\n"
 133       "\n"
 134    );
 135    }
 136
 137    exit(3);
 138 }
 139 #endif
 140
 141
 142 /*---------------------------------------------------*/
 143 static
 144 int bz_config_ok ( void )
 145 {
 146    if (sizeof(int)   != 4) return 0;
 147    if (sizeof(short) != 2) return 0;
 148    if (sizeof(char)  != 1) return 0;
 149    return 1;
 150 }
 151
 152
 153 /*---------------------------------------------------*/
 154 static
 155 void* default_bzalloc ( void* opaque, Int32 items, Int32 size )
 156 {
 157    void* v = malloc ( items * size );
 158    return v;
 159 }
 160
 161 static
 162 void default_bzfree ( void* opaque, void* addr )
 163 {
 164    if (addr != NULL) free ( addr );
 165 }
 166
 167 #ifndef BZ_NO_COMPRESS
 168 /*---------------------------------------------------*/
 169 static
 170 void prepare_new_block ( EState* s )
 171 {
 172    Int32 i;
 173    s->nblock = 0;
 174    s->numZ = 0;
 175    s->state_out_pos = 0;
 176    BZ_INITIALISE_CRC ( s->blockCRC );
 177    for (i = 0; i < 256; i++) s->inUse[i] = False;
 178    s->blockNo++;
 179 }
 180
 181
 182 /*---------------------------------------------------*/
 183 static
 184 void init_RL ( EState* s )
 185 {
 186    s->state_in_ch  = 256;
 187    s->state_in_len = 0;
 188 }
 189
 190
 191 static
 192 Bool isempty_RL ( EState* s )
 193 {
 194    if (s->state_in_ch < 256 && s->state_in_len > 0)
 195       return False; else
 196       return True;
 197 }
 198
 199 /*---------------------------------------------------*/
 200 int BZ_API(BZ2_bzCompressInit)
 201                     ( bz_stream* strm,
 202                      int        blockSize100k,
 203                      int        verbosity,
 204                      int        workFactor )
 205 {
 206    Int32   n;
 207    EState* s;
 208
 209    if (!bz_config_ok()) return BZ_CONFIG_ERROR;
 210
 211    if (strm == NULL ||
 212        blockSize100k < 1 || blockSize100k > 9 ||
 213        workFactor < 0 || workFactor > 250)
 214      return BZ_PARAM_ERROR;
 215
 216    if (workFactor == 0) workFactor = 30;
 217    if (strm->bzalloc == NULL) strm->bzalloc = default_bzalloc;
 218    if (strm->bzfree == NULL) strm->bzfree = default_bzfree;
 219
 220    s = BZALLOC( sizeof(EState) );
 221    if (s == NULL) return BZ_MEM_ERROR;
 222    s->strm = strm;
 223
 224    s->arr1 = NULL;
 225    s->arr2 = NULL;
 226    s->ftab = NULL;
 227
 228    n       = 100000 * blockSize100k;
 229    s->arr1 = BZALLOC( n                  * sizeof(UInt32) );
 230    s->arr2 = BZALLOC( (n+BZ_N_OVERSHOOT) * sizeof(UInt32) );
 231    s->ftab = BZALLOC( 65537              * sizeof(UInt32) );
 232
 233    if (s->arr1 == NULL || s->arr2 == NULL || s->ftab == NULL) {
 234       if (s->arr1 != NULL) BZFREE(s->arr1);
 235       if (s->arr2 != NULL) BZFREE(s->arr2);
 236       if (s->ftab != NULL) BZFREE(s->ftab);
 237       if (s       != NULL) BZFREE(s);
 238       return BZ_MEM_ERROR;
 239    }
 240
 241    s->blockNo           = 0;
 242    s->state             = BZ_S_INPUT;
 243    s->mode              = BZ_M_RUNNING;
 244    s->combinedCRC       = 0;
 245    s->blockSize100k     = blockSize100k;
 246    s->nblockMAX         = 100000 * blockSize100k - 19;
 247    s->verbosity         = verbosity;
 248    s->workFactor        = workFactor;
 249
 250    s->block             = (UChar*)s->arr2;
 251    s->mtfv              = (UInt16*)s->arr1;
 252    s->zbits             = NULL;
 253    s->ptr               = (UInt32*)s->arr1;
 254
 255    strm->state          = s;
 256    strm->total_in_lo32  = 0;
 257    strm->total_in_hi32  = 0;
 258    strm->total_out_lo32 = 0;
 259    strm->total_out_hi32 = 0;
 260    init_RL ( s );
 261    prepare_new_block ( s );
 262    return BZ_OK;
 263 }
 264
 265
 266 /*---------------------------------------------------*/
 267 static
 268 void add_pair_to_block ( EState* s )
 269 {
 270    Int32 i;
 271    UChar ch = (UChar)(s->state_in_ch);
 272    for (i = 0; i < s->state_in_len; i++) {
 273       BZ_UPDATE_CRC( s->blockCRC, ch );
 274    }
 275    s->inUse[s->state_in_ch] = True;
 276    switch (s->state_in_len) {
 277       case 1:
 278          s->block[s->nblock] = (UChar)ch; s->nblock++;
 279          break;
 280       case 2:
 281          s->block[s->nblock] = (UChar)ch; s->nblock++;
 282          s->block[s->nblock] = (UChar)ch; s->nblock++;
 283          break;
 284       case 3:
 285          s->block[s->nblock] = (UChar)ch; s->nblock++;
 286          s->block[s->nblock] = (UChar)ch; s->nblock++;
 287          s->block[s->nblock] = (UChar)ch; s->nblock++;
 288          break;
 289       default:
 290          s->inUse[s->state_in_len-4] = True;
 291          s->block[s->nblock] = (UChar)ch; s->nblock++;
 292          s->block[s->nblock] = (UChar)ch; s->nblock++;
 293          s->block[s->nblock] = (UChar)ch; s->nblock++;
 294          s->block[s->nblock] = (UChar)ch; s->nblock++;
 295          s->block[s->nblock] = ((UChar)(s->state_in_len-4));
 296          s->nblock++;
 297          break;
 298    }
 299 }
 300
 301
 302 /*---------------------------------------------------*/
 303 static
 304 void flush_RL ( EState* s )
 305 {
 306    if (s->state_in_ch < 256) add_pair_to_block ( s );
 307    init_RL ( s );
 308 }
 309
 310
 311 /*---------------------------------------------------*/
 312 #define ADD_CHAR_TO_BLOCK(zs,zchh0)               \
 313 {                                                 \
 314    UInt32 zchh = (UInt32)(zchh0);                 \
 315    /*-- fast track the common case --*/           \
 316    if (zchh != zs->state_in_ch &&                 \
 317        zs->state_in_len == 1) {                   \
 318       UChar ch = (UChar)(zs->state_in_ch);        \
 319       BZ_UPDATE_CRC( zs->blockCRC, ch );          \
 320       zs->inUse[zs->state_in_ch] = True;          \
 321       zs->block[zs->nblock] = (UChar)ch;          \
 322       zs->nblock++;                               \
 323       zs->state_in_ch = zchh;                     \
 324    }                                              \
 325    else                                           \
 326    /*-- general, uncommon cases --*/              \
 327    if (zchh != zs->state_in_ch ||                 \
 328       zs->state_in_len == 255) {                  \
 329       if (zs->state_in_ch < 256)                  \
 330          add_pair_to_block ( zs );                \
 331       zs->state_in_ch = zchh;                     \
 332       zs->state_in_len = 1;                       \
 333    } else {                                       \
 334       zs->state_in_len++;                         \
 335    }                                              \
 336 }
 337
 338
 339 /*---------------------------------------------------*/
 340 static
 341 Bool copy_input_until_stop ( EState* s )
 342 {
 343    Bool progress_in = False;
 344
 345    if (s->mode == BZ_M_RUNNING) {
 346
 347       /*-- fast track the common case --*/
 348       while (True) {
 349          /*-- block full? --*/
 350          if (s->nblock >= s->nblockMAX) break;
 351          /*-- no input? --*/
 352          if (s->strm->avail_in == 0) break;
 353          progress_in = True;
 354          ADD_CHAR_TO_BLOCK ( s, (UInt32)(*((UChar*)(s->strm->next_in))) );
 355          s->strm->next_in++;
 356          s->strm->avail_in--;
 357          s->strm->total_in_lo32++;
 358          if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++;
 359       }
 360
 361    } else {
 362
 363       /*-- general, uncommon case --*/
 364       while (True) {
 365          /*-- block full? --*/
 366          if (s->nblock >= s->nblockMAX) break;
 367          /*-- no input? --*/
 368          if (s->strm->avail_in == 0) break;
 369          /*-- flush/finish end? --*/
 370          if (s->avail_in_expect == 0) break;
 371          progress_in = True;
 372          ADD_CHAR_TO_BLOCK ( s, (UInt32)(*((UChar*)(s->strm->next_in))) );
 373          s->strm->next_in++;
 374          s->strm->avail_in--;
 375          s->strm->total_in_lo32++;
 376          if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++;
 377          s->avail_in_expect--;
 378       }
 379    }
 380    return progress_in;
 381 }
 382
 383
 384 /*---------------------------------------------------*/
 385 static
 386 Bool copy_output_until_stop ( EState* s )
 387 {
 388    Bool progress_out = False;
 389
 390    while (True) {
 391
 392       /*-- no output space? --*/
 393       if (s->strm->avail_out == 0) break;
 394
 395       /*-- block done? --*/
 396       if (s->state_out_pos >= s->numZ) break;
 397
 398       progress_out = True;
 399       *(s->strm->next_out) = s->zbits[s->state_out_pos];
 400       s->state_out_pos++;
 401       s->strm->avail_out--;
 402       s->strm->next_out++;
 403       s->strm->total_out_lo32++;
 404       if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
 405    }
 406
 407    return progress_out;
 408 }
 409
 410
 411 /*---------------------------------------------------*/
 412 static
 413 Bool handle_compress ( bz_stream* strm )
 414 {
 415    Bool progress_in  = False;
 416    Bool progress_out = False;
 417    EState* s = strm->state;
 418
 419    while (True) {
 420
 421       if (s->state == BZ_S_OUTPUT) {
 422          progress_out |= copy_output_until_stop ( s );
 423          if (s->state_out_pos < s->numZ) break;
 424          if (s->mode == BZ_M_FINISHING &&
 425              s->avail_in_expect == 0 &&
 426              isempty_RL(s)) break;
 427          prepare_new_block ( s );
 428          s->state = BZ_S_INPUT;
 429          if (s->mode == BZ_M_FLUSHING &&
 430              s->avail_in_expect == 0 &&
 431              isempty_RL(s)) break;
 432       }
 433
 434       if (s->state == BZ_S_INPUT) {
 435          progress_in |= copy_input_until_stop ( s );
 436          if (s->mode != BZ_M_RUNNING && s->avail_in_expect == 0) {
 437             flush_RL ( s );
 438             BZ2_compressBlock ( s, (Bool)(s->mode == BZ_M_FINISHING) );
 439             s->state = BZ_S_OUTPUT;
 440          }
 441          else
 442          if (s->nblock >= s->nblockMAX) {
 443             BZ2_compressBlock ( s, False );
 444             s->state = BZ_S_OUTPUT;
 445          }
 446          else
 447          if (s->strm->avail_in == 0) {
 448             break;
 449          }
 450       }
 451
 452    }
 453
 454    return progress_in || progress_out;
 455 }
 456
 457
 458 /*---------------------------------------------------*/
 459 int BZ_API(BZ2_bzCompress) ( bz_stream *strm, int action )
 460 {
 461    Bool progress;
 462    EState* s;
 463    if (strm == NULL) return BZ_PARAM_ERROR;
 464    s = strm->state;
 465    if (s == NULL) return BZ_PARAM_ERROR;
 466    if (s->strm != strm) return BZ_PARAM_ERROR;
 467
 468    preswitch:
 469    switch (s->mode) {
 470
 471       case BZ_M_IDLE:
 472          return BZ_SEQUENCE_ERROR;
 473
 474       case BZ_M_RUNNING:
 475          if (action == BZ_RUN) {
 476             progress = handle_compress ( strm );
 477             return progress ? BZ_RUN_OK : BZ_PARAM_ERROR;
 478          }
 479          else
 480          if (action == BZ_FLUSH) {
 481             s->avail_in_expect = strm->avail_in;
 482             s->mode = BZ_M_FLUSHING;
 483             goto preswitch;
 484          }
 485          else
 486          if (action == BZ_FINISH) {
 487             s->avail_in_expect = strm->avail_in;
 488             s->mode = BZ_M_FINISHING;
 489             goto preswitch;
 490          }
 491          else
 492             return BZ_PARAM_ERROR;
 493
 494       case BZ_M_FLUSHING:
 495          if (action != BZ_FLUSH) return BZ_SEQUENCE_ERROR;
 496          if (s->avail_in_expect != s->strm->avail_in)
 497             return BZ_SEQUENCE_ERROR;
 498          progress = handle_compress ( strm );
 499          if (s->avail_in_expect > 0 || !isempty_RL(s) ||
 500              s->state_out_pos < s->numZ) return BZ_FLUSH_OK;
 501          s->mode = BZ_M_RUNNING;
 502          return BZ_RUN_OK;
 503
 504       case BZ_M_FINISHING:
 505          if (action != BZ_FINISH) return BZ_SEQUENCE_ERROR;
 506          if (s->avail_in_expect != s->strm->avail_in)
 507             return BZ_SEQUENCE_ERROR;
 508          progress = handle_compress ( strm );
 509          if (!progress) return BZ_SEQUENCE_ERROR;
 510          if (s->avail_in_expect > 0 || !isempty_RL(s) ||
 511              s->state_out_pos < s->numZ) return BZ_FINISH_OK;
 512          s->mode = BZ_M_IDLE;
 513          return BZ_STREAM_END;
 514    }
 515    return BZ_OK; /*--not reached--*/
 516 }
 517
 518
 519 /*---------------------------------------------------*/
 520 int BZ_API(BZ2_bzCompressEnd)  ( bz_stream *strm )
 521 {
 522    EState* s;
 523    if (strm == NULL) return BZ_PARAM_ERROR;
 524    s = strm->state;
 525    if (s == NULL) return BZ_PARAM_ERROR;
 526    if (s->strm != strm) return BZ_PARAM_ERROR;
 527
 528    if (s->arr1 != NULL) BZFREE(s->arr1);
 529    if (s->arr2 != NULL) BZFREE(s->arr2);
 530    if (s->ftab != NULL) BZFREE(s->ftab);
 531    BZFREE(strm->state);
 532
 533    strm->state = NULL;
 534
 535    return BZ_OK;
 536 }
 537 #endif /* BZ_NO_COMPRESS */
 538
 539 /*---------------------------------------------------*/
 540 /*--- Decompression stuff                         ---*/
 541 /*---------------------------------------------------*/
 542
 543 /*---------------------------------------------------*/
 544 int BZ_API(BZ2_bzDecompressInit)
 545                      ( bz_stream* strm,
 546                        int        verbosity,
 547                        int        small )
 548 {
 549    DState* s;
 550
 551    if (!bz_config_ok()) return BZ_CONFIG_ERROR;
 552
 553    if (strm == NULL) return BZ_PARAM_ERROR;
 554    if (small != 0 && small != 1) return BZ_PARAM_ERROR;
 555    if (verbosity < 0 || verbosity > 4) return BZ_PARAM_ERROR;
 556
 557    if (strm->bzalloc == NULL) strm->bzalloc = default_bzalloc;
 558    if (strm->bzfree == NULL) strm->bzfree = default_bzfree;
 559
 560    s = BZALLOC( sizeof(DState) );
 561    if (s == NULL) return BZ_MEM_ERROR;
 562    s->strm                  = strm;
 563    strm->state              = s;
 564    s->state                 = BZ_X_MAGIC_1;
 565    s->bsLive                = 0;
 566    s->bsBuff                = 0;
 567    s->calculatedCombinedCRC = 0;
 568    strm->total_in_lo32      = 0;
 569    strm->total_in_hi32      = 0;
 570    strm->total_out_lo32     = 0;
 571    strm->total_out_hi32     = 0;
 572    s->smallDecompress       = (Bool)small;
 573    s->ll4                   = NULL;
 574    s->ll16                  = NULL;
 575    s->tt                    = NULL;
 576    s->currBlockNo           = 0;
 577    s->verbosity             = verbosity;
 578
 579    return BZ_OK;
 580 }
 581
 582
 583 /*---------------------------------------------------*/
 584 static
 585 void unRLE_obuf_to_output_FAST ( DState* s )
 586 {
 587    UChar k1;
 588
 589    if (s->blockRandomised) {
 590
 591       while (True) {
 592          /* try to finish existing run */
 593          while (True) {
 594             if (s->strm->avail_out == 0) return;
 595             if (s->state_out_len == 0) break;
 596             *( (UChar*)(s->strm->next_out) ) = s->state_out_ch;
 597             BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch );
 598             s->state_out_len--;
 599             s->strm->next_out++;
 600             s->strm->avail_out--;
 601             s->strm->total_out_lo32++;
 602             if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
 603          }
 604
 605          /* can a new run be started? */
 606          if (s->nblock_used == s->save_nblock+1) return;
 607
 608
 609          s->state_out_len = 1;
 610          s->state_out_ch = s->k0;
 611          BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
 612          k1 ^= BZ_RAND_MASK; s->nblock_used++;
 613          if (s->nblock_used == s->save_nblock+1) continue;
 614          if (k1 != s->k0) { s->k0 = k1; continue; };
 615
 616          s->state_out_len = 2;
 617          BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
 618          k1 ^= BZ_RAND_MASK; s->nblock_used++;
 619          if (s->nblock_used == s->save_nblock+1) continue;
 620          if (k1 != s->k0) { s->k0 = k1; continue; };
 621
 622          s->state_out_len = 3;
 623          BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
 624          k1 ^= BZ_RAND_MASK; s->nblock_used++;
 625          if (s->nblock_used == s->save_nblock+1) continue;
 626          if (k1 != s->k0) { s->k0 = k1; continue; };
 627
 628          BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
 629          k1 ^= BZ_RAND_MASK; s->nblock_used++;
 630          s->state_out_len = ((Int32)k1) + 4;
 631          BZ_GET_FAST(s->k0); BZ_RAND_UPD_MASK;
 632          s->k0 ^= BZ_RAND_MASK; s->nblock_used++;
 633       }
 634
 635    } else {
 636
 637       /* restore */
 638       UInt32        c_calculatedBlockCRC = s->calculatedBlockCRC;
 639       UChar         c_state_out_ch       = s->state_out_ch;
 640       Int32         c_state_out_len      = s->state_out_len;
 641       Int32         c_nblock_used        = s->nblock_used;
 642       Int32         c_k0                 = s->k0;
 643       UInt32*       c_tt                 = s->tt;
 644       UInt32        c_tPos               = s->tPos;
 645       char*         cs_next_out          = s->strm->next_out;
 646       unsigned int  cs_avail_out         = s->strm->avail_out;
 647       /* end restore */
 648
 649       UInt32       avail_out_INIT = cs_avail_out;
 650       Int32        s_save_nblockPP = s->save_nblock+1;
 651       unsigned int total_out_lo32_old;
 652
 653       while (True) {
 654
 655          /* try to finish existing run */
 656          if (c_state_out_len > 0) {
 657             while (True) {
 658                if (cs_avail_out == 0) goto return_notr;
 659                if (c_state_out_len == 1) break;
 660                *( (UChar*)(cs_next_out) ) = c_state_out_ch;
 661                BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch );
 662                c_state_out_len--;
 663                cs_next_out++;
 664                cs_avail_out--;
 665             }
 666             s_state_out_len_eq_one:
 667             {
 668                if (cs_avail_out == 0) {
 669                   c_state_out_len = 1; goto return_notr;
 670                };
 671                *( (UChar*)(cs_next_out) ) = c_state_out_ch;
 672                BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch );
 673                cs_next_out++;
 674                cs_avail_out--;
 675             }
 676          }
 677          /* can a new run be started? */
 678          if (c_nblock_used == s_save_nblockPP) {
 679             c_state_out_len = 0; goto return_notr;
 680          };
 681          c_state_out_ch = c_k0;
 682          BZ_GET_FAST_C(k1); c_nblock_used++;
 683          if (k1 != c_k0) {
 684             c_k0 = k1; goto s_state_out_len_eq_one;
 685          };
 686          if (c_nblock_used == s_save_nblockPP)
 687             goto s_state_out_len_eq_one;
 688
 689          c_state_out_len = 2;
 690          BZ_GET_FAST_C(k1); c_nblock_used++;
 691          if (c_nblock_used == s_save_nblockPP) continue;
 692          if (k1 != c_k0) { c_k0 = k1; continue; };
 693
 694          c_state_out_len = 3;
 695          BZ_GET_FAST_C(k1); c_nblock_used++;
 696          if (c_nblock_used == s_save_nblockPP) continue;
 697          if (k1 != c_k0) { c_k0 = k1; continue; };
 698
 699          BZ_GET_FAST_C(k1); c_nblock_used++;
 700          c_state_out_len = ((Int32)k1) + 4;
 701          BZ_GET_FAST_C(c_k0); c_nblock_used++;
 702       }
 703
 704       return_notr:
 705       total_out_lo32_old = s->strm->total_out_lo32;
 706       s->strm->total_out_lo32 += (avail_out_INIT - cs_avail_out);
 707       if (s->strm->total_out_lo32 < total_out_lo32_old)
 708          s->strm->total_out_hi32++;
 709
 710       /* save */
 711       s->calculatedBlockCRC = c_calculatedBlockCRC;
 712       s->state_out_ch       = c_state_out_ch;
 713       s->state_out_len      = c_state_out_len;
 714       s->nblock_used        = c_nblock_used;
 715       s->k0                 = c_k0;
 716       s->tt                 = c_tt;
 717       s->tPos               = c_tPos;
 718       s->strm->next_out     = cs_next_out;
 719       s->strm->avail_out    = cs_avail_out;
 720       /* end save */
 721    }
 722 }
 723
 724
 725 /*---------------------------------------------------*/
 726 __inline__ Int32 BZ2_indexIntoF ( Int32 indx, Int32 *cftab )
 727 {
 728    Int32 nb, na, mid;
 729    nb = 0;
 730    na = 256;
 731    do {
 732       mid = (nb + na) >> 1;
 733       if (indx >= cftab[mid]) nb = mid; else na = mid;
 734    }
 735    while (na - nb != 1);
 736    return nb;
 737 }
 738
 739
 740 /*---------------------------------------------------*/
 741 static
 742 void unRLE_obuf_to_output_SMALL ( DState* s )
 743 {
 744    UChar k1;
 745
 746    if (s->blockRandomised) {
 747
 748       while (True) {
 749          /* try to finish existing run */
 750          while (True) {
 751             if (s->strm->avail_out == 0) return;
 752             if (s->state_out_len == 0) break;
 753             *( (UChar*)(s->strm->next_out) ) = s->state_out_ch;
 754             BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch );
 755             s->state_out_len--;
 756             s->strm->next_out++;
 757             s->strm->avail_out--;
 758             s->strm->total_out_lo32++;
 759             if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
 760          }
 761
 762          /* can a new run be started? */
 763          if (s->nblock_used == s->save_nblock+1) return;
 764
 765
 766          s->state_out_len = 1;
 767          s->state_out_ch = s->k0;
 768          BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
 769          k1 ^= BZ_RAND_MASK; s->nblock_used++;
 770          if (s->nblock_used == s->save_nblock+1) continue;
 771          if (k1 != s->k0) { s->k0 = k1; continue; };
 772
 773          s->state_out_len = 2;
 774          BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
 775          k1 ^= BZ_RAND_MASK; s->nblock_used++;
 776          if (s->nblock_used == s->save_nblock+1) continue;
 777          if (k1 != s->k0) { s->k0 = k1; continue; };
 778
 779          s->state_out_len = 3;
 780          BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
 781          k1 ^= BZ_RAND_MASK; s->nblock_used++;
 782          if (s->nblock_used == s->save_nblock+1) continue;
 783          if (k1 != s->k0) { s->k0 = k1; continue; };
 784
 785          BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
 786          k1 ^= BZ_RAND_MASK; s->nblock_used++;
 787          s->state_out_len = ((Int32)k1) + 4;
 788          BZ_GET_SMALL(s->k0); BZ_RAND_UPD_MASK;
 789          s->k0 ^= BZ_RAND_MASK; s->nblock_used++;
 790       }
 791
 792    } else {
 793
 794       while (True) {
 795          /* try to finish existing run */
 796          while (True) {
 797             if (s->strm->avail_out == 0) return;
 798             if (s->state_out_len == 0) break;
 799             *( (UChar*)(s->strm->next_out) ) = s->state_out_ch;
 800             BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch );
 801             s->state_out_len--;
 802             s->strm->next_out++;
 803             s->strm->avail_out--;
 804             s->strm->total_out_lo32++;
 805             if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
 806          }
 807
 808          /* can a new run be started? */
 809          if (s->nblock_used == s->save_nblock+1) return;
 810
 811          s->state_out_len = 1;
 812          s->state_out_ch = s->k0;
 813          BZ_GET_SMALL(k1); s->nblock_used++;
 814          if (s->nblock_used == s->save_nblock+1) continue;
 815          if (k1 != s->k0) { s->k0 = k1; continue; };
 816
 817          s->state_out_len = 2;
 818          BZ_GET_SMALL(k1); s->nblock_used++;
 819          if (s->nblock_used == s->save_nblock+1) continue;
 820          if (k1 != s->k0) { s->k0 = k1; continue; };
 821
 822          s->state_out_len = 3;
 823          BZ_GET_SMALL(k1); s->nblock_used++;
 824          if (s->nblock_used == s->save_nblock+1) continue;
 825          if (k1 != s->k0) { s->k0 = k1; continue; };
 826
 827          BZ_GET_SMALL(k1); s->nblock_used++;
 828          s->state_out_len = ((Int32)k1) + 4;
 829          BZ_GET_SMALL(s->k0); s->nblock_used++;
 830       }
 831
 832    }
 833 }
 834
 835
 836 /*---------------------------------------------------*/
 837 int BZ_API(BZ2_bzDecompress) ( bz_stream *strm )
 838 {
 839    DState* s;
 840    if (strm == NULL) return BZ_PARAM_ERROR;
 841    s = strm->state;
 842    if (s == NULL) return BZ_PARAM_ERROR;
 843    if (s->strm != strm) return BZ_PARAM_ERROR;
 844
 845    while (True) {
 846 #if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
 847         WATCHDOG_RESET();
 848 #endif
 849       if (s->state == BZ_X_IDLE) return BZ_SEQUENCE_ERROR;
 850       if (s->state == BZ_X_OUTPUT) {
 851          if (s->smallDecompress)
 852             unRLE_obuf_to_output_SMALL ( s ); else
 853             unRLE_obuf_to_output_FAST  ( s );
 854          if (s->nblock_used == s->save_nblock+1 && s->state_out_len == 0) {
 855             BZ_FINALISE_CRC ( s->calculatedBlockCRC );
 856             if (s->verbosity >= 3)
 857                VPrintf2 ( " {0x%x, 0x%x}", s->storedBlockCRC,
 858                           s->calculatedBlockCRC );
 859             if (s->verbosity >= 2) VPrintf0 ( "]" );
 860             if (s->calculatedBlockCRC != s->storedBlockCRC)
 861                return BZ_DATA_ERROR;
 862             s->calculatedCombinedCRC
 863                = (s->calculatedCombinedCRC << 1) |
 864                     (s->calculatedCombinedCRC >> 31);
 865             s->calculatedCombinedCRC ^= s->calculatedBlockCRC;
 866             s->state = BZ_X_BLKHDR_1;
 867          } else {
 868             return BZ_OK;
 869          }
 870       }
 871       if (s->state >= BZ_X_MAGIC_1) {
 872          Int32 r = BZ2_decompress ( s );
 873          if (r == BZ_STREAM_END) {
 874             if (s->verbosity >= 3)
 875                VPrintf2 ( "\n    combined CRCs: stored = 0x%x, computed = 0x%x",
 876                           s->storedCombinedCRC, s->calculatedCombinedCRC );
 877             if (s->calculatedCombinedCRC != s->storedCombinedCRC)
 878                return BZ_DATA_ERROR;
 879             return r;
 880          }
 881          if (s->state != BZ_X_OUTPUT) return r;
 882       }
 883    }
 884
 885    AssertH ( 0, 6001 );
 886
 887    return 0;  /*NOTREACHED*/
 888 }
 889
 890
 891 /*---------------------------------------------------*/
 892 int BZ_API(BZ2_bzDecompressEnd)  ( bz_stream *strm )
 893 {
 894    DState* s;
 895    if (strm == NULL) return BZ_PARAM_ERROR;
 896    s = strm->state;
 897    if (s == NULL) return BZ_PARAM_ERROR;
 898    if (s->strm != strm) return BZ_PARAM_ERROR;
 899
 900    if (s->tt   != NULL) BZFREE(s->tt);
 901    if (s->ll16 != NULL) BZFREE(s->ll16);
 902    if (s->ll4  != NULL) BZFREE(s->ll4);
 903
 904    BZFREE(strm->state);
 905    strm->state = NULL;
 906
 907    return BZ_OK;
 908 }
 909
 910
 911 #ifndef BZ_NO_STDIO
 912 /*---------------------------------------------------*/
 913 /*--- File I/O stuff                              ---*/
 914 /*---------------------------------------------------*/
 915
 916 #define BZ_SETERR(eee)                    \
 917 {                                         \
 918    if (bzerror != NULL) *bzerror = eee;   \
 919    if (bzf != NULL) bzf->lastErr = eee;   \
 920 }
 921
 922 typedef
 923    struct {
 924       FILE*     handle;
 925       Char      buf[BZ_MAX_UNUSED];
 926       Int32     bufN;
 927       Bool      writing;
 928       bz_stream strm;
 929       Int32     lastErr;
 930       Bool      initialisedOk;
 931    }
 932    bzFile;
 933
 934
 935 /*---------------------------------------------*/
 936 static Bool myfeof ( FILE* f )
 937 {
 938    Int32 c = fgetc ( f );
 939    if (c == EOF) return True;
 940    ungetc ( c, f );
 941    return False;
 942 }
 943
 944
 945 /*---------------------------------------------------*/
 946 BZFILE* BZ_API(BZ2_bzWriteOpen)
 947                     ( int*  bzerror,
 948                       FILE* f,
 949                       int   blockSize100k,
 950                       int   verbosity,
 951                       int   workFactor )
 952 {
 953    Int32   ret;
 954    bzFile* bzf = NULL;
 955
 956    BZ_SETERR(BZ_OK);
 957
 958    if (f == NULL ||
 959        (blockSize100k < 1 || blockSize100k > 9) ||
 960        (workFactor < 0 || workFactor > 250) ||
 961        (verbosity < 0 || verbosity > 4))
 962       { BZ_SETERR(BZ_PARAM_ERROR); return NULL; };
 963
 964    if (ferror(f))
 965       { BZ_SETERR(BZ_IO_ERROR); return NULL; };
 966
 967    bzf = malloc ( sizeof(bzFile) );
 968    if (bzf == NULL)
 969       { BZ_SETERR(BZ_MEM_ERROR); return NULL; };
 970
 971    BZ_SETERR(BZ_OK);
 972    bzf->initialisedOk = False;
 973    bzf->bufN          = 0;
 974    bzf->handle        = f;
 975    bzf->writing       = True;
 976    bzf->strm.bzalloc  = NULL;
 977    bzf->strm.bzfree   = NULL;
 978    bzf->strm.opaque   = NULL;
 979
 980    if (workFactor == 0) workFactor = 30;
 981    ret = BZ2_bzCompressInit ( &(bzf->strm), blockSize100k,
 982                               verbosity, workFactor );
 983    if (ret != BZ_OK)
 984       { BZ_SETERR(ret); free(bzf); return NULL; };
 985
 986    bzf->strm.avail_in = 0;
 987    bzf->initialisedOk = True;
 988    return bzf;
 989 }
 990
 991
 992 /*---------------------------------------------------*/
 993 void BZ_API(BZ2_bzWrite)
 994              ( int*    bzerror,
 995                BZFILE* b,
 996                void*   buf,
 997                int     len )
 998 {
 999    Int32 n, n2, ret;
1000    bzFile* bzf = (bzFile*)b;
1001
1002    BZ_SETERR(BZ_OK);
1003    if (bzf == NULL || buf == NULL || len < 0)
1004       { BZ_SETERR(BZ_PARAM_ERROR); return; };
1005    if (!(bzf->writing))
1006       { BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
1007    if (ferror(bzf->handle))
1008       { BZ_SETERR(BZ_IO_ERROR); return; };
1009
1010    if (len == 0)
1011       { BZ_SETERR(BZ_OK); return; };
1012
1013    bzf->strm.avail_in = len;
1014    bzf->strm.next_in  = buf;
1015
1016    while (True) {
1017       bzf->strm.avail_out = BZ_MAX_UNUSED;
1018       bzf->strm.next_out = bzf->buf;
1019       ret = BZ2_bzCompress ( &(bzf->strm), BZ_RUN );
1020       if (ret != BZ_RUN_OK)
1021          { BZ_SETERR(ret); return; };
1022
1023       if (bzf->strm.avail_out < BZ_MAX_UNUSED) {
1024          n = BZ_MAX_UNUSED - bzf->strm.avail_out;
1025          n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar),
1026                        n, bzf->handle );
1027          if (n != n2 || ferror(bzf->handle))
1028             { BZ_SETERR(BZ_IO_ERROR); return; };
1029       }
1030
1031       if (bzf->strm.avail_in == 0)
1032          { BZ_SETERR(BZ_OK); return; };
1033    }
1034 }
1035
1036
1037 /*---------------------------------------------------*/
1038 void BZ_API(BZ2_bzWriteClose)
1039                   ( int*          bzerror,
1040                     BZFILE*       b,
1041                     int           abandon,
1042                     unsigned int* nbytes_in,
1043                     unsigned int* nbytes_out )
1044 {
1045    BZ2_bzWriteClose64 ( bzerror, b, abandon,
1046                         nbytes_in, NULL, nbytes_out, NULL );
1047 }
1048
1049
1050 void BZ_API(BZ2_bzWriteClose64)
1051                   ( int*          bzerror,
1052                     BZFILE*       b,
1053                     int           abandon,
1054                     unsigned int* nbytes_in_lo32,
1055                     unsigned int* nbytes_in_hi32,
1056                     unsigned int* nbytes_out_lo32,
1057                     unsigned int* nbytes_out_hi32 )
1058 {
1059    Int32   n, n2, ret;
1060    bzFile* bzf = (bzFile*)b;
1061
1062    if (bzf == NULL)
1063       { BZ_SETERR(BZ_OK); return; };
1064    if (!(bzf->writing))
1065       { BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
1066    if (ferror(bzf->handle))
1067       { BZ_SETERR(BZ_IO_ERROR); return; };
1068
1069    if (nbytes_in_lo32 != NULL) *nbytes_in_lo32 = 0;
1070    if (nbytes_in_hi32 != NULL) *nbytes_in_hi32 = 0;
1071    if (nbytes_out_lo32 != NULL) *nbytes_out_lo32 = 0;
1072    if (nbytes_out_hi32 != NULL) *nbytes_out_hi32 = 0;
1073
1074    if ((!abandon) && bzf->lastErr == BZ_OK) {
1075       while (True) {
1076          bzf->strm.avail_out = BZ_MAX_UNUSED;
1077          bzf->strm.next_out = bzf->buf;
1078          ret = BZ2_bzCompress ( &(bzf->strm), BZ_FINISH );
1079          if (ret != BZ_FINISH_OK && ret != BZ_STREAM_END)
1080             { BZ_SETERR(ret); return; };
1081
1082          if (bzf->strm.avail_out < BZ_MAX_UNUSED) {
1083             n = BZ_MAX_UNUSED - bzf->strm.avail_out;
1084             n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar),
1085                           n, bzf->handle );
1086             if (n != n2 || ferror(bzf->handle))
1087                { BZ_SETERR(BZ_IO_ERROR); return; };
1088          }
1089
1090          if (ret == BZ_STREAM_END) break;
1091       }
1092    }
1093
1094    if ( !abandon && !ferror ( bzf->handle ) ) {
1095       fflush ( bzf->handle );
1096       if (ferror(bzf->handle))
1097          { BZ_SETERR(BZ_IO_ERROR); return; };
1098    }
1099
1100    if (nbytes_in_lo32 != NULL)
1101       *nbytes_in_lo32 = bzf->strm.total_in_lo32;
1102    if (nbytes_in_hi32 != NULL)
1103       *nbytes_in_hi32 = bzf->strm.total_in_hi32;
1104    if (nbytes_out_lo32 != NULL)
1105       *nbytes_out_lo32 = bzf->strm.total_out_lo32;
1106    if (nbytes_out_hi32 != NULL)
1107       *nbytes_out_hi32 = bzf->strm.total_out_hi32;
1108
1109    BZ_SETERR(BZ_OK);
1110    BZ2_bzCompressEnd ( &(bzf->strm) );
1111    free ( bzf );
1112 }
1113
1114
1115 /*---------------------------------------------------*/
1116 BZFILE* BZ_API(BZ2_bzReadOpen)
1117                    ( int*  bzerror,
1118                      FILE* f,
1119                      int   verbosity,
1120                      int   small,
1121                      void* unused,
1122                      int   nUnused )
1123 {
1124    bzFile* bzf = NULL;
1125    int     ret;
1126
1127    BZ_SETERR(BZ_OK);
1128
1129    if (f == NULL ||
1130        (small != 0 && small != 1) ||
1131        (verbosity < 0 || verbosity > 4) ||
1132        (unused == NULL && nUnused != 0) ||
1133        (unused != NULL && (nUnused < 0 || nUnused > BZ_MAX_UNUSED)))
1134       { BZ_SETERR(BZ_PARAM_ERROR); return NULL; };
1135
1136    if (ferror(f))
1137       { BZ_SETERR(BZ_IO_ERROR); return NULL; };
1138
1139    bzf = malloc ( sizeof(bzFile) );
1140    if (bzf == NULL)
1141       { BZ_SETERR(BZ_MEM_ERROR); return NULL; };
1142
1143    BZ_SETERR(BZ_OK);
1144
1145    bzf->initialisedOk = False;
1146    bzf->handle        = f;
1147    bzf->bufN          = 0;
1148    bzf->writing       = False;
1149    bzf->strm.bzalloc  = NULL;
1150    bzf->strm.bzfree   = NULL;
1151    bzf->strm.opaque   = NULL;
1152
1153    while (nUnused > 0) {
1154       bzf->buf[bzf->bufN] = *((UChar*)(unused)); bzf->bufN++;
1155       unused = ((void*)( 1 + ((UChar*)(unused))  ));
1156       nUnused--;
1157    }
1158
1159    ret = BZ2_bzDecompressInit ( &(bzf->strm), verbosity, small );
1160    if (ret != BZ_OK)
1161       { BZ_SETERR(ret); free(bzf); return NULL; };
1162
1163    bzf->strm.avail_in = bzf->bufN;
1164    bzf->strm.next_in  = bzf->buf;
1165
1166    bzf->initialisedOk = True;
1167    return bzf;
1168 }
1169
1170
1171 /*---------------------------------------------------*/
1172 void BZ_API(BZ2_bzReadClose) ( int *bzerror, BZFILE *b )
1173 {
1174    bzFile* bzf = (bzFile*)b;
1175
1176    BZ_SETERR(BZ_OK);
1177    if (bzf == NULL)
1178       { BZ_SETERR(BZ_OK); return; };
1179
1180    if (bzf->writing)
1181       { BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
1182
1183    if (bzf->initialisedOk)
1184       (void)BZ2_bzDecompressEnd ( &(bzf->strm) );
1185    free ( bzf );
1186 }
1187
1188
1189 /*---------------------------------------------------*/
1190 int BZ_API(BZ2_bzRead)
1191            ( int*    bzerror,
1192              BZFILE* b,
1193              void*   buf,
1194              int     len )
1195 {
1196    Int32   n, ret;
1197    bzFile* bzf = (bzFile*)b;
1198
1199    BZ_SETERR(BZ_OK);
1200
1201    if (bzf == NULL || buf == NULL || len < 0)
1202       { BZ_SETERR(BZ_PARAM_ERROR); return 0; };
1203
1204    if (bzf->writing)
1205       { BZ_SETERR(BZ_SEQUENCE_ERROR); return 0; };
1206
1207    if (len == 0)
1208       { BZ_SETERR(BZ_OK); return 0; };
1209
1210    bzf->strm.avail_out = len;
1211    bzf->strm.next_out = buf;
1212
1213    while (True) {
1214
1215       if (ferror(bzf->handle))
1216          { BZ_SETERR(BZ_IO_ERROR); return 0; };
1217
1218       if (bzf->strm.avail_in == 0 && !myfeof(bzf->handle)) {
1219          n = fread ( bzf->buf, sizeof(UChar),
1220                      BZ_MAX_UNUSED, bzf->handle );
1221          if (ferror(bzf->handle))
1222             { BZ_SETERR(BZ_IO_ERROR); return 0; };
1223          bzf->bufN = n;
1224          bzf->strm.avail_in = bzf->bufN;
1225          bzf->strm.next_in = bzf->buf;
1226       }
1227
1228       ret = BZ2_bzDecompress ( &(bzf->strm) );
1229
1230       if (ret != BZ_OK && ret != BZ_STREAM_END)
1231          { BZ_SETERR(ret); return 0; };
1232
1233       if (ret == BZ_OK && myfeof(bzf->handle) &&
1234           bzf->strm.avail_in == 0 && bzf->strm.avail_out > 0)
1235          { BZ_SETERR(BZ_UNEXPECTED_EOF); return 0; };
1236
1237       if (ret == BZ_STREAM_END)
1238          { BZ_SETERR(BZ_STREAM_END);
1239            return len - bzf->strm.avail_out; };
1240       if (bzf->strm.avail_out == 0)
1241          { BZ_SETERR(BZ_OK); return len; };
1242
1243    }
1244
1245    return 0; /*not reached*/
1246 }
1247
1248
1249 /*---------------------------------------------------*/
1250 void BZ_API(BZ2_bzReadGetUnused)
1251                      ( int*    bzerror,
1252                        BZFILE* b,
1253                        void**  unused,
1254                        int*    nUnused )
1255 {
1256    bzFile* bzf = (bzFile*)b;
1257    if (bzf == NULL)
1258       { BZ_SETERR(BZ_PARAM_ERROR); return; };
1259    if (bzf->lastErr != BZ_STREAM_END)
1260       { BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
1261    if (unused == NULL || nUnused == NULL)
1262       { BZ_SETERR(BZ_PARAM_ERROR); return; };
1263
1264    BZ_SETERR(BZ_OK);
1265    *nUnused = bzf->strm.avail_in;
1266    *unused = bzf->strm.next_in;
1267 }
1268 #endif
1269
1270
1271 /*---------------------------------------------------*/
1272 /*--- Misc convenience stuff                      ---*/
1273 /*---------------------------------------------------*/
1274 #ifndef BZ_NO_COMPRESS
1275 /*---------------------------------------------------*/
1276 int BZ_API(BZ2_bzBuffToBuffCompress)
1277                          ( char*         dest,
1278                            unsigned int* destLen,
1279                            char*         source,
1280                            unsigned int  sourceLen,
1281                            int           blockSize100k,
1282                            int           verbosity,
1283                            int           workFactor )
1284 {
1285    bz_stream strm;
1286    int ret;
1287
1288    if (dest == NULL || destLen == NULL ||
1289        source == NULL ||
1290        blockSize100k < 1 || blockSize100k > 9 ||
1291        verbosity < 0 || verbosity > 4 ||
1292        workFactor < 0 || workFactor > 250)
1293       return BZ_PARAM_ERROR;
1294
1295    if (workFactor == 0) workFactor = 30;
1296    strm.bzalloc = NULL;
1297    strm.bzfree = NULL;
1298    strm.opaque = NULL;
1299    ret = BZ2_bzCompressInit ( &strm, blockSize100k,
1300                               verbosity, workFactor );
1301    if (ret != BZ_OK) return ret;
1302
1303    strm.next_in = source;
1304    strm.next_out = dest;
1305    strm.avail_in = sourceLen;
1306    strm.avail_out = *destLen;
1307
1308    ret = BZ2_bzCompress ( &strm, BZ_FINISH );
1309    if (ret == BZ_FINISH_OK) goto output_overflow;
1310    if (ret != BZ_STREAM_END) goto errhandler;
1311
1312    /* normal termination */
1313    *destLen -= strm.avail_out;
1314    BZ2_bzCompressEnd ( &strm );
1315    return BZ_OK;
1316
1317    output_overflow:
1318    BZ2_bzCompressEnd ( &strm );
1319    return BZ_OUTBUFF_FULL;
1320
1321    errhandler:
1322    BZ2_bzCompressEnd ( &strm );
1323    return ret;
1324 }
1325 #endif /* BZ_NO_COMPRESS */
1326
1327 /*---------------------------------------------------*/
1328 int BZ_API(BZ2_bzBuffToBuffDecompress)
1329                            ( char*         dest,
1330                              unsigned int* destLen,
1331                              char*         source,
1332                              unsigned int  sourceLen,
1333                              int           small,
1334                              int           verbosity )
1335 {
1336    bz_stream strm;
1337    int ret;
1338
1339    if (destLen == NULL || source == NULL)
1340           return BZ_PARAM_ERROR;
1341
1342    strm.bzalloc = NULL;
1343    strm.bzfree = NULL;
1344    strm.opaque = NULL;
1345    ret = BZ2_bzDecompressInit ( &strm, verbosity, small );
1346    if (ret != BZ_OK) return ret;
1347
1348    strm.next_in = source;
1349    strm.next_out = dest;
1350    strm.avail_in = sourceLen;
1351    strm.avail_out = *destLen;
1352
1353    ret = BZ2_bzDecompress ( &strm );
1354    if (ret == BZ_OK) goto output_overflow_or_eof;
1355    if (ret != BZ_STREAM_END) goto errhandler;
1356
1357    /* normal termination */
1358    *destLen -= strm.avail_out;
1359    BZ2_bzDecompressEnd ( &strm );
1360    return BZ_OK;
1361
1362    output_overflow_or_eof:
1363    if (strm.avail_out > 0) {
1364       BZ2_bzDecompressEnd ( &strm );
1365       return BZ_UNEXPECTED_EOF;
1366    } else {
1367       BZ2_bzDecompressEnd ( &strm );
1368       return BZ_OUTBUFF_FULL;
1369    };
1370
1371    errhandler:
1372    BZ2_bzDecompressEnd ( &strm );
1373    return ret;
1374 }
1375
1376
1377 /*---------------------------------------------------*/
1378 /*--
1379    Code contributed by Yoshioka Tsuneo
1380    (QWF00133@niftyserve.or.jp/tsuneo-y@is.aist-nara.ac.jp),
1381    to support better zlib compatibility.
1382    This code is not _officially_ part of libbzip2 (yet);
1383    I haven't tested it, documented it, or considered the
1384    threading-safeness of it.
1385    If this code breaks, please contact both Yoshioka and me.
1386 --*/
1387 /*---------------------------------------------------*/
1388
1389 /*---------------------------------------------------*/
1390 /*--
1391    return version like "0.9.0c".
1392 --*/
1393 const char * BZ_API(BZ2_bzlibVersion)(void)
1394 {
1395    return BZ_VERSION;
1396 }
1397
1398
1399 #ifndef BZ_NO_STDIO
1400 /*---------------------------------------------------*/
1401
1402 #if defined(_WIN32) || defined(OS2) || defined(MSDOS)
1403 #   include <fcntl.h>
1404 #   include <io.h>
1405 #   define SET_BINARY_MODE(file) setmode(fileno(file),O_BINARY)
1406 #else
1407 #   define SET_BINARY_MODE(file)
1408 #endif
1409 static
1410 BZFILE * bzopen_or_bzdopen
1411                ( const char *path,   /* no use when bzdopen */
1412                  int fd,             /* no use when bzdopen */
1413                  const char *mode,
1414                  int open_mode)      /* bzopen: 0, bzdopen:1 */
1415 {
1416    int    bzerr;
1417    char   unused[BZ_MAX_UNUSED];
1418    int    blockSize100k = 9;
1419    int    writing       = 0;
1420    char   mode2[10]     = "";
1421    FILE   *fp           = NULL;
1422    BZFILE *bzfp         = NULL;
1423    int    verbosity     = 0;
1424    int    workFactor    = 30;
1425    int    smallMode     = 0;
1426    int    nUnused       = 0;
1427
1428    if (mode == NULL) return NULL;
1429    while (*mode) {
1430       switch (*mode) {
1431       case 'r':
1432          writing = 0; break;
1433       case 'w':
1434          writing = 1; break;
1435       case 's':
1436          smallMode = 1; break;
1437       default:
1438          if (isdigit((int)(*mode))) {
1439             blockSize100k = *mode-BZ_HDR_0;
1440          }
1441       }
1442       mode++;
1443    }
1444    strcat(mode2, writing ? "w" : "r" );
1445    strcat(mode2,"b");   /* binary mode */
1446
1447    if (open_mode==0) {
1448       if (path==NULL || strcmp(path,"")==0) {
1449         fp = (writing ? stdout : stdin);
1450         SET_BINARY_MODE(fp);
1451       } else {
1452         fp = fopen(path,mode2);
1453       }
1454    } else {
1455 #ifdef BZ_STRICT_ANSI
1456       fp = NULL;
1457 #else
1458       fp = fdopen(fd,mode2);
1459 #endif
1460    }
1461    if (fp == NULL) return NULL;
1462
1463    if (writing) {
1464       /* Guard against total chaos and anarchy -- JRS */
1465       if (blockSize100k < 1) blockSize100k = 1;
1466       if (blockSize100k > 9) blockSize100k = 9;
1467       bzfp = BZ2_bzWriteOpen(&bzerr,fp,blockSize100k,
1468                              verbosity,workFactor);
1469    } else {
1470       bzfp = BZ2_bzReadOpen(&bzerr,fp,verbosity,smallMode,
1471                             unused,nUnused);
1472    }
1473    if (bzfp == NULL) {
1474       if (fp != stdin && fp != stdout) fclose(fp);
1475       return NULL;
1476    }
1477    return bzfp;
1478 }
1479
1480
1481 /*---------------------------------------------------*/
1482 /*--
1483    open file for read or write.
1484       ex) bzopen("file","w9")
1485       case path="" or NULL => use stdin or stdout.
1486 --*/
1487 BZFILE * BZ_API(BZ2_bzopen)
1488                ( const char *path,
1489                  const char *mode )
1490 {
1491    return bzopen_or_bzdopen(path,-1,mode,/*bzopen*/0);
1492 }
1493
1494
1495 /*---------------------------------------------------*/
1496 BZFILE * BZ_API(BZ2_bzdopen)
1497                ( int fd,
1498                  const char *mode )
1499 {
1500    return bzopen_or_bzdopen(NULL,fd,mode,/*bzdopen*/1);
1501 }
1502
1503
1504 /*---------------------------------------------------*/
1505 int BZ_API(BZ2_bzread) (BZFILE* b, void* buf, int len )
1506 {
1507    int bzerr, nread;
1508    if (((bzFile*)b)->lastErr == BZ_STREAM_END) return 0;
1509    nread = BZ2_bzRead(&bzerr,b,buf,len);
1510    if (bzerr == BZ_OK || bzerr == BZ_STREAM_END) {
1511       return nread;
1512    } else {
1513       return -1;
1514    }
1515 }
1516
1517
1518 /*---------------------------------------------------*/
1519 int BZ_API(BZ2_bzwrite) (BZFILE* b, void* buf, int len )
1520 {
1521    int bzerr;
1522
1523    BZ2_bzWrite(&bzerr,b,buf,len);
1524    if(bzerr == BZ_OK){
1525       return len;
1526    }else{
1527       return -1;
1528    }
1529 }
1530
1531
1532 /*---------------------------------------------------*/
1533 int BZ_API(BZ2_bzflush) (BZFILE *b)
1534 {
1535    /* do nothing now... */
1536    return 0;
1537 }
1538
1539
1540 /*---------------------------------------------------*/
1541 void BZ_API(BZ2_bzclose) (BZFILE* b)
1542 {
1543    int bzerr;
1544    FILE *fp = ((bzFile *)b)->handle;
1545
1546    if (b==NULL) {return;}
1547    if(((bzFile*)b)->writing){
1548       BZ2_bzWriteClose(&bzerr,b,0,NULL,NULL);
1549       if(bzerr != BZ_OK){
1550          BZ2_bzWriteClose(NULL,b,1,NULL,NULL);
1551       }
1552    }else{
1553       BZ2_bzReadClose(&bzerr,b);
1554    }
1555    if(fp!=stdin && fp!=stdout){
1556       fclose(fp);
1557    }
1558 }
1559
1560
1561 /*---------------------------------------------------*/
1562 /*--
1563    return last error code
1564 --*/
1565 static char *bzerrorstrings[] = {
1566        "OK"
1567       ,"SEQUENCE_ERROR"
1568       ,"PARAM_ERROR"
1569       ,"MEM_ERROR"
1570       ,"DATA_ERROR"
1571       ,"DATA_ERROR_MAGIC"
1572       ,"IO_ERROR"
1573       ,"UNEXPECTED_EOF"
1574       ,"OUTBUFF_FULL"
1575       ,"CONFIG_ERROR"
1576       ,"???"   /* for future */
1577       ,"???"   /* for future */
1578       ,"???"   /* for future */
1579       ,"???"   /* for future */
1580       ,"???"   /* for future */
1581       ,"???"   /* for future */
1582 };
1583
1584
1585 const char * BZ_API(BZ2_bzerror) (BZFILE *b, int *errnum)
1586 {
1587    int err = ((bzFile *)b)->lastErr;
1588
1589    if(err>0) err = 0;
1590    *errnum = err;
1591    return bzerrorstrings[err*-1];
1592 }
1593 #endif
1594
1595 void bz_internal_error(int errcode)
1596 {
1597         printf ("BZIP2 internal error %d\n", errcode);
1598 }
1599
1600 /*-------------------------------------------------------------*/
1601 /*--- end                                           bzlib.c ---*/
1602 /*-------------------------------------------------------------*/
1603
1604 #endif /* CONFIG_BZIP2 */