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