/* lzotest.c -- very comprehensive test driver for the LZO library

   This file is part of the LZO real-time data compression library.

   Copyright (C) 1996-2014 Markus Franz Xaver Johannes Oberhumer

   All Rights Reserved.

   The LZO library is free software; you can redistribute it and/or

   modify it under the terms of the GNU General Public License as

   published by the Free Software Foundation; either version 2 of

   the License, or (at your option) any later version.

   The LZO library is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with the LZO library; see the file COPYING.

   If not, write to the Free Software Foundation, Inc.,

   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

   Markus F.X.J. Oberhumer

   <markus@oberhumer.com>

   http://www.oberhumer.com/opensource/lzo/

 */

#include "lzo/lzoconf.h"

/*************************************************************************

// util

**************************************************************************/

/* portability layer */

#define WANT_LZO_MALLOC 1

#define WANT_LZO_FREAD 1

#define WANT_LZO_WILDARGV 1

#define WANT_LZO_PCLOCK 1

#define LZO_WANT_ACCLIB_GETOPT 1

#include "examples/portab.h"

#if defined(HAVE_STRNICMP) && !defined(HAVE_STRNCASECMP)

#  define strncasecmp(a,b,c) strnicmp(a,b,c)

#  define HAVE_STRNCASECMP 1

#endif

#if 0

#  define is_digit(x)   (isdigit((unsigned char)(x)))

#  define is_space(x)   (isspace((unsigned char)(x)))

#else

#  define is_digit(x)   ((unsigned)(x) - '0' <= 9)

#  define is_space(x)   ((x)==' ' || (x)=='\t' || (x)=='\r' || (x)=='\n')

#endif

/*************************************************************************

// compression include section

**************************************************************************/

#define HAVE_LZO1_H 1

#define HAVE_LZO1A_H 1

#define HAVE_LZO1B_H 1

#define HAVE_LZO1C_H 1

#define HAVE_LZO1F_H 1

#define HAVE_LZO1X_H 1

#define HAVE_LZO1Y_H 1

#define HAVE_LZO1Z_H 1

#define HAVE_LZO2A_H 1

#if defined(NO_ZLIB_H) || (SIZEOF_INT < 4)

#undef HAVE_ZLIB_H

#endif

#if defined(NO_BZLIB_H) || (SIZEOF_INT != 4)

#undef HAVE_BZLIB_H

#endif

#if 0 && defined(LZO_OS_DOS16)

/* don't make this test program too big */

#undef HAVE_LZO1_H

#undef HAVE_LZO1A_H

#undef HAVE_LZO1C_H

#undef HAVE_LZO1Z_H

#undef HAVE_LZO2A_H

#undef HAVE_LZO2B_H

#undef HAVE_ZLIB_H

#endif

/* LZO algorithms */

#if defined(HAVE_LZO1_H)

#  include "lzo/lzo1.h"

#endif

#if defined(HAVE_LZO1A_H)

#  include "lzo/lzo1a.h"

#endif

#if defined(HAVE_LZO1B_H)

#  include "lzo/lzo1b.h"

#endif

#if defined(HAVE_LZO1C_H)

#  include "lzo/lzo1c.h"

#endif

#if defined(HAVE_LZO1F_H)

#  include "lzo/lzo1f.h"

#endif

#if defined(HAVE_LZO1X_H)

#  include "lzo/lzo1x.h"

#  if defined(__LZO_PROFESSIONAL__)

#    include "lzo/lzopro/lzo1x.h"

#  endif

#endif

#if defined(HAVE_LZO1Y_H)

#  include "lzo/lzo1y.h"

#  if defined(__LZO_PROFESSIONAL__)

#    include "lzo/lzopro/lzo1y.h"

#  endif

#endif

#if defined(HAVE_LZO1Z_H)

#  include "lzo/lzo1z.h"

#endif

#if defined(HAVE_LZO2A_H)

#  include "lzo/lzo2a.h"

#endif

#if defined(HAVE_LZO2B_H)

#  include "lzo/lzo2b.h"

#endif

#if defined(__LZO_PROFESSIONAL__)

#  include "lzopro/t_config.ch"

#endif

/* other compressors */

#if defined(HAVE_ZLIB_H)

#  include <zlib.h>

#  define ALG_ZLIB 1

#endif

#if defined(HAVE_BZLIB_H)

#  include <bzlib.h>

#  define ALG_BZIP2 1

#endif

