/*-----------------------------------------------------------*/

/*--- A block-sorting, lossless compressor        bzip2.c ---*/

/*-----------------------------------------------------------*/

/* ------------------------------------------------------------------

   This file is part of bzip2/libbzip2, a program and library for

   lossless, block-sorting data compression.

   bzip2/libbzip2 version 1.0.6 of 6 September 2010

   Copyright (C) 1996-2010 Julian Seward <jseward@bzip.org>

   Please read the WARNING, DISCLAIMER and PATENTS sections in the 

   README file.

   This program is released under the terms of the license contained

   in the file LICENSE.

   ------------------------------------------------------------------ */

/* Place a 1 beside your platform, and 0 elsewhere.

   Generic 32-bit Unix.

   Also works on 64-bit Unix boxes.

   This is the default.

*/

#define BZ_UNIX      1

/*--

  Win32, as seen by Jacob Navia's excellent

  port of (Chris Fraser & David Hanson)'s excellent

  lcc compiler.  Or with MS Visual C.

  This is selected automatically if compiled by a compiler which

  defines _WIN32, not including the Cygwin GCC.

--*/

#define BZ_LCCWIN32  0

#if defined(_WIN32) && !defined(__CYGWIN__)

#undef  BZ_LCCWIN32

#define BZ_LCCWIN32 1

#undef  BZ_UNIX

#define BZ_UNIX 0

#endif

/*---------------------------------------------*/

/*--

  Some stuff for all platforms.

--*/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <signal.h>

#include <math.h>

#include <errno.h>

#include <ctype.h>

#include "bzlib.h"

#define ERROR_IF_EOF(i)       { if ((i) == EOF)  ioError(); }

#define ERROR_IF_NOT_ZERO(i)  { if ((i) != 0)    ioError(); }

#define ERROR_IF_MINUS_ONE(i) { if ((i) == (-1)) ioError(); }

/*---------------------------------------------*/

/*--

   Platform-specific stuff.

--*/

#if BZ_UNIX

#   include <fcntl.h>

#   include <sys/types.h>

#   include <utime.h>

#   include <unistd.h>

#   include <sys/stat.h>

#   include <sys/times.h>

#   define PATH_SEP    '/'

#   define MY_LSTAT    lstat

#   define MY_STAT     stat

#   define MY_S_ISREG  S_ISREG

#   define MY_S_ISDIR  S_ISDIR

#   define APPEND_FILESPEC(root, name) \

      root=snocString((root), (name))

#   define APPEND_FLAG(root, name) \

      root=snocString((root), (name))

#   define SET_BINARY_MODE(fd) /**/

#   ifdef __GNUC__

#      define NORETURN __attribute__ ((noreturn))

#   else

#      define NORETURN /**/

#   endif

#   ifdef __DJGPP__

#     include <io.h>

#     include <fcntl.h>

#     undef MY_LSTAT

#     undef MY_STAT

#     define MY_LSTAT stat

#     define MY_STAT stat

#     undef SET_BINARY_MODE

#     define SET_BINARY_MODE(fd)                        \

        do {                                            \

           int retVal = setmode ( fileno ( fd ),        \

                                  O_BINARY );           \

           ERROR_IF_MINUS_ONE ( retVal );               \

        } while ( 0 )

#   endif

#   ifdef __CYGWIN__

#     include <io.h>

#     include <fcntl.h>

#     undef SET_BINARY_MODE

#     define SET_BINARY_MODE(fd)                        \

        do {                                            \

           int retVal = setmode ( fileno ( fd ),        \

                                  O_BINARY );           \

           ERROR_IF_MINUS_ONE ( retVal );               \

        } while ( 0 )

#   endif

#endif /* BZ_UNIX */

#if BZ_LCCWIN32

#   include <io.h>

#   include <fcntl.h>

#   include <sys\stat.h>

#   define NORETURN       /**/

#   define PATH_SEP       '\\'

#   define MY_LSTAT       _stat

#   define MY_STAT        _stat

#   define MY_S_ISREG(x)  ((x) & _S_IFREG)

