1

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

     2

     3

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

     4

     5

   Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer

     6

   Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer

     7

   Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer

     8

   Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer

     9

   Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer

    10

   Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer

    11

   Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer

    12

   All Rights Reserved.

    13

    14

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

    15

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

    16

   published by the Free Software Foundation; either version 2 of

    17

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

    18

    19

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

    20

   but WITHOUT ANY WARRANTY; without even the implied warranty of

    21

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    22

   GNU General Public License for more details.

    23

    24

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

    25

   along with the LZO library; see the file COPYING.

    26

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

    27

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

    28

    29

   Markus F.X.J. Oberhumer

    30

   <markus@oberhumer.com>

    31

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

    32

 */

    33

    34

    35

#ifndef __LZOCONF_H

    36

#define __LZOCONF_H

    37

    38

#define LZO_VERSION             0x1080

    39

#define LZO_VERSION_STRING      "1.08"

    40

#define LZO_VERSION_DATE        "Jul 12 2002"

    41

    42

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

    43

#if defined(LZO_HAVE_CONFIG_H)

    44

#  include <config.h>

    45

#endif

    46

#include <limits.h>

    47

    48

#ifdef __cplusplus

    49

extern "C" {

    50

#endif

    51

    52

    53

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

    54

// LZO requires a conforming <limits.h>

    55

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

    56

    57

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

    58

#  error "invalid CHAR_BIT"

    59

#endif

    60

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

    61

#  error "check your compiler installation"

    62

#endif

    63

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

    64

#  error "your limits.h macros are broken"

    65

#endif

    66

    67

/* workaround a cpp bug under hpux 10.20 */

    68

#define LZO_0xffffffffL         4294967295ul

    69

    70

#if !defined(LZO_UINT32_C)

    71

#  if (UINT_MAX < LZO_0xffffffffL)

    72

#    define LZO_UINT32_C(c)     c ## UL

    73

#  else

    74

#    define LZO_UINT32_C(c)     c ## U

    75

#  endif

    76

#endif

    77

    78

    79

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

    80

// architecture defines

    81

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

    82

    83

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

    84

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

    85

#    define __LZO_WIN

    86

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

    87

#    define __LZO_WIN

    88

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

    89

#    define __LZO_WIN

    90

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

    91

#    define __LZO_DOS

    92

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

    93

#    define __LZO_OS2

    94

#  elif defined(__palmos__)

    95

#    define __LZO_PALMOS

    96

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

    97

#    define __LZO_TOS

    98

#  endif

    99

#endif

   100

   101

#if (UINT_MAX < LZO_0xffffffffL)

   102

#  if defined(__LZO_WIN)

   103

#    define __LZO_WIN16

   104

#  elif defined(__LZO_DOS)

   105

#    define __LZO_DOS16

   106

#  elif defined(__LZO_PALMOS)

   107

#    define __LZO_PALMOS16

   108

#  elif defined(__LZO_TOS)

   109

#    define __LZO_TOS16

   110

#  elif defined(__C166__)

   111

#  else

   112

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

   113

      * everything with -D__LZO_STRICT_16BIT */

   114

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

   115

#  endif

   116

#endif

   117

   118

#if !defined(__LZO_i386)

   119

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

   120

#    define __LZO_i386

   121

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

   122

#    define __LZO_i386

   123

#  endif

   124

#endif

   125

   126

#if defined(__LZO_STRICT_16BIT)

   127

#  if (UINT_MAX < LZO_0xffffffffL)

   128

#    include <lzo16bit.h>

   129

#  endif

   130

#endif

   131

   132

/* memory checkers */

   133

#if !defined(__LZO_CHECKER)

   134

#  if defined(__BOUNDS_CHECKING_ON)

   135

#    define __LZO_CHECKER

   136

#  elif defined(__CHECKER__)

   137

#    define __LZO_CHECKER

   138

#  elif defined(__INSURE__)

   139

#    define __LZO_CHECKER

   140

#  elif defined(__PURIFY__)

   141

#    define __LZO_CHECKER

   142

#  endif

   143

#endif

   144

   145

   146

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

   147

// integral and pointer types

   148

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

   149

   150

/* Integral types with 32 bits or more */

   151

#if !defined(LZO_UINT32_MAX)

   152

#  if (UINT_MAX >= LZO_0xffffffffL)

   153

     typedef unsigned int       lzo_uint32;

   154

     typedef int                lzo_int32;

   155

#    define LZO_UINT32_MAX      UINT_MAX

   156

#    define LZO_INT32_MAX       INT_MAX

   157

#    define LZO_INT32_MIN       INT_MIN

   158

#  elif (ULONG_MAX >= LZO_0xffffffffL)

   159

     typedef unsigned long      lzo_uint32;

   160

     typedef long               lzo_int32;

   161

#    define LZO_UINT32_MAX      ULONG_MAX

   162

#    define LZO_INT32_MAX       LONG_MAX

   163

#    define LZO_INT32_MIN       LONG_MIN

   164

#  else

   165

#    error "lzo_uint32"

   166

#  endif

   167

#endif

   168

   169

/* lzo_uint is used like size_t */

   170

#if !defined(LZO_UINT_MAX)

   171

#  if (UINT_MAX >= LZO_0xffffffffL)

   172

     typedef unsigned int       lzo_uint;

   173

     typedef int                lzo_int;

   174

#    define LZO_UINT_MAX        UINT_MAX

   175

#    define LZO_INT_MAX         INT_MAX

   176

#    define LZO_INT_MIN         INT_MIN

   177

#  elif (ULONG_MAX >= LZO_0xffffffffL)

   178

     typedef unsigned long      lzo_uint;

   179

     typedef long               lzo_int;

   180

#    define LZO_UINT_MAX        ULONG_MAX

   181

#    define LZO_INT_MAX         LONG_MAX

   182

#    define LZO_INT_MIN         LONG_MIN

   183

#  else

   184

#    error "lzo_uint"

   185

#  endif

   186

#endif

   187

   188

typedef int lzo_bool;

   189

   190

   191

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

   192

// memory models

   193

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

   194

   195

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

   196

#if !defined(__LZO_CMODEL)

   197

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

   198

#    define __LZO_CMODEL        __far

   199

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

   200

#    define __LZO_CMODEL        __near

   201

#  else

   202

#    define __LZO_CMODEL

   203

#  endif

   204

#endif

   205

   206

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

   207

#if !defined(__LZO_DMODEL)

   208

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

   209

#    define __LZO_DMODEL        __far

   210

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

   211

#    define __LZO_DMODEL        __near

   212

#  else

   213

#    define __LZO_DMODEL

   214

#  endif

   215

#endif

   216

   217

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

   218

#if !defined(__LZO_MMODEL)

   219

#  if (LZO_UINT_MAX <= UINT_MAX)

   220

#    define __LZO_MMODEL

   221

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

   222

#    define __LZO_MMODEL        __huge

   223

#    define LZO_999_UNSUPPORTED

   224

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

   225

#    define __LZO_MMODEL

   226

#  else

   227

#    error "__LZO_MMODEL"

   228

#  endif

   229

#endif

   230

   231

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

   232

#define lzo_byte                unsigned char __LZO_MMODEL

   233

#define lzo_bytep               unsigned char __LZO_MMODEL *

   234

#define lzo_charp               char __LZO_MMODEL *

   235

#define lzo_voidp               void __LZO_MMODEL *

   236

#define lzo_shortp              short __LZO_MMODEL *

   237

#define lzo_ushortp             unsigned short __LZO_MMODEL *

   238

#define lzo_uint32p             lzo_uint32 __LZO_MMODEL *

   239

#define lzo_int32p              lzo_int32 __LZO_MMODEL *

   240

#define lzo_uintp               lzo_uint __LZO_MMODEL *

   241

#define lzo_intp                lzo_int __LZO_MMODEL *

   242

#define lzo_voidpp              lzo_voidp __LZO_MMODEL *

   243

#define lzo_bytepp              lzo_bytep __LZO_MMODEL *

   244

   245

#ifndef lzo_sizeof_dict_t

   246

#  define lzo_sizeof_dict_t     sizeof(lzo_bytep)

   247

#endif

   248

   249

   250

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

   251

// calling conventions and function types

   252

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

   253

   254

/* linkage */

   255

#if !defined(__LZO_EXTERN_C)

   256

#  ifdef __cplusplus

   257

#    define __LZO_EXTERN_C      extern "C"

   258

#  else

   259

#    define __LZO_EXTERN_C      extern

   260

#  endif

   261

#endif

   262

   263

/* calling convention */

   264

#if !defined(__LZO_CDECL)

   265

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

   266

#    define __LZO_CDECL         __LZO_CMODEL __cdecl

   267

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

   268

#    define __LZO_CDECL         __LZO_CMODEL __cdecl

   269

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

   270

#    define __LZO_CDECL         __LZO_CMODEL __cdecl

   271

#  else

   272

#    define __LZO_CDECL         __LZO_CMODEL

   273

#  endif

   274

#endif

   275

#if !defined(__LZO_ENTRY)

   276

#  define __LZO_ENTRY           __LZO_CDECL

   277

#endif

   278

   279

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

   280

#if !defined(__cplusplus)

   281

#  undef LZO_NOTHROW

   282

#  define LZO_NOTHROW

   283

#elif !defined(LZO_NOTHROW)

   284

#  define LZO_NOTHROW

   285

#endif

   286

   287

   288

typedef int

   289

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

   290

                                        lzo_byte *dst, lzo_uintp dst_len,

   291

                                        lzo_voidp wrkmem );

   292

   293

