bzlib.c File Reference

#include "bzlib_private.h"

Include dependency graph for bzlib.c:

Go to the source code of this file.

Classes
struct	bzFile

Macros
#define	ADD_CHAR_TO_BLOCK(zs, zchh0)
#define	BZ_SETERR(eee)
#define	SET_BINARY_MODE(file)

Functions
ABC_NAMESPACE_IMPL_START void	BZ2_bz__AssertH__fail (int errcode)
int BZ_API	BZ2_bzCompressInit (bz_stream *strm, int blockSize100k, int verbosity, int workFactor)
int BZ_API	BZ2_bzCompress (bz_stream *strm, int action)
int BZ_API	BZ2_bzCompressEnd (bz_stream *strm)
int BZ_API	BZ2_bzDecompressInit (bz_stream *strm, int verbosity, int small)
Int32	BZ2_indexIntoF (Int32 indx, Int32 *cftab)
int BZ_API	BZ2_bzDecompress (bz_stream *strm)
int BZ_API	BZ2_bzDecompressEnd (bz_stream *strm)
BZFILE *BZ_API	BZ2_bzWriteOpen (int *bzerror, FILE *f, int blockSize100k, int verbosity, int workFactor)
void BZ_API	BZ2_bzWrite (int *bzerror, BZFILE *b, void *buf, int len)
void BZ_API	BZ2_bzWriteClose (int *bzerror, BZFILE *b, int abandon, unsigned int *nbytes_in, unsigned int *nbytes_out)
void BZ_API	BZ2_bzWriteClose64 (int *bzerror, BZFILE *b, int abandon, unsigned int *nbytes_in_lo32, unsigned int *nbytes_in_hi32, unsigned int *nbytes_out_lo32, unsigned int *nbytes_out_hi32)
BZFILE *BZ_API	BZ2_bzReadOpen (int *bzerror, FILE *f, int verbosity, int small, void *unused, int nUnused)
void BZ_API	BZ2_bzReadClose (int *bzerror, BZFILE *b)
int BZ_API	BZ2_bzRead (int *bzerror, BZFILE *b, void *buf, int len)
void BZ_API	BZ2_bzReadGetUnused (int *bzerror, BZFILE *b, void **unused, int *nUnused)
int BZ_API	BZ2_bzBuffToBuffCompress (char *dest, unsigned int *destLen, char *source, unsigned int sourceLen, int blockSize100k, int verbosity, int workFactor)
int BZ_API	BZ2_bzBuffToBuffDecompress (char *dest, unsigned int *destLen, char *source, unsigned int sourceLen, int small, int verbosity)
const char *BZ_API	BZ2_bzlibVersion (void)
BZFILE *BZ_API	BZ2_bzopen (const char *path, const char *mode)
BZFILE *BZ_API	BZ2_bzdopen (int fd, const char *mode)
int BZ_API	BZ2_bzread (BZFILE *b, void *buf, int len)
int BZ_API	BZ2_bzwrite (BZFILE *b, void *buf, int len)
int BZ_API	BZ2_bzflush (BZFILE *b)
void BZ_API	BZ2_bzclose (BZFILE *b)
const char *BZ_API	BZ2_bzerror (BZFILE *b, int *errnum)

Macro Definition Documentation

ADD_CHAR_TO_BLOCK

#define ADD_CHAR_TO_BLOCK	(		zs,
			zchh0 )

Value:

{                                                 \
   UInt32 zchh = (UInt32)(zchh0);                 \
   /*-- fast track the common case --*/           \
   if (zchh != zs->state_in_ch &&                 \
       zs->state_in_len == 1) {                   \
      UChar ch = (UChar)(zs->state_in_ch);        \
      BZ_UPDATE_CRC( zs->blockCRC, ch );          \
      zs->inUse[zs->state_in_ch] = True;          \
      zs->block[zs->nblock] = (UChar)ch;          \
      zs->nblock++;                               \
      zs->state_in_ch = zchh;                     \
   }                                              \
   else                                           \
   /*-- general, uncommon cases --*/              \
   if (zchh != zs->state_in_ch ||                 \
      zs->state_in_len == 255) {                  \
      if (zs->state_in_ch < 256)                  \
         add_pair_to_block ( zs );                \
      zs->state_in_ch = zchh;                     \
      zs->state_in_len = 1;                       \
   } else {                                       \
      zs->state_in_len++;                         \
   }                                              \
}

Definition at line 271 of file bzlib.c.

