1

/* $Id$ */

     2

     3

/** @file lzoconf.h -- configuration for the LZO real-time data compression library

     4

     5

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

     6

     7

   Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer

     8

   Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer

     9

   Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer

    10

   Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer

    11

   Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer

    12

   Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer

    13

   Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer

    14

   All Rights Reserved.

    15

    16

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

    17

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

    18

   published by the Free Software Foundation; either version 2 of

    19

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

    20

    21

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

    22

   but WITHOUT ANY WARRANTY; without even the implied warranty of

    23

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    24

   GNU General Public License for more details.

    25

    26

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

    27

   along with the LZO library; see the file COPYING.

    28

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

    29

   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

    30

    31

   Markus F.X.J. Oberhumer

    32

   <markus@oberhumer.com>   http://www.oberhumer.com/opensource/lzo/

    33

 */

    34

    35

    36

#ifndef LZOCONF_H

    37

#define LZOCONF_H

    38

    39

#define LZO_VERSION             0x1080

    40

#define LZO_VERSION_STRING      "1.08"

    41

#define LZO_VERSION_DATE        "Jul 12 2002"

    42

    43

/* internal Autoconf configuration file - only used when building LZO */

    44

#if defined(LZO_HAVE_CONFIG_H)

    45

#  include <config.h>

    46

#endif

    47

#include <limits.h>

    48

    49

#ifdef __cplusplus

    50