/*************************************************************************

// enumerate all methods

**************************************************************************/

enum {

/* compression algorithms */

    M_LZO1B_1     =     1,

    M_LZO1B_2, M_LZO1B_3, M_LZO1B_4, M_LZO1B_5,

    M_LZO1B_6, M_LZO1B_7, M_LZO1B_8, M_LZO1B_9,

    M_LZO1C_1     =    11,

    M_LZO1C_2, M_LZO1C_3, M_LZO1C_4, M_LZO1C_5,

    M_LZO1C_6, M_LZO1C_7, M_LZO1C_8, M_LZO1C_9,

    M_LZO1        =    21,

    M_LZO1A       =    31,

    M_LZO1B_99    =   901,

    M_LZO1B_999   =   902,

    M_LZO1C_99    =   911,

    M_LZO1C_999   =   912,

    M_LZO1_99     =   921,

    M_LZO1A_99    =   931,

    M_LZO1F_1     =    61,

    M_LZO1F_999   =   962,

    M_LZO1X_1     =    71,

    M_LZO1X_1_11  =   111,

    M_LZO1X_1_12  =   112,

    M_LZO1X_1_15  =   115,

    M_LZO1X_999   =   972,

    M_LZO1Y_1     =    81,

    M_LZO1Y_999   =   982,

    M_LZO1Z_999   =   992,

    M_LZO2A_999   =   942,

    M_LZO2B_999   =   952,

    M_LAST_LZO_COMPRESSOR = 998,

/* other compressors */

#if defined(ALG_ZLIB)

    M_ZLIB_8_1 =  1101,

    M_ZLIB_8_2, M_ZLIB_8_3, M_ZLIB_8_4, M_ZLIB_8_5,

    M_ZLIB_8_6, M_ZLIB_8_7, M_ZLIB_8_8, M_ZLIB_8_9,

#endif

#if defined(ALG_BZIP2)

    M_BZIP2_1  =  1201,

    M_BZIP2_2, M_BZIP2_3, M_BZIP2_4, M_BZIP2_5,

    M_BZIP2_6, M_BZIP2_7, M_BZIP2_8, M_BZIP2_9,

#endif

/* dummy compressor - for benchmarking */

    M_MEMCPY      =   999,

    M_LAST_COMPRESSOR = 4999,

/* dummy algorithms - for benchmarking */

    M_MEMSET      =  5001,

/* checksum algorithms - for benchmarking */

    M_ADLER32     =  6001,

    M_CRC32       =  6002,

#if defined(ALG_ZLIB)

    M_Z_ADLER32   =  6011,

    M_Z_CRC32     =  6012,

#endif

#if defined(__LZO_PROFESSIONAL__)

#  include "lzopro/m_enum.ch"

#endif

    M_UNUSED

};

/*************************************************************************

// command line options

**************************************************************************/

int opt_verbose = 2;

long opt_c_loops = 0;

long opt_d_loops = 0;

const char *opt_corpus_path = NULL;

const char *opt_dump_compressed_data = NULL;

lzo_bool opt_use_safe_decompressor = 0;

lzo_bool opt_use_asm_decompressor = 0;

lzo_bool opt_use_asm_fast_decompressor = 0;

lzo_bool opt_optimize_compressed_data = 0;

int opt_dict = 0;

lzo_uint opt_max_dict_len = LZO_UINT_MAX;

const char *opt_dictionary_file = NULL;

lzo_bool opt_read_from_stdin = 0;

/* set these to 1 to measure the speed impact of a checksum */

lzo_bool opt_compute_adler32 = 0;

lzo_bool opt_compute_crc32 = 0;

static lzo_uint32_t adler_in, adler_out;

static lzo_uint32_t crc_in, crc_out;

lzo_bool opt_execution_time = 0;

int opt_pclock = -1;

lzo_bool opt_clear_wrkmem = 0;

static const lzo_bool opt_try_to_compress_0_bytes = 1;

/*************************************************************************

// misc globals

**************************************************************************/

static const char *progname = "";

static lzo_pclock_handle_t pch;

/* for statistics and benchmark */

int opt_totals = 0;

static unsigned long total_n = 0;

static unsigned long total_c_len = 0;

static unsigned long total_d_len = 0;

static unsigned long total_blocks = 0;

static double total_perc = 0.0;

static const char *total_method_name = NULL;

static unsigned total_method_names = 0;