#   define MY_S_ISDIR(x)  ((x) & _S_IFDIR)

#   define APPEND_FLAG(root, name) \

      root=snocString((root), (name))

#   define APPEND_FILESPEC(root, name)                \

      root = snocString ((root), (name))

#   define SET_BINARY_MODE(fd)                        \

      do {                                            \

         int retVal = setmode ( fileno ( fd ),        \

                                O_BINARY );           \

         ERROR_IF_MINUS_ONE ( retVal );               \

      } while ( 0 )

#endif /* BZ_LCCWIN32 */

/*---------------------------------------------*/

/*--

  Some more stuff for all platforms :-)

--*/

typedef char            Char;

typedef unsigned char   Bool;

typedef unsigned char   UChar;

typedef int             Int32;

typedef unsigned int    UInt32;

typedef short           Int16;

typedef unsigned short  UInt16;

#define True  ((Bool)1)

#define False ((Bool)0)

/*--

  IntNative is your platform's `native' int size.

  Only here to avoid probs with 64-bit platforms.

--*/

typedef int IntNative;

/*---------------------------------------------------*/

/*--- Misc (file handling) data decls             ---*/

/*---------------------------------------------------*/

Int32   verbosity;

Bool    keepInputFiles, smallMode, deleteOutputOnInterrupt;

Bool    forceOverwrite, testFailsExist, unzFailsExist, noisy;

Int32   numFileNames, numFilesProcessed, blockSize100k;

Int32   exitValue;

/*-- source modes; F==file, I==stdin, O==stdout --*/

#define SM_I2O           1

#define SM_F2O           2

#define SM_F2F           3

/*-- operation modes --*/

#define OM_Z             1

#define OM_UNZ           2

#define OM_TEST          3

Int32   opMode;

Int32   srcMode;

#define FILE_NAME_LEN 1034

Int32   longestFileName;

Char    inName [FILE_NAME_LEN];

Char    outName[FILE_NAME_LEN];

Char    tmpName[FILE_NAME_LEN];

Char    *progName;

Char    progNameReally[FILE_NAME_LEN];

FILE    *outputHandleJustInCase;

Int32   workFactor;

static void    panic                 ( const Char* ) NORETURN;

static void    ioError               ( void )        NORETURN;

static void    outOfMemory           ( void )        NORETURN;

static void    configError           ( void )        NORETURN;

static void    crcError              ( void )        NORETURN;

static void    cleanUpAndFail        ( Int32 )       NORETURN;

static void    compressedStreamEOF   ( void )        NORETURN;

static void    copyFileName ( Char*, Char* );

static void*   myMalloc     ( Int32 );

static void    applySavedFileAttrToOutputFile ( IntNative fd );

/*---------------------------------------------------*/

/*--- An implementation of 64-bit ints.  Sigh.    ---*/

/*--- Roll on widespread deployment of ANSI C9X ! ---*/

/*---------------------------------------------------*/

typedef

   struct { UChar b[8]; } 

   UInt64;

static

void uInt64_from_UInt32s ( UInt64* n, UInt32 lo32, UInt32 hi32 )

{

   n->b[7] = (UChar)((hi32 >> 24) & 0xFF);

   n->b[6] = (UChar)((hi32 >> 16) & 0xFF);

   n->b[5] = (UChar)((hi32 >> 8)  & 0xFF);

   n->b[4] = (UChar) (hi32        & 0xFF);

   n->b[3] = (UChar)((lo32 >> 24) & 0xFF);

   n->b[2] = (UChar)((lo32 >> 16) & 0xFF);

   n->b[1] = (UChar)((lo32 >> 8)  & 0xFF);

   n->b[0] = (UChar) (lo32        & 0xFF);

}

static

double uInt64_to_double ( UInt64* n )

{

   Int32  i;

   double base = 1.0;

   double sum  = 0.0;

   for (i = 0; i < 8; i++) {

      sum  += base * (double)(n->b[i]);

      base *= 256.0;

   }

   return sum;

}

static

Bool uInt64_isZero ( UInt64* n )