extern "C" {

    51

#endif

    52

    53

    54

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

    55

 * LZO requires a conforming <limits.h>

    56

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

    57

    58

#if !defined(CHAR_BIT) || (CHAR_BIT != 8)

    59

#  error "invalid CHAR_BIT"

    60

#endif

    61

#if !defined(UCHAR_MAX) || !defined(UINT_MAX) || !defined(ULONG_MAX)

    62

#  error "check your compiler installation"

    63

#endif

    64

#if (USHRT_MAX < 1) || (UINT_MAX < 1) || (ULONG_MAX < 1)

    65

#  error "your limits.h macros are broken"

    66

#endif

    67

    68

/* workaround a cpp bug under hpux 10.20 */

    69

#define LZO_0xffffffffL         4294967295ul

    70

    71

#if !defined(LZO_UINT32_C)

    72

#  if (UINT_MAX < LZO_0xffffffffL)

    73

#    define LZO_UINT32_C(c)     c ## UL

    74

#  else

    75

#    define LZO_UINT32_C(c)     c ## U

    76

#  endif

    77

#endif

    78

    79

    80

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

    81

 * architecture defines

    82

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

    83

    84

#if !defined(__LZO_WIN) && !defined(__LZO_DOS) && !defined(__LZO_OS2)

    85

#  if defined(__WINDOWS__) || defined(_WINDOWS) || defined(_Windows)

    86

#    define __LZO_WIN

    87

#  elif defined(__WIN32__) || defined(_WIN32) || defined(WIN32)

    88

#    define __LZO_WIN

    89

#  elif defined(__NT__) || defined(__NT_DLL__) || defined(__WINDOWS_386__)

    90

#    define __LZO_WIN

    91

#  elif defined(__DOS__) || defined(__MSDOS__) || defined(MSDOS)

    92

#    define __LZO_DOS

    93

#  elif defined(__OS2__) || defined(__OS2V2__) || defined(OS2)

    94

#    define __LZO_OS2

    95

#  elif defined(__palmos__)

    96

#    define __LZO_PALMOS

    97

#  elif defined(__TOS__) || defined(__atarist__)

    98

#    define __LZO_TOS

    99

#  endif

   100

#endif

   101

   102

#if (UINT_MAX < LZO_0xffffffffL)

   103

#  if defined(__LZO_WIN)

   104

#    define __LZO_WIN16

   105

#  elif defined(__LZO_DOS)

   106

#    define __LZO_DOS16

   107

#  elif defined(__LZO_PALMOS)

   108

#    define __LZO_PALMOS16

   109

#  elif defined(__LZO_TOS)

   110

#    define __LZO_TOS16

   111

#  elif defined(__C166__)

   112

#  else

   113

     /* porting hint: for pure 16-bit architectures try compiling

   114

      * everything with -D__LZO_STRICT_16BIT */

   115

#    error "16-bit target not supported - contact me for porting hints"

   116

#  endif

   117

#endif

   118

   119

#if !defined(__LZO_i386)

   120

#  if defined(__LZO_DOS) || defined(__LZO_WIN16)

   121

#    define __LZO_i386

   122

#  elif defined(__i386__) || defined(__386__) || defined(_M_IX86)

   123

#    define __LZO_i386

   124

#  endif

   125

#endif

   126

   127

#if defined(__LZO_STRICT_16BIT)

   128

#  if (UINT_MAX < LZO_0xffffffffL)

   129

#    include <lzo16bit.h>

   130

#  endif

   131

#endif

   132

   133

/* memory checkers */

   134

#if !defined(__LZO_CHECKER)

   135

#  if defined(__BOUNDS_CHECKING_ON)

   136

#    define __LZO_CHECKER

   137

#  elif defined(__CHECKER__)

   138

#    define __LZO_CHECKER

   139

#  elif defined(__INSURE__)

   140

#    define __LZO_CHECKER

   141

#  elif defined(__PURIFY__)

   142

#    define __LZO_CHECKER

   143

#  endif

   144

#endif

   145

   146

   147

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

   148

 * integral and pointer types

   149

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

   150

   151

/* Integral types with 32 bits or more */

   152

#if !defined(LZO_UINT32_MAX)

   153

#  if (UINT_MAX >= LZO_0xffffffffL)

   154

     typedef unsigned int       lzo_uint32;

   155

     typedef int                lzo_int32;

   156

#    define LZO_UINT32_MAX      UINT_MAX

   157

#    define LZO_INT32_MAX       INT_MAX

   158

#    define LZO_INT32_MIN       INT_MIN

   159

#  elif (ULONG_MAX >= LZO_0xffffffffL)

   160

     typedef unsigned long      lzo_uint32;

   161

     typedef long               lzo_int32;

   162

#    define LZO_UINT32_MAX      ULONG_MAX

   163

#    define LZO_INT32_MAX       LONG_MAX

   164

#    define LZO_INT32_MIN       LONG_MIN

   165

#  else

   166

#    error "lzo_uint32"

   167

#  endif

   168

#endif

   169

   170

/* lzo_uint is used like size_t */

   171

#if !defined(LZO_UINT_MAX)

   172

#  if (UINT_MAX >= LZO_0xffffffffL)

   173

     typedef unsigned int       lzo_uint;

   174

     typedef int                lzo_int;

   175

#    define LZO_UINT_MAX        UINT_MAX

   176

#    define LZO_INT_MAX         INT_MAX

   177

#    define LZO_INT_MIN         INT_MIN

   178

#  elif (ULONG_MAX >= LZO_0xffffffffL)

   179

     typedef unsigned long      lzo_uint;

   180

     typedef long               lzo_int;

   181

#    define LZO_UINT_MAX        ULONG_MAX

   182

#    define LZO_INT_MAX         LONG_MAX

   183

#    define LZO_INT_MIN         LONG_MIN

   184

#  else

   185

#    error "lzo_uint"

   186

#  endif

   187

#endif

   188

   189

typedef int lzo_bool;

   190

   191

   192

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

   193

 * memory models

   194

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

   195

   196

/* Memory model for the public code segment. */

   197

#if !defined(__LZO_CMODEL)

   198

#  if defined(__LZO_DOS16) || defined(__LZO_WIN16)

   199

#    define __LZO_CMODEL        __far

   200

#  elif defined(__LZO_i386) && defined(__WATCOMC__)

   201

#    define __LZO_CMODEL        __near

   202

#  else

   203

#    define __LZO_CMODEL

   204

#  endif

   205

#endif

   206

   207

/* Memory model for the public data segment. */

   208

#if !defined(__LZO_DMODEL)

   209

#  if defined(__LZO_DOS16) || defined(__LZO_WIN16)

   210

#    define __LZO_DMODEL        __far

   211

#  elif defined(__LZO_i386) && defined(__WATCOMC__)

   212

#    define __LZO_DMODEL        __near

   213

#  else

   214

#    define __LZO_DMODEL

   215

#  endif

   216

#endif

   217

   218

/* Memory model that allows to access memory at offsets of lzo_uint. */

   219

#if !defined(__LZO_MMODEL)

   220

#  if (LZO_UINT_MAX <= UINT_MAX)

   221

#    define __LZO_MMODEL

   222

#  elif defined(__LZO_DOS16) || defined(__LZO_WIN16)

   223

#    define __LZO_MMODEL        __huge

   224

#    define LZO_999_UNSUPPORTED

   225

#  elif defined(__LZO_PALMOS16) || defined(__LZO_TOS16)

   226

#    define __LZO_MMODEL

   227

#  else

   228

#    error "__LZO_MMODEL"

   229

#  endif

   230

#endif

   231

   232

/* no typedef here because of const-pointer issues */

   233

#define lzo_byte                unsigned char __LZO_MMODEL

   234

#define lzo_bytep               unsigned char __LZO_MMODEL *

   235

#define lzo_charp               char __LZO_MMODEL *

   236

#define lzo_voidp               void __LZO_MMODEL *

   237

#define lzo_shortp              short __LZO_MMODEL *

   238

#define lzo_ushortp             unsigned short __LZO_MMODEL *

   239

#define lzo_uint32p             lzo_uint32 __LZO_MMODEL *

   240

#define lzo_int32p              lzo_int32 __LZO_MMODEL *

   241

#define lzo_uintp               lzo_uint __LZO_MMODEL *

   242

#define lzo_intp                lzo_int __LZO_MMODEL *

   243

#define lzo_voidpp              lzo_voidp __LZO_MMODEL *

   244

#define lzo_bytepp              lzo_bytep __LZO_MMODEL *

   245

   246

#ifndef lzo_sizeof_dict_t

   247

#  define lzo_sizeof_dict_t     sizeof(lzo_bytep)

   248

#endif

   249

   250

   251

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

   252

 * calling conventions and function types

   253

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

   254

   255

/* linkage */

   256

#if !defined(__LZO_EXTERN_C)

   257

#  ifdef __cplusplus

   258

#    define __LZO_EXTERN_C      extern "C"

   259

#  else

   260

#    define __LZO_EXTERN_C      extern

   261

#  endif

   262

#endif

   263

   264

/* calling convention */

   265

#if !defined(__LZO_CDECL)

   266

#  if defined(__LZO_DOS16) || defined(__LZO_WIN16)

   267

#    define __LZO_CDECL         __LZO_CMODEL __cdecl

   268

#  elif defined(__LZO_i386) && defined(_MSC_VER)

   269

#    define __LZO_CDECL         __LZO_CMODEL __cdecl

   270

#  elif defined(__LZO_i386) && defined(__WATCOMC__)

   271

#    define __LZO_CDECL         __LZO_CMODEL __cdecl

   272

#  else

   273

#    define __LZO_CDECL         __LZO_CMODEL

   274

#  endif

   275

#endif

   276

#if !defined(__LZO_ENTRY)

   277

#  define __LZO_ENTRY           __LZO_CDECL

   278

#endif

   279

   280

/* C++ exception specification for extern "C" function types */

   281

#if !defined(__cplusplus)

   282

#  undef LZO_NOTHROW

   283

#  define LZO_NOTHROW

   284

#elif !defined(LZO_NOTHROW)

   285

#  define LZO_NOTHROW

   286

#endif

   287

   288

   289

typedef int

   290

(__LZO_ENTRY *lzo_compress_t)   ( const lzo_byte *src, lzo_uint  src_len,

   291

                                        lzo_byte *dst, lzo_uintp dst_len,

   292

                                        lzo_voidp wrkmem );

   293

   294

typedef int

   295

(__LZO_ENTRY *lzo_decompress_t) ( const lzo_byte *src, lzo_uint  src_len,

   296

                                        lzo_byte *dst, lzo_uintp dst_len,

   297

                                        lzo_voidp wrkmem );

   298

   299

typedef int

   300

(__LZO_ENTRY *lzo_optimize_t)   (       lzo_byte *src, lzo_uint  src_len,

   301

                                        lzo_byte *dst, lzo_uintp dst_len,

   302

                                        lzo_voidp wrkmem );

   303

   304

typedef int

   305

(__LZO_ENTRY *lzo_compress_dict_t)(const lzo_byte *src, lzo_uint  src_len,

   306

                                        lzo_byte *dst, lzo_uintp dst_len,

   307

                                        lzo_voidp wrkmem,

   308

                                  const lzo_byte *dict, lzo_uint dict_len );

   309

   310

typedef int

   311

(__LZO_ENTRY *lzo_decompress_dict_t)(const lzo_byte *src, lzo_uint  src_len,

   312

                                        lzo_byte *dst, lzo_uintp dst_len,

   313

                                        lzo_voidp wrkmem,

   314

                                  const lzo_byte *dict, lzo_uint dict_len );

   315

   316

   317

/* assembler versions always use __cdecl */

   318

typedef int

   319

(__LZO_CDECL *lzo_compress_asm_t)( const lzo_byte *src, lzo_uint  src_len,

   320

                                        lzo_byte *dst, lzo_uintp dst_len,

   321

                                        lzo_voidp wrkmem );

   322

   323

typedef int

   324

(__LZO_CDECL *lzo_decompress_asm_t)( const lzo_byte *src, lzo_uint  src_len,

   325

                                        lzo_byte *dst, lzo_uintp dst_len,

   326

                                        lzo_voidp wrkmem );

   327

   328

   329

/* a progress indicator callback function */

   330

typedef void (__LZO_ENTRY *lzo_progress_callback_t) (lzo_uint, lzo_uint);

   331

   332

   333

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

   334

 * export information

   335

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

   336

   337

/* DLL export information */

   338

#if !defined(__LZO_EXPORT1)

   339

#  define __LZO_EXPORT1

   340

#endif

   341

#if !defined(__LZO_EXPORT2)

   342

#  define __LZO_EXPORT2

   343

#endif

   344

   345

/* exported calling convention for C functions */

   346

#if !defined(LZO_PUBLIC)

   347

#  define LZO_PUBLIC(_rettype) \

   348

                __LZO_EXPORT1 _rettype __LZO_EXPORT2 __LZO_ENTRY

   349

#endif

   350

#if !defined(LZO_EXTERN)

   351

#  define LZO_EXTERN(_rettype)          __LZO_EXTERN_C LZO_PUBLIC(_rettype)

   352

#endif

   353

#if !defined(LZO_PRIVATE)

   354

#  define LZO_PRIVATE(_rettype)         static _rettype __LZO_ENTRY

   355

#endif

   356

   357

/* exported __cdecl calling convention for assembler functions */

   358

#if !defined(LZO_PUBLIC_CDECL)

   359

#  define LZO_PUBLIC_CDECL(_rettype) \

   360

                __LZO_EXPORT1 _rettype __LZO_EXPORT2 __LZO_CDECL

   361

#endif

   362

#if !defined(LZO_EXTERN_CDECL)

   363

#  define LZO_EXTERN_CDECL(_rettype)    __LZO_EXTERN_C LZO_PUBLIC_CDECL(_rettype)

   364

#endif

   365

   366

/* exported global variables (LZO currently uses no static variables and

   367

 * is fully thread safe) */

   368

#if !defined(LZO_PUBLIC_VAR)

   369

#  define LZO_PUBLIC_VAR(_type) \

   370

                __LZO_EXPORT1 _type __LZO_EXPORT2 __LZO_DMODEL

   371

#endif

   372

#if !defined(LZO_EXTERN_VAR)

   373

#  define LZO_EXTERN_VAR(_type)         extern LZO_PUBLIC_VAR(_type)

   374

#endif

   375

   376

   377

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

   378

 * error codes and prototypes

   379

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

   380

   381

/* Error codes for the compression/decompression functions. Negative

   382

 * values are errors, positive values will be used for special but

   383

 * normal events.

   384

 */

   385

#define LZO_E_OK                    0

   386

#define LZO_E_ERROR                 (-1)

   387

#define LZO_E_OUT_OF_MEMORY         (-2)    /* not used right now */

   388

#define LZO_E_NOT_COMPRESSIBLE      (-3)    /* not used right now */

   389

#define LZO_E_INPUT_OVERRUN         (-4)

   390

#define LZO_E_OUTPUT_OVERRUN        (-5)

   391

#define LZO_E_LOOKBEHIND_OVERRUN    (-6)

   392

#define LZO_E_EOF_NOT_FOUND         (-7)

   393

#define LZO_E_INPUT_NOT_CONSUMED    (-8)

   394

   395

   396

/* lzo_init() should be the first function you call.

   397

 * Check the return code !

   398

 *

   399

 * lzo_init() is a macro to allow checking that the library and the

   400

 * compiler's view of various types are consistent.

   401

 */

   402

#define lzo_init() __lzo_init2(LZO_VERSION,(int)sizeof(short),(int)sizeof(int),\

   403

    (int)sizeof(long),(int)sizeof(lzo_uint32),(int)sizeof(lzo_uint),\

   404

    (int)lzo_sizeof_dict_t,(int)sizeof(char *),(int)sizeof(lzo_voidp),\

   405

    (int)sizeof(lzo_compress_t))

   406