/* Note: the average value of a rate (e.g. compression speed) is defined

 * by the Harmonic Mean (and _not_ by the Arithmethic Mean ) */

static unsigned long total_c_mbs_n = 0;

static unsigned long total_d_mbs_n = 0;

static double total_c_mbs_harmonic = 0.0;

static double total_d_mbs_harmonic = 0.0;

static double total_c_mbs_sum = 0.0;

static double total_d_mbs_sum = 0.0;

#if defined(HAVE_LZO1X_H)

int default_method = M_LZO1X_1;

#elif defined(HAVE_LZO1B_H)

int default_method = M_LZO1B_1;

#elif defined(HAVE_LZO1C_H)

int default_method = M_LZO1C_1;

#elif defined(HAVE_LZO1F_H)

int default_method = M_LZO1F_1;

#elif defined(HAVE_LZO1Y_H)

int default_method = M_LZO1Y_1;

#else

int default_method = M_MEMCPY;

#endif

static const int benchmark_methods[] = {

    M_LZO1B_1, M_LZO1B_9,

    M_LZO1C_1, M_LZO1C_9,

    M_LZO1F_1,

    M_LZO1X_1,

    0

};

static const int x1_methods[] = {

    M_LZO1, M_LZO1A, M_LZO1B_1, M_LZO1C_1, M_LZO1F_1, M_LZO1X_1, M_LZO1Y_1,

    0

};

static const int x99_methods[] = {

    M_LZO1_99, M_LZO1A_99, M_LZO1B_99, M_LZO1C_99,

    0

};

static const int x999_methods[] = {

    M_LZO1B_999, M_LZO1C_999, M_LZO1F_999, M_LZO1X_999, M_LZO1Y_999,

    M_LZO1Z_999,

    M_LZO2A_999,

    0

};

/* exit codes of this test program */

#define EXIT_OK         0

#define EXIT_USAGE      1

#define EXIT_FILE       2

#define EXIT_MEM        3

#define EXIT_ADLER      4

#define EXIT_LZO_ERROR  5

#define EXIT_LZO_INIT   6

#define EXIT_INTERNAL   7

/*************************************************************************

// memory setup

**************************************************************************/

static lzo_uint opt_block_size;

static lzo_uint opt_max_data_len;

typedef struct {

    lzo_bytep   ptr;

    lzo_uint    len;

    lzo_uint32_t adler;

    lzo_uint32_t crc;

    lzo_bytep   alloc_ptr;

    lzo_uint    alloc_len;

    lzo_uint    saved_len;

} mblock_t;

static mblock_t file_data;      /* original uncompressed data */

static mblock_t block_c;        /* compressed data */

static mblock_t block_d;        /* decompressed data */

static mblock_t block_w;        /* wrkmem */

static mblock_t dict;

static void mb_alloc_extra(mblock_t *mb, lzo_uint len, lzo_uint extra_bottom, lzo_uint extra_top)

{

    lzo_uint align = (lzo_uint) sizeof(lzo_align_t);

    mb->alloc_ptr = mb->ptr = NULL;

    mb->alloc_len = mb->len = 0;

    mb->alloc_len = extra_bottom + len + extra_top;

    if (mb->alloc_len == 0) mb->alloc_len = 1;

    mb->alloc_ptr = (lzo_bytep) lzo_malloc(mb->alloc_len);

    if (mb->alloc_ptr == NULL) {

        fprintf(stderr, "%s: out of memory (wanted %lu bytes)\n", progname, (unsigned long)mb->alloc_len);

        exit(EXIT_MEM);

    }

    if (mb->alloc_len >= align && __lzo_align_gap(mb->alloc_ptr, align) != 0) {

        fprintf(stderr, "%s: C library problem: malloc() returned misaligned pointer!\n", progname);

        exit(EXIT_MEM);

    }

    mb->ptr = mb->alloc_ptr + extra_bottom;

    mb->len = mb->saved_len = len;

    mb->adler = 1;

    mb->crc = 0;

}

static void mb_alloc(mblock_t *mb, lzo_uint len)

{

    mb_alloc_extra(mb, len, 0, 0);

}

static void mb_free(mblock_t *mb)

{

    if (!mb) return;

    if (mb->alloc_ptr) lzo_free(mb->alloc_ptr);

    mb->alloc_ptr = mb->ptr = NULL;

    mb->alloc_len = mb->len = 0;

}

static lzo_uint get_max_compression_expansion(int m, lzo_uint bl)

