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

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

   Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 1996 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></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_UCLOCK 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

#include "mygetopt.h"

#include "mygetopt.ch"

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

// 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"

#endif

#if defined(HAVE_LZO1Y_H)

#  include "lzo/lzo1y.h"

#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

/* other compressors */

#if defined(__LZO_PROFESSIONAL__)

#  include "lzopro/t_config.ch"

#endif

#if defined(HAVE_ZLIB_H)

#  include <zlib.h></zlib.h>

#  define ALG_ZLIB

#endif

#if defined(HAVE_BZLIB_H)

#  include <bzlib.h></bzlib.h>

#  define ALG_BZIP2

#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

    M_UNUSED

};

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

// command line options

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

struct corpus_entry_t;

int opt_verbose = 2;

long opt_c_loops = 0;

long opt_d_loops = 0;

const struct corpus_entry_t *opt_corpus = NULL;

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 adler_in, adler_out;

static lzo_uint32 crc_in, crc_out;

lzo_bool opt_execution_time = 0;

int opt_uclock = -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_uclock_handle_t uch;

/* 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  adler;

    lzo_uint32  crc;

    lzo_bytep   alloc_ptr;

    lzo_uint    alloc_len;

    lzo_uint    saved_len;

} mblock_t;

static mblock_t file_data;

static mblock_t block1;

static mblock_t block2;

static mblock_t wrkmem;

static mblock_t dict;

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

{

    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);

    }

    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);

        fclose(fp);

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

    }

}

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

// compression database

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

typedef struct

{

    const char *            name;

    int                     id;

    lzo_uint32              mem_compress;

    lzo_uint32              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"

#include "wrap.h"

#define M_PRIVATE       LZO_PRIVATE

#define m_uint          lzo_uint

#define m_uint32        lzo_uint32

#define m_voidp         lzo_voidp

#define m_bytep         lzo_bytep

#define m_uintp         lzo_uintp

#include "wrapmisc.h"

static const compress_t compress_database[] = {

#include "db.h"

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

};

#if defined(LZOTEST_USE_DYNLOAD)

#  include "dynload/db.ch"

#endif

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

// 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;

#if defined(LZOTEST_USE_DYNLOAD)

#  include "dynload/find_id.ch"

#endif

    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;

#if defined(LZOTEST_USE_DYNLOAD)

#  include "dynload/find_name.ch"

#endif

    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

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

void memchecker_init ( mblock_t *mb, lzo_xint 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

}

int memchecker_check ( mblock_t *mb, lzo_xint 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 && wrkmem.len >= c->mem_compress)

    {

        unsigned char random_byte = (unsigned char) src_len;

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

        if (opt_clear_wrkmem)

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

        if (opt_dict && c->compress_dict)

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

        else

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

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

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

    }

    if (r == 0 && opt_compute_adler32)

    {

        lzo_uint32 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 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 && wrkmem.len >= c->mem_decompress)

    {

        unsigned char random_byte = (unsigned char) src_len;

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

        if (opt_clear_wrkmem)

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

        if (opt_dict && c->decompress_dict_safe)

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

        else

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

        if (memchecker_check(&wrkmem, 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 && wrkmem.len >= c->mem_decompress)

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

    return 0;

}

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

// read a file

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

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

{

    FILE *fp;

    long ll = -1;

    lzo_uint l;

    int r;

    mblock_t *mb = &file_data;

    mb_free(mb);

    fp = fopen(file_name,"rb");

    if (fp == NULL)

    {

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

        perror("fopen");

        fflush(stderr);

        return EXIT_FILE;

    }

    r = fseek(fp,(long)max_len,SEEK_SET);

    if (r != 0)

        r = fseek(fp,0,SEEK_END);

    if (r == 0)

    {

        ll = ftell(fp);

        r = fseek(fp,0,SEEK_SET);

    }

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

    {

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

        perror("fseek");

        fflush(stderr);

        return EXIT_FILE;

    }

    l = (lzo_uint) ll;

    if (max_len > 0 && l > max_len)

        l = max_len;

    mb_alloc(mb, l);

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

    if (fclose(fp) != 0)

    {

        mb_free(mb);

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

        perror("fclose");

        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) {

        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);

}

static

void print_stats ( const char *method_name, const char *file_name,

                   long t_loops, long c_loops, long d_loops,

                   double t_secs, double c_secs, double d_secs,

                   unsigned long c_len, unsigned long d_len,

                   unsigned long blocks )

{

    unsigned long x_len = d_len;