{

   Int32 i;

   for (i = 0; i < 8; i++)

      if (n->b[i] != 0) return 0;

   return 1;

}

/* Divide *n by 10, and return the remainder.  */

static 

Int32 uInt64_qrm10 ( UInt64* n )

{

   UInt32 rem, tmp;

   Int32  i;

   rem = 0;

   for (i = 7; i >= 0; i--) {

      tmp = rem * 256 + n->b[i];

      n->b[i] = tmp / 10;

      rem = tmp % 10;

   }

   return rem;

}

/* ... and the Whole Entire Point of all this UInt64 stuff is

   so that we can supply the following function.

*/

static

void uInt64_toAscii ( char* outbuf, UInt64* n )

{

   Int32  i, q;

   UChar  buf[32];

   Int32  nBuf   = 0;

   UInt64 n_copy = *n;

   do {

      q = uInt64_qrm10 ( &n_copy );

      buf[nBuf] = q + '0';

      nBuf++;

   } while (!uInt64_isZero(&n_copy));

   outbuf[nBuf] = 0;

   for (i = 0; i < nBuf; i++) 

      outbuf[i] = buf[nBuf-i-1];

}

/*---------------------------------------------------*/

/*--- Processing of complete files and streams    ---*/

/*---------------------------------------------------*/

/*---------------------------------------------*/

static 

Bool myfeof ( FILE* f )

{

   Int32 c = fgetc ( f );

   if (c == EOF) return True;

   ungetc ( c, f );

   return False;

}

/*---------------------------------------------*/

static 

void compressStream ( FILE *stream, FILE *zStream )

{

   BZFILE* bzf = NULL;

   UChar   ibuf[5000];

   Int32   nIbuf;

   UInt32  nbytes_in_lo32, nbytes_in_hi32;

   UInt32  nbytes_out_lo32, nbytes_out_hi32;

   Int32   bzerr, bzerr_dummy, ret;

   SET_BINARY_MODE(stream);

   SET_BINARY_MODE(zStream);

   if (ferror(stream)) goto errhandler_io;

   if (ferror(zStream)) goto errhandler_io;

   bzf = BZ2_bzWriteOpen ( &bzerr, zStream, 

                           blockSize100k, verbosity, workFactor );   

   if (bzerr != BZ_OK) goto errhandler;

   if (verbosity >= 2) fprintf ( stderr, "\n" );

   while (True) {

      if (myfeof(stream)) break;

      nIbuf = fread ( ibuf, sizeof(UChar), 5000, stream );

      if (ferror(stream)) goto errhandler_io;

      if (nIbuf > 0) BZ2_bzWrite ( &bzerr, bzf, (void*)ibuf, nIbuf );

      if (bzerr != BZ_OK) goto errhandler;

   }

   BZ2_bzWriteClose64 ( &bzerr, bzf, 0, 

                        &nbytes_in_lo32, &nbytes_in_hi32,

                        &nbytes_out_lo32, &nbytes_out_hi32 );

   if (bzerr != BZ_OK) goto errhandler;

   if (ferror(zStream)) goto errhandler_io;

   ret = fflush ( zStream );

   if (ret == EOF) goto errhandler_io;

   if (zStream != stdout) {

      Int32 fd = fileno ( zStream );

      if (fd < 0) goto errhandler_io;

      applySavedFileAttrToOutputFile ( fd );

      ret = fclose ( zStream );

      outputHandleJustInCase = NULL;

      if (ret == EOF) goto errhandler_io;

   }

   outputHandleJustInCase = NULL;

   if (ferror(stream)) goto errhandler_io;

   ret = fclose ( stream );

   if (ret == EOF) goto errhandler_io;

   if (verbosity >= 1) {

      if (nbytes_in_lo32 == 0 && nbytes_in_hi32 == 0) {

	 fprintf ( stderr, " no data compressed.\n");

      } else {

	 Char   buf_nin[32], buf_nout[32];

	 UInt64 nbytes_in,   nbytes_out;

	 double nbytes_in_d, nbytes_out_d;

	 uInt64_from_UInt32s ( &nbytes_in, 

			       nbytes_in_lo32, nbytes_in_hi32 );

	 uInt64_from_UInt32s ( &nbytes_out, 

			       nbytes_out_lo32, nbytes_out_hi32 );

	 nbytes_in_d  = uInt64_to_double ( &nbytes_in );

	 nbytes_out_d = uInt64_to_double ( &nbytes_out );

	 uInt64_toAscii ( buf_nin, &nbytes_in );

	 uInt64_toAscii ( buf_nout, &nbytes_out );

	 fprintf ( stderr, "%6.3f:1, %6.3f bits/byte, "

		   "%5.2f%% saved, %s in, %s out.\n",

		   nbytes_in_d / nbytes_out_d,

		   (8.0 * nbytes_out_d) / nbytes_in_d,

		   100.0 * (1.0 - nbytes_out_d / nbytes_in_d),

		   buf_nin,

		   buf_nout

		 );

      }

   }

   return;

   errhandler:

   BZ2_bzWriteClose64 ( &bzerr_dummy, bzf, 1, 

                        &nbytes_in_lo32, &nbytes_in_hi32,

                        &nbytes_out_lo32, &nbytes_out_hi32 );

   switch (bzerr) {

      case BZ_CONFIG_ERROR:

         configError(); break;

      case BZ_MEM_ERROR:

         outOfMemory (); break;

      case BZ_IO_ERROR:

         errhandler_io:

         ioError(); break;

      default:

         panic ( "compress:unexpected error" );

   }

   panic ( "compress:end" );

   /*notreached*/

}