LZO_EXTERN(int) __lzo_init2(unsigned,int,int,int,int,int,int,int,int,int);

   407

   408

/* version functions (useful for shared libraries) */

   409

LZO_EXTERN(unsigned) lzo_version();

   410

LZO_EXTERN(const char *) lzo_version_string();

   411

LZO_EXTERN(const char *) lzo_version_date();

   412

LZO_EXTERN(const lzo_charp) _lzo_version_string();

   413

LZO_EXTERN(const lzo_charp) _lzo_version_date();

   414

   415

/* string functions */

   416

LZO_EXTERN(int)

   417

lzo_memcmp(const lzo_voidp _s1, const lzo_voidp _s2, lzo_uint _len);

   418

LZO_EXTERN(lzo_voidp)

   419

lzo_memcpy(lzo_voidp _dest, const lzo_voidp _src, lzo_uint _len);

   420

LZO_EXTERN(lzo_voidp)

   421

lzo_memmove(lzo_voidp _dest, const lzo_voidp _src, lzo_uint _len);

   422

LZO_EXTERN(lzo_voidp)

   423

lzo_memset(lzo_voidp _s, int _c, lzo_uint _len);

   424

   425

/* checksum functions */

   426

LZO_EXTERN(lzo_uint32)

   427

lzo_adler32(lzo_uint32 _adler, const lzo_byte *_buf, lzo_uint _len);

   428