{

    if (m == M_MEMCPY || m >= M_LAST_COMPRESSOR)

        return 0;

    if (m == M_LZO2A_999 || m == M_LZO2B_999)

        return bl / 8 + 256;

    if (m > 0  && m < M_LAST_LZO_COMPRESSOR)

        return bl / 16 +  64 + 3;

    return bl / 8 + 256;

}

static lzo_uint get_max_decompression_overrun(int m, lzo_uint bl)

{

    LZO_UNUSED(m);

    LZO_UNUSED(bl);

    /* may overwrite 3 bytes past the end of the decompressed block */

    if (opt_use_asm_fast_decompressor)

        return  (lzo_uint) sizeof(lzo_voidp) - 1;

    return 0;

}

/*************************************************************************

// dictionary support

**************************************************************************/

static void dict_alloc(lzo_uint max_dict_len)

{

    lzo_uint l = 0xbfff;    /* MAX_DICT_LEN */

    if (max_dict_len > 0 && l > max_dict_len)

        l = max_dict_len;

    mb_alloc(&dict, l);

}

/* this default dictionary does not provide good contexts... */

static void dict_set_default(void)

{

    lzo_uint d = 0;

    unsigned i, j;

    dict.len = 16 * 256;

    if (dict.len > dict.alloc_len)

        dict.len = dict.alloc_len;

    lzo_memset(dict.ptr, 0, dict.len);

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

        for (j = 0; j < 16; j++) {

            if (d >= dict.len)

                goto done;

            dict.ptr[d++] = (unsigned char) i;

        }

done:

    dict.adler = lzo_adler32(1, dict.ptr, dict.len);

}

static void dict_load(const char *file_name)

{

    FILE *fp;

    dict.len = 0;

    fp = fopen(file_name, "rb");

    if (fp)

    {

        dict.len = (lzo_uint) lzo_fread(fp, dict.ptr, dict.alloc_len);

        (void) fclose(fp);

        dict.adler = lzo_adler32(1, dict.ptr, dict.len);

    }

}

/*************************************************************************

// compression database

**************************************************************************/

typedef struct

{

    const char *            name;

    int                     id;

    lzo_uint32_t            mem_compress;

    lzo_uint32_t            mem_decompress;

    lzo_compress_t          compress;

    lzo_optimize_t          optimize;

    lzo_decompress_t        decompress;

    lzo_decompress_t        decompress_safe;

    lzo_decompress_t        decompress_asm;

    lzo_decompress_t        decompress_asm_safe;

    lzo_decompress_t        decompress_asm_fast;

    lzo_decompress_t        decompress_asm_fast_safe;

    lzo_compress_dict_t     compress_dict;

    lzo_decompress_dict_t   decompress_dict_safe;

}

compress_t;

#include "asm.h"

#ifdef __cplusplus

extern "C" {

#endif

#include "wrap.h"

#define M_PRIVATE       LZO_PRIVATE

#define m_uint          lzo_uint

#define m_uint32_t      lzo_uint32_t

#define m_voidp         lzo_voidp

#define m_bytep         lzo_bytep

#define m_uintp         lzo_uintp

#include "wrapmisc.h"

#ifdef __cplusplus

} /* extern "C" */

#endif

static const compress_t compress_database[] = {

#include "db.h"

{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }

};

/*************************************************************************

// method info

**************************************************************************/

static

lzo_decompress_t get_decomp_info ( const compress_t *c, const char **nn )

{

    lzo_decompress_t d = 0;

    const char *n = NULL;

    /* safe has priority over asm/fast */

    if (!d && opt_use_safe_decompressor && opt_use_asm_fast_decompressor)

    {

        d = c->decompress_asm_fast_safe;

        n = " [fs]";

    }

    if (!d && opt_use_safe_decompressor && opt_use_asm_decompressor)

    {

        d = c->decompress_asm_safe;

        n = " [as]";

    }

    if (!d && opt_use_safe_decompressor)

    {

        d = c->decompress_safe;

        n = " [s]";

    }

    if (!d && opt_use_asm_fast_decompressor)

    {

        d = c->decompress_asm_fast;

        n = " [f]";

    }

    if (!d && opt_use_asm_decompressor)

    {

        d = c->decompress_asm;

        n = " [a]";

    }

    if (!d)

    {

        d = c->decompress;

        n = "";

    }

    if (!d)

        n = "(null)";

    if (opt_dict && c->decompress_dict_safe)

        n = "";

    if (nn)

        *nn = n;

    return d;

}