/*---------------------------------------------*/

static 

Bool uncompressStream ( FILE *zStream, FILE *stream )

{

   BZFILE* bzf = NULL;

   Int32   bzerr, bzerr_dummy, ret, nread, streamNo, i;

   UChar   obuf[5000];

   UChar   unused[BZ_MAX_UNUSED];

   Int32   nUnused;

   void*   unusedTmpV;

   UChar*  unusedTmp;

   nUnused = 0;

   streamNo = 0;

   SET_BINARY_MODE(stream);

   SET_BINARY_MODE(zStream);

   if (ferror(stream)) goto errhandler_io;

   if (ferror(zStream)) goto errhandler_io;

   while (True) {

      bzf = BZ2_bzReadOpen ( 

               &bzerr, zStream, verbosity, 

               (int)smallMode, unused, nUnused

            );

      if (bzf == NULL || bzerr != BZ_OK) goto errhandler;

      streamNo++;

      while (bzerr == BZ_OK) {

         nread = BZ2_bzRead ( &bzerr, bzf, obuf, 5000 );

         if (bzerr == BZ_DATA_ERROR_MAGIC) goto trycat;

         if ((bzerr == BZ_OK || bzerr == BZ_STREAM_END) && nread > 0)

            fwrite ( obuf, sizeof(UChar), nread, stream );

         if (ferror(stream)) goto errhandler_io;

      }

      if (bzerr != BZ_STREAM_END) goto errhandler;

      BZ2_bzReadGetUnused ( &bzerr, bzf, &unusedTmpV, &nUnused );

      if (bzerr != BZ_OK) panic ( "decompress:bzReadGetUnused" );

      unusedTmp = (UChar*)unusedTmpV;

      for (i = 0; i < nUnused; i++) unused[i] = unusedTmp[i];

      BZ2_bzReadClose ( &bzerr, bzf );

      if (bzerr != BZ_OK) panic ( "decompress:bzReadGetUnused" );

      if (nUnused == 0 && myfeof(zStream)) break;

   }

   closeok:

   if (ferror(zStream)) goto errhandler_io;

   if (stream != stdout) {

      Int32 fd = fileno ( stream );

      if (fd < 0) goto errhandler_io;

      applySavedFileAttrToOutputFile ( fd );

   }

   ret = fclose ( zStream );

   if (ret == EOF) goto errhandler_io;

   if (ferror(stream)) goto errhandler_io;

   ret = fflush ( stream );

   if (ret != 0) goto errhandler_io;

   if (stream != stdout) {

      ret = fclose ( stream );

      outputHandleJustInCase = NULL;

      if (ret == EOF) goto errhandler_io;

   }

   outputHandleJustInCase = NULL;

   if (verbosity >= 2) fprintf ( stderr, "\n    " );

   return True;

   trycat: 

   if (forceOverwrite) {

      rewind(zStream);

      while (True) {

      	 if (myfeof(zStream)) break;

      	 nread = fread ( obuf, sizeof(UChar), 5000, zStream );

      	 if (ferror(zStream)) goto errhandler_io;

      	 if (nread > 0) fwrite ( obuf, sizeof(UChar), nread, stream );

      	 if (ferror(stream)) goto errhandler_io;

      }

      goto closeok;

   }

   errhandler:

   BZ2_bzReadClose ( &bzerr_dummy, bzf );

   switch (bzerr) {

      case BZ_CONFIG_ERROR:

         configError(); break;

      case BZ_IO_ERROR:

         errhandler_io:

         ioError(); break;

      case BZ_DATA_ERROR:

         crcError();

      case BZ_MEM_ERROR:

         outOfMemory();

      case BZ_UNEXPECTED_EOF:

         compressedStreamEOF();

      case BZ_DATA_ERROR_MAGIC:

         if (zStream != stdin) fclose(zStream);

         if (stream != stdout) fclose(stream);

         if (streamNo == 1) {

            return False;

         } else {

            if (noisy)

            fprintf ( stderr, 

                      "\n%s: %s: trailing garbage after EOF ignored\n",

                      progName, inName );

            return True;       

         }

      default:

         panic ( "decompress:unexpected error" );

   }

   panic ( "decompress:end" );

   return True; /*notreached*/

}