typedef int

   294

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

   295

                                        lzo_byte *dst, lzo_uintp dst_len,

   296

                                        lzo_voidp wrkmem );

   297

   298

typedef int

   299

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

   300

                                        lzo_byte *dst, lzo_uintp dst_len,

   301

                                        lzo_voidp wrkmem );

   302

   303

typedef int

   304

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

   305

                                        lzo_byte *dst, lzo_uintp dst_len,

   306

                                        lzo_voidp wrkmem,

   307

                                  const lzo_byte *dict, lzo_uint dict_len );

   308

   309

typedef int

   310

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

   311

                                        lzo_byte *dst, lzo_uintp dst_len,

   312

                                        lzo_voidp wrkmem,

   313

                                  const lzo_byte *dict, lzo_uint dict_len );

   314

   315

   316

/* assembler versions always use __cdecl */

   317

typedef int

   318

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

   319

                                        lzo_byte *dst, lzo_uintp dst_len,

   320

                                        lzo_voidp wrkmem );

   321

   322

typedef int

   323

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

   324

                                        lzo_byte *dst, lzo_uintp dst_len,

   325

                                        lzo_voidp wrkmem );

   326

   327

   328

/* a progress indicator callback function */

   329

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

   330

   331

   332

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

   333

// export information

   334

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

   335

   336