LZO_EXTERN(lzo_uint32)

   429

lzo_crc32(lzo_uint32 _c, const lzo_byte *_buf, lzo_uint _len);

   430

   431

/* misc. */

   432

LZO_EXTERN(lzo_bool) lzo_assert(int _expr);

   433

LZO_EXTERN(int) _lzo_config_check();

   434

typedef union { lzo_bytep p; lzo_uint u; } __lzo_pu_u;

   435

typedef union { lzo_bytep p; lzo_uint32 u32; } __lzo_pu32_u;

   436

typedef union { void *vp; lzo_bytep bp; lzo_uint32 u32; long l; } lzo_align_t;

   437

   438

/* align a char pointer on a boundary that is a multiple of `size' */

   439

LZO_EXTERN(unsigned) __lzo_align_gap(const lzo_voidp _ptr, lzo_uint _size);

   440

#define LZO_PTR_ALIGN_UP(_ptr,_size) \

   441

    ((_ptr) + (lzo_uint) __lzo_align_gap((const lzo_voidp)(_ptr),(lzo_uint)(_size)))

   442

   443

/* deprecated - only for backward compatibility */

   444

#define LZO_ALIGN(_ptr,_size) LZO_PTR_ALIGN_UP(_ptr,_size)

   445

   446

   447

#ifdef __cplusplus

   448

} /* extern "C" */

   449

#endif

   450

   451

#endif /* LZOCONF_H */