/*---------------------------------------------*/

static 

Bool testStream ( FILE *zStream )

{

   BZFILE* bzf = NULL;

   Int32   bzerr, bzerr_dummy, ret, nread, streamNo, i;

   UChar   obuf[5000];

   UChar   unused[BZ_MAX_UNUSED];

   Int32   nUnused;

   void*   unusedTmpV;

   UChar*  unusedTmp;

   nUnused = 0;

   streamNo = 0;

   SET_BINARY_MODE(zStream);

   if (ferror(zStream)) goto errhandler_io;

   while (True) {

      bzf = BZ2_bzReadOpen ( 

               &bzerr, zStream, verbosity, 

               (int)smallMode, unused, nUnused

            );

      if (bzf == NULL || bzerr != BZ_OK) goto errhandler;

      streamNo++;

      while (bzerr == BZ_OK) {

         nread = BZ2_bzRead ( &bzerr, bzf, obuf, 5000 );

         if (bzerr == BZ_DATA_ERROR_MAGIC) goto errhandler;

      }

      if (bzerr != BZ_STREAM_END) goto errhandler;

      BZ2_bzReadGetUnused ( &bzerr, bzf, &unusedTmpV, &nUnused );

      if (bzerr != BZ_OK) panic ( "test:bzReadGetUnused" );

      unusedTmp = (UChar*)unusedTmpV;

      for (i = 0; i < nUnused; i++) unused[i] = unusedTmp[i];

      BZ2_bzReadClose ( &bzerr, bzf );

      if (bzerr != BZ_OK) panic ( "test:bzReadGetUnused" );

      if (nUnused == 0 && myfeof(zStream)) break;

   }

   if (ferror(zStream)) goto errhandler_io;

   ret = fclose ( zStream );

   if (ret == EOF) goto errhandler_io;

   if (verbosity >= 2) fprintf ( stderr, "\n    " );

   return True;

   errhandler:

   BZ2_bzReadClose ( &bzerr_dummy, bzf );

   if (verbosity == 0) 

      fprintf ( stderr, "%s: %s: ", progName, inName );

   switch (bzerr) {

      case BZ_CONFIG_ERROR:

         configError(); break;

      case BZ_IO_ERROR:

         errhandler_io:

         ioError(); break;

      case BZ_DATA_ERROR:

         fprintf ( stderr,

                   "data integrity (CRC) error in data\n" );

         return False;

      case BZ_MEM_ERROR:

         outOfMemory();

      case BZ_UNEXPECTED_EOF:

         fprintf ( stderr,

                   "file ends unexpectedly\n" );

         return False;

      case BZ_DATA_ERROR_MAGIC:

         if (zStream != stdin) fclose(zStream);

         if (streamNo == 1) {

          fprintf ( stderr, 

                    "bad magic number (file not created by bzip2)\n" );

            return False;

         } else {

            if (noisy)

            fprintf ( stderr, 

                      "trailing garbage after EOF ignored\n" );

            return True;       

         }

      default:

         panic ( "test:unexpected error" );

   }

   panic ( "test:end" );

   return True; /*notreached*/

}

