drivers/lib/bzip2/bzip2.c

   1
   2 /*-----------------------------------------------------------*/
   3 /*--- A block-sorting, lossless compressor        bzip2.c ---*/
   4 /*-----------------------------------------------------------*/
   5
   6 /*--
   7   This file is a part of bzip2 and/or libbzip2, a program and
   8   library for lossless, block-sorting data compression.
   9
  10   Copyright (C) 1996-2000 Julian R Seward.  All rights reserved.
  11
  12   Redistribution and use in source and binary forms, with or without
  13   modification, are permitted provided that the following conditions
  14   are met:
  15
  16   1. Redistributions of source code must retain the above copyright
  17      notice, this list of conditions and the following disclaimer.
  18
  19   2. The origin of this software must not be misrepresented; you must
  20      not claim that you wrote the original software.  If you use this
  21      software in a product, an acknowledgment in the product
  22      documentation would be appreciated but is not required.
  23
  24   3. Altered source versions must be plainly marked as such, and must
  25      not be misrepresented as being the original software.
  26
  27   4. The name of the author may not be used to endorse or promote
  28      products derived from this software without specific prior written
  29      permission.
  30
  31   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
  32   OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  33   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  34   ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  35   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  37   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  38   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  39   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  40   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  41   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  42
  43   Julian Seward, Cambridge, UK.
  44   jseward@acm.org
  45   bzip2/libbzip2 version 1.0 of 21 March 2000
  46
  47   This program is based on (at least) the work of:
  48      Mike Burrows
  49      David Wheeler
  50      Peter Fenwick
  51      Alistair Moffat
  52      Radford Neal
  53      Ian H. Witten
  54      Robert Sedgewick
  55      Jon L. Bentley
  56
  57   For more information on these sources, see the manual.
  58 --*/
  59
  60
  61 /*----------------------------------------------------*/
  62 /*--- IMPORTANT                                    ---*/
  63 /*----------------------------------------------------*/
  64
  65 /*--
  66    WARNING:
  67       This program and library (attempts to) compress data by
  68       performing several non-trivial transformations on it.
  69       Unless you are 100% familiar with *all* the algorithms
  70       contained herein, and with the consequences of modifying them,
  71       you should NOT meddle with the compression or decompression
  72       machinery.  Incorrect changes can and very likely *will*
  73       lead to disasterous loss of data.
  74
  75    DISCLAIMER:
  76       I TAKE NO RESPONSIBILITY FOR ANY LOSS OF DATA ARISING FROM THE
  77       USE OF THIS PROGRAM, HOWSOEVER CAUSED.
  78
  79       Every compression of a file implies an assumption that the
  80       compressed file can be decompressed to reproduce the original.
  81       Great efforts in design, coding and testing have been made to
  82       ensure that this program works correctly.  However, the
  83       complexity of the algorithms, and, in particular, the presence
  84       of various special cases in the code which occur with very low
  85       but non-zero probability make it impossible to rule out the
  86       possibility of bugs remaining in the program.  DO NOT COMPRESS
  87       ANY DATA WITH THIS PROGRAM AND/OR LIBRARY UNLESS YOU ARE PREPARED
  88       TO ACCEPT THE POSSIBILITY, HOWEVER SMALL, THAT THE DATA WILL
  89       NOT BE RECOVERABLE.
  90
  91       That is not to say this program is inherently unreliable.
  92       Indeed, I very much hope the opposite is true.  bzip2/libbzip2
  93       has been carefully constructed and extensively tested.
  94
  95    PATENTS:
  96       To the best of my knowledge, bzip2/libbzip2 does not use any
  97       patented algorithms.  However, I do not have the resources
  98       available to carry out a full patent search.  Therefore I cannot
  99       give any guarantee of the above statement.
 100 --*/
 101
 102
 103
 104 /*----------------------------------------------------*/
 105 /*--- and now for something much more pleasant :-) ---*/
 106 /*----------------------------------------------------*/
 107
 108 /*---------------------------------------------*/
 109 /*--
 110   Place a 1 beside your platform, and 0 elsewhere.
 111 --*/
 112
 113 /*--
 114   Generic 32-bit Unix.
 115   Also works on 64-bit Unix boxes.
 116 --*/
 117 #define BZ_UNIX      1
 118
 119 /*--
 120   Win32, as seen by Jacob Navia's excellent
 121   port of (Chris Fraser & David Hanson)'s excellent
 122   lcc compiler.
 123 --*/
 124 #define BZ_LCCWIN32  0
 125
 126 #if defined(_WIN32) && !defined(__CYGWIN__)
 127 #undef  BZ_LCCWIN32
 128 #define BZ_LCCWIN32 1
 129 #undef  BZ_UNIX
 130 #define BZ_UNIX 0
 131 #endif
 132
 133
 134 /*---------------------------------------------*/
 135 /*--
 136   Some stuff for all platforms.
 137 --*/
 138
 139 #include <stdio.h>
 140 #include <stdlib.h>
 141 #include <string.h>
 142 #include <signal.h>
 143 #include <math.h>
 144 #include <errno.h>
 145 #include <ctype.h>
 146 #include "bzlib.h"
 147
 148 #define ERROR_IF_EOF(i)       { if ((i) == EOF)  ioError(); }
 149 #define ERROR_IF_NOT_ZERO(i)  { if ((i) != 0)    ioError(); }
 150 #define ERROR_IF_MINUS_ONE(i) { if ((i) == (-1)) ioError(); }
 151
 152
 153 /*---------------------------------------------*/
 154 /*--
 155    Platform-specific stuff.
 156 --*/
 157
 158 #if BZ_UNIX
 159 #   include <sys/types.h>
 160 #   include <utime.h>
 161 #   include <unistd.h>
 162 #   include <sys/stat.h>
 163 #   include <sys/times.h>
 164
 165 #   define PATH_SEP    '/'
 166 #   define MY_LSTAT    lstat
 167 #   define MY_S_IFREG  S_ISREG
 168 #   define MY_STAT     stat
 169
 170 #   define APPEND_FILESPEC(root, name) \
 171       root=snocString((root), (name))
 172
 173 #   define APPEND_FLAG(root, name) \
 174       root=snocString((root), (name))
 175
 176 #   define SET_BINARY_MODE(fd) /**/
 177
 178 #   ifdef __GNUC__
 179 #      define NORETURN __attribute__ ((noreturn))
 180 #   else
 181 #      define NORETURN /**/
 182 #   endif
 183 #   ifdef __DJGPP__
 184 #     include <io.h>
 185 #     include <fcntl.h>
 186 #     undef MY_LSTAT
 187 #     define MY_LSTAT stat
 188 #     undef SET_BINARY_MODE
 189 #     define SET_BINARY_MODE(fd)                        \
 190         do {                                            \
 191            int retVal = setmode ( fileno ( fd ),        \
 192                                  O_BINARY );            \
 193            ERROR_IF_MINUS_ONE ( retVal );               \
 194         } while ( 0 )
 195 #   endif
 196 #   ifdef __CYGWIN__
 197 #     include <io.h>
 198 #     include <fcntl.h>
 199 #     undef SET_BINARY_MODE
 200 #     define SET_BINARY_MODE(fd)                        \
 201         do {                                            \
 202            int retVal = setmode ( fileno ( fd ),        \
 203                                  O_BINARY );            \
 204            ERROR_IF_MINUS_ONE ( retVal );               \
 205         } while ( 0 )
 206 #   endif
 207 #endif
 208
 209
 210
 211 #if BZ_LCCWIN32
 212 #   include <io.h>
 213 #   include <fcntl.h>
 214 #   include <sys\stat.h>
 215
 216 #   define NORETURN       /**/
 217 #   define PATH_SEP       '\\'
 218 #   define MY_LSTAT       _stat
 219 #   define MY_STAT        _stat
 220 #   define MY_S_IFREG(x)  ((x) & _S_IFREG)
 221
 222 #   define APPEND_FLAG(root, name) \
 223       root=snocString((root), (name))
 224
 225 #   if 0
 226    /*-- lcc-win32 seems to expand wildcards itself --*/
 227 #   define APPEND_FILESPEC(root, spec)                \
 228       do {                                            \
 229          if ((spec)[0] == '-') {                      \
 230             root = snocString((root), (spec));        \
 231          } else {                                     \
 232             struct _finddata_t c_file;                \
 233             long hFile;                               \
 234             hFile = _findfirst((spec), &c_file);      \
 235             if ( hFile == -1L ) {                     \
 236                root = snocString ((root), (spec));    \
 237             } else {                                  \
 238                int anInt = 0;                         \
 239                while ( anInt == 0 ) {                 \
 240                   root = snocString((root),           \
 241                             &c_file.name[0]);         \
 242                   anInt = _findnext(hFile, &c_file);  \
 243                }                                      \
 244             }                                         \
 245          }                                            \
 246       } while ( 0 )
 247 #   else
 248 #   define APPEND_FILESPEC(root, name)                \
 249       root = snocString ((root), (name))
 250 #   endif
 251
 252 #   define SET_BINARY_MODE(fd)                        \
 253       do {                                            \
 254          int retVal = setmode ( fileno ( fd ),        \
 255                                O_BINARY );            \
 256          ERROR_IF_MINUS_ONE ( retVal );               \
 257       } while ( 0 )
 258
 259 #endif
 260
 261
 262 /*---------------------------------------------*/
 263 /*--
 264   Some more stuff for all platforms :-)
 265 --*/
 266
 267 typedef char            Char;
 268 typedef unsigned char   Bool;
 269 typedef unsigned char   UChar;
 270 typedef int             Int32;
 271 typedef unsigned int    UInt32;
 272 typedef short           Int16;
 273 typedef unsigned short  UInt16;
 274
 275 #define True  ((Bool)1)
 276 #define False ((Bool)0)
 277
 278 /*--
 279   IntNative is your platform's `native' int size.
 280   Only here to avoid probs with 64-bit platforms.
 281 --*/
 282 typedef int IntNative;
 283
 284
 285 /*---------------------------------------------------*/
 286 /*--- Misc (file handling) data decls             ---*/
 287 /*---------------------------------------------------*/
 288
 289 Int32   verbosity;
 290 Bool    keepInputFiles, smallMode, deleteOutputOnInterrupt;
 291 Bool    forceOverwrite, testFailsExist, unzFailsExist, noisy;
 292 Int32   numFileNames, numFilesProcessed, blockSize100k;
 293 Int32   exitValue;
 294
 295 /*-- source modes; F==file, I==stdin, O==stdout --*/
 296 #define SM_I2O           1
 297 #define SM_F2O           2
 298 #define SM_F2F           3
 299
 300 /*-- operation modes --*/
 301 #define OM_Z             1
 302 #define OM_UNZ           2
 303 #define OM_TEST          3
 304
 305 Int32   opMode;
 306 Int32   srcMode;
 307
 308 #define FILE_NAME_LEN 1034
 309
 310 Int32   longestFileName;
 311 Char    inName [FILE_NAME_LEN];
 312 Char    outName[FILE_NAME_LEN];
 313 Char    tmpName[FILE_NAME_LEN];
 314 Char    *progName;
 315 Char    progNameReally[FILE_NAME_LEN];
 316 FILE    *outputHandleJustInCase;
 317 Int32   workFactor;
 318
 319 static void    panic                 ( Char* )   NORETURN;
 320 static void    ioError               ( void )    NORETURN;
 321 static void    outOfMemory           ( void )    NORETURN;
 322 static void    configError           ( void )    NORETURN;
 323 static void    crcError              ( void )    NORETURN;
 324 static void    cleanUpAndFail        ( Int32 )   NORETURN;
 325 static void    compressedStreamEOF   ( void )    NORETURN;
 326
 327 static void    copyFileName ( Char*, Char* );
 328 static void*   myMalloc     ( Int32 );
 329
 330
 331
 332 /*---------------------------------------------------*/
 333 /*--- An implementation of 64-bit ints.  Sigh.    ---*/
 334 /*--- Roll on widespread deployment of ANSI C9X ! ---*/
 335 /*---------------------------------------------------*/
 336
 337 typedef
 338    struct { UChar b[8]; }
 339    UInt64;
 340
 341 static
 342 void uInt64_from_UInt32s ( UInt64* n, UInt32 lo32, UInt32 hi32 )
 343 {
 344    n->b[7] = (UChar)((hi32 >> 24) & 0xFF);
 345    n->b[6] = (UChar)((hi32 >> 16) & 0xFF);
 346    n->b[5] = (UChar)((hi32 >> 8)  & 0xFF);
 347    n->b[4] = (UChar) (hi32        & 0xFF);
 348    n->b[3] = (UChar)((lo32 >> 24) & 0xFF);
 349    n->b[2] = (UChar)((lo32 >> 16) & 0xFF);
 350    n->b[1] = (UChar)((lo32 >> 8)  & 0xFF);
 351    n->b[0] = (UChar) (lo32        & 0xFF);
 352 }
 353
 354 static
 355 double uInt64_to_double ( UInt64* n )
 356 {
 357    Int32  i;
 358    double base = 1.0;
 359    double sum  = 0.0;
 360    for (i = 0; i < 8; i++) {
 361       sum  += base * (double)(n->b[i]);
 362       base *= 256.0;
 363    }
 364    return sum;
 365 }
 366
 367 static
 368 void uInt64_add ( UInt64* src, UInt64* dst )
 369 {
 370    Int32 i;
 371    Int32 carry = 0;
 372    for (i = 0; i < 8; i++) {
 373       carry += ( ((Int32)src->b[i]) + ((Int32)dst->b[i]) );
 374       dst->b[i] = (UChar)(carry & 0xFF);
 375       carry >>= 8;
 376    }
 377 }
 378
 379 static
 380 void uInt64_sub ( UInt64* src, UInt64* dst )
 381 {
 382    Int32 t, i;
 383    Int32 borrow = 0;
 384    for (i = 0; i < 8; i++) {
 385       t = ((Int32)dst->b[i]) - ((Int32)src->b[i]) - borrow;
 386       if (t < 0) {
 387          dst->b[i] = (UChar)(t + 256);
 388          borrow = 1;
 389       } else {
 390          dst->b[i] = (UChar)t;
 391          borrow = 0;
 392       }
 393    }
 394 }
 395
 396 static
 397 void uInt64_mul ( UInt64* a, UInt64* b, UInt64* r_hi, UInt64* r_lo )
 398 {
 399    UChar sum[16];
 400    Int32 ia, ib, carry;
 401    for (ia = 0; ia < 16; ia++) sum[ia] = 0;
 402    for (ia = 0; ia < 8; ia++) {
 403       carry = 0;
 404       for (ib = 0; ib < 8; ib++) {
 405          carry += ( ((Int32)sum[ia+ib])
 406                     + ((Int32)a->b[ia]) * ((Int32)b->b[ib]) );
 407          sum[ia+ib] = (UChar)(carry & 0xFF);
 408          carry >>= 8;
 409       }
 410       sum[ia+8] = (UChar)(carry & 0xFF);
 411       if ((carry >>= 8) != 0) panic ( "uInt64_mul" );
 412    }
 413
 414    for (ia = 0; ia < 8; ia++) r_hi->b[ia] = sum[ia+8];
 415    for (ia = 0; ia < 8; ia++) r_lo->b[ia] = sum[ia];
 416 }
 417
 418
 419 static
 420 void uInt64_shr1 ( UInt64* n )
 421 {
 422    Int32 i;
 423    for (i = 0; i < 8; i++) {
 424       n->b[i] >>= 1;
 425       if (i < 7 && (n->b[i+1] & 1)) n->b[i] |= 0x80;
 426    }
 427 }
 428
 429 static
 430 void uInt64_shl1 ( UInt64* n )
 431 {
 432    Int32 i;
 433    for (i = 7; i >= 0; i--) {
 434       n->b[i] <<= 1;
 435       if (i > 0 && (n->b[i-1] & 0x80)) n->b[i]++;
 436    }
 437 }
 438
 439 static
 440 Bool uInt64_isZero ( UInt64* n )
 441 {
 442    Int32 i;
 443    for (i = 0; i < 8; i++)
 444       if (n->b[i] != 0) return 0;
 445    return 1;
 446 }
 447
 448 static
 449 Int32 uInt64_qrm10 ( UInt64* n )
 450 {
 451    /* Divide *n by 10, and return the remainder.  Long division
 452       is difficult, so we cheat and instead multiply by
 453       0xCCCC CCCC CCCC CCCD, which is 0.8 (viz, 0.1 << 3).
 454    */
 455    Int32  i;
 456    UInt64 tmp1, tmp2, n_orig, zero_point_eight;
 457
 458    zero_point_eight.b[1] = zero_point_eight.b[2] =
 459    zero_point_eight.b[3] = zero_point_eight.b[4] =
 460    zero_point_eight.b[5] = zero_point_eight.b[6] =
 461    zero_point_eight.b[7] = 0xCC;
 462    zero_point_eight.b[0] = 0xCD;
 463
 464    n_orig = *n;
 465
 466    /* divide n by 10,
 467       by multiplying by 0.8 and then shifting right 3 times */
 468    uInt64_mul ( n, &zero_point_eight, &tmp1, &tmp2 );
 469    uInt64_shr1(&tmp1); uInt64_shr1(&tmp1); uInt64_shr1(&tmp1);
 470    *n = tmp1;
 471
 472    /* tmp1 = 8*n, tmp2 = 2*n */
 473    uInt64_shl1(&tmp1); uInt64_shl1(&tmp1); uInt64_shl1(&tmp1);
 474    tmp2 = *n; uInt64_shl1(&tmp2);
 475
 476    /* tmp1 = 10*n */
 477    uInt64_add ( &tmp2, &tmp1 );
 478
 479    /* n_orig = n_orig - 10*n */
 480    uInt64_sub ( &tmp1, &n_orig );
 481
 482    /* n_orig should now hold quotient, in range 0 .. 9 */
 483    for (i = 7; i >= 1; i--)
 484       if (n_orig.b[i] != 0) panic ( "uInt64_qrm10(1)" );
 485    if (n_orig.b[0] > 9)
 486       panic ( "uInt64_qrm10(2)" );
 487
 488    return (int)n_orig.b[0];
 489 }
 490
 491 /* ... and the Whole Entire Point of all this UInt64 stuff is
 492    so that we can supply the following function.
 493 */
 494 static
 495 void uInt64_toAscii ( char* outbuf, UInt64* n )
 496 {
 497    Int32  i, q;
 498    UChar  buf[32];
 499    Int32  nBuf   = 0;
 500    UInt64 n_copy = *n;
 501    do {
 502       q = uInt64_qrm10 ( &n_copy );
 503       buf[nBuf] = q + '0';
 504       nBuf++;
 505    } while (!uInt64_isZero(&n_copy));
 506    outbuf[nBuf] = 0;
 507    for (i = 0; i < nBuf; i++) outbuf[i] = buf[nBuf-i-1];
 508 }
 509
 510
 511 /*---------------------------------------------------*/
 512 /*--- Processing of complete files and streams    ---*/
 513 /*---------------------------------------------------*/
 514
 515 /*---------------------------------------------*/
 516 static
 517 Bool myfeof ( FILE* f )
 518 {
 519    Int32 c = fgetc ( f );
 520    if (c == EOF) return True;
 521    ungetc ( c, f );
 522    return False;
 523 }
 524
 525
 526 /*---------------------------------------------*/
 527 static
 528 void compressStream ( FILE *stream, FILE *zStream )
 529 {
 530    BZFILE* bzf = NULL;
 531    UChar   ibuf[5000];
 532    Int32   nIbuf;
 533    UInt32  nbytes_in_lo32, nbytes_in_hi32;
 534    UInt32  nbytes_out_lo32, nbytes_out_hi32;
 535    Int32   bzerr, bzerr_dummy, ret;
 536
 537    SET_BINARY_MODE(stream);
 538    SET_BINARY_MODE(zStream);
 539
 540    if (ferror(stream)) goto errhandler_io;
 541    if (ferror(zStream)) goto errhandler_io;
 542
 543    bzf = BZ2_bzWriteOpen ( &bzerr, zStream,
 544                            blockSize100k, verbosity, workFactor );
 545    if (bzerr != BZ_OK) goto errhandler;
 546
 547    if (verbosity >= 2) fprintf ( stderr, "\n" );
 548
 549    while (True) {
 550
 551       if (myfeof(stream)) break;
 552       nIbuf = fread ( ibuf, sizeof(UChar), 5000, stream );
 553       if (ferror(stream)) goto errhandler_io;
 554       if (nIbuf > 0) BZ2_bzWrite ( &bzerr, bzf, (void*)ibuf, nIbuf );
 555       if (bzerr != BZ_OK) goto errhandler;
 556
 557    }
 558
 559    BZ2_bzWriteClose64 ( &bzerr, bzf, 0,
 560                         &nbytes_in_lo32, &nbytes_in_hi32,
 561                         &nbytes_out_lo32, &nbytes_out_hi32 );
 562    if (bzerr != BZ_OK) goto errhandler;
 563
 564    if (ferror(zStream)) goto errhandler_io;
 565    ret = fflush ( zStream );
 566    if (ret == EOF) goto errhandler_io;
 567    if (zStream != stdout) {
 568       ret = fclose ( zStream );
 569       if (ret == EOF) goto errhandler_io;
 570    }
 571    if (ferror(stream)) goto errhandler_io;
 572    ret = fclose ( stream );
 573    if (ret == EOF) goto errhandler_io;
 574
 575    if (nbytes_in_lo32 == 0 && nbytes_in_hi32 == 0)
 576       nbytes_in_lo32 = 1;
 577
 578    if (verbosity >= 1) {
 579       Char   buf_nin[32], buf_nout[32];
 580       UInt64 nbytes_in,   nbytes_out;
 581       double nbytes_in_d, nbytes_out_d;
 582       uInt64_from_UInt32s ( &nbytes_in,
 583                             nbytes_in_lo32, nbytes_in_hi32 );
 584       uInt64_from_UInt32s ( &nbytes_out,
 585                             nbytes_out_lo32, nbytes_out_hi32 );
 586       nbytes_in_d  = uInt64_to_double ( &nbytes_in );
 587       nbytes_out_d = uInt64_to_double ( &nbytes_out );
 588       uInt64_toAscii ( buf_nin, &nbytes_in );
 589       uInt64_toAscii ( buf_nout, &nbytes_out );
 590       fprintf ( stderr, "%6.3f:1, %6.3f bits/byte, "
 591                         "%5.2f%% saved, %s in, %s out.\n",
 592                 nbytes_in_d / nbytes_out_d,
 593                 (8.0 * nbytes_out_d) / nbytes_in_d,
 594                 100.0 * (1.0 - nbytes_out_d / nbytes_in_d),
 595                 buf_nin,
 596                 buf_nout
 597               );
 598    }
 599
 600    return;
 601
 602    errhandler:
 603    BZ2_bzWriteClose64 ( &bzerr_dummy, bzf, 1,
 604                         &nbytes_in_lo32, &nbytes_in_hi32,
 605                         &nbytes_out_lo32, &nbytes_out_hi32 );
 606    switch (bzerr) {
 607       case BZ_CONFIG_ERROR:
 608          configError(); break;
 609       case BZ_MEM_ERROR:
 610          outOfMemory (); break;
 611       case BZ_IO_ERROR:
 612          errhandler_io:
 613          ioError(); break;
 614       default:
 615          panic ( "compress:unexpected error" );
 616    }
 617
 618    panic ( "compress:end" );
 619    /*notreached*/
 620 }
 621
 622
 623
 624 /*---------------------------------------------*/
 625 static
 626 Bool uncompressStream ( FILE *zStream, FILE *stream )
 627 {
 628    BZFILE* bzf = NULL;
 629    Int32   bzerr, bzerr_dummy, ret, nread, streamNo, i;
 630    UChar   obuf[5000];
 631    UChar   unused[BZ_MAX_UNUSED];
 632    Int32   nUnused;
 633    UChar*  unusedTmp;
 634
 635    nUnused = 0;
 636    streamNo = 0;
 637
 638    SET_BINARY_MODE(stream);
 639    SET_BINARY_MODE(zStream);
 640
 641    if (ferror(stream)) goto errhandler_io;
 642    if (ferror(zStream)) goto errhandler_io;
 643
 644    while (True) {
 645
 646       bzf = BZ2_bzReadOpen (
 647                &bzerr, zStream, verbosity,
 648                (int)smallMode, unused, nUnused
 649             );
 650       if (bzf == NULL || bzerr != BZ_OK) goto errhandler;
 651       streamNo++;
 652
 653       while (bzerr == BZ_OK) {
 654          nread = BZ2_bzRead ( &bzerr, bzf, obuf, 5000 );
 655          if (bzerr == BZ_DATA_ERROR_MAGIC) goto errhandler;
 656          if ((bzerr == BZ_OK || bzerr == BZ_STREAM_END) && nread > 0)
 657             fwrite ( obuf, sizeof(UChar), nread, stream );
 658          if (ferror(stream)) goto errhandler_io;
 659       }
 660       if (bzerr != BZ_STREAM_END) goto errhandler;
 661
 662       BZ2_bzReadGetUnused ( &bzerr, bzf, (void**)(&unusedTmp), &nUnused );
 663       if (bzerr != BZ_OK) panic ( "decompress:bzReadGetUnused" );
 664
 665       for (i = 0; i < nUnused; i++) unused[i] = unusedTmp[i];
 666
 667       BZ2_bzReadClose ( &bzerr, bzf );
 668       if (bzerr != BZ_OK) panic ( "decompress:bzReadGetUnused" );
 669
 670       if (nUnused == 0 && myfeof(zStream)) break;
 671
 672    }
 673
 674    if (ferror(zStream)) goto errhandler_io;
 675    ret = fclose ( zStream );
 676    if (ret == EOF) goto errhandler_io;
 677
 678    if (ferror(stream)) goto errhandler_io;
 679    ret = fflush ( stream );
 680    if (ret != 0) goto errhandler_io;
 681    if (stream != stdout) {
 682       ret = fclose ( stream );
 683       if (ret == EOF) goto errhandler_io;
 684    }
 685    if (verbosity >= 2) fprintf ( stderr, "\n    " );
 686    return True;
 687
 688    errhandler:
 689    BZ2_bzReadClose ( &bzerr_dummy, bzf );
 690    switch (bzerr) {
 691       case BZ_CONFIG_ERROR:
 692          configError(); break;
 693       case BZ_IO_ERROR:
 694          errhandler_io:
 695          ioError(); break;
 696       case BZ_DATA_ERROR:
 697          crcError();
 698       case BZ_MEM_ERROR:
 699          outOfMemory();
 700       case BZ_UNEXPECTED_EOF:
 701          compressedStreamEOF();
 702       case BZ_DATA_ERROR_MAGIC:
 703          if (zStream != stdin) fclose(zStream);
 704          if (stream != stdout) fclose(stream);
 705          if (streamNo == 1) {
 706             return False;
 707          } else {
 708             if (noisy)
 709             fprintf ( stderr,
 710                       "\n%s: %s: trailing garbage after EOF ignored\n",
 711                       progName, inName );
 712             return True;
 713          }
 714       default:
 715          panic ( "decompress:unexpected error" );
 716    }
 717
 718    panic ( "decompress:end" );
 719    return True; /*notreached*/
 720 }
 721
 722
 723 /*---------------------------------------------*/
 724 static
 725 Bool testStream ( FILE *zStream )
 726 {
 727    BZFILE* bzf = NULL;
 728    Int32   bzerr, bzerr_dummy, ret, nread, streamNo, i;
 729    UChar   obuf[5000];
 730    UChar   unused[BZ_MAX_UNUSED];
 731    Int32   nUnused;
 732    UChar*  unusedTmp;
 733
 734    nUnused = 0;
 735    streamNo = 0;
 736
 737    SET_BINARY_MODE(zStream);
 738    if (ferror(zStream)) goto errhandler_io;
 739
 740    while (True) {
 741
 742       bzf = BZ2_bzReadOpen (
 743                &bzerr, zStream, verbosity,
 744                (int)smallMode, unused, nUnused
 745             );
 746       if (bzf == NULL || bzerr != BZ_OK) goto errhandler;
 747       streamNo++;
 748
 749       while (bzerr == BZ_OK) {
 750          nread = BZ2_bzRead ( &bzerr, bzf, obuf, 5000 );
 751          if (bzerr == BZ_DATA_ERROR_MAGIC) goto errhandler;
 752       }
 753       if (bzerr != BZ_STREAM_END) goto errhandler;
 754
 755       BZ2_bzReadGetUnused ( &bzerr, bzf, (void**)(&unusedTmp), &nUnused );
 756       if (bzerr != BZ_OK) panic ( "test:bzReadGetUnused" );
 757
 758       for (i = 0; i < nUnused; i++) unused[i] = unusedTmp[i];
 759
 760       BZ2_bzReadClose ( &bzerr, bzf );
 761       if (bzerr != BZ_OK) panic ( "test:bzReadGetUnused" );
 762       if (nUnused == 0 && myfeof(zStream)) break;
 763
 764    }
 765
 766    if (ferror(zStream)) goto errhandler_io;
 767    ret = fclose ( zStream );
 768    if (ret == EOF) goto errhandler_io;
 769
 770    if (verbosity >= 2) fprintf ( stderr, "\n    " );
 771    return True;
 772
 773    errhandler:
 774    BZ2_bzReadClose ( &bzerr_dummy, bzf );
 775    if (verbosity == 0)
 776       fprintf ( stderr, "%s: %s: ", progName, inName );
 777    switch (bzerr) {
 778       case BZ_CONFIG_ERROR:
 779          configError(); break;
 780       case BZ_IO_ERROR:
 781          errhandler_io:
 782          ioError(); break;
 783       case BZ_DATA_ERROR:
 784          fprintf ( stderr,
 785                    "data integrity (CRC) error in data\n" );
 786          return False;
 787       case BZ_MEM_ERROR:
 788          outOfMemory();
 789       case BZ_UNEXPECTED_EOF:
 790          fprintf ( stderr,
 791                    "file ends unexpectedly\n" );
 792          return False;
 793       case BZ_DATA_ERROR_MAGIC:
 794          if (zStream != stdin) fclose(zStream);
 795          if (streamNo == 1) {
 796           fprintf ( stderr,
 797                     "bad magic number (file not created by bzip2)\n" );
 798             return False;
 799          } else {
 800             if (noisy)
 801             fprintf ( stderr,
 802                       "trailing garbage after EOF ignored\n" );
 803             return True;
 804          }
 805       default:
 806          panic ( "test:unexpected error" );
 807    }
 808
 809    panic ( "test:end" );
 810    return True; /*notreached*/
 811 }
 812
 813
 814 /*---------------------------------------------------*/
 815 /*--- Error [non-] handling grunge                ---*/
 816 /*---------------------------------------------------*/
 817
 818 /*---------------------------------------------*/
 819 static
 820 void setExit ( Int32 v )
 821 {
 822    if (v > exitValue) exitValue = v;
 823 }
 824
 825
 826 /*---------------------------------------------*/
 827 static
 828 void cadvise ( void )
 829 {
 830    if (noisy)
 831    fprintf (
 832       stderr,
 833       "\nIt is possible that the compressed file(s) have become corrupted.\n"
 834         "You can use the -tvv option to test integrity of such files.\n\n"
 835         "You can use the `bzip2recover' program to *attempt* to recover\n"
 836         "data from undamaged sections of corrupted files.\n\n"
 837     );
 838 }
 839
 840
 841 /*---------------------------------------------*/
 842 static
 843 void showFileNames ( void )
 844 {
 845    if (noisy)
 846    fprintf (
 847       stderr,
 848       "\tInput file = %s, output file = %s\n",
 849       inName, outName
 850    );
 851 }
 852
 853
 854 /*---------------------------------------------*/
 855 static
 856 void cleanUpAndFail ( Int32 ec )
 857 {
 858    IntNative retVal;
 859
 860    if ( srcMode == SM_F2F
 861         && opMode != OM_TEST
 862         && deleteOutputOnInterrupt ) {
 863       if (noisy)
 864       fprintf ( stderr, "%s: Deleting output file %s, if it exists.\n",
 865                 progName, outName );
 866       if (outputHandleJustInCase != NULL)
 867          fclose ( outputHandleJustInCase );
 868       retVal = remove ( outName );
 869       if (retVal != 0)
 870          fprintf ( stderr,
 871                    "%s: WARNING: deletion of output file (apparently) failed.\n",
 872                    progName );
 873    }
 874    if (noisy && numFileNames > 0 && numFilesProcessed < numFileNames) {
 875       fprintf ( stderr,
 876                 "%s: WARNING: some files have not been processed:\n"
 877                 "\t%d specified on command line, %d not processed yet.\n\n",
 878                 progName, numFileNames,
 879                           numFileNames - numFilesProcessed );
 880    }
 881    setExit(ec);
 882    exit(exitValue);
 883 }
 884
 885
 886 /*---------------------------------------------*/
 887 static
 888 void panic ( Char* s )
 889 {
 890    fprintf ( stderr,
 891              "\n%s: PANIC -- internal consistency error:\n"
 892              "\t%s\n"
 893              "\tThis is a BUG.  Please report it to me at:\n"
 894              "\tjseward@acm.org\n",
 895              progName, s );
 896    showFileNames();
 897    cleanUpAndFail( 3 );
 898 }
 899
 900
 901 /*---------------------------------------------*/
 902 static
 903 void crcError ( void )
 904 {
 905    fprintf ( stderr,
 906              "\n%s: Data integrity error when decompressing.\n",
 907              progName );
 908    showFileNames();
 909    cadvise();
 910    cleanUpAndFail( 2 );
 911 }
 912
 913
 914 /*---------------------------------------------*/
 915 static
 916 void compressedStreamEOF ( void )
 917 {
 918    fprintf ( stderr,
 919              "\n%s: Compressed file ends unexpectedly;\n\t"
 920              "perhaps it is corrupted?  *Possible* reason follows.\n",
 921              progName );
 922    perror ( progName );
 923    showFileNames();
 924    cadvise();
 925    cleanUpAndFail( 2 );
 926 }
 927
 928
 929 /*---------------------------------------------*/
 930 static
 931 void ioError ( void )
 932 {
 933    fprintf ( stderr,
 934              "\n%s: I/O or other error, bailing out.  "
 935              "Possible reason follows.\n",
 936              progName );
 937    perror ( progName );
 938    showFileNames();
 939    cleanUpAndFail( 1 );
 940 }
 941
 942
 943 /*---------------------------------------------*/
 944 static
 945 void mySignalCatcher ( IntNative n )
 946 {
 947    fprintf ( stderr,
 948              "\n%s: Control-C or similar caught, quitting.\n",
 949              progName );
 950    cleanUpAndFail(1);
 951 }
 952
 953
 954 /*---------------------------------------------*/
 955 static
 956 void mySIGSEGVorSIGBUScatcher ( IntNative n )
 957 {
 958    if (opMode == OM_Z)
 959       fprintf (
 960       stderr,
 961       "\n%s: Caught a SIGSEGV or SIGBUS whilst compressing.\n"
 962       "\n"
 963       "   Possible causes are (most likely first):\n"
 964       "   (1) This computer has unreliable memory or cache hardware\n"
 965       "       (a surprisingly common problem; try a different machine.)\n"
 966       "   (2) A bug in the compiler used to create this executable\n"
 967       "       (unlikely, if you didn't compile bzip2 yourself.)\n"
 968       "   (3) A real bug in bzip2 -- I hope this should never be the case.\n"
 969       "   The user's manual, Section 4.3, has more info on (1) and (2).\n"
 970       "   \n"
 971       "   If you suspect this is a bug in bzip2, or are unsure about (1)\n"
 972       "   or (2), feel free to report it to me at: jseward@acm.org.\n"
 973       "   Section 4.3 of the user's manual describes the info a useful\n"
 974       "   bug report should have.  If the manual is available on your\n"
 975       "   system, please try and read it before mailing me.  If you don't\n"
 976       "   have the manual or can't be bothered to read it, mail me anyway.\n"
 977       "\n",
 978       progName );
 979       else
 980       fprintf (
 981       stderr,
 982       "\n%s: Caught a SIGSEGV or SIGBUS whilst decompressing.\n"
 983       "\n"
 984       "   Possible causes are (most likely first):\n"
 985       "   (1) The compressed data is corrupted, and bzip2's usual checks\n"
 986       "       failed to detect this.  Try bzip2 -tvv my_file.bz2.\n"
 987       "   (2) This computer has unreliable memory or cache hardware\n"
 988       "       (a surprisingly common problem; try a different machine.)\n"
 989       "   (3) A bug in the compiler used to create this executable\n"
 990       "       (unlikely, if you didn't compile bzip2 yourself.)\n"
 991       "   (4) A real bug in bzip2 -- I hope this should never be the case.\n"
 992       "   The user's manual, Section 4.3, has more info on (2) and (3).\n"
 993       "   \n"
 994       "   If you suspect this is a bug in bzip2, or are unsure about (2)\n"
 995       "   or (3), feel free to report it to me at: jseward@acm.org.\n"
 996       "   Section 4.3 of the user's manual describes the info a useful\n"
 997       "   bug report should have.  If the manual is available on your\n"
 998       "   system, please try and read it before mailing me.  If you don't\n"
 999       "   have the manual or can't be bothered to read it, mail me anyway.\n"
1000       "\n",
1001       progName );
1002
1003    showFileNames();
1004    if (opMode == OM_Z)
1005       cleanUpAndFail( 3 ); else
1006       { cadvise(); cleanUpAndFail( 2 ); }
1007 }
1008
1009
1010 /*---------------------------------------------*/
1011 static
1012 void outOfMemory ( void )
1013 {
1014    fprintf ( stderr,
1015              "\n%s: couldn't allocate enough memory\n",
1016              progName );
1017    showFileNames();
1018    cleanUpAndFail(1);
1019 }
1020
1021
1022 /*---------------------------------------------*/
1023 static
1024 void configError ( void )
1025 {
1026    fprintf ( stderr,
1027              "bzip2: I'm not configured correctly for this platform!\n"
1028              "\tI require Int32, Int16 and Char to have sizes\n"
1029              "\tof 4, 2 and 1 bytes to run properly, and they don't.\n"
1030              "\tProbably you can fix this by defining them correctly,\n"
1031              "\tand recompiling.  Bye!\n" );
1032    setExit(3);
1033    exit(exitValue);
1034 }
1035
1036
1037 /*---------------------------------------------------*/
1038 /*--- The main driver machinery                   ---*/
1039 /*---------------------------------------------------*/
1040
1041 /*---------------------------------------------*/
1042 static
1043 void pad ( Char *s )
1044 {
1045    Int32 i;
1046    if ( (Int32)strlen(s) >= longestFileName ) return;
1047    for (i = 1; i <= longestFileName - (Int32)strlen(s); i++)
1048       fprintf ( stderr, " " );
1049 }
1050
1051
1052 /*---------------------------------------------*/
1053 static
1054 void copyFileName ( Char* to, Char* from )
1055 {
1056    if ( strlen(from) > FILE_NAME_LEN-10 )  {
1057       fprintf (
1058          stderr,
1059          "bzip2: file name\n`%s'\n"
1060          "is suspiciously (more than %d chars) long.\n"
1061          "Try using a reasonable file name instead.  Sorry! :-)\n",
1062          from, FILE_NAME_LEN-10
1063       );
1064       setExit(1);
1065       exit(exitValue);
1066    }
1067
1068   strncpy(to,from,FILE_NAME_LEN-10);
1069   to[FILE_NAME_LEN-10]='\0';
1070 }
1071
1072
1073 /*---------------------------------------------*/
1074 static
1075 Bool fileExists ( Char* name )
1076 {
1077    FILE *tmp   = fopen ( name, "rb" );
1078    Bool exists = (tmp != NULL);
1079    if (tmp != NULL) fclose ( tmp );
1080    return exists;
1081 }
1082
1083
1084 /*---------------------------------------------*/
1085 /*--
1086   if in doubt, return True
1087 --*/
1088 static
1089 Bool notAStandardFile ( Char* name )
1090 {
1091    IntNative      i;
1092    struct MY_STAT statBuf;
1093
1094    i = MY_LSTAT ( name, &statBuf );
1095    if (i != 0) return True;
1096    if (MY_S_IFREG(statBuf.st_mode)) return False;
1097    return True;
1098 }
1099
1100
1101 /*---------------------------------------------*/
1102 /*--
1103   rac 11/21/98 see if file has hard links to it
1104 --*/
1105 static
1106 Int32 countHardLinks ( Char* name )
1107 {
1108    IntNative      i;
1109    struct MY_STAT statBuf;
1110
1111    i = MY_LSTAT ( name, &statBuf );
1112    if (i != 0) return 0;
1113    return (statBuf.st_nlink - 1);
1114 }
1115
1116
1117 /*---------------------------------------------*/
1118 static
1119 void copyDatePermissionsAndOwner ( Char *srcName, Char *dstName )
1120 {
1121 #if BZ_UNIX
1122    IntNative      retVal;
1123    struct MY_STAT statBuf;
1124    struct utimbuf uTimBuf;
1125
1126    retVal = MY_LSTAT ( srcName, &statBuf );
1127    ERROR_IF_NOT_ZERO ( retVal );
1128    uTimBuf.actime = statBuf.st_atime;
1129    uTimBuf.modtime = statBuf.st_mtime;
1130
1131    retVal = chmod ( dstName, statBuf.st_mode );
1132    ERROR_IF_NOT_ZERO ( retVal );
1133
1134    retVal = utime ( dstName, &uTimBuf );
1135    ERROR_IF_NOT_ZERO ( retVal );
1136
1137    retVal = chown ( dstName, statBuf.st_uid, statBuf.st_gid );
1138    /* chown() will in many cases return with EPERM, which can
1139       be safely ignored.
1140    */
1141 #endif
1142 }
1143
1144
1145 /*---------------------------------------------*/
1146 static
1147 void setInterimPermissions ( Char *dstName )
1148 {
1149 #if BZ_UNIX
1150    IntNative      retVal;
1151    retVal = chmod ( dstName, S_IRUSR | S_IWUSR );
1152    ERROR_IF_NOT_ZERO ( retVal );
1153 #endif
1154 }
1155
1156
1157 /*---------------------------------------------*/
1158 static
1159 Bool containsDubiousChars ( Char* name )
1160 {
1161    Bool cdc = False;
1162    for (; *name != '\0'; name++)
1163       if (*name == '?' || *name == '*') cdc = True;
1164    return cdc;
1165 }
1166
1167
1168 /*---------------------------------------------*/
1169 #define BZ_N_SUFFIX_PAIRS 4
1170
1171 Char* zSuffix[BZ_N_SUFFIX_PAIRS]
1172    = { ".bz2", ".bz", ".tbz2", ".tbz" };
1173 Char* unzSuffix[BZ_N_SUFFIX_PAIRS]
1174    = { "", "", ".tar", ".tar" };
1175
1176 static
1177 Bool hasSuffix ( Char* s, Char* suffix )
1178 {
1179    Int32 ns = strlen(s);
1180    Int32 nx = strlen(suffix);
1181    if (ns < nx) return False;
1182    if (strcmp(s + ns - nx, suffix) == 0) return True;
1183    return False;
1184 }
1185
1186 static
1187 Bool mapSuffix ( Char* name,
1188                  Char* oldSuffix, Char* newSuffix )
1189 {
1190    if (!hasSuffix(name,oldSuffix)) return False;
1191    name[strlen(name)-strlen(oldSuffix)] = 0;
1192    strcat ( name, newSuffix );
1193    return True;
1194 }
1195
1196
1197 /*---------------------------------------------*/
1198 static
1199 void compress ( Char *name )
1200 {
1201    FILE  *inStr;
1202    FILE  *outStr;
1203    Int32 n, i;
1204
1205    deleteOutputOnInterrupt = False;
1206
1207    if (name == NULL && srcMode != SM_I2O)
1208       panic ( "compress: bad modes\n" );
1209
1210    switch (srcMode) {
1211       case SM_I2O:
1212          copyFileName ( inName, "(stdin)" );
1213          copyFileName ( outName, "(stdout)" );
1214          break;
1215       case SM_F2F:
1216          copyFileName ( inName, name );
1217          copyFileName ( outName, name );
1218          strcat ( outName, ".bz2" );
1219          break;
1220       case SM_F2O:
1221          copyFileName ( inName, name );
1222          copyFileName ( outName, "(stdout)" );
1223          break;
1224    }
1225
1226    if ( srcMode != SM_I2O && containsDubiousChars ( inName ) ) {
1227       if (noisy)
1228       fprintf ( stderr, "%s: There are no files matching `%s'.\n",
1229                 progName, inName );
1230       setExit(1);
1231       return;
1232    }
1233    if ( srcMode != SM_I2O && !fileExists ( inName ) ) {
1234       fprintf ( stderr, "%s: Can't open input file %s: %s.\n",
1235                 progName, inName, strerror(errno) );
1236       setExit(1);
1237       return;
1238    }
1239    for (i = 0; i < BZ_N_SUFFIX_PAIRS; i++) {
1240       if (hasSuffix(inName, zSuffix[i])) {
1241          if (noisy)
1242          fprintf ( stderr,
1243                    "%s: Input file %s already has %s suffix.\n",
1244                    progName, inName, zSuffix[i] );
1245          setExit(1);
1246          return;
1247       }
1248    }
1249    if ( srcMode == SM_F2F && !forceOverwrite && notAStandardFile ( inName )) {
1250       if (noisy)
1251       fprintf ( stderr, "%s: Input file %s is not a normal file.\n",
1252                 progName, inName );
1253       setExit(1);
1254       return;
1255    }
1256    if ( srcMode == SM_F2F && !forceOverwrite && fileExists ( outName ) ) {
1257       fprintf ( stderr, "%s: Output file %s already exists.\n",
1258                 progName, outName );
1259       setExit(1);
1260       return;
1261    }
1262    if ( srcMode == SM_F2F && !forceOverwrite &&
1263         (n=countHardLinks ( inName )) > 0) {
1264       fprintf ( stderr, "%s: Input file %s has %d other link%s.\n",
1265                 progName, inName, n, n > 1 ? "s" : "" );
1266       setExit(1);
1267       return;
1268    }
1269
1270    switch ( srcMode ) {
1271
1272       case SM_I2O:
1273          inStr = stdin;
1274          outStr = stdout;
1275          if ( isatty ( fileno ( stdout ) ) ) {
1276             fprintf ( stderr,
1277                       "%s: I won't write compressed data to a terminal.\n",
1278                       progName );
1279             fprintf ( stderr, "%s: For help, type: `%s --help'.\n",
1280                               progName, progName );
1281             setExit(1);
1282             return;
1283          };
1284          break;
1285
1286       case SM_F2O:
1287          inStr = fopen ( inName, "rb" );
1288          outStr = stdout;
1289          if ( isatty ( fileno ( stdout ) ) ) {
1290             fprintf ( stderr,
1291                       "%s: I won't write compressed data to a terminal.\n",
1292                       progName );
1293             fprintf ( stderr, "%s: For help, type: `%s --help'.\n",
1294                               progName, progName );
1295             if ( inStr != NULL ) fclose ( inStr );
1296             setExit(1);
1297             return;
1298          };
1299          if ( inStr == NULL ) {
1300             fprintf ( stderr, "%s: Can't open input file %s: %s.\n",
1301                       progName, inName, strerror(errno) );
1302             setExit(1);
1303             return;
1304          };
1305          break;
1306
1307       case SM_F2F:
1308          inStr = fopen ( inName, "rb" );
1309          outStr = fopen ( outName, "wb" );
1310          if ( outStr == NULL) {
1311             fprintf ( stderr, "%s: Can't create output file %s: %s.\n",
1312                       progName, outName, strerror(errno) );
1313             if ( inStr != NULL ) fclose ( inStr );
1314             setExit(1);
1315             return;
1316          }
1317          if ( inStr == NULL ) {
1318             fprintf ( stderr, "%s: Can't open input file %s: %s.\n",
1319                       progName, inName, strerror(errno) );
1320             if ( outStr != NULL ) fclose ( outStr );
1321             setExit(1);
1322             return;
1323          };
1324          setInterimPermissions ( outName );
1325          break;
1326
1327       default:
1328          panic ( "compress: bad srcMode" );
1329          break;
1330    }
1331
1332    if (verbosity >= 1) {
1333       fprintf ( stderr,  "  %s: ", inName );
1334       pad ( inName );
1335       fflush ( stderr );
1336    }
1337
1338    /*--- Now the input and output handles are sane.  Do the Biz. ---*/
1339    outputHandleJustInCase = outStr;
1340    deleteOutputOnInterrupt = True;
1341    compressStream ( inStr, outStr );
1342    outputHandleJustInCase = NULL;
1343
1344    /*--- If there was an I/O error, we won't get here. ---*/
1345    if ( srcMode == SM_F2F ) {
1346       copyDatePermissionsAndOwner ( inName, outName );
1347       deleteOutputOnInterrupt = False;
1348       if ( !keepInputFiles ) {
1349          IntNative retVal = remove ( inName );
1350          ERROR_IF_NOT_ZERO ( retVal );
1351       }
1352    }
1353
1354    deleteOutputOnInterrupt = False;
1355 }
1356
1357
1358 /*---------------------------------------------*/
1359 static
1360 void uncompress ( Char *name )
1361 {
1362    FILE  *inStr;
1363    FILE  *outStr;
1364    Int32 n, i;
1365    Bool  magicNumberOK;
1366    Bool  cantGuess;
1367
1368    deleteOutputOnInterrupt = False;
1369
1370    if (name == NULL && srcMode != SM_I2O)
1371       panic ( "uncompress: bad modes\n" );
1372
1373    cantGuess = False;
1374    switch (srcMode) {
1375       case SM_I2O:
1376          copyFileName ( inName, "(stdin)" );
1377          copyFileName ( outName, "(stdout)" );
1378          break;
1379       case SM_F2F:
1380          copyFileName ( inName, name );
1381          copyFileName ( outName, name );
1382          for (i = 0; i < BZ_N_SUFFIX_PAIRS; i++)
1383             if (mapSuffix(outName,zSuffix[i],unzSuffix[i]))
1384                goto zzz;
1385          cantGuess = True;
1386          strcat ( outName, ".out" );
1387          break;
1388       case SM_F2O:
1389          copyFileName ( inName, name );
1390          copyFileName ( outName, "(stdout)" );
1391          break;
1392    }
1393
1394    zzz:
1395    if ( srcMode != SM_I2O && containsDubiousChars ( inName ) ) {
1396       if (noisy)
1397       fprintf ( stderr, "%s: There are no files matching `%s'.\n",
1398                 progName, inName );
1399       setExit(1);
1400       return;
1401    }
1402    if ( srcMode != SM_I2O && !fileExists ( inName ) ) {
1403       fprintf ( stderr, "%s: Can't open input file %s: %s.\n",
1404                 progName, inName, strerror(errno) );
1405       setExit(1);
1406       return;
1407    }
1408    if ( srcMode == SM_F2F && !forceOverwrite && notAStandardFile ( inName )) {
1409       if (noisy)
1410       fprintf ( stderr, "%s: Input file %s is not a normal file.\n",
1411                 progName, inName );
1412       setExit(1);
1413       return;
1414    }
1415    if ( /* srcMode == SM_F2F implied && */ cantGuess ) {
1416       if (noisy)
1417       fprintf ( stderr,
1418                 "%s: Can't guess original name for %s -- using %s\n",
1419                 progName, inName, outName );
1420       /* just a warning, no return */
1421    }
1422    if ( srcMode == SM_F2F && !forceOverwrite && fileExists ( outName ) ) {
1423       fprintf ( stderr, "%s: Output file %s already exists.\n",
1424                 progName, outName );
1425       setExit(1);
1426       return;
1427    }
1428    if ( srcMode == SM_F2F && !forceOverwrite &&
1429         (n=countHardLinks ( inName ) ) > 0) {
1430       fprintf ( stderr, "%s: Input file %s has %d other link%s.\n",
1431                 progName, inName, n, n > 1 ? "s" : "" );
1432       setExit(1);
1433       return;
1434    }
1435
1436    switch ( srcMode ) {
1437
1438       case SM_I2O:
1439          inStr = stdin;
1440          outStr = stdout;
1441          if ( isatty ( fileno ( stdin ) ) ) {
1442             fprintf ( stderr,
1443                       "%s: I won't read compressed data from a terminal.\n",
1444                       progName );
1445             fprintf ( stderr, "%s: For help, type: `%s --help'.\n",
1446                               progName, progName );
1447             setExit(1);
1448             return;
1449          };
1450          break;
1451
1452       case SM_F2O:
1453          inStr = fopen ( inName, "rb" );
1454          outStr = stdout;
1455          if ( inStr == NULL ) {
1456             fprintf ( stderr, "%s: Can't open input file %s:%s.\n",
1457                       progName, inName, strerror(errno) );
1458             if ( inStr != NULL ) fclose ( inStr );
1459             setExit(1);
1460             return;
1461          };
1462          break;
1463
1464       case SM_F2F:
1465          inStr = fopen ( inName, "rb" );
1466          outStr = fopen ( outName, "wb" );
1467          if ( outStr == NULL) {
1468             fprintf ( stderr, "%s: Can't create output file %s: %s.\n",
1469                       progName, outName, strerror(errno) );
1470             if ( inStr != NULL ) fclose ( inStr );
1471             setExit(1);
1472             return;
1473          }
1474          if ( inStr == NULL ) {
1475             fprintf ( stderr, "%s: Can't open input file %s: %s.\n",
1476                       progName, inName, strerror(errno) );
1477             if ( outStr != NULL ) fclose ( outStr );
1478             setExit(1);
1479             return;
1480          };
1481          setInterimPermissions ( outName );
1482          break;
1483
1484       default:
1485          panic ( "uncompress: bad srcMode" );
1486          break;
1487    }
1488
1489    if (verbosity >= 1) {
1490       fprintf ( stderr, "  %s: ", inName );
1491       pad ( inName );
1492       fflush ( stderr );
1493    }
1494
1495    /*--- Now the input and output handles are sane.  Do the Biz. ---*/
1496    outputHandleJustInCase = outStr;
1497    deleteOutputOnInterrupt = True;
1498    magicNumberOK = uncompressStream ( inStr, outStr );
1499    outputHandleJustInCase = NULL;
1500
1501    /*--- If there was an I/O error, we won't get here. ---*/
1502    if ( magicNumberOK ) {
1503       if ( srcMode == SM_F2F ) {
1504          copyDatePermissionsAndOwner ( inName, outName );
1505          deleteOutputOnInterrupt = False;
1506          if ( !keepInputFiles ) {
1507             IntNative retVal = remove ( inName );
1508             ERROR_IF_NOT_ZERO ( retVal );
1509          }
1510       }
1511    } else {
1512       unzFailsExist = True;
1513       deleteOutputOnInterrupt = False;
1514       if ( srcMode == SM_F2F ) {
1515          IntNative retVal = remove ( outName );
1516          ERROR_IF_NOT_ZERO ( retVal );
1517       }
1518    }
1519    deleteOutputOnInterrupt = False;
1520
1521    if ( magicNumberOK ) {
1522       if (verbosity >= 1)
1523          fprintf ( stderr, "done\n" );
1524    } else {
1525       setExit(2);
1526       if (verbosity >= 1)
1527          fprintf ( stderr, "not a bzip2 file.\n" ); else
1528          fprintf ( stderr,
1529                    "%s: %s is not a bzip2 file.\n",
1530                    progName, inName );
1531    }
1532
1533 }
1534
1535
1536 /*---------------------------------------------*/
1537 static
1538 void testf ( Char *name )
1539 {
1540    FILE *inStr;
1541    Bool allOK;
1542
1543    deleteOutputOnInterrupt = False;
1544
1545    if (name == NULL && srcMode != SM_I2O)
1546       panic ( "testf: bad modes\n" );
1547
1548    copyFileName ( outName, "(none)" );
1549    switch (srcMode) {
1550       case SM_I2O: copyFileName ( inName, "(stdin)" ); break;
1551       case SM_F2F: copyFileName ( inName, name ); break;
1552       case SM_F2O: copyFileName ( inName, name ); break;
1553    }
1554
1555    if ( srcMode != SM_I2O && containsDubiousChars ( inName ) ) {
1556       if (noisy)
1557       fprintf ( stderr, "%s: There are no files matching `%s'.\n",
1558                 progName, inName );
1559       setExit(1);
1560       return;
1561    }
1562    if ( srcMode != SM_I2O && !fileExists ( inName ) ) {
1563       fprintf ( stderr, "%s: Can't open input %s: %s.\n",
1564                 progName, inName, strerror(errno) );
1565       setExit(1);
1566       return;
1567    }
1568
1569    switch ( srcMode ) {
1570
1571       case SM_I2O:
1572          if ( isatty ( fileno ( stdin ) ) ) {
1573             fprintf ( stderr,
1574                       "%s: I won't read compressed data from a terminal.\n",
1575                       progName );
1576             fprintf ( stderr, "%s: For help, type: `%s --help'.\n",
1577                               progName, progName );
1578             setExit(1);
1579             return;
1580          };
1581          inStr = stdin;
1582          break;
1583
1584       case SM_F2O: case SM_F2F:
1585          inStr = fopen ( inName, "rb" );
1586          if ( inStr == NULL ) {
1587             fprintf ( stderr, "%s: Can't open input file %s:%s.\n",
1588                       progName, inName, strerror(errno) );
1589             setExit(1);
1590             return;
1591          };
1592          break;
1593
1594       default:
1595          panic ( "testf: bad srcMode" );
1596          break;
1597    }
1598
1599    if (verbosity >= 1) {
1600       fprintf ( stderr, "  %s: ", inName );
1601       pad ( inName );
1602       fflush ( stderr );
1603    }
1604
1605    /*--- Now the input handle is sane.  Do the Biz. ---*/
1606    allOK = testStream ( inStr );
1607
1608    if (allOK && verbosity >= 1) fprintf ( stderr, "ok\n" );
1609    if (!allOK) testFailsExist = True;
1610 }
1611
1612
1613 /*---------------------------------------------*/
1614 static
1615 void license ( void )
1616 {
1617    fprintf ( stderr,
1618
1619     "bzip2, a block-sorting file compressor.  "
1620     "Version %s.\n"
1621     "   \n"
1622     "   Copyright (C) 1996-2000 by Julian Seward.\n"
1623     "   \n"
1624     "   This program is free software; you can redistribute it and/or modify\n"
1625     "   it under the terms set out in the LICENSE file, which is included\n"
1626     "   in the bzip2-1.0 source distribution.\n"
1627     "   \n"
1628     "   This program is distributed in the hope that it will be useful,\n"
1629     "   but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1630     "   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
1631     "   LICENSE file for more details.\n"
1632     "   \n",
1633     BZ2_bzlibVersion()
1634    );
1635 }
1636
1637
1638 /*---------------------------------------------*/
1639 static
1640 void usage ( Char *fullProgName )
1641 {
1642    fprintf (
1643       stderr,
1644       "bzip2, a block-sorting file compressor.  "
1645       "Version %s.\n"
1646       "\n   usage: %s [flags and input files in any order]\n"
1647       "\n"
1648       "   -h --help           print this message\n"
1649       "   -d --decompress     force decompression\n"
1650       "   -z --compress       force compression\n"
1651       "   -k --keep           keep (don't delete) input files\n"
1652       "   -f --force          overwrite existing output files\n"
1653       "   -t --test           test compressed file integrity\n"
1654       "   -c --stdout         output to standard out\n"
1655       "   -q --quiet          suppress noncritical error messages\n"
1656       "   -v --verbose        be verbose (a 2nd -v gives more)\n"
1657       "   -L --license        display software version & license\n"
1658       "   -V --version        display software version & license\n"
1659       "   -s --small          use less memory (at most 2500k)\n"
1660       "   -1 .. -9            set block size to 100k .. 900k\n"
1661       "\n"
1662       "   If invoked as `bzip2', default action is to compress.\n"
1663       "              as `bunzip2',  default action is to decompress.\n"
1664       "              as `bzcat', default action is to decompress to stdout.\n"
1665       "\n"
1666       "   If no file names are given, bzip2 compresses or decompresses\n"
1667       "   from standard input to standard output.  You can combine\n"
1668       "   short flags, so `-v -4' means the same as -v4 or -4v, &c.\n"
1669 #if BZ_UNIX
1670       "\n"
1671 #endif
1672       ,
1673
1674       BZ2_bzlibVersion(),
1675       fullProgName
1676    );
1677 }
1678
1679
1680 /*---------------------------------------------*/
1681 static
1682 void redundant ( Char* flag )
1683 {
1684    fprintf (
1685       stderr,
1686       "%s: %s is redundant in versions 0.9.5 and above\n",
1687       progName, flag );
1688 }
1689
1690
1691 /*---------------------------------------------*/
1692 /*--
1693   All the garbage from here to main() is purely to
1694   implement a linked list of command-line arguments,
1695   into which main() copies argv[1 .. argc-1].
1696
1697   The purpose of this exercise is to facilitate
1698   the expansion of wildcard characters * and ? in
1699   filenames for OSs which don't know how to do it
1700   themselves, like MSDOS, Windows 95 and NT.
1701
1702   The actual Dirty Work is done by the platform-
1703   specific macro APPEND_FILESPEC.
1704 --*/
1705
1706 typedef
1707    struct zzzz {
1708       Char        *name;
1709       struct zzzz *link;
1710    }
1711    Cell;
1712
1713
1714 /*---------------------------------------------*/
1715 static
1716 void *myMalloc ( Int32 n )
1717 {
1718    void* p;
1719
1720    p = malloc ( (size_t)n );
1721    if (p == NULL) outOfMemory ();
1722    return p;
1723 }
1724
1725
1726 /*---------------------------------------------*/
1727 static
1728 Cell *mkCell ( void )
1729 {
1730    Cell *c;
1731
1732    c = (Cell*) myMalloc ( sizeof ( Cell ) );
1733    c->name = NULL;
1734    c->link = NULL;
1735    return c;
1736 }
1737
1738
1739 /*---------------------------------------------*/
1740 static
1741 Cell *snocString ( Cell *root, Char *name )
1742 {
1743    if (root == NULL) {
1744       Cell *tmp = mkCell();
1745       tmp->name = (Char*) myMalloc ( 5 + strlen(name) );
1746       strcpy ( tmp->name, name );
1747       return tmp;
1748    } else {
1749       Cell *tmp = root;
1750       while (tmp->link != NULL) tmp = tmp->link;
1751       tmp->link = snocString ( tmp->link, name );
1752       return root;
1753    }
1754 }
1755
1756
1757 /*---------------------------------------------*/
1758 static
1759 void addFlagsFromEnvVar ( Cell** argList, Char* varName )
1760 {
1761    Int32 i, j, k;
1762    Char *envbase, *p;
1763
1764    envbase = getenv(varName);
1765    if (envbase != NULL) {
1766       p = envbase;
1767       i = 0;
1768       while (True) {
1769          if (p[i] == 0) break;
1770          p += i;
1771          i = 0;
1772          while (isspace((Int32)(p[0]))) p++;
1773          while (p[i] != 0 && !isspace((Int32)(p[i]))) i++;
1774          if (i > 0) {
1775             k = i; if (k > FILE_NAME_LEN-10) k = FILE_NAME_LEN-10;
1776             for (j = 0; j < k; j++) tmpName[j] = p[j];
1777             tmpName[k] = 0;
1778             APPEND_FLAG(*argList, tmpName);
1779          }
1780       }
1781    }
1782 }
1783
1784
1785 /*---------------------------------------------*/
1786 #define ISFLAG(s) (strcmp(aa->name, (s))==0)
1787
1788 IntNative main ( IntNative argc, Char *argv[] )
1789 {
1790    Int32  i, j;
1791    Char   *tmp;
1792    Cell   *argList;
1793    Cell   *aa;
1794    Bool   decode;
1795
1796    /*-- Be really really really paranoid :-) --*/
1797    if (sizeof(Int32) != 4 || sizeof(UInt32) != 4  ||
1798        sizeof(Int16) != 2 || sizeof(UInt16) != 2  ||
1799        sizeof(Char)  != 1 || sizeof(UChar)  != 1)
1800       configError();
1801
1802    /*-- Initialise --*/
1803    outputHandleJustInCase  = NULL;
1804    smallMode               = False;
1805    keepInputFiles          = False;
1806    forceOverwrite          = False;
1807    noisy                   = True;
1808    verbosity               = 0;
1809    blockSize100k           = 9;
1810    testFailsExist          = False;
1811    unzFailsExist           = False;
1812    numFileNames            = 0;
1813    numFilesProcessed       = 0;
1814    workFactor              = 30;
1815    deleteOutputOnInterrupt = False;
1816    exitValue               = 0;
1817    i = j = 0; /* avoid bogus warning from egcs-1.1.X */
1818
1819    /*-- Set up signal handlers for mem access errors --*/
1820    signal (SIGSEGV, mySIGSEGVorSIGBUScatcher);
1821 #if BZ_UNIX
1822 #ifndef __DJGPP__
1823    signal (SIGBUS,  mySIGSEGVorSIGBUScatcher);
1824 #endif
1825 #endif
1826
1827    copyFileName ( inName,  "(none)" );
1828    copyFileName ( outName, "(none)" );
1829
1830    copyFileName ( progNameReally, argv[0] );
1831    progName = &progNameReally[0];
1832    for (tmp = &progNameReally[0]; *tmp != '\0'; tmp++)
1833       if (*tmp == PATH_SEP) progName = tmp + 1;
1834
1835
1836    /*-- Copy flags from env var BZIP2, and
1837         expand filename wildcards in arg list.
1838    --*/
1839    argList = NULL;
1840    addFlagsFromEnvVar ( &argList,  "BZIP2" );
1841    addFlagsFromEnvVar ( &argList,  "BZIP" );
1842    for (i = 1; i <= argc-1; i++)
1843       APPEND_FILESPEC(argList, argv[i]);
1844
1845
1846    /*-- Find the length of the longest filename --*/
1847    longestFileName = 7;
1848    numFileNames    = 0;
1849    decode          = True;
1850    for (aa = argList; aa != NULL; aa = aa->link) {
1851       if (ISFLAG("--")) { decode = False; continue; }
1852       if (aa->name[0] == '-' && decode) continue;
1853       numFileNames++;
1854       if (longestFileName < (Int32)strlen(aa->name) )
1855          longestFileName = (Int32)strlen(aa->name);
1856    }
1857
1858
1859    /*-- Determine source modes; flag handling may change this too. --*/
1860    if (numFileNames == 0)
1861       srcMode = SM_I2O; else srcMode = SM_F2F;
1862
1863
1864    /*-- Determine what to do (compress/uncompress/test/cat). --*/
1865    /*-- Note that subsequent flag handling may change this. --*/
1866    opMode = OM_Z;
1867
1868    if ( (strstr ( progName, "unzip" ) != 0) ||
1869         (strstr ( progName, "UNZIP" ) != 0) )
1870       opMode = OM_UNZ;
1871
1872    if ( (strstr ( progName, "z2cat" ) != 0) ||
1873         (strstr ( progName, "Z2CAT" ) != 0) ||
1874         (strstr ( progName, "zcat" ) != 0)  ||
1875         (strstr ( progName, "ZCAT" ) != 0) )  {
1876       opMode = OM_UNZ;
1877       srcMode = (numFileNames == 0) ? SM_I2O : SM_F2O;
1878    }
1879
1880
1881    /*-- Look at the flags. --*/
1882    for (aa = argList; aa != NULL; aa = aa->link) {
1883       if (ISFLAG("--")) break;
1884       if (aa->name[0] == '-' && aa->name[1] != '-') {
1885          for (j = 1; aa->name[j] != '\0'; j++) {
1886             switch (aa->name[j]) {
1887                case 'c': srcMode          = SM_F2O; break;
1888                case 'd': opMode           = OM_UNZ; break;
1889                case 'z': opMode           = OM_Z; break;
1890                case 'f': forceOverwrite   = True; break;
1891                case 't': opMode           = OM_TEST; break;
1892                case 'k': keepInputFiles   = True; break;
1893                case 's': smallMode        = True; break;
1894                case 'q': noisy            = False; break;
1895                case '1': blockSize100k    = 1; break;
1896                case '2': blockSize100k    = 2; break;
1897                case '3': blockSize100k    = 3; break;
1898                case '4': blockSize100k    = 4; break;
1899                case '5': blockSize100k    = 5; break;
1900                case '6': blockSize100k    = 6; break;
1901                case '7': blockSize100k    = 7; break;
1902                case '8': blockSize100k    = 8; break;
1903                case '9': blockSize100k    = 9; break;
1904                case 'V':
1905                case 'L': license();            break;
1906                case 'v': verbosity++; break;
1907                case 'h': usage ( progName );
1908                          exit ( 0 );
1909                          break;
1910                default:  fprintf ( stderr, "%s: Bad flag `%s'\n",
1911                                    progName, aa->name );
1912                          usage ( progName );
1913                          exit ( 1 );
1914                          break;
1915             }
1916          }
1917       }
1918    }
1919
1920    /*-- And again ... --*/
1921    for (aa = argList; aa != NULL; aa = aa->link) {
1922       if (ISFLAG("--")) break;
1923       if (ISFLAG("--stdout"))            srcMode          = SM_F2O;  else
1924       if (ISFLAG("--decompress"))        opMode           = OM_UNZ;  else
1925       if (ISFLAG("--compress"))          opMode           = OM_Z;    else
1926       if (ISFLAG("--force"))             forceOverwrite   = True;    else
1927       if (ISFLAG("--test"))              opMode           = OM_TEST; else
1928       if (ISFLAG("--keep"))              keepInputFiles   = True;    else
1929       if (ISFLAG("--small"))             smallMode        = True;    else
1930       if (ISFLAG("--quiet"))             noisy            = False;   else
1931       if (ISFLAG("--version"))           license();                  else
1932       if (ISFLAG("--license"))           license();                  else
1933       if (ISFLAG("--exponential"))       workFactor = 1;             else
1934       if (ISFLAG("--repetitive-best"))   redundant(aa->name);        else
1935       if (ISFLAG("--repetitive-fast"))   redundant(aa->name);        else
1936       if (ISFLAG("--verbose"))           verbosity++;                else
1937       if (ISFLAG("--help"))              { usage ( progName ); exit ( 0 ); }
1938          else
1939          if (strncmp ( aa->name, "--", 2) == 0) {
1940             fprintf ( stderr, "%s: Bad flag `%s'\n", progName, aa->name );
1941             usage ( progName );
1942             exit ( 1 );
1943          }
1944    }
1945
1946    if (verbosity > 4) verbosity = 4;
1947    if (opMode == OM_Z && smallMode && blockSize100k > 2)
1948       blockSize100k = 2;
1949
1950    if (opMode == OM_TEST && srcMode == SM_F2O) {
1951       fprintf ( stderr, "%s: -c and -t cannot be used together.\n",
1952                 progName );
1953       exit ( 1 );
1954    }
1955
1956    if (srcMode == SM_F2O && numFileNames == 0)
1957       srcMode = SM_I2O;
1958
1959    if (opMode != OM_Z) blockSize100k = 0;
1960
1961    if (srcMode == SM_F2F) {
1962       signal (SIGINT,  mySignalCatcher);
1963       signal (SIGTERM, mySignalCatcher);
1964 #     if BZ_UNIX
1965       signal (SIGHUP,  mySignalCatcher);
1966 #     endif
1967    }
1968
1969    if (opMode == OM_Z) {
1970      if (srcMode == SM_I2O) {
1971         compress ( NULL );
1972      } else {
1973         decode = True;
1974         for (aa = argList; aa != NULL; aa = aa->link) {
1975            if (ISFLAG("--")) { decode = False; continue; }
1976            if (aa->name[0] == '-' && decode) continue;
1977            numFilesProcessed++;
1978            compress ( aa->name );
1979         }
1980      }
1981    }
1982    else
1983
1984    if (opMode == OM_UNZ) {
1985       unzFailsExist = False;
1986       if (srcMode == SM_I2O) {
1987          uncompress ( NULL );
1988       } else {
1989          decode = True;
1990          for (aa = argList; aa != NULL; aa = aa->link) {
1991             if (ISFLAG("--")) { decode = False; continue; }
1992             if (aa->name[0] == '-' && decode) continue;
1993             numFilesProcessed++;
1994             uncompress ( aa->name );
1995          }
1996       }
1997       if (unzFailsExist) {
1998          setExit(2);
1999          exit(exitValue);
2000       }
2001    }
2002
2003    else {
2004       testFailsExist = False;
2005       if (srcMode == SM_I2O) {
2006          testf ( NULL );
2007       } else {
2008          decode = True;
2009          for (aa = argList; aa != NULL; aa = aa->link) {
2010             if (ISFLAG("--")) { decode = False; continue; }
2011             if (aa->name[0] == '-' && decode) continue;
2012             numFilesProcessed++;
2013             testf ( aa->name );
2014          }
2015       }
2016       if (testFailsExist && noisy) {
2017          fprintf ( stderr,
2018            "\n"
2019            "You can use the `bzip2recover' program to attempt to recover\n"
2020            "data from undamaged sections of corrupted files.\n\n"
2021          );
2022          setExit(2);
2023          exit(exitValue);
2024       }
2025    }
2026
2027    /* Free the argument list memory to mollify leak detectors
2028       (eg) Purify, Checker.  Serves no other useful purpose.
2029    */
2030    aa = argList;
2031    while (aa != NULL) {
2032       Cell* aa2 = aa->link;
2033       if (aa->name != NULL) free(aa->name);
2034       free(aa);
2035       aa = aa2;
2036    }
2037
2038    return exitValue;
2039 }
2040
2041
2042 /*-----------------------------------------------------------*/
2043 /*--- end                                         bzip2.c ---*/
2044 /*-----------------------------------------------------------*/