static

const compress_t *find_method_by_id ( int method )

{

    const compress_t *db;

    size_t size = sizeof(compress_database) / sizeof(*(compress_database));

    size_t i;

    db = compress_database;

    for (i = 0; i < size && db->name != NULL; i++, db++)

    {

        if (method == db->id)

            return db;

    }

    return NULL;

}

static

const compress_t *find_method_by_name ( const char *name )

{

    const compress_t *db;

    size_t size = sizeof(compress_database) / sizeof(*(compress_database));

    size_t i;

    db = compress_database;

    for (i = 0; i < size && db->name != NULL; i++, db++)

    {

        size_t n = strlen(db->name);

#if defined(HAVE_STRNCASECMP)

        if (strncasecmp(name,db->name,n) == 0 && (!name[n] || name[n] == ','))

            return db;

#else

        if (strncmp(name,db->name,n) == 0 && (!name[n] || name[n] == ','))

            return db;

#endif

    }

    return NULL;

}

static

lzo_bool is_compressor ( const compress_t *c )

{

    return (c->id <= M_LAST_COMPRESSOR || c->id >= 9721);

}

/*************************************************************************

// check that memory gets accessed within bounds

**************************************************************************/

static void memchecker_init ( mblock_t *mb, lzo_uint l, unsigned char random_byte )

{

    lzo_uint i;

    lzo_uint len = (lzo_uint) l;

    lzo_bytep p;

    assert(len <= mb->len);

    /* bottom */

    p = mb->ptr;

    for (i = 0; i < 16 && p > mb->alloc_ptr; i++)

        *--p = random_byte++;

    /* top */

    p = mb->ptr + len;

    for (i = 0; i < 16 && p < mb->alloc_ptr + mb->alloc_len; i++)

        *p++ = random_byte++;

#if 0 || defined(LZO_DEBUG)

    /* fill in garbage */

    p = mb->ptr;

    random_byte |= 1;

    for (i = 0; i < len; i++, random_byte += 2)

        *p++ = random_byte;

#endif

}

static int memchecker_check ( mblock_t *mb, lzo_uint l, unsigned char random_byte )

{

    lzo_uint i;

    lzo_uint len = (lzo_uint) l;

    lzo_bytep p;

    assert(len <= mb->len);

    /* bottom */

    p = mb->ptr;

    for (i = 0; i < 16 && p > mb->alloc_ptr; i++)

        if (*--p != random_byte++)

            return -1;

    /* top */

    p = mb->ptr + len;

    for (i = 0; i < 16 && p < mb->alloc_ptr + mb->alloc_len; i++)

        if (*p++ != random_byte++)

            return -1;

    return 0;

}

/*************************************************************************

// compress a block

**************************************************************************/

static

int call_compressor   ( const compress_t *c,

                        const lzo_bytep src, lzo_uint  src_len,

                              lzo_bytep dst, lzo_uintp dst_len )

{

    int r = -100;

    if (c && c->compress && block_w.len >= c->mem_compress)

    {

        unsigned char random_byte = (unsigned char) src_len;

        memchecker_init(&block_w, c->mem_compress, random_byte);

        if (opt_clear_wrkmem)

            lzo_memset(block_w.ptr, 0, c->mem_compress);

        if (opt_dict && c->compress_dict)

            r = c->compress_dict(src,src_len,dst,dst_len,block_w.ptr,dict.ptr,dict.len);

        else

            r = c->compress(src,src_len,dst,dst_len,block_w.ptr);

        if (memchecker_check(&block_w, c->mem_compress, random_byte) != 0)

            printf("WARNING: wrkmem overwrite error (compress) !!!\n");

    }

    if (r == 0 && opt_compute_adler32)

    {

        lzo_uint32_t adler;

        adler = lzo_adler32(0, NULL, 0);

        adler = lzo_adler32(adler, src, src_len);

        adler_in = adler;

    }

    if (r == 0 && opt_compute_crc32)

    {

        lzo_uint32_t crc;

        crc = lzo_crc32(0, NULL, 0);

        crc = lzo_crc32(crc, src, src_len);

        crc_in = crc;

    }

    return r;

}

/*************************************************************************

// decompress a block

**************************************************************************/

static