/*---------------------------------------------------*/

/*--- Error [non-] handling grunge                ---*/

/*---------------------------------------------------*/

/*---------------------------------------------*/

static

void setExit ( Int32 v )

{

   if (v > exitValue) exitValue = v;

}

/*---------------------------------------------*/

static 

void cadvise ( void )

{

   if (noisy)

   fprintf (

      stderr,

      "\nIt is possible that the compressed file(s) have become corrupted.\n"

        "You can use the -tvv option to test integrity of such files.\n\n"

        "You can use the `bzip2recover' program to attempt to recover\n"

        "data from undamaged sections of corrupted files.\n\n"

    );

}

/*---------------------------------------------*/

static 

void showFileNames ( void )

{

   if (noisy)

   fprintf (

      stderr,

      "\tInput file = %s, output file = %s\n",

      inName, outName 

   );

}

/*---------------------------------------------*/

static 

void cleanUpAndFail ( Int32 ec )

{

   IntNative      retVal;

   struct MY_STAT statBuf;

   if ( srcMode == SM_F2F 

        && opMode != OM_TEST

        && deleteOutputOnInterrupt ) {

      /* Check whether input file still exists.  Delete output file

         only if input exists to avoid loss of data.  Joerg Prante, 5

         January 2002.  (JRS 06-Jan-2002: other changes in 1.0.2 mean

         this is less likely to happen.  But to be ultra-paranoid, we

         do the check anyway.)  */

      retVal = MY_STAT ( inName, &statBuf );

      if (retVal == 0) {

         if (noisy)

            fprintf ( stderr, 

                      "%s: Deleting output file %s, if it exists.\n",

                      progName, outName );

         if (outputHandleJustInCase != NULL)

            fclose ( outputHandleJustInCase );

         retVal = remove ( outName );

         if (retVal != 0)

            fprintf ( stderr,

                      "%s: WARNING: deletion of output file "

                      "(apparently) failed.\n",

                      progName );

      } else {

         fprintf ( stderr,

                   "%s: WARNING: deletion of output file suppressed\n",

                    progName );

         fprintf ( stderr,

                   "%s:    since input file no longer exists.  Output file\n",

                   progName );

         fprintf ( stderr,

                   "%s:    `%s' may be incomplete.\n",

                   progName, outName );

         fprintf ( stderr, 

                   "%s:    I suggest doing an integrity test (bzip2 -tv)"

                   " of it.\n",

                   progName );

      }

   }

   if (noisy && numFileNames > 0 && numFilesProcessed < numFileNames) {

      fprintf ( stderr, 

                "%s: WARNING: some files have not been processed:\n"

                "%s:    %d specified on command line, %d not processed yet.\n\n",

                progName, progName,

                numFileNames, numFileNames - numFilesProcessed );

   }

   setExit(ec);

   exit(exitValue);

}

/*---------------------------------------------*/

static 

void panic ( const Char* s )

{

   fprintf ( stderr,

             "\n%s: PANIC -- internal consistency error:\n"

             "\t%s\n"

             "\tThis is a BUG.  Please report it to me at:\n"

             "\tjseward@bzip.org\n",

             progName, s );

   showFileNames();

   cleanUpAndFail( 3 );

}

/*---------------------------------------------*/