/* DLL export information */

   337

#if !defined(__LZO_EXPORT1)

   338

#  define __LZO_EXPORT1

   339

#endif

   340

#if !defined(__LZO_EXPORT2)

   341

#  define __LZO_EXPORT2

   342

#endif

   343

   344

/* exported calling convention for C functions */

   345

#if !defined(LZO_PUBLIC)

   346

#  define LZO_PUBLIC(_rettype) \

   347

                __LZO_EXPORT1 _rettype __LZO_EXPORT2 __LZO_ENTRY

   348

#endif

   349

#if !defined(LZO_EXTERN)

   350

#  define LZO_EXTERN(_rettype)          __LZO_EXTERN_C LZO_PUBLIC(_rettype)

   351

#endif

   352

#if !defined(LZO_PRIVATE)

   353

#  define LZO_PRIVATE(_rettype)         static _rettype __LZO_ENTRY

   354

#endif

   355

   356

/* exported __cdecl calling convention for assembler functions */

   357

#if !defined(LZO_PUBLIC_CDECL)

   358

#  define LZO_PUBLIC_CDECL(_rettype) \

   359

                __LZO_EXPORT1 _rettype __LZO_EXPORT2 __LZO_CDECL

   360

#endif

   361

#if !defined(LZO_EXTERN_CDECL)

   362

#  define LZO_EXTERN_CDECL(_rettype)    __LZO_EXTERN_C LZO_PUBLIC_CDECL(_rettype)

   363

#endif

   364

   365

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

   366

 * is fully thread safe) */

   367

#if !defined(LZO_PUBLIC_VAR)

   368

#  define LZO_PUBLIC_VAR(_type) \

   369

                __LZO_EXPORT1 _type __LZO_EXPORT2 __LZO_DMODEL

   370

#endif

   371

#if !defined(LZO_EXTERN_VAR)

   372

#  define LZO_EXTERN_VAR(_type)         extern LZO_PUBLIC_VAR(_type)

   373

#endif

   374

   375

   376

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

   377

// error codes and prototypes

   378

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

   379

   380

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

   381

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

   382

 * normal events.

   383

 */

   384

#define LZO_E_OK                    0

   385

#define LZO_E_ERROR                 (-1)

   386

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

   387

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

   388

#define LZO_E_INPUT_OVERRUN         (-4)

   389

#define LZO_E_OUTPUT_OVERRUN        (-5)

   390

#define LZO_E_LOOKBEHIND_OVERRUN    (-6)

   391

#define LZO_E_EOF_NOT_FOUND         (-7)

   392

#define LZO_E_INPUT_NOT_CONSUMED    (-8)

   393

   394

   395

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

   396

 * Check the return code !

   397

 *

   398

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

   399

 * compiler's view of various types are consistent.

   400

 */

   401

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

   402

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

   403

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

   404

    (int)sizeof(lzo_compress_t))

   405

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

   406

   407

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

   408

LZO_EXTERN(unsigned) lzo_version(void);

   409

LZO_EXTERN(const char *) lzo_version_string(void);

   410

LZO_EXTERN(const char *) lzo_version_date(void);

   411

LZO_EXTERN(const lzo_charp) _lzo_version_string(void);

   412

LZO_EXTERN(const lzo_charp) _lzo_version_date(void);

   413

   414

/* string functions */

   415

LZO_EXTERN(int)

   416

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

   417

LZO_EXTERN(lzo_voidp)

   418

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

   419

LZO_EXTERN(lzo_voidp)

   420

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

   421

LZO_EXTERN(lzo_voidp)

   422

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

   423

   424

/* checksum functions */

   425

LZO_EXTERN(lzo_uint32)

   426

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

   427

LZO_EXTERN(lzo_uint32)

   428

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

   429

   430

/* misc. */

   431

LZO_EXTERN(lzo_bool) lzo_assert(int _expr);

   432

LZO_EXTERN(int) _lzo_config_check(void);

   433

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

   434

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

   435

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

   436

   437

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

   438

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

   439

#define LZO_PTR_ALIGN_UP(_ptr,_size) \

   440

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

   441

   442

/* deprecated - only for backward compatibility */

   443

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

   444

   445

   446

#ifdef __cplusplus

   447

} /* extern "C" */

   448

#endif

   449

   450

#endif /* already included */

   451