int call_decompressor ( const compress_t *c, lzo_decompress_t d,

                        const lzo_bytep src, lzo_uint  src_len,

                              lzo_bytep dst, lzo_uintp dst_len )

{

    int r = -100;

    if (c && d && block_w.len >= c->mem_decompress)

    {

        unsigned char random_byte = (unsigned char) src_len;

        memchecker_init(&block_w, c->mem_decompress, random_byte);

        if (opt_clear_wrkmem)

            lzo_memset(block_w.ptr, 0, c->mem_decompress);

        if (opt_dict && c->decompress_dict_safe)

            r = c->decompress_dict_safe(src,src_len,dst,dst_len,block_w.ptr,dict.ptr,dict.len);

        else

            r = d(src,src_len,dst,dst_len,block_w.ptr);

        if (memchecker_check(&block_w, c->mem_decompress, random_byte) != 0)

            printf("WARNING: wrkmem overwrite error (decompress) !!!\n");

    }

    if (r == 0 && opt_compute_adler32)

        adler_out = lzo_adler32(1, dst, *dst_len);

    if (r == 0 && opt_compute_crc32)

        crc_out = lzo_crc32(0, dst, *dst_len);

    return r;

}

/*************************************************************************

// optimize a block

**************************************************************************/

static

int call_optimizer   ( const compress_t *c,

                             lzo_bytep src, lzo_uint  src_len,

                             lzo_bytep dst, lzo_uintp dst_len )

{

    if (c && c->optimize && block_w.len >= c->mem_decompress)

        return c->optimize(src,src_len,dst,dst_len,block_w.ptr);

    return 0;

}

/***********************************************************************

// read a file

************************************************************************/

static int load_file(const char *file_name, lzo_uint max_data_len)

{

    FILE *fp;

#if (HAVE_FTELLO)

    off_t ll = -1;

#else

    long ll = -1;

#endif

    lzo_uint l;

    int r;

    mblock_t *mb = &file_data;

    mb_free(mb);

    fp = fopen(file_name, "rb");

    if (fp == NULL)

    {

        fflush(stdout); fflush(stderr);

        fprintf(stderr, "%s: ", file_name);

        fflush(stderr);

        perror("fopen");

        fflush(stdout); fflush(stderr);

        return EXIT_FILE;

    }

    r = fseek(fp, 0, SEEK_END);

    if (r == 0)

    {

#if (HAVE_FTELLO)

        ll = ftello(fp);

#else

        ll = ftell(fp);

#endif

        r = fseek(fp, 0, SEEK_SET);

    }

    if (r != 0 || ll < 0)

    {

        fflush(stdout); fflush(stderr);

        fprintf(stderr, "%s: ", file_name);

        fflush(stderr);

        perror("fseek");

        fflush(stdout); fflush(stderr);

        (void) fclose(fp);

        return EXIT_FILE;

    }

    l = (lzo_uint) ll;

    if (l > max_data_len) l = max_data_len;

#if (HAVE_FTELLO)

    if ((off_t) l != ll) l = max_data_len;

#else

    if ((long) l != ll) l = max_data_len;

#endif

    mb_alloc(mb, l);

    mb->len = (lzo_uint) lzo_fread(fp, mb->ptr, mb->len);

    r = ferror(fp);

    if (fclose(fp) != 0 || r != 0)

    {

        mb_free(mb);

        fflush(stdout); fflush(stderr);

        fprintf(stderr, "%s: ", file_name);

        fflush(stderr);

        perror("fclose");

        fflush(stdout); fflush(stderr);

        return EXIT_FILE;

    }

    return EXIT_OK;

}

/***********************************************************************

// print some compression statistics

************************************************************************/

static double t_div(double a, double b)

{

    return b > 0.00001 ? a / b : 0;

}

static double set_perc_d(double perc, char *s)

{

    if (perc <= 0.0) {

        strcpy(s, "0.0");

        return 0;

    }

    if (perc <= 100 - 1.0 / 16) {

        sprintf(s, "%4.1f", perc);

    }

    else {

        long p = (long) (perc + 0.5);

        if (p < 100)

            strcpy(s, "???");

        else if (p >= 9999)

            strcpy(s, "9999");

        else

            sprintf(s, "%ld", p);

    }

    return perc;

}

static double set_perc(unsigned long c_len, unsigned long d_len, char *s)

{

    double perc = 0.0;

    if (d_len > 0)

        perc = c_len * 100.0 / d_len;

    return set_perc_d(perc, s);

}