static 

void crcError ( void )

{

   fprintf ( stderr,

             "\n%s: Data integrity error when decompressing.\n",

             progName );

   showFileNames();

   cadvise();

   cleanUpAndFail( 2 );

}

/*---------------------------------------------*/

static 

void compressedStreamEOF ( void )

{

  if (noisy) {

    fprintf ( stderr,

	      "\n%s: Compressed file ends unexpectedly;\n\t"

	      "perhaps it is corrupted?  *Possible* reason follows.\n",

	      progName );

    perror ( progName );

    showFileNames();

    cadvise();

  }

  cleanUpAndFail( 2 );

}

/*---------------------------------------------*/

static 

void ioError ( void )

{

   fprintf ( stderr,

             "\n%s: I/O or other error, bailing out.  "

             "Possible reason follows.\n",

             progName );

   perror ( progName );

   showFileNames();

   cleanUpAndFail( 1 );

}

/*---------------------------------------------*/

static 

void mySignalCatcher ( IntNative n )

{

   fprintf ( stderr,

             "\n%s: Control-C or similar caught, quitting.\n",

             progName );

   cleanUpAndFail(1);

}

/*---------------------------------------------*/

static 

void mySIGSEGVorSIGBUScatcher ( IntNative n )

{

   if (opMode == OM_Z)

      fprintf ( 

      stderr,

      "\n%s: Caught a SIGSEGV or SIGBUS whilst compressing.\n"

      "\n"

      "   Possible causes are (most likely first):\n"

      "   (1) This computer has unreliable memory or cache hardware\n"

      "       (a surprisingly common problem; try a different machine.)\n"

      "   (2) A bug in the compiler used to create this executable\n"

      "       (unlikely, if you didn't compile bzip2 yourself.)\n"

      "   (3) A real bug in bzip2 -- I hope this should never be the case.\n"

      "   The user's manual, Section 4.3, has more info on (1) and (2).\n"

      "   \n"

      "   If you suspect this is a bug in bzip2, or are unsure about (1)\n"

      "   or (2), feel free to report it to me at: jseward@bzip.org.\n"

      "   Section 4.3 of the user's manual describes the info a useful\n"

      "   bug report should have.  If the manual is available on your\n"

      "   system, please try and read it before mailing me.  If you don't\n"

      "   have the manual or can't be bothered to read it, mail me anyway.\n"

      "\n",

      progName );

      else

      fprintf ( 

      stderr,

      "\n%s: Caught a SIGSEGV or SIGBUS whilst decompressing.\n"

      "\n"

      "   Possible causes are (most likely first):\n"

      "   (1) The compressed data is corrupted, and bzip2's usual checks\n"

      "       failed to detect this.  Try bzip2 -tvv my_file.bz2.\n"

      "   (2) This computer has unreliable memory or cache hardware\n"

      "       (a surprisingly common problem; try a different machine.)\n"

      "   (3) A bug in the compiler used to create this executable\n"

      "       (unlikely, if you didn't compile bzip2 yourself.)\n"

      "   (4) A real bug in bzip2 -- I hope this should never be the case.\n"

      "   The user's manual, Section 4.3, has more info on (2) and (3).\n"

      "   \n"

      "   If you suspect this is a bug in bzip2, or are unsure about (2)\n"

      "   or (3), feel free to report it to me at: jseward@bzip.org.\n"

      "   Section 4.3 of the user's manual describes the info a useful\n"

      "   bug report should have.  If the manual is available on your\n"

      "   system, please try and read it before mailing me.  If you don't\n"

      "   have the manual or can't be bothered to read it, mail me anyway.\n"

      "\n",

      progName );

   showFileNames();

   if (opMode == OM_Z)

      cleanUpAndFail( 3 ); else

      { cadvise(); cleanUpAndFail( 2 ); }

}

/*---------------------------------------------*/

static 

void outOfMemory ( void )

{

   fprintf ( stderr,

             "\n%s: couldn't allocate enough memory\n",

             progName );

   showFileNames();

   cleanUpAndFail(1);

}