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