#define ADD_CHAR_TO_BLOCK(zs,zchh0)               \
{                                                 \
   UInt32 zchh = (UInt32)(zchh0);                 \
   /*-- fast track the common case --*/           \
   if (zchh != zs->state_in_ch &&                 \
       zs->state_in_len == 1) {                   \
      UChar ch = (UChar)(zs->state_in_ch);        \
      BZ_UPDATE_CRC( zs->blockCRC, ch );          \
      zs->inUse[zs->state_in_ch] = True;          \
      zs->block[zs->nblock] = (UChar)ch;          \
      zs->nblock++;                               \
      zs->state_in_ch = zchh;                     \
   }                                              \
   else                                           \
   /*-- general, uncommon cases --*/              \
   if (zchh != zs->state_in_ch ||                 \
      zs->state_in_len == 255) {                  \
      if (zs->state_in_ch < 256)                  \
         add_pair_to_block ( zs );                \
      zs->state_in_ch = zchh;                     \
      zs->state_in_len = 1;                       \
   } else {                                       \
      zs->state_in_len++;                         \
   }                                              \
}

BZ_SETERR

#define BZ_SETERR

(

eee

)

Value:

{                                         \
   if (bzerror != NULL) *bzerror = eee;   \
   if (bzf != NULL) bzf->lastErr = eee;   \
}

Definition at line 897 of file bzlib.c.

#define BZ_SETERR(eee)                    \
{                                         \
   if (bzerror != NULL) *bzerror = eee;   \
   if (bzf != NULL) bzf->lastErr = eee;   \
}

SET_BINARY_MODE

#define SET_BINARY_MODE

(

file

)

Definition at line 1391 of file bzlib.c.

Function Documentation

BZ2_bz__AssertH__fail()

ABC_NAMESPACE_IMPL_START void BZ2_bz__AssertH__fail

(

int

errcode

)

Definition at line 52 of file bzlib.c.

{
   fprintf(stderr, 
      "\n\nbzip2/libbzip2: internal error number %d.\n"
      "This is a bug in bzip2/libbzip2, %s.\n"
      "Please report it to me at: jseward@bzip.org.  If this happened\n"
      "when you were using some program which uses libbzip2 as a\n"
      "component, you should also report this bug to the author(s)\n"
      "of that program.  Please make an effort to report this bug;\n"
      "timely and accurate bug reports eventually lead to higher\n"
      "quality software.  Thanks.  Julian Seward, 10 December 2007.\n\n",
      errcode,
      BZ2_bzlibVersion()
   );
 
   if (errcode == 1007) {
   fprintf(stderr,
      "\n*** A special note about internal error number 1007 ***\n"
      "\n"
      "Experience suggests that a common cause of i.e. 1007\n"
      "is unreliable memory or other hardware.  The 1007 assertion\n"
      "just happens to cross-check the results of huge numbers of\n"
      "memory reads/writes, and so acts (unintendedly) as a stress\n"
      "test of your memory system.\n"
      "\n"
      "I suggest the following: try compressing the file again,\n"
      "possibly monitoring progress in detail with the -vv flag.\n"
      "\n"
      "* If the error cannot be reproduced, and/or happens at different\n"
      "  points in compression, you may have a flaky memory system.\n"
      "  Try a memory-test program.  I have used Memtest86\n"
      "  (www.memtest86.com).  At the time of writing it is free (GPLd).\n"
      "  Memtest86 tests memory much more thorougly than your BIOSs\n"
      "  power-on test, and may find failures that the BIOS doesn't.\n"
      "\n"
      "* If the error can be repeatably reproduced, this is a bug in\n"
      "  bzip2, and I would very much like to hear about it.  Please\n"
      "  let me know, and, ideally, save a copy of the file causing the\n"
      "  problem -- without which I will be unable to investigate it.\n"
      "\n"
   );
   }
 
   exit(3);
}

Here is the call graph for this function:

BZ2_bzBuffToBuffCompress()

int BZ_API BZ2_bzBuffToBuffCompress	(	char *	dest,
		unsigned int *	destLen,
		char *	source,
		unsigned int	sourceLen,
		int	blockSize100k,
		int	verbosity,
		int	workFactor )

Definition at line 1258 of file bzlib.c.

