text: /* lzo_conf.h -- main internal configuration file for the 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/
   */
  
  
  /* WARNING: this file should *not* be used by applications. It is
     part of the implementation of the library and is subject
     to change.
   */
  
  
  #ifndef __LZO_CONF_H
  #define __LZO_CONF_H 1
  
  #if !defined(__LZO_IN_MINILZO)
  #if defined(LZO_CFG_FREESTANDING) && (LZO_CFG_FREESTANDING)
  #  define LZO_LIBC_FREESTANDING 1
  #  define LZO_OS_FREESTANDING 1
  #endif
  #if defined(LZO_CFG_EXTRA_CONFIG_HEADER)
  #  include LZO_CFG_EXTRA_CONFIG_HEADER
  #endif
  #if defined(__LZOCONF_H) || defined(__LZOCONF_H_INCLUDED)
  #  error "include this file first"
  #endif
  #include "lzo/lzoconf.h"
  #if defined(LZO_CFG_EXTRA_CONFIG_HEADER2)
  #  include LZO_CFG_EXTRA_CONFIG_HEADER2
  #endif
  #endif
  
  #if (LZO_VERSION < 0x2070) || !defined(__LZOCONF_H_INCLUDED)
  #  error "version mismatch"
  #endif
  
  
  /***********************************************************************
  // pragmas
  ************************************************************************/
  
  #if (LZO_CC_MSC && (_MSC_VER >= 1000 && _MSC_VER < 1100))
     /* disable bogus "unreachable code" warnings */
  #  pragma warning(disable: 4702)
  #endif
  #if (LZO_CC_MSC && (_MSC_VER >= 1000))
  #  pragma warning(disable: 4127 4701)
     /* disable warnings about inlining */
  #  pragma warning(disable: 4514 4710 4711)
  #endif
  #if (LZO_CC_MSC && (_MSC_VER >= 1300))
     /* disable '-Wall' warnings in system header files */
  #  pragma warning(disable: 4820)
  #endif
  #if (LZO_CC_MSC && (_MSC_VER >= 1800))
     /* disable '-Wall' warnings in system header files */
  #  pragma warning(disable: 4746)
  #endif
  
  #if (LZO_CC_SUNPROC)
  #if !defined(__cplusplus)
  #  pragma error_messages(off,E_END_OF_LOOP_CODE_NOT_REACHED)
  #  pragma error_messages(off,E_LOOP_NOT_ENTERED_AT_TOP)
  #  pragma error_messages(off,E_STATEMENT_NOT_REACHED)
  #endif
  #endif
  
  
  /***********************************************************************
  //
  ************************************************************************/
  
  #if defined(__LZO_IN_MINILZO) || (LZO_CFG_FREESTANDING)
  #elif 1
  #  include <string.h>
  #else
  #  define LZO_WANT_ACC_INCD_H 1
  #endif
  #if defined(LZO_HAVE_CONFIG_H)
  #  define LZO_CFG_NO_CONFIG_HEADER 1
  #endif
  #include "lzo_supp.h"
  
  /* Integral types */
  #if 1 || defined(lzo_int8_t) || defined(lzo_uint8_t)
  LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int8_t)  == 1)
  LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint8_t) == 1)
  #endif
  #if 1 || defined(lzo_int16_t) || defined(lzo_uint16_t)
  LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int16_t)  == 2)
  LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint16_t) == 2)
  #endif
  #if 1 || defined(lzo_int32_t) || defined(lzo_uint32_t)
  LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32_t)  == 4)
  LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint32_t) == 4)
  #endif
  #if defined(lzo_int64_t) || defined(lzo_uint64_t)
  LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64_t)  == 8)
  LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint64_t) == 8)
  #endif
  
  #if (LZO_CFG_FREESTANDING)
  #  undef HAVE_MEMCMP
  #  undef HAVE_MEMCPY
  #  undef HAVE_MEMMOVE
  #  undef HAVE_MEMSET
  #endif
  
  #if !(HAVE_MEMCMP)
  #  undef memcmp
  #  define memcmp(a,b,c)         lzo_memcmp(a,b,c)
  #else
  #  undef lzo_memcmp
  #  define lzo_memcmp(a,b,c)     memcmp(a,b,c)
  #endif
  #if !(HAVE_MEMCPY)
  #  undef memcpy
  #  define memcpy(a,b,c)         lzo_memcpy(a,b,c)
  #else
  #  undef lzo_memcpy
  #  define lzo_memcpy(a,b,c)     memcpy(a,b,c)
  #endif
  #if !(HAVE_MEMMOVE)
  #  undef memmove
  #  define memmove(a,b,c)        lzo_memmove(a,b,c)
  #else
  #  undef lzo_memmove
  #  define lzo_memmove(a,b,c)    memmove(a,b,c)
  #endif
  #if !(HAVE_MEMSET)
  #  undef memset
  #  define memset(a,b,c)         lzo_memset(a,b,c)
  #else
  #  undef lzo_memset
  #  define lzo_memset(a,b,c)     memset(a,b,c)
  #endif
  
  #undef NDEBUG
  #if (LZO_CFG_FREESTANDING)
  #  undef LZO_DEBUG
  #  define NDEBUG 1
  #  undef assert
  #  define assert(e) ((void)0)
  #else
  #  if !defined(LZO_DEBUG)
  #    define NDEBUG 1
  #  endif
  #  include <assert.h>
  #endif
  
  #if 0 && defined(__BOUNDS_CHECKING_ON)
  #  include <unchecked.h>
  #else
  #  define BOUNDS_CHECKING_OFF_DURING(stmt)      stmt
  #  define BOUNDS_CHECKING_OFF_IN_EXPR(expr)     (expr)
  #endif
  
  #if (LZO_CFG_PGO)
  #  undef __lzo_likely
  #  undef __lzo_unlikely
  #  define __lzo_likely(e)       (e)
  #  define __lzo_unlikely(e)     (e)
  #endif
  
  #undef _
  #undef __
  #undef ___
  #undef ____
  #undef _p0
  #undef _p1
  #undef _p2
  #undef _p3
  #undef _p4
  #undef _s0
  #undef _s1
  #undef _s2
  #undef _s3
  #undef _s4
  #undef _ww
  
  
  /***********************************************************************
  //
  ************************************************************************/
  
  #if 1
  #  define LZO_BYTE(x)       ((unsigned char) (x))
  #else
  #  define LZO_BYTE(x)       ((unsigned char) ((x) & 0xff))
  #endif
  
  #define LZO_MAX(a,b)        ((a) >= (b) ? (a) : (b))
  #define LZO_MIN(a,b)        ((a) <= (b) ? (a) : (b))
  #define LZO_MAX3(a,b,c)     ((a) >= (b) ? LZO_MAX(a,c) : LZO_MAX(b,c))
  #define LZO_MIN3(a,b,c)     ((a) <= (b) ? LZO_MIN(a,c) : LZO_MIN(b,c))
  
  #define lzo_sizeof(type)    ((lzo_uint) (sizeof(type)))
  
  #define LZO_HIGH(array)     ((lzo_uint) (sizeof(array)/sizeof(*(array))))
  
  /* this always fits into 32 bits */
  #define LZO_SIZE(bits)      (1u << (bits))
  #define LZO_MASK(bits)      (LZO_SIZE(bits) - 1)
  
  #define LZO_USIZE(bits)     ((lzo_uint) 1 << (bits))
  #define LZO_UMASK(bits)     (LZO_USIZE(bits) - 1)
  
  #if !defined(DMUL)
  #if 0
     /* 32*32 multiplies may be faster than 64*64 on some 64-bit machines,
      * but then we need extra casts from unsigned<->size_t */
  #  define DMUL(a,b) ((lzo_xint) ((lzo_uint32_t)(a) * (lzo_uint32_t)(b)))
  #else
  #  define DMUL(a,b) ((lzo_xint) ((a) * (b)))
  #endif
  #endif
  
  
  /***********************************************************************
  // compiler and architecture specific stuff
  ************************************************************************/
  
  /* Some defines that indicate if memory can be accessed at unaligned
   * memory addresses. You should also test that this is actually faster
   * even if it is allowed by your system.
   */
  
  #include "lzo_func.h"
  
  #ifndef UA_SET1
  #define UA_SET1             LZO_MEMOPS_SET1
  #endif
  #ifndef UA_SET2
  #define UA_SET2             LZO_MEMOPS_SET2
  #endif
  #ifndef UA_SET3
  #define UA_SET3             LZO_MEMOPS_SET3
  #endif
  #ifndef UA_SET4
  #define UA_SET4             LZO_MEMOPS_SET4
  #endif
  #ifndef UA_MOVE1
  #define UA_MOVE1            LZO_MEMOPS_MOVE1
  #endif
  #ifndef UA_MOVE2
  #define UA_MOVE2            LZO_MEMOPS_MOVE2
  #endif
  #ifndef UA_MOVE3
  #define UA_MOVE3            LZO_MEMOPS_MOVE3
  #endif
  #ifndef UA_MOVE4
  #define UA_MOVE4            LZO_MEMOPS_MOVE4
  #endif
  #ifndef UA_MOVE8
  #define UA_MOVE8            LZO_MEMOPS_MOVE8
  #endif
  #ifndef UA_COPY1
  #define UA_COPY1            LZO_MEMOPS_COPY1
  #endif
  #ifndef UA_COPY2
  #define UA_COPY2            LZO_MEMOPS_COPY2
  #endif
  #ifndef UA_COPY3
  #define UA_COPY3            LZO_MEMOPS_COPY3
  #endif
  #ifndef UA_COPY4
  #define UA_COPY4            LZO_MEMOPS_COPY4
  #endif
  #ifndef UA_COPY8
  #define UA_COPY8            LZO_MEMOPS_COPY8
  #endif
  #ifndef UA_COPYN
  #define UA_COPYN            LZO_MEMOPS_COPYN
  #endif
  #ifndef UA_COPYN_X
  #define UA_COPYN_X          LZO_MEMOPS_COPYN
  #endif
  #ifndef UA_GET_LE16
  #define UA_GET_LE16         LZO_MEMOPS_GET_LE16
  #endif
  #ifndef UA_GET_LE32
  #define UA_GET_LE32         LZO_MEMOPS_GET_LE32
  #endif
  #ifdef LZO_MEMOPS_GET_LE64
  #ifndef UA_GET_LE64
  #define UA_GET_LE64         LZO_MEMOPS_GET_LE64
  #endif
  #endif
  #ifndef UA_GET_NE16
  #define UA_GET_NE16         LZO_MEMOPS_GET_NE16
  #endif
  #ifndef UA_GET_NE32
  #define UA_GET_NE32         LZO_MEMOPS_GET_NE32
  #endif
  #ifdef LZO_MEMOPS_GET_NE64
  #ifndef UA_GET_NE64
  #define UA_GET_NE64         LZO_MEMOPS_GET_NE64
  #endif
  #endif
  #ifndef UA_PUT_LE16
  #define UA_PUT_LE16         LZO_MEMOPS_PUT_LE16
  #endif
  #ifndef UA_PUT_LE32
  #define UA_PUT_LE32         LZO_MEMOPS_PUT_LE32
  #endif
  #ifndef UA_PUT_NE16
  #define UA_PUT_NE16         LZO_MEMOPS_PUT_NE16
  #endif
  #ifndef UA_PUT_NE32
  #define UA_PUT_NE32         LZO_MEMOPS_PUT_NE32
  #endif
  
  
  /* Fast memcpy that copies multiples of 8 byte chunks.
   * len is the number of bytes.
   * note: all parameters must be lvalues, len >= 8
   *       dest and src advance, len is undefined afterwards
   */
  
  #define MEMCPY8_DS(dest,src,len) \
      lzo_memcpy(dest,src,len); dest += len; src += len
  
  #define BZERO8_PTR(s,l,n) \
      lzo_memset((lzo_voidp)(s),0,(lzo_uint)(l)*(n))
  
  #define MEMCPY_DS(dest,src,len) \
      do *dest++ = *src++; while (--len > 0)
  
  
  /***********************************************************************
  //
  ************************************************************************/
  
  LZO_EXTERN(const lzo_bytep) lzo_copyright(void);
  
  #include "lzo_ptr.h"
  
  /* Generate compressed data in a deterministic way.
   * This is fully portable, and compression can be faster as well.
   * A reason NOT to be deterministic is when the block size is
   * very small (e.g. 8kB) or the dictionary is big, because
   * then the initialization of the dictionary becomes a relevant
   * magnitude for compression speed.
   */
  #ifndef LZO_DETERMINISTIC
  #define LZO_DETERMINISTIC 1
  #endif
  
  
  #ifndef LZO_DICT_USE_PTR
  #define LZO_DICT_USE_PTR 1
  #endif
  
  #if (LZO_DICT_USE_PTR)
  #  define lzo_dict_t    const lzo_bytep
  #  define lzo_dict_p    lzo_dict_t *
  #else
  #  define lzo_dict_t    lzo_uint
  #  define lzo_dict_p    lzo_dict_t *
  #endif
  
  
  #endif /* already included */
  
  /*
  vi:ts=4:et
  */
  
  