{
   bz_stream strm;
   int ret;
 
   if (dest == NULL || destLen == NULL || 
       source == NULL ||
       blockSize100k < 1 || blockSize100k > 9 ||
       verbosity < 0 || verbosity > 4 ||
       workFactor < 0 || workFactor > 250) 
      return BZ_PARAM_ERROR;
 
   if (workFactor == 0) workFactor = 30;
   strm.bzalloc = NULL;
   strm.bzfree = NULL;
   strm.opaque = NULL;
   ret = BZ2_bzCompressInit ( &strm, blockSize100k, 
                              verbosity, workFactor );
   if (ret != BZ_OK) return ret;
 
   strm.next_in = source;
   strm.next_out = dest;
   strm.avail_in = sourceLen;
   strm.avail_out = *destLen;
 
   ret = BZ2_bzCompress ( &strm, BZ_FINISH );
   if (ret == BZ_FINISH_OK) goto output_overflow;
   if (ret != BZ_STREAM_END) goto errhandler;
 
   /* normal termination */
   *destLen -= strm.avail_out;   
   BZ2_bzCompressEnd ( &strm );
   return BZ_OK;
 
   output_overflow:
   BZ2_bzCompressEnd ( &strm );
   return BZ_OUTBUFF_FULL;
 
   errhandler:
   BZ2_bzCompressEnd ( &strm );
   return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_bzBuffToBuffDecompress()

int BZ_API BZ2_bzBuffToBuffDecompress	(	char *	dest,
		unsigned int *	destLen,
		char *	source,
		unsigned int	sourceLen,
		int	small,
		int	verbosity )

Definition at line 1310 of file bzlib.c.

{
   bz_stream strm;
   int ret;
 
   if (dest == NULL || destLen == NULL || 
       source == NULL ||
       (small != 0 && small != 1) ||
       verbosity < 0 || verbosity > 4) 
          return BZ_PARAM_ERROR;
 
   strm.bzalloc = NULL;
   strm.bzfree = NULL;
   strm.opaque = NULL;
   ret = BZ2_bzDecompressInit ( &strm, verbosity, small );
   if (ret != BZ_OK) return ret;
 
   strm.next_in = source;
   strm.next_out = dest;
   strm.avail_in = sourceLen;
   strm.avail_out = *destLen;
 
   ret = BZ2_bzDecompress ( &strm );
   if (ret == BZ_OK) goto output_overflow_or_eof;
   if (ret != BZ_STREAM_END) goto errhandler;
 
   /* normal termination */
   *destLen -= strm.avail_out;
   BZ2_bzDecompressEnd ( &strm );
   return BZ_OK;
 
   output_overflow_or_eof:
   if (strm.avail_out > 0) {
      BZ2_bzDecompressEnd ( &strm );
      return BZ_UNEXPECTED_EOF;
   } else {
      BZ2_bzDecompressEnd ( &strm );
      return BZ_OUTBUFF_FULL;
   };      
 
   errhandler:
   BZ2_bzDecompressEnd ( &strm );
   return ret; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_bzclose()

void BZ_API BZ2_bzclose

(

BZFILE *

b

)

Definition at line 1525 of file bzlib.c.

{
   int bzerr;
   FILE *fp;
   
   if (b==NULL) {return;}
   fp = ((bzFile *)b)->handle;
   if(((bzFile*)b)->writing){
      BZ2_bzWriteClose(&bzerr,b,0,NULL,NULL);
      if(bzerr != BZ_OK){
         BZ2_bzWriteClose(NULL,b,1,NULL,NULL);
      }
   }else{
      BZ2_bzReadClose(&bzerr,b);
   }
   if(fp!=stdin && fp!=stdout){
      fclose(fp);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_bzCompress()

int BZ_API BZ2_bzCompress	(	bz_stream *	strm,
		int	action )

Definition at line 418 of file bzlib.c.

{
   Bool progress;
   EState* s;
   if (strm == NULL) return BZ_PARAM_ERROR;
   s = (EState *)strm->state;
   if (s == NULL) return BZ_PARAM_ERROR;
   if (s->strm != strm) return BZ_PARAM_ERROR;
 
   preswitch:
   switch (s->mode) {
 
      case BZ_M_IDLE:
         return BZ_SEQUENCE_ERROR;
 
      case BZ_M_RUNNING:
         if (action == BZ_RUN) {
            progress = handle_compress ( strm );
            return progress ? BZ_RUN_OK : BZ_PARAM_ERROR;
         } 
         else
     if (action == BZ_FLUSH) {
            s->avail_in_expect = strm->avail_in;
            s->mode = BZ_M_FLUSHING;
            goto preswitch;
         }
         else
         if (action == BZ_FINISH) {
            s->avail_in_expect = strm->avail_in;
            s->mode = BZ_M_FINISHING;
            goto preswitch;
         }
         else 
            return BZ_PARAM_ERROR;
 
      case BZ_M_FLUSHING:
         if (action != BZ_FLUSH) return BZ_SEQUENCE_ERROR;
         if (s->avail_in_expect != s->strm->avail_in) 
            return BZ_SEQUENCE_ERROR;
         progress = handle_compress ( strm );
         if (s->avail_in_expect > 0 || !isempty_RL(s) ||
             s->state_out_pos < s->numZ) return BZ_FLUSH_OK;
         s->mode = BZ_M_RUNNING;
         return BZ_RUN_OK;
 
      case BZ_M_FINISHING:
         if (action != BZ_FINISH) return BZ_SEQUENCE_ERROR;
         if (s->avail_in_expect != s->strm->avail_in) 
            return BZ_SEQUENCE_ERROR;
         progress = handle_compress ( strm );
         if (!progress) return BZ_SEQUENCE_ERROR;
         if (s->avail_in_expect > 0 || !isempty_RL(s) ||
             s->state_out_pos < s->numZ) return BZ_FINISH_OK;
         s->mode = BZ_M_IDLE;
         return BZ_STREAM_END;
   }
   return BZ_OK; /*--not reached--*/
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_bzCompressEnd()

int BZ_API BZ2_bzCompressEnd

(

bz_stream *

strm

)

Definition at line 479 of file bzlib.c.

{
   EState* s;
   if (strm == NULL) return BZ_PARAM_ERROR;
   s = (EState *)strm->state;
   if (s == NULL) return BZ_PARAM_ERROR;
   if (s->strm != strm) return BZ_PARAM_ERROR;
 
   if (s->arr1 != NULL) BZFREE(s->arr1);
   if (s->arr2 != NULL) BZFREE(s->arr2);
   if (s->ftab != NULL) BZFREE(s->ftab);
   BZFREE(strm->state);
 
   strm->state = NULL;   
 
   return BZ_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_bzCompressInit()

int BZ_API BZ2_bzCompressInit	(	bz_stream *	strm,
		int	blockSize100k,
		int	verbosity,
		int	workFactor )

Definition at line 159 of file bzlib.c.

{
   Int32   n;
   EState* s;
 
   if (!bz_config_ok()) return BZ_CONFIG_ERROR;
 
   if (strm == NULL || 
       blockSize100k < 1 || blockSize100k > 9 ||
       workFactor < 0 || workFactor > 250)
     return BZ_PARAM_ERROR;
 
   if (workFactor == 0) workFactor = 30;
   if (strm->bzalloc == NULL) strm->bzalloc = default_bzalloc;
   if (strm->bzfree == NULL) strm->bzfree = default_bzfree;
 
   s = (EState *)BZALLOC( sizeof(EState) );
   if (s == NULL) return BZ_MEM_ERROR;
   s->strm = strm;
 
   s->arr1 = NULL;
   s->arr2 = NULL;
   s->ftab = NULL;
 
   n       = 100000 * blockSize100k;
   s->arr1 = (unsigned *)BZALLOC( n                  * sizeof(UInt32) );
   s->arr2 = (unsigned *)BZALLOC( (n+BZ_N_OVERSHOOT) * sizeof(UInt32) );
   s->ftab = (unsigned *)BZALLOC( 65537              * sizeof(UInt32) );
 
   if (s->arr1 == NULL || s->arr2 == NULL || s->ftab == NULL) {
      if (s->arr1 != NULL) BZFREE(s->arr1);
      if (s->arr2 != NULL) BZFREE(s->arr2);
      if (s->ftab != NULL) BZFREE(s->ftab);
      if (s       != NULL) BZFREE(s);
      return BZ_MEM_ERROR;
   }
 
   s->blockNo           = 0;
   s->state             = BZ_S_INPUT;
   s->mode              = BZ_M_RUNNING;
   s->combinedCRC       = 0;
   s->blockSize100k     = blockSize100k;
   s->nblockMAX         = 100000 * blockSize100k - 19;
   s->verbosity         = verbosity;
   s->workFactor        = workFactor;
 
   s->block             = (UChar*)s->arr2;
   s->mtfv              = (UInt16*)s->arr1;
   s->zbits             = NULL;
   s->ptr               = (UInt32*)s->arr1;
 
   strm->state          = s;
   strm->total_in_lo32  = 0;
   strm->total_in_hi32  = 0;
   strm->total_out_lo32 = 0;
   strm->total_out_hi32 = 0;
   init_RL ( s );
   prepare_new_block ( s );
   return BZ_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_bzDecompress()

int BZ_API BZ2_bzDecompress

(

bz_stream *

strm

)

Definition at line 819 of file bzlib.c.

{
   Bool    corrupt;
   DState* s;
   if (strm == NULL) return BZ_PARAM_ERROR;
   s = (DState *)strm->state;
   if (s == NULL) return BZ_PARAM_ERROR;
   if (s->strm != strm) return BZ_PARAM_ERROR;
 
   while (True) {
      if (s->state == BZ_X_IDLE) return BZ_SEQUENCE_ERROR;
      if (s->state == BZ_X_OUTPUT) {
         if (s->smallDecompress)
            corrupt = unRLE_obuf_to_output_SMALL ( s ); else
            corrupt = unRLE_obuf_to_output_FAST  ( s );
         if (corrupt) return BZ_DATA_ERROR;
         if (s->nblock_used == s->save_nblock+1 && s->state_out_len == 0) {
            BZ_FINALISE_CRC ( s->calculatedBlockCRC );
            if (s->verbosity >= 3) 
               VPrintf2 ( " {0x%08x, 0x%08x}", s->storedBlockCRC, 
                          s->calculatedBlockCRC );
            if (s->verbosity >= 2) VPrintf0 ( "]" );
            if (s->calculatedBlockCRC != s->storedBlockCRC)
               return BZ_DATA_ERROR;
            s->calculatedCombinedCRC 
               = (s->calculatedCombinedCRC << 1) | 
                    (s->calculatedCombinedCRC >> 31);
            s->calculatedCombinedCRC ^= s->calculatedBlockCRC;
            s->state = BZ_X_BLKHDR_1;
         } else {
            return BZ_OK;
         }
      }
      if (s->state >= BZ_X_MAGIC_1) {
         Int32 r = BZ2_decompress ( s );
         if (r == BZ_STREAM_END) {
            if (s->verbosity >= 3)
               VPrintf2 ( "\n    combined CRCs: stored = 0x%08x, computed = 0x%08x", 
                          s->storedCombinedCRC, s->calculatedCombinedCRC );
            if (s->calculatedCombinedCRC != s->storedCombinedCRC)
               return BZ_DATA_ERROR;
            return r;
         }
         if (s->state != BZ_X_OUTPUT) return r;
      }
   }
 
   AssertH ( 0, 6001 );
 
   return 0;  /*NOTREACHED*/
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_bzDecompressEnd()

int BZ_API BZ2_bzDecompressEnd

(

bz_stream *

strm

)

Definition at line 873 of file bzlib.c.

{
   DState* s;
   if (strm == NULL) return BZ_PARAM_ERROR;
   s = (DState *)strm->state;
   if (s == NULL) return BZ_PARAM_ERROR;
   if (s->strm != strm) return BZ_PARAM_ERROR;
 
   if (s->tt   != NULL) BZFREE(s->tt);
   if (s->ll16 != NULL) BZFREE(s->ll16);
   if (s->ll4  != NULL) BZFREE(s->ll4);
 
   BZFREE(strm->state);
   strm->state = NULL;
 
   return BZ_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_bzDecompressInit()

int BZ_API BZ2_bzDecompressInit	(	bz_stream *	strm,
		int	verbosity,
		int	small )

Definition at line 503 of file bzlib.c.

{
   DState* s;
 
   if (!bz_config_ok()) return BZ_CONFIG_ERROR;
 
   if (strm == NULL) return BZ_PARAM_ERROR;
   if (small != 0 && small != 1) return BZ_PARAM_ERROR;
   if (verbosity < 0 || verbosity > 4) return BZ_PARAM_ERROR;
 
   if (strm->bzalloc == NULL) strm->bzalloc = default_bzalloc;
   if (strm->bzfree == NULL) strm->bzfree = default_bzfree;
 
   s = (DState *)BZALLOC( sizeof(DState) );
   if (s == NULL) return BZ_MEM_ERROR;
   s->strm                  = strm;
   strm->state              = s;
   s->state                 = BZ_X_MAGIC_1;
   s->bsLive                = 0;
   s->bsBuff                = 0;
   s->calculatedCombinedCRC = 0;
   strm->total_in_lo32      = 0;
   strm->total_in_hi32      = 0;
   strm->total_out_lo32     = 0;
   strm->total_out_hi32     = 0;
   s->smallDecompress       = (Bool)small;
   s->ll4                   = NULL;
   s->ll16                  = NULL;
   s->tt                    = NULL;
   s->currBlockNo           = 0;
   s->verbosity             = verbosity;
 
   return BZ_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_bzdopen()

BZFILE *BZ_API BZ2_bzdopen	(	int	fd,
		const char *	mode )

Definition at line 1480 of file bzlib.c.

{
   return bzopen_or_bzdopen(NULL,fd,mode,/*bzdopen*/1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_bzerror()

const char *BZ_API BZ2_bzerror	(	BZFILE *	b,
		int *	errnum )

Definition at line 1570 of file bzlib.c.

{
   int err = ((bzFile *)b)->lastErr;
 
   if(err>0) err = 0;
   *errnum = err;
   return bzerrorstrings[err*-1];
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_bzflush()

int BZ_API BZ2_bzflush

(

BZFILE *

b

)

Definition at line 1517 of file bzlib.c.

{
   /* do nothing now... */
   return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_bzlibVersion()

const char *BZ_API BZ2_bzlibVersion

(

void

)

Definition at line 1377 of file bzlib.c.

{
   return BZ_VERSION;
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_bzopen()

BZFILE *BZ_API BZ2_bzopen	(	const char *	path,
		const char *	mode )

Definition at line 1471 of file bzlib.c.

{
   return bzopen_or_bzdopen(path,-1,mode,/*bzopen*/0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_bzRead()

int BZ_API BZ2_bzRead	(	int *	bzerror,
		BZFILE *	b,
		void *	buf,
		int	len )

Definition at line 1172 of file bzlib.c.

{
   Int32   n, ret;
   bzFile* bzf = (bzFile*)b;
 
   BZ_SETERR(BZ_OK);
 
   if (bzf == NULL || buf == NULL || len < 0)
      { BZ_SETERR(BZ_PARAM_ERROR); return 0; };
 
   if (bzf->writing)
      { BZ_SETERR(BZ_SEQUENCE_ERROR); return 0; };
 
   if (len == 0)
      { BZ_SETERR(BZ_OK); return 0; };
 
   bzf->strm.avail_out = len;
   bzf->strm.next_out = (char *)buf;
 
   while (True) {
 
      if (ferror(bzf->handle)) 
         { BZ_SETERR(BZ_IO_ERROR); return 0; };
 
      if (bzf->strm.avail_in == 0 && !myfeof(bzf->handle)) {
         n = fread ( bzf->buf, sizeof(UChar), 
                     BZ_MAX_UNUSED, bzf->handle );
         if (ferror(bzf->handle))
            { BZ_SETERR(BZ_IO_ERROR); return 0; };
         bzf->bufN = n;
         bzf->strm.avail_in = bzf->bufN;
         bzf->strm.next_in = bzf->buf;
      }
 
      ret = BZ2_bzDecompress ( &(bzf->strm) );
 
      if (ret != BZ_OK && ret != BZ_STREAM_END)
         { BZ_SETERR(ret); return 0; };
 
      if (ret == BZ_OK && myfeof(bzf->handle) && 
          bzf->strm.avail_in == 0 && bzf->strm.avail_out > 0)
         { BZ_SETERR(BZ_UNEXPECTED_EOF); return 0; };
 
      if (ret == BZ_STREAM_END)
         { BZ_SETERR(BZ_STREAM_END);
           return len - bzf->strm.avail_out; };
      if (bzf->strm.avail_out == 0)
         { BZ_SETERR(BZ_OK); return len; };
      
   }
 
   return 0; /*not reached*/
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_bzread()

int BZ_API BZ2_bzread	(	BZFILE *	b,
		void *	buf,
		int	len )

Definition at line 1489 of file bzlib.c.

{
   int bzerr, nread;
   if (((bzFile*)b)->lastErr == BZ_STREAM_END) return 0;
   nread = BZ2_bzRead(&bzerr,b,buf,len);
   if (bzerr == BZ_OK || bzerr == BZ_STREAM_END) {
      return nread;
   } else {
      return -1;
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_bzReadClose()

void BZ_API BZ2_bzReadClose	(	int *	bzerror,
		BZFILE *	b )

Definition at line 1154 of file bzlib.c.

{
   bzFile* bzf = (bzFile*)b;
 
   BZ_SETERR(BZ_OK);
   if (bzf == NULL)
      { BZ_SETERR(BZ_OK); return; };
 
   if (bzf->writing)
      { BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
 
   if (bzf->initialisedOk)
      (void)BZ2_bzDecompressEnd ( &(bzf->strm) );
   free ( bzf );
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_bzReadGetUnused()

void BZ_API BZ2_bzReadGetUnused	(	int *	bzerror,
		BZFILE *	b,
		void **	unused,
		int *	nUnused )

Definition at line 1232 of file bzlib.c.

{
   bzFile* bzf = (bzFile*)b;
   if (bzf == NULL)
      { BZ_SETERR(BZ_PARAM_ERROR); return; };
   if (bzf->lastErr != BZ_STREAM_END)
      { BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
   if (unused == NULL || nUnused == NULL)
      { BZ_SETERR(BZ_PARAM_ERROR); return; };
 
   BZ_SETERR(BZ_OK);
   *nUnused = bzf->strm.avail_in;
   *unused = bzf->strm.next_in;
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_bzReadOpen()

BZFILE *BZ_API BZ2_bzReadOpen	(	int *	bzerror,
		FILE *	f,
		int	verbosity,
		int	small,
		void *	unused,
		int	nUnused )

Definition at line 1098 of file bzlib.c.

{
   bzFile* bzf = NULL;
   int     ret;
 
   BZ_SETERR(BZ_OK);
 
   if (f == NULL || 
       (small != 0 && small != 1) ||
       (verbosity < 0 || verbosity > 4) ||
       (unused == NULL && nUnused != 0) ||
       (unused != NULL && (nUnused < 0 || nUnused > BZ_MAX_UNUSED)))
      { BZ_SETERR(BZ_PARAM_ERROR); return NULL; };
 
   if (ferror(f))
      { BZ_SETERR(BZ_IO_ERROR); return NULL; };
 
   bzf = (bzFile *)malloc ( sizeof(bzFile) );
   if (bzf == NULL) 
      { BZ_SETERR(BZ_MEM_ERROR); return NULL; };
 
   BZ_SETERR(BZ_OK);
 
   bzf->initialisedOk = False;
   bzf->handle        = f;
   bzf->bufN          = 0;
   bzf->writing       = False;
   bzf->strm.bzalloc  = NULL;
   bzf->strm.bzfree   = NULL;
   bzf->strm.opaque   = NULL;
   
   while (nUnused > 0) {
      bzf->buf[bzf->bufN] = *((UChar*)(unused)); bzf->bufN++;
      unused = ((void*)( 1 + ((UChar*)(unused))  ));
      nUnused--;
   }
 
   ret = BZ2_bzDecompressInit ( &(bzf->strm), verbosity, small );
   if (ret != BZ_OK)
      { BZ_SETERR(ret); free(bzf); return NULL; };
 
   bzf->strm.avail_in = bzf->bufN;
   bzf->strm.next_in  = bzf->buf;
 
   bzf->initialisedOk = True;
   return bzf;   
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_bzWrite()

void BZ_API BZ2_bzWrite	(	int *	bzerror,
		BZFILE *	b,
		void *	buf,
		int	len )

Definition at line 975 of file bzlib.c.

{
   Int32 n, n2, ret;
   bzFile* bzf = (bzFile*)b;
 
   BZ_SETERR(BZ_OK);
   if (bzf == NULL || buf == NULL || len < 0)
      { BZ_SETERR(BZ_PARAM_ERROR); return; };
   if (!(bzf->writing))
      { BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
   if (ferror(bzf->handle))
      { BZ_SETERR(BZ_IO_ERROR); return; };
 
   if (len == 0)
      { BZ_SETERR(BZ_OK); return; };
 
   bzf->strm.avail_in = len;
   bzf->strm.next_in  = (char *)buf;
 
   while (True) {
      bzf->strm.avail_out = BZ_MAX_UNUSED;
      bzf->strm.next_out = bzf->buf;
      ret = BZ2_bzCompress ( &(bzf->strm), BZ_RUN );
      if (ret != BZ_RUN_OK)
         { BZ_SETERR(ret); return; };
 
      if (bzf->strm.avail_out < BZ_MAX_UNUSED) {
         n = BZ_MAX_UNUSED - bzf->strm.avail_out;
         n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar), 
                       n, bzf->handle );
         if (n != n2 || ferror(bzf->handle))
            { BZ_SETERR(BZ_IO_ERROR); return; };
      }
 
      if (bzf->strm.avail_in == 0)
         { BZ_SETERR(BZ_OK); return; };
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_bzwrite()

int BZ_API BZ2_bzwrite	(	BZFILE *	b,
		void *	buf,
		int	len )

Definition at line 1503 of file bzlib.c.

{
   int bzerr;
 
   BZ2_bzWrite(&bzerr,b,buf,len);
   if(bzerr == BZ_OK){
      return len;
   }else{
      return -1;
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_bzWriteClose()

void BZ_API BZ2_bzWriteClose	(	int *	bzerror,
		BZFILE *	b,
		int	abandon,
		unsigned int *	nbytes_in,
		unsigned int *	nbytes_out )

Definition at line 1020 of file bzlib.c.

{
   BZ2_bzWriteClose64 ( bzerror, b, abandon, 
                        nbytes_in, NULL, nbytes_out, NULL );
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_bzWriteClose64()

void BZ_API BZ2_bzWriteClose64	(	int *	bzerror,
		BZFILE *	b,
		int	abandon,
		unsigned int *	nbytes_in_lo32,
		unsigned int *	nbytes_in_hi32,
		unsigned int *	nbytes_out_lo32,
		unsigned int *	nbytes_out_hi32 )

Definition at line 1032 of file bzlib.c.

{
   Int32   n, n2, ret;
   bzFile* bzf = (bzFile*)b;
 
   if (bzf == NULL)
      { BZ_SETERR(BZ_OK); return; };
   if (!(bzf->writing))
      { BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
   if (ferror(bzf->handle))
      { BZ_SETERR(BZ_IO_ERROR); return; };
 
   if (nbytes_in_lo32 != NULL) *nbytes_in_lo32 = 0;
   if (nbytes_in_hi32 != NULL) *nbytes_in_hi32 = 0;
   if (nbytes_out_lo32 != NULL) *nbytes_out_lo32 = 0;
   if (nbytes_out_hi32 != NULL) *nbytes_out_hi32 = 0;
 
   if ((!abandon) && bzf->lastErr == BZ_OK) {
      while (True) {
         bzf->strm.avail_out = BZ_MAX_UNUSED;
         bzf->strm.next_out = bzf->buf;
         ret = BZ2_bzCompress ( &(bzf->strm), BZ_FINISH );
         if (ret != BZ_FINISH_OK && ret != BZ_STREAM_END)
            { BZ_SETERR(ret); return; };
 
         if (bzf->strm.avail_out < BZ_MAX_UNUSED) {
            n = BZ_MAX_UNUSED - bzf->strm.avail_out;
            n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar), 
                          n, bzf->handle );
            if (n != n2 || ferror(bzf->handle))
               { BZ_SETERR(BZ_IO_ERROR); return; };
         }
 
         if (ret == BZ_STREAM_END) break;
      }
   }
 
   if ( !abandon && !ferror ( bzf->handle ) ) {
      fflush ( bzf->handle );
      if (ferror(bzf->handle))
         { BZ_SETERR(BZ_IO_ERROR); return; };
   }
 
   if (nbytes_in_lo32 != NULL)
      *nbytes_in_lo32 = bzf->strm.total_in_lo32;
   if (nbytes_in_hi32 != NULL)
      *nbytes_in_hi32 = bzf->strm.total_in_hi32;
   if (nbytes_out_lo32 != NULL)
      *nbytes_out_lo32 = bzf->strm.total_out_lo32;
   if (nbytes_out_hi32 != NULL)
      *nbytes_out_hi32 = bzf->strm.total_out_hi32;
 
   BZ_SETERR(BZ_OK);
   BZ2_bzCompressEnd ( &(bzf->strm) );
   free ( bzf );
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_bzWriteOpen()

BZFILE *BZ_API BZ2_bzWriteOpen	(	int *	bzerror,
		FILE *	f,
		int	blockSize100k,
		int	verbosity,
		int	workFactor )

Definition at line 927 of file bzlib.c.

{
   Int32   ret;
   bzFile* bzf = NULL;
 
   BZ_SETERR(BZ_OK);
 
   if (f == NULL ||
       (blockSize100k < 1 || blockSize100k > 9) ||
       (workFactor < 0 || workFactor > 250) ||
       (verbosity < 0 || verbosity > 4))
      { BZ_SETERR(BZ_PARAM_ERROR); return NULL; };
 
   if (ferror(f))
      { BZ_SETERR(BZ_IO_ERROR); return NULL; };
 
   bzf = (bzFile *)malloc ( sizeof(bzFile) );
   if (bzf == NULL)
      { BZ_SETERR(BZ_MEM_ERROR); return NULL; };
 
   BZ_SETERR(BZ_OK);
   bzf->initialisedOk = False;
   bzf->bufN          = 0;
   bzf->handle        = f;
   bzf->writing       = True;
   bzf->strm.bzalloc  = NULL;
   bzf->strm.bzfree   = NULL;
   bzf->strm.opaque   = NULL;
 
   if (workFactor == 0) workFactor = 30;
   ret = BZ2_bzCompressInit ( &(bzf->strm), blockSize100k, 
                              verbosity, workFactor );
   if (ret != BZ_OK)
      { BZ_SETERR(ret); free(bzf); return NULL; };
 
   bzf->strm.avail_in = 0;
   bzf->initialisedOk = True;
   return bzf;   
}

Here is the call graph for this function:

Here is the caller graph for this function:

BZ2_indexIntoF()

Int32 BZ2_indexIntoF	(	Int32	indx,
		Int32 *	cftab )

Definition at line 698 of file bzlib.c.

{
   Int32 nb, na, mid;
   nb = 0;
   na = 256;
   do {
      mid = (nb + na) >> 1;
      if (indx >= cftab[mid]) nb = mid; else na = mid;
   }
   while (na - nb != 1);
   return nb;
}