Changeset - r12741:8667e369bdf5
Parent rev.
Child rev.
[Not reviewed]
master
0 2 0
rubidium - 15 years ago 2009-08-18 22:51:43
rubidium@openttd.org
(svn r17217) -Fix (r17216): silence some warnings for the more exotic GCC-alikes
2 files changed with 17 insertions and 17 deletions:
src/3rdparty/minilzo/lzodefs.h
15
15
src/3rdparty/minilzo/minilzo.c
2
2
0 comments (0 inline, 0 general)
src/3rdparty/minilzo/lzodefs.h
➞
Show inline comments
 
@@ -1141,559 +1141,559 @@ extern "C" {
 
#  elif (LZO_MM_COMPACT || LZO_MM_LARGE || LZO_MM_HUGE)
 
#    define LZO_SIZEOF_VOID_P       4
 
#  else
 
#    error "LZO_MM"
 
#  endif
 
#elif defined(LZO_ARCH_AVR) || defined(LZO_ARCH_Z80)
 
#  define __LZO_WORDSIZE            1
 
#  define LZO_SIZEOF_VOID_P         2
 
#elif defined(LZO_ARCH_C166) || defined(LZO_ARCH_MCS51) || defined(LZO_ARCH_MCS251) || defined(LZO_ARCH_MSP430)
 
#  define LZO_SIZEOF_VOID_P         2
 
#elif defined(LZO_ARCH_H8300)
 
#  if defined(__NORMAL_MODE__)
 
#    define __LZO_WORDSIZE          4
 
#    define LZO_SIZEOF_VOID_P       2
 
#  elif defined(__H8300H__) || defined(__H8300S__) || defined(__H8300SX__)
 
#    define __LZO_WORDSIZE          4
 
#    define LZO_SIZEOF_VOID_P       4
 
#  else
 
#    define __LZO_WORDSIZE          2
 
#    define LZO_SIZEOF_VOID_P       2
 
#  endif
 
#  if (LZO_CC_GNUC && (LZO_CC_GNUC < 0x040000ul)) && (LZO_SIZEOF_INT == 4)
 
#    define LZO_SIZEOF_SIZE_T       LZO_SIZEOF_INT
 
#    define LZO_SIZEOF_PTRDIFF_T    LZO_SIZEOF_INT
 
#  endif
 
#elif defined(LZO_ARCH_M16C)
 
#  define __LZO_WORDSIZE            2
 
#  if defined(__m32c_cpu__) || defined(__m32cm_cpu__)
 
#    define LZO_SIZEOF_VOID_P       4
 
#  else
 
#    define LZO_SIZEOF_VOID_P       2
 
#  endif
 
#elif (LZO_SIZEOF_LONG == 8) && ((defined(__mips__) && defined(__R5900__)) || defined(__MIPS_PSX2__))
 
#  define __LZO_WORDSIZE            8
 
#  define LZO_SIZEOF_VOID_P         4
 
#elif defined(__LLP64__) || defined(__LLP64) || defined(_LLP64) || defined(_WIN64)
 
#  define __LZO_WORDSIZE            8
 
#  define LZO_SIZEOF_VOID_P         8
 
#elif (defined(LZO_OS_OS400) || defined(__OS400__)) && defined(__LLP64_IFC__)
 
#  define LZO_SIZEOF_VOID_P         LZO_SIZEOF_LONG
 
#  define LZO_SIZEOF_SIZE_T         LZO_SIZEOF_LONG
 
#  define LZO_SIZEOF_PTRDIFF_T      LZO_SIZEOF_LONG
 
#elif (defined(LZO_OS_OS400) || defined(__OS400__))
 
#  define __LZO_WORDSIZE            LZO_SIZEOF_LONG
 
#  define LZO_SIZEOF_VOID_P         16
 
#  define LZO_SIZEOF_SIZE_T         LZO_SIZEOF_LONG
 
#  define LZO_SIZEOF_PTRDIFF_T      LZO_SIZEOF_LONG
 
#elif (defined(__vms) || defined(__VMS)) && (__INITIAL_POINTER_SIZE+0 == 64)
 
#  define LZO_SIZEOF_VOID_P         8
 
#  define LZO_SIZEOF_SIZE_T         LZO_SIZEOF_LONG
 
#  define LZO_SIZEOF_PTRDIFF_T      LZO_SIZEOF_LONG
 
#elif defined(LZO_ARCH_SPU)
 
# if 0
 
#  define __LZO_WORDSIZE            16
 
# endif
 
#  define LZO_SIZEOF_VOID_P         4
 
#else
 
#  define LZO_SIZEOF_VOID_P         LZO_SIZEOF_LONG
 
#endif
 
#endif
 
#if !defined(LZO_WORDSIZE)
 
#  if defined(__LZO_WORDSIZE)
 
#    define LZO_WORDSIZE            __LZO_WORDSIZE
 
#  else
 
#    define LZO_WORDSIZE            LZO_SIZEOF_VOID_P
 
#  endif
 
#endif
 
#if !defined(LZO_SIZEOF_SIZE_T)
 
#if defined(LZO_ARCH_I086) || defined(LZO_ARCH_M16C)
 
#  define LZO_SIZEOF_SIZE_T         2
 
#else
 
#  define LZO_SIZEOF_SIZE_T         LZO_SIZEOF_VOID_P
 
#endif
 
#endif
 
#if !defined(LZO_SIZEOF_PTRDIFF_T)
 
#if defined(LZO_ARCH_I086)
 
#  if defined(LZO_MM_TINY) || defined(LZO_MM_SMALL) || defined(LZO_MM_MEDIUM) || defined(LZO_MM_HUGE)
 
#    define LZO_SIZEOF_PTRDIFF_T    LZO_SIZEOF_VOID_P
 
#  elif defined(LZO_MM_COMPACT) || defined(LZO_MM_LARGE)
 
#    if defined(LZO_CC_BORLANDC) || defined(LZO_CC_TURBOC)
 
#      define LZO_SIZEOF_PTRDIFF_T  4
 
#    else
 
#      define LZO_SIZEOF_PTRDIFF_T  2
 
#    endif
 
#  else
 
#    error "LZO_MM"
 
#  endif
 
#else
 
#  define LZO_SIZEOF_PTRDIFF_T      LZO_SIZEOF_SIZE_T
 
#endif
 
#endif
 
#if defined(LZO_ABI_NEUTRAL_ENDIAN)
 
#  undef LZO_ABI_BIG_ENDIAN
 
#  undef LZO_ABI_LITTLE_ENDIAN
 
#elif !defined(LZO_ABI_BIG_ENDIAN) && !defined(LZO_ABI_LITTLE_ENDIAN)
 
#if defined(LZO_ARCH_ALPHA) && defined(LZO_ARCH_CRAY_MPP)
 
#  define LZO_ABI_BIG_ENDIAN        1
 
#elif defined(LZO_ARCH_ALPHA) || defined(LZO_ARCH_AMD64) || defined(LZO_ARCH_BLACKFIN) || defined(LZO_ARCH_CRIS) || defined(LZO_ARCH_I086) || defined(LZO_ARCH_I386) || defined(LZO_ARCH_MSP430)
 
#  define LZO_ABI_LITTLE_ENDIAN     1
 
#elif defined(LZO_ARCH_M68K) || defined(LZO_ARCH_S390)
 
#  define LZO_ABI_BIG_ENDIAN        1
 
#elif 1 && defined(__IAR_SYSTEMS_ICC__) && defined(__LITTLE_ENDIAN__)
 
#  if (__LITTLE_ENDIAN__ == 1)
 
#    define LZO_ABI_LITTLE_ENDIAN   1
 
#  else
 
#    define LZO_ABI_BIG_ENDIAN      1
 
#  endif
 
#elif 1 && defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)
 
#  define LZO_ABI_BIG_ENDIAN        1
 
#elif 1 && defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
 
#  define LZO_ABI_LITTLE_ENDIAN     1
 
#elif 1 && defined(LZO_ARCH_ARM) && defined(__ARMEB__) && !defined(__ARMEL__)
 
#  define LZO_ABI_BIG_ENDIAN        1
 
#elif 1 && defined(LZO_ARCH_ARM) && defined(__ARMEL__) && !defined(__ARMEB__)
 
#  define LZO_ABI_LITTLE_ENDIAN     1
 
#elif 1 && defined(LZO_ARCH_MIPS) && defined(__MIPSEB__) && !defined(__MIPSEL__)
 
#  define LZO_ABI_BIG_ENDIAN        1
 
#elif 1 && defined(LZO_ARCH_MIPS) && defined(__MIPSEL__) && !defined(__MIPSEB__)
 
#  define LZO_ABI_LITTLE_ENDIAN     1
 
#endif
 
#endif
 
#if defined(LZO_ABI_BIG_ENDIAN) && defined(LZO_ABI_LITTLE_ENDIAN)
 
#  error "this should not happen"
 
#endif
 
#if defined(LZO_ABI_BIG_ENDIAN)
 
#  define LZO_INFO_ABI_ENDIAN       "be"
 
#elif defined(LZO_ABI_LITTLE_ENDIAN)
 
#  define LZO_INFO_ABI_ENDIAN       "le"
 
#elif defined(LZO_ABI_NEUTRAL_ENDIAN)
 
#  define LZO_INFO_ABI_ENDIAN       "neutral"
 
#endif
 
#if (LZO_SIZEOF_INT == 1 && LZO_SIZEOF_LONG == 2 && LZO_SIZEOF_VOID_P == 2)
 
#  define LZO_ABI_I8LP16         1
 
#  define LZO_INFO_ABI_PM       "i8lp16"
 
#elif (LZO_SIZEOF_INT == 2 && LZO_SIZEOF_LONG == 2 && LZO_SIZEOF_VOID_P == 2)
 
#  define LZO_ABI_ILP16         1
 
#  define LZO_INFO_ABI_PM       "ilp16"
 
#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 4 && LZO_SIZEOF_VOID_P == 4)
 
#  define LZO_ABI_ILP32         1
 
#  define LZO_INFO_ABI_PM       "ilp32"
 
#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 4 && LZO_SIZEOF_VOID_P == 8 && LZO_SIZEOF_SIZE_T == 8)
 
#  define LZO_ABI_LLP64         1
 
#  define LZO_INFO_ABI_PM       "llp64"
 
#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 8 && LZO_SIZEOF_VOID_P == 8)
 
#  define LZO_ABI_LP64          1
 
#  define LZO_INFO_ABI_PM       "lp64"
 
#elif (LZO_SIZEOF_INT == 8 && LZO_SIZEOF_LONG == 8 && LZO_SIZEOF_VOID_P == 8)
 
#  define LZO_ABI_ILP64         1
 
#  define LZO_INFO_ABI_PM       "ilp64"
 
#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 8 && LZO_SIZEOF_VOID_P == 4)
 
#  define LZO_ABI_IP32L64       1
 
#  define LZO_INFO_ABI_PM       "ip32l64"
 
#endif
 
#if !defined(__LZO_LIBC_OVERRIDE)
 
#if defined(LZO_LIBC_NAKED)
 
#  define LZO_INFO_LIBC         "naked"
 
#elif defined(LZO_LIBC_FREESTANDING)
 
#  define LZO_INFO_LIBC         "freestanding"
 
#elif defined(LZO_LIBC_MOSTLY_FREESTANDING)
 
#  define LZO_INFO_LIBC         "mfreestanding"
 
#elif defined(LZO_LIBC_ISOC90)
 
#  define LZO_INFO_LIBC         "isoc90"
 
#elif defined(LZO_LIBC_ISOC99)
 
#  define LZO_INFO_LIBC         "isoc99"
 
#elif defined(__dietlibc__)
 
#  define LZO_LIBC_DIETLIBC     1
 
#  define LZO_INFO_LIBC         "dietlibc"
 
#elif defined(_NEWLIB_VERSION)
 
#  define LZO_LIBC_NEWLIB       1
 
#  define LZO_INFO_LIBC         "newlib"
 
#elif defined(__UCLIBC__) && defined(__UCLIBC_MAJOR__) && defined(__UCLIBC_MINOR__)
 
#  if defined(__UCLIBC_SUBLEVEL__)
 
#    define LZO_LIBC_UCLIBC     (__UCLIBC_MAJOR__ * 0x10000L + __UCLIBC_MINOR__ * 0x100 + __UCLIBC_SUBLEVEL__)
 
#  else
 
#    define LZO_LIBC_UCLIBC     0x00090bL
 
#  endif
 
#  define LZO_INFO_LIBC         "uclibc"
 
#elif defined(__GLIBC__) && defined(__GLIBC_MINOR__)
 
#  define LZO_LIBC_GLIBC        (__GLIBC__ * 0x10000L + __GLIBC_MINOR__ * 0x100)
 
#  define LZO_INFO_LIBC         "glibc"
 
#elif defined(LZO_CC_MWERKS) && defined(__MSL__)
 
#  define LZO_LIBC_MSL          __MSL__
 
#  define LZO_INFO_LIBC         "msl"
 
#elif 1 && defined(__IAR_SYSTEMS_ICC__)
 
#  define LZO_LIBC_ISOC90       1
 
#  define LZO_INFO_LIBC         "isoc90"
 
#else
 
#  define LZO_LIBC_DEFAULT      1
 
#  define LZO_INFO_LIBC         "default"
 
#endif
 
#endif
 
#if !defined(__lzo_gnuc_extension__)
 
#if (LZO_CC_GNUC >= 0x020800ul)
 
#if defined(LZO_CC_GNUC) && (LZO_CC_GNUC >= 0x020800ul)
 
#  define __lzo_gnuc_extension__    __extension__
 
#elif (LZO_CC_LLVM || LZO_CC_PATHSCALE)
 
#elif defined(LZO_CC_LLVM) || defined(LZO_CC_PATHSCALE)
 
#  define __lzo_gnuc_extension__    __extension__
 
#else
 
#  define __lzo_gnuc_extension__
 
#endif
 
#endif
 
#if !defined(__lzo_ua_volatile)
 
#  define __lzo_ua_volatile     volatile
 
#endif
 
#if !defined(__lzo_alignof)
 
#if defined(LZO_CC_CILLY) || defined(LZO_CC_GNUC) || defined(LZO_CC_LLVM) || defined(LZO_CC_PATHSCALE) || defined(LZO_CC_PGI)
 
#  define __lzo_alignof(e)      __alignof__(e)
 
#elif defined(LZO_CC_INTELC) && (__INTEL_COMPILER >= 700)
 
#  define __lzo_alignof(e)      __alignof__(e)
 
#elif defined(LZO_CC_MSC) && (_MSC_VER >= 1300)
 
#  define __lzo_alignof(e)      __alignof(e)
 
#endif
 
#endif
 
#if defined(__lzo_alignof)
 
#  define __lzo_HAVE_alignof 1
 
#endif
 
#if !defined(__lzo_constructor)
 
#if (LZO_CC_GNUC >= 0x030400ul)
 
#if defined(LZO_CC_GNUC) && (LZO_CC_GNUC >= 0x030400ul)
 
#  define __lzo_constructor     __attribute__((__constructor__,__used__))
 
#elif (LZO_CC_GNUC >= 0x020700ul)
 
#elif defined(LZO_CC_GNUC) && (LZO_CC_GNUC >= 0x020700ul)
 
#  define __lzo_constructor     __attribute__((__constructor__))
 
#elif (LZO_CC_LLVM || LZO_CC_PATHSCALE)
 
#elif defined(LZO_CC_LLVM) || defined(LZO_CC_PATHSCALE)
 
#  define __lzo_constructor     __attribute__((__constructor__))
 
#endif
 
#endif
 
#if defined(__lzo_constructor)
 
#  define __lzo_HAVE_constructor 1
 
#endif
 
#if !defined(__lzo_destructor)
 
#if (LZO_CC_GNUC >= 0x030400ul)
 
#if defined(LZO_CC_GNUC) && (LZO_CC_GNUC >= 0x030400ul)
 
#  define __lzo_destructor      __attribute__((__destructor__,__used__))
 
#elif (LZO_CC_GNUC >= 0x020700ul)
 
#elif defined(LZO_CC_GNUC) && (LZO_CC_GNUC >= 0x020700ul)
 
#  define __lzo_destructor      __attribute__((__destructor__))
 
#elif (LZO_CC_LLVM || LZO_CC_PATHSCALE)
 
#elif defined(LZO_CC_LLVM) || defined(LZO_CC_PATHSCALE)
 
#  define __lzo_destructor      __attribute__((__destructor__))
 
#endif
 
#endif
 
#if defined(__lzo_destructor)
 
#  define __lzo_HAVE_destructor 1
 
#endif
 
#if defined(__lzo_HAVE_destructor) && !defined(__lzo_HAVE_constructor)
 
#  error "this should not happen"
 
#endif
 
#if !defined(__lzo_inline)
 
#if defined(LZO_CC_TURBOC) && (__TURBOC__ <= 0x0295)
 
#elif defined(__cplusplus)
 
#  define __lzo_inline          inline
 
#elif defined(LZO_CC_BORLANDC) && (__BORLANDC__ >= 0x0550)
 
#  define __lzo_inline          __inline
 
#elif defined(LZO_CC_CILLY) || defined(LZO_CC_GNUC) || defined(LZO_CC_LLVM) || defined(LZO_CC_PATHSCALE) || defined(LZO_CC_PGI)
 
#  define __lzo_inline          __inline__
 
#elif defined(LZO_CC_DMC)
 
#  define __lzo_inline          __inline
 
#elif defined(LZO_CC_INTELC)
 
#  define __lzo_inline          __inline
 
#elif defined(LZO_CC_MWERKS) && (__MWERKS__ >= 0x2405)
 
#  define __lzo_inline          __inline
 
#elif defined(LZO_CC_MSC) && (_MSC_VER >= 900)
 
#  define __lzo_inline          __inline
 
#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
 
#  define __lzo_inline          inline
 
#endif
 
#endif
 
#if defined(__lzo_inline)
 
#  define __lzo_HAVE_inline 1
 
#else
 
#  define __lzo_inline
 
#endif
 
#if !defined(__lzo_forceinline)
 
#if (LZO_CC_GNUC >= 0x030200ul)
 
#if defined(LZO_CC_GNUC) && (LZO_CC_GNUC >= 0x030200ul)
 
#  define __lzo_forceinline     __inline__ __attribute__((__always_inline__))
 
#elif defined(LZO_CC_INTELC) && (__INTEL_COMPILER >= 450) && defined(LZO_CC_SYNTAX_MSC)
 
#  define __lzo_forceinline     __forceinline
 
#elif defined(LZO_CC_INTELC) && (__INTEL_COMPILER >= 800) && defined(LZO_CC_SYNTAX_GNUC)
 
#  define __lzo_forceinline     __inline__ __attribute__((__always_inline__))
 
#elif defined(LZO_CC_LLVM) || defined(LZO_CC_PATHSCALE)
 
#  define __lzo_forceinline     __inline__ __attribute__((__always_inline__))
 
#elif defined(LZO_CC_MSC) && (_MSC_VER >= 1200)
 
#  define __lzo_forceinline     __forceinline
 
#endif
 
#endif
 
#if defined(__lzo_forceinline)
 
#  define __lzo_HAVE_forceinline 1
 
#else
 
#  define __lzo_forceinline
 
#endif
 
#if !defined(__lzo_noinline)
 
#if 1 && defined(LZO_ARCH_I386) && (LZO_CC_GNUC >= 0x040000ul) && (LZO_CC_GNUC < 0x040003ul)
 
#  define __lzo_noinline        __attribute__((__noinline__,__used__))
 
#elif (LZO_CC_GNUC >= 0x030200ul)
 
#elif defined(LZO_CC_GNUC) && (LZO_CC_GNUC >= 0x030200ul)
 
#  define __lzo_noinline        __attribute__((__noinline__))
 
#elif defined(LZO_CC_INTELC) && (__INTEL_COMPILER >= 600) && defined(LZO_CC_SYNTAX_MSC)
 
#  define __lzo_noinline        __declspec(noinline)
 
#elif defined(LZO_CC_INTELC) && (__INTEL_COMPILER >= 800) && defined(LZO_CC_SYNTAX_GNUC)
 
#  define __lzo_noinline        __attribute__((__noinline__))
 
#elif defined(LZO_CC_LLVM) || defined(LZO_CC_PATHSCALE)
 
#  define __lzo_noinline        __attribute__((__noinline__))
 
#elif defined(LZO_CC_MSC) && (_MSC_VER >= 1300)
 
#  define __lzo_noinline        __declspec(noinline)
 
#elif defined(LZO_CC_MWERKS) && (__MWERKS__ >= 0x3200) && (defined(LZO_OS_WIN32) || (defined(LZO_OS_WIN64))
 
#elif defined(LZO_CC_MWERKS) && (__MWERKS__ >= 0x3200) && (defined(LZO_OS_WIN32) || (defined(LZO_OS_WIN64)))
 
#  if defined(__cplusplus)
 
#  else
 
#    define __lzo_noinline      __declspec(noinline)
 
#  endif
 
#endif
 
#endif
 
#if defined(__lzo_noinline)
 
#  define __lzo_HAVE_noinline 1
 
#else
 
#  define __lzo_noinline
 
#endif
 
#if (defined(__lzo_HAVE_forceinline) || defined(__lzo_HAVE_noinline)) && !defined(__lzo_HAVE_inline)
 
#  error "this should not happen"
 
#endif
 
#if !defined(__lzo_noreturn)
 
#if (LZO_CC_GNUC >= 0x020700ul)
 
#if defined(LZO_CC_GNUC) && (LZO_CC_GNUC >= 0x020700ul)
 
#  define __lzo_noreturn        __attribute__((__noreturn__))
 
#elif defined(LZO_CC_INTELC) && (__INTEL_COMPILER >= 450) && defined(LZO_CC_SYNTAX_MSC)
 
#  define __lzo_noreturn        __declspec(noreturn)
 
#elif defined(LZO_CC_INTELC) && (__INTEL_COMPILER >= 600) && defined(LZO_CC_SYNTAX_GNUC)
 
#  define __lzo_noreturn        __attribute__((__noreturn__))
 
#elif defined(LZO_CC_LLVM) || defined(LZO_CC_PATHSCALE)
 
#  define __lzo_noreturn        __attribute__((__noreturn__))
 
#elif defined(LZO_CC_MSC) && (_MSC_VER >= 1200)
 
#  define __lzo_noreturn        __declspec(noreturn)
 
#endif
 
#endif
 
#if defined(__lzo_noreturn)
 
#  define __lzo_HAVE_noreturn 1
 
#else
 
#  define __lzo_noreturn
 
#endif
 
#if !defined(__lzo_nothrow)
 
#if (LZO_CC_GNUC >= 0x030300ul)
 
#if defined(LZO_CC_GNUC) && (LZO_CC_GNUC >= 0x030300ul)
 
#  define __lzo_nothrow         __attribute__((__nothrow__))
 
#elif defined(LZO_CC_INTELC) && (__INTEL_COMPILER >= 450) && defined(LZO_CC_SYNTAX_MSC) && defined(__cplusplus)
 
#  define __lzo_nothrow         __declspec(nothrow)
 
#elif defined(LZO_CC_INTELC) && (__INTEL_COMPILER >= 800) && defined(LZO_CC_SYNTAX_GNUC)
 
#  define __lzo_nothrow         __attribute__((__nothrow__))
 
#elif defined(LZO_CC_LLVM) || defined(LZO_CC_PATHSCALE)
 
#  define __lzo_nothrow         __attribute__((__nothrow__))
 
#elif defined(LZO_CC_MSC) && (_MSC_VER >= 1200) && defined(__cplusplus)
 
#  define __lzo_nothrow         __declspec(nothrow)
 
#endif
 
#endif
 
#if defined(__lzo_nothrow)
 
#  define __lzo_HAVE_nothrow 1
 
#else
 
#  define __lzo_nothrow
 
#endif
 
#if !defined(__lzo_restrict)
 
#if (LZO_CC_GNUC >= 0x030400ul)
 
#if defined(LZO_CC_GNUC) && (LZO_CC_GNUC >= 0x030400ul)
 
#  define __lzo_restrict        __restrict__
 
#elif defined(LZO_CC_INTELC) && (__INTEL_COMPILER >= 600) && defined(LZO_CC_SYNTAX_GNUC)
 
#  define __lzo_restrict        __restrict__
 
#elif defined(LZO_CC_LLVM)
 
#  define __lzo_restrict        __restrict__
 
#elif defined(LZO_CC_MSC) && (_MSC_VER >= 1400)
 
#  define __lzo_restrict        __restrict
 
#endif
 
#endif
 
#if defined(__lzo_restrict)
 
#  define __lzo_HAVE_restrict 1
 
#else
 
#  define __lzo_restrict
 
#endif
 
#if !defined(__lzo_likely) && !defined(__lzo_unlikely)
 
#if (LZO_CC_GNUC >= 0x030200ul)
 
#if defined(LZO_CC_GNUC) && (LZO_CC_GNUC >= 0x030200ul)
 
#  define __lzo_likely(e)       (__builtin_expect(!!(e),1))
 
#  define __lzo_unlikely(e)     (__builtin_expect(!!(e),0))
 
#elif defined(LZO_CC_INTELC) && (__INTEL_COMPILER >= 800)
 
#  define __lzo_likely(e)       (__builtin_expect(!!(e),1))
 
#  define __lzo_unlikely(e)     (__builtin_expect(!!(e),0))
 
#elif defined(LZO_CC_LLVM) || defined(LZO_CC_PATHSCALE)
 
#  define __lzo_likely(e)       (__builtin_expect(!!(e),1))
 
#  define __lzo_unlikely(e)     (__builtin_expect(!!(e),0))
 
#endif
 
#endif
 
#if defined(__lzo_likely)
 
#  define __lzo_HAVE_likely 1
 
#else
 
#  define __lzo_likely(e)       (e)
 
#endif
 
#if defined(__lzo_unlikely)
 
#  define __lzo_HAVE_unlikely 1
 
#else
 
#  define __lzo_unlikely(e)     (e)
 
#endif
 
#if !defined(LZO_UNUSED)
 
#  if defined(LZO_CC_BORLANDC) && (__BORLANDC__ >= 0x0600)
 
#    define LZO_UNUSED(var)         ((void) &var)
 
#  elif defined(LZO_CC_BORLANDC) || defined(LZO_CC_HIGHC) || defined(LZO_CC_NDPC) || defined(LZO_CC_PELLESC) || defined(LZO_CC_TURBOC)
 
#    define LZO_UNUSED(var)         if (&var) ; else
 
#  elif defined(LZO_CC_GNUC) || defined(LZO_CC_LLVM) || defined(LZO_CC_PATHSCALE)
 
#    define LZO_UNUSED(var)         ((void) var)
 
#  elif defined(LZO_CC_MSC) && (_MSC_VER < 900)
 
#    define LZO_UNUSED(var)         if (&var) ; else
 
#  elif defined(LZO_CC_KEILC)
 
#    define LZO_UNUSED(var)         {extern int __lzo_unused[1-2*!(sizeof(var)>0)];}
 
#  elif defined(LZO_CC_PACIFICC)
 
#    define LZO_UNUSED(var)         ((void) sizeof(var))
 
#  elif defined(LZO_CC_WATCOMC) && defined(__cplusplus)
 
#    define LZO_UNUSED(var)         ((void) var)
 
#  else
 
#    define LZO_UNUSED(var)         ((void) &var)
 
#  endif
 
#endif
 
#if !defined(LZO_UNUSED_FUNC)
 
#  if defined(LZO_CC_BORLANDC) && (__BORLANDC__ >= 0x0600)
 
#    define LZO_UNUSED_FUNC(func)   ((void) func)
 
#  elif defined(LZO_CC_BORLANDC) || defined(LZO_CC_NDPC) || defined(LZO_CC_TURBOC)
 
#    define LZO_UNUSED_FUNC(func)   if (func) ; else
 
#  elif defined(LZO_CC_LLVM)
 
#    define LZO_UNUSED_FUNC(func)   ((void) &func)
 
#  elif defined(LZO_CC_MSC) && (_MSC_VER < 900)
 
#    define LZO_UNUSED_FUNC(func)   if (func) ; else
 
#  elif defined(LZO_CC_MSC)
 
#    define LZO_UNUSED_FUNC(func)   ((void) &func)
 
#  elif defined(LZO_CC_KEILC) || defined(LZO_CC_PELLESC)
 
#    define LZO_UNUSED_FUNC(func)   {extern int __lzo_unused[1-2*!(sizeof((int)func)>0)];}
 
#  else
 
#    define LZO_UNUSED_FUNC(func)   ((void) func)
 
#  endif
 
#endif
 
#if !defined(LZO_UNUSED_LABEL)
 
#  if defined(LZO_CC_WATCOMC) && defined(__cplusplus)
 
#    define LZO_UNUSED_LABEL(l)     switch(0) case 1:goto l
 
#  elif defined(LZO_CC_INTELC) || defined(LZO_CC_WATCOMC)
 
#    define LZO_UNUSED_LABEL(l)     if (0) goto l
 
#  else
 
#    define LZO_UNUSED_LABEL(l)     switch(0) case 1:goto l
 
#  endif
 
#endif
 
#if !defined(LZO_DEFINE_UNINITIALIZED_VAR)
 
#  if 0
 
#    define LZO_DEFINE_UNINITIALIZED_VAR(type,var,init)  type var
 
#  elif 0 && defined(LZO_CC_GNUC)
 
#    define LZO_DEFINE_UNINITIALIZED_VAR(type,var,init)  type var = var
 
#  else
 
#    define LZO_DEFINE_UNINITIALIZED_VAR(type,var,init)  type var = init
 
#  endif
 
#endif
 
#if !defined(LZO_COMPILE_TIME_ASSERT_HEADER)
 
#  if defined(LZO_CC_AZTECC) || defined(LZO_CC_ZORTECHC)
 
#    define LZO_COMPILE_TIME_ASSERT_HEADER(e)  extern int __lzo_cta[1-!(e)];
 
#  elif defined(LZO_CC_DMC) || defined(LZO_CC_SYMANTECC)
 
#    define LZO_COMPILE_TIME_ASSERT_HEADER(e)  extern int __lzo_cta[1u-2*!(e)];
 
#  elif defined(LZO_CC_TURBOC) && (__TURBOC__ == 0x0295)
 
#    define LZO_COMPILE_TIME_ASSERT_HEADER(e)  extern int __lzo_cta[1-!(e)];
 
#  else
 
#    define LZO_COMPILE_TIME_ASSERT_HEADER(e)  extern const int __ct_assert__[1 - 2 * !(e)];
 
#  endif
 
#endif
 
#if !defined(LZO_COMPILE_TIME_ASSERT)
 
#  if defined(LZO_CC_AZTECC)
 
#    define LZO_COMPILE_TIME_ASSERT(e)  {typedef int __lzo_cta_t[1-!(e)];}
 
#  elif defined(LZO_CC_DMC) || defined(LZO_CC_PACIFICC) || defined(LZO_CC_SYMANTECC) || defined(LZO_CC_ZORTECHC)
 
#    define LZO_COMPILE_TIME_ASSERT(e)  switch(0) case 1:case !(e):break;
 
#  elif defined(LZO_CC_MSC) && (_MSC_VER < 900)
 
#    define LZO_COMPILE_TIME_ASSERT(e)  switch(0) case 1:case !(e):break;
 
#  elif defined(LZO_CC_TURBOC) && (__TURBOC__ == 0x0295)
 
#    define LZO_COMPILE_TIME_ASSERT(e)  switch(0) case 1:case !(e):break;
 
#  else
 
#    define LZO_COMPILE_TIME_ASSERT(e)  {typedef int __lzo_cta_t[1-2*!(e)];}
 
#  endif
 
#endif
 
#if (defined(LZO_ARCH_I086) || defined(LZO_ARCH_I386)) && (defined(LZO_OS_DOS16) || defined(LZO_OS_DOS32) || defined(LZO_OS_OS2) || defined(LZO_OS_OS216) || defined(LZO_OS_WIN16) || defined(LZO_OS_WIN32 )|| defined(LZO_OS_WIN64))
 
#  if defined(LZO_CC_GNUC) || defined(LZO_CC_HIGHC) || defined(LZO_CC_NDPC) || defined(LZO_CC_PACIFICC)
 
#  elif defined(LZO_CC_DMC) || defined(LZO_CC_SYMANTECC) || defined(LZO_CC_ZORTECHC)
 
#    define __lzo_cdecl                 __cdecl
 
#    define __lzo_cdecl_atexit
 
#    define __lzo_cdecl_main            __cdecl
 
#    if defined(LZO_OS_OS2) && defined(LZO_CC_DMC) || defined(LZO_CC_SYMANTECC))
 
#      define __lzo_cdecl_qsort         __pascal
 
#    elif defined(LZO_OS_OS2) && defined(LZO_CC_ZORTECHC))
 
#      define __lzo_cdecl_qsort         _stdcall
 
#    else
 
#      define __lzo_cdecl_qsort         __cdecl
 
#    endif
 
#  elif defined(LZO_CC_WATCOMC)
 
#    define __lzo_cdecl                 __cdecl
 
#  else
 
#    define __lzo_cdecl                 __cdecl
 
#    define __lzo_cdecl_atexit          __cdecl
 
#    define __lzo_cdecl_main            __cdecl
 
#    define __lzo_cdecl_qsort           __cdecl
 
#  endif
 
#  if defined(LZO_CC_GNUC) || defined(LZO_CC_HIGHC) || defined(LZO_CC_NDPC) || defined(LZO_CC_PACIFICC) || defined(LZO_CC_WATCOMC)
 
#  elif defined(LZO_OS_OS2) && (defined(LZO_CC_DMC) || defined(LZO_CC_SYMANTECC))
 
#    define __lzo_cdecl_sighandler      __pascal
 
#  elif defined(LZO_OS_OS2) && defined(LZO_CC_ZORTECHC)
 
#    define __lzo_cdecl_sighandler      _stdcall
 
#  elif defined(LZO_CC_MSC) && (_MSC_VER >= 1400) && defined(_M_CEE_PURE)
 
#    define __lzo_cdecl_sighandler      __clrcall
 
#  elif defined(LZO_CC_MSC) && (_MSC_VER >= 600 && _MSC_VER < 700)
 
#    if defined(_DLL)
 
#      define __lzo_cdecl_sighandler    _far _cdecl _loadds
 
#    elif defined(_MT)
 
#      define __lzo_cdecl_sighandler    _far _cdecl
 
#    else
 
#      define __lzo_cdecl_sighandler    _cdecl
 
#    endif
 
#  else
 
#    define __lzo_cdecl_sighandler      __cdecl
 
#  endif
 
#elif defined(LZO_ARCH_I386) && defined(LZO_CC_WATCOMC)
 
#  define __lzo_cdecl                   __cdecl
 
#elif defined(LZO_ARCH_M68K) && defined(LZO_OS_TOS) && (defined(LZO_CC_PUREC) || defined(LZO_CC_TURBOC))
 
#  define __lzo_cdecl                   cdecl
 
#endif
 
#if !defined(__lzo_cdecl)
 
#  define __lzo_cdecl
 
#endif
 
#if !defined(__lzo_cdecl_atexit)
 
#  define __lzo_cdecl_atexit
 
#endif
 
#if !defined(__lzo_cdecl_main)
 
#  define __lzo_cdecl_main
 
#endif
 
#if !defined(__lzo_cdecl_qsort)
 
#  define __lzo_cdecl_qsort
 
#endif
 
#if !defined(__lzo_cdecl_sighandler)
 
#  define __lzo_cdecl_sighandler
 
#endif
 
#if !defined(__lzo_cdecl_va)
 
#  define __lzo_cdecl_va                __lzo_cdecl
 
#endif
 
#if !defined(LZO_CFG_NO_WINDOWS_H)
 
#if defined(LZO_OS_CYGWIN) || (defined(LZO_OS_EMX) && defined(__RSXNT__)) || defined(LZO_OS_WIN32) || defined(LZO_OS_WIN64)
 
#  if defined(LZO_CC_WATCOMC) && (__WATCOMC__ < 1000)
 
#  elif defined(LZO_OS_WIN32) && defined(LZO_CC_GNUC) && defined(__PW32__)
 
#  elif ((defined(LZO_OS_CYGWIN) || defined(__MINGW32__)) && (defined(LZO_CC_GNUC) && (LZO_CC_GNUC < 0x025f00ul)))
 
#  else
 
#    define LZO_HAVE_WINDOWS_H 1
 
#  endif
 
#endif
 
#endif
 
#if defined(LZO_ARCH_ALPHA)
 
#  define LZO_OPT_AVOID_UINT_INDEX  1
 
#  define LZO_OPT_AVOID_SHORT       1
 
#  define LZO_OPT_AVOID_USHORT      1
 
#elif defined(LZO_ARCH_AMD64)
 
#  define LZO_OPT_AVOID_INT_INDEX   1
 
#  define LZO_OPT_AVOID_UINT_INDEX  1
 
#  define LZO_OPT_UNALIGNED16       1
 
#  define LZO_OPT_UNALIGNED32       1
 
#  define LZO_OPT_UNALIGNED64       1
 
#elif defined(LZO_ARCH_ARM) && defined(LZO_ARCH_ARM_THUMB)
 
#elif defined(LZO_ARCH_ARM)
 
#  define LZO_OPT_AVOID_SHORT       1
 
#  define LZO_OPT_AVOID_USHORT      1
 
#elif defined(LZO_ARCH_CRIS)
 
#  define LZO_OPT_UNALIGNED16       1
 
#  define LZO_OPT_UNALIGNED32       1
 
#elif defined(LZO_ARCH_I386)
 
#  define LZO_OPT_UNALIGNED16       1
 
#  define LZO_OPT_UNALIGNED32       1
 
#elif defined(LZO_ARCH_IA64)
 
#  define LZO_OPT_AVOID_INT_INDEX   1
src/3rdparty/minilzo/minilzo.c
➞
Show inline comments
 
@@ -1736,385 +1736,385 @@ extern "C" {
 
#    define LZO_OPT_UNALIGNED16     1
 
#    define LZO_OPT_UNALIGNED32     1
 
#  endif
 
#elif defined(LZO_ARCH_S390)
 
#  define LZO_OPT_UNALIGNED16       1
 
#  define LZO_OPT_UNALIGNED32       1
 
#  if (LZO_SIZEOF_SIZE_T == 8)
 
#    define LZO_OPT_UNALIGNED64     1
 
#  endif
 
#elif defined(LZO_ARCH_SH)
 
#  define LZO_OPT_PREFER_POSTINC    1
 
#  define LZO_OPT_PREFER_PREDEC     1
 
#endif
 
#if !defined(LZO_CFG_NO_INLINE_ASM)
 
#if defined(LZO_CC_LLVM)
 
#  define LZO_CFG_NO_INLINE_ASM 1
 
#endif
 
#endif
 
#if !defined(LZO_CFG_NO_UNALIGNED)
 
#if defined(LZO_ABI_NEUTRAL_ENDIAN) || defined(LZO_ARCH_GENERIC)
 
#  define LZO_CFG_NO_UNALIGNED 1
 
#endif
 
#endif
 
#if defined(LZO_CFG_NO_UNALIGNED)
 
#  undef LZO_OPT_UNALIGNED16
 
#  undef LZO_OPT_UNALIGNED32
 
#  undef LZO_OPT_UNALIGNED64
 
#endif
 
#if defined(LZO_CFG_NO_INLINE_ASM)
 
#elif defined(LZO_ARCH_I386) && (defined(LZO_OS_DOS32) || defined(LZO_OS_WIN32)) && (defined(LZO_CC_DMC) || defined(LZO_CC_INTELC) || defined(LZO_CC_MSC) || defined(LZO_CC_PELLESC))
 
#  define LZO_ASM_SYNTAX_MSC 1
 
#elif defined(LZO_OS_WIN64) && (defined(LZO_CC_DMC) || defined(LZO_CC_INTELC) || defined(LZO_CC_MSC) || defined(LZO_CC_PELLESC))
 
#elif defined(LZO_ARCH_I386) && (defined(LZO_CC_GNUC) || defined(LZO_CC_INTELC) || defined(LZO_CC_PATHSCALE))
 
#  define LZO_ASM_SYNTAX_GNUC 1
 
#elif defined(LZO_ARCH_AMD64) && (defined(LZO_CC_GNUC) || defined(LZO_CC_INTELC) || defined(LZO_CC_PATHSCALE))
 
#  define LZO_ASM_SYNTAX_GNUC 1
 
#endif
 
#if defined(LZO_ASM_SYNTAX_GNUC)
 
#if defined(LZO_ARCH_I386) && defined(LZO_CC_GNUC) && (LZO_CC_GNUC < 0x020000ul)
 
#  define __LZO_ASM_CLOBBER         "ax"
 
#elif defined(LZO_CC_INTELC)
 
#  define __LZO_ASM_CLOBBER         "memory"
 
#else
 
#  define __LZO_ASM_CLOBBER         "cc", "memory"
 
#endif
 
#endif
 
#if defined(__LZO_INFOSTR_MM)
 
#elif defined(LZO_MM_FLAT) && (defined(__LZO_INFOSTR_PM) || defined(LZO_INFO_ABI_PM))
 
#  define __LZO_INFOSTR_MM          ""
 
#elif defined(LZO_INFO_MM)
 
#  define __LZO_INFOSTR_MM          "." LZO_INFO_MM
 
#else
 
#  define __LZO_INFOSTR_MM          ""
 
#endif
 
#if defined(__LZO_INFOSTR_PM)
 
#elif defined(LZO_INFO_ABI_PM)
 
#  define __LZO_INFOSTR_PM          "." LZO_INFO_ABI_PM
 
#else
 
#  define __LZO_INFOSTR_PM          ""
 
#endif
 
#if defined(__LZO_INFOSTR_ENDIAN)
 
#elif defined(LZO_INFO_ABI_ENDIAN)
 
#  define __LZO_INFOSTR_ENDIAN      "." LZO_INFO_ABI_ENDIAN
 
#else
 
#  define __LZO_INFOSTR_ENDIAN      ""
 
#endif
 
#if defined(__LZO_INFOSTR_OSNAME)
 
#elif defined(LZO_INFO_OS_CONSOLE)
 
#  define __LZO_INFOSTR_OSNAME      LZO_INFO_OS "." LZO_INFO_OS_CONSOLE
 
#elif defined(LZO_INFO_OS_POSIX)
 
#  define __LZO_INFOSTR_OSNAME      LZO_INFO_OS "." LZO_INFO_OS_POSIX
 
#else
 
#  define __LZO_INFOSTR_OSNAME      LZO_INFO_OS
 
#endif
 
#if defined(__LZO_INFOSTR_LIBC)
 
#elif defined(LZO_INFO_LIBC)
 
#  define __LZO_INFOSTR_LIBC        "." LZO_INFO_LIBC
 
#else
 
#  define __LZO_INFOSTR_LIBC        ""
 
#endif
 
#if defined(__LZO_INFOSTR_CCVER)
 
#elif defined(LZO_INFO_CCVER)
 
#  define __LZO_INFOSTR_CCVER       " " LZO_INFO_CCVER
 
#else
 
#  define __LZO_INFOSTR_CCVER       ""
 
#endif
 
#define LZO_INFO_STRING \
 
    LZO_INFO_ARCH __LZO_INFOSTR_MM __LZO_INFOSTR_PM __LZO_INFOSTR_ENDIAN \
 
    " " __LZO_INFOSTR_OSNAME __LZO_INFOSTR_LIBC " " LZO_INFO_CC __LZO_INFOSTR_CCVER
 

			




	
	
	
		
 
#endif /* already included */

			




	
	
	
		
 

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#undef LZO_HAVE_CONFIG_H

			




	
	
	
		
 
#include "minilzo.h"

			




	
	
	
		
 

			




	
	
	
		
 
#if !defined(MINILZO_VERSION) || (MINILZO_VERSION != 0x2030)

			




	
	
	
		
 
#  error "version mismatch in miniLZO source files"

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#ifdef MINILZO_HAVE_CONFIG_H

			




	
	
	
		
 
#  define LZO_HAVE_CONFIG_H

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef __LZO_CONF_H

			




	
	
	
		
 
#define __LZO_CONF_H

			




	
	
	
		
 

			




	
	
	
		
 
#if !defined(__LZO_IN_MINILZO)

			




	
	
	
		
 
#if defined(LZO_CFG_FREESTANDING)

			




	
	
	
		
 
#  define LZO_LIBC_FREESTANDING 1

			




	
	
	
		
 
#  define LZO_OS_FREESTANDING 1

			




	
	
	
		
 
#  define ACC_LIBC_FREESTANDING 1

			




	
	
	
		
 
#  define ACC_OS_FREESTANDING 1

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if defined(LZO_CFG_NO_UNALIGNED)

			




	
	
	
		
 
#  define ACC_CFG_NO_UNALIGNED 1

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if defined(LZO_ARCH_GENERIC)

			




	
	
	
		
 
#  define ACC_ARCH_GENERIC 1

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if defined(LZO_ABI_NEUTRAL_ENDIAN)

			




	
	
	
		
 
#  define ACC_ABI_NEUTRAL_ENDIAN 1

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if defined(LZO_HAVE_CONFIG_H)

			




	
	
	
		
 
#  define ACC_CONFIG_NO_HEADER 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"

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#if (LZO_VERSION < 0x02000) || !defined(__LZOCONF_H_INCLUDED)

			




	
	
	
		
 
#  error "version mismatch"

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#if defined(LZO_CC_BORLANDC) && defined(LZO_ARCH_I086)

			




	
	
	
		
 
#  pragma option -h

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#if defined(LZO_CC_MSC) && (_MSC_VER >= 1000)

			




	
	
	
		
 
#  pragma warning(disable: 4127 4701)

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if defined(LZO_CC_MSC) && (_MSC_VER >= 1300)

			




	
	
	
		
 
#  pragma warning(disable: 4820)

			




	
	
	
		
 
#  pragma warning(disable: 4514 4710 4711)

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#if defined(LZO_CC_SUNPROC)

			




	
	
	
		
 
#  pragma error_messages(off,E_END_OF_LOOP_CODE_NOT_REACHED)

			




	
	
	
		
 
#  pragma error_messages(off,E_LOOP_NOT_ENTERED_AT_TOP)

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#if defined(__LZO_MMODEL_HUGE) && (!LZO_HAVE_MM_HUGE_PTR)

			




	
	
	
		
 
#  error "this should not happen - check defines for __huge"

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#if defined(__LZO_IN_MINILZO) || defined(LZO_CFG_FREESTANDING)

			




	
	
	
		
 
#elif defined(LZO_OS_DOS16) || defined(LZO_OS_OS216) || defined(LZO_OS_WIN16)

			




	
	
	
		
 
#  define ACC_WANT_ACC_INCD_H 1

			




	
	
	
		
 
#  define ACC_WANT_ACC_INCE_H 1

			




	
	
	
		
 
#  define ACC_WANT_ACC_INCI_H 1

			




	
	
	
		
 
#elif 1

			




	
	
	
		
 
#  include <string.h>

			




	
	
	
		
 
#else

			




	
	
	
		
 
#  define ACC_WANT_ACC_INCD_H 1

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#if defined(LZO_ARCH_I086)

			




	
	
	
		
 
#  define ACC_MM_AHSHIFT        LZO_MM_AHSHIFT

			




	
	
	
		
 
#  define ACC_PTR_FP_OFF(x)     (((const unsigned __far*)&(x))[0])

			




	
	
	
		
 
#  define ACC_PTR_FP_SEG(x)     (((const unsigned __far*)&(x))[1])

			




	
	
	
		
 
#  define ACC_PTR_MK_FP(s,o)    ((void __far*)(((unsigned long)(s)<<16)+(unsigned)(o)))

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#if !defined(lzo_uintptr_t)

			




	
	
	
		
 
#  if defined(__LZO_MMODEL_HUGE)

			




	
	
	
		
 
#    define lzo_uintptr_t       unsigned long

			




	
	
	
		
 
#  elif 1 && defined(LZO_OS_OS400) && (LZO_SIZEOF_VOID_P == 16)

			




	
	
	
		
 
#    define __LZO_UINTPTR_T_IS_POINTER 1

			




	
	
	
		
 
     typedef char*              lzo_uintptr_t;

			




	
	
	
		
 
#    define lzo_uintptr_t       lzo_uintptr_t

			




	
	
	
		
 
#  elif (LZO_SIZEOF_SIZE_T == LZO_SIZEOF_VOID_P)

			




	
	
	
		
 
#    define lzo_uintptr_t       size_t

			




	
	
	
		
 
#  elif (LZO_SIZEOF_LONG == LZO_SIZEOF_VOID_P)

			




	
	
	
		
 
#    define lzo_uintptr_t       unsigned long

			




	
	
	
		
 
#  elif (LZO_SIZEOF_INT == LZO_SIZEOF_VOID_P)

			




	
	
	
		
 
#    define lzo_uintptr_t       unsigned int

			




	
	
	
		
 
#  elif (LZO_SIZEOF_LONG_LONG == LZO_SIZEOF_VOID_P)

			




	
	
	
		
 
#  elif defined(LZO_SIZEOF_LONG_LONG) && (LZO_SIZEOF_LONG_LONG == LZO_SIZEOF_VOID_P)

			




	
	
	
		
 
#    define lzo_uintptr_t       unsigned long long

			




	
	
	
		
 
#  else

			




	
	
	
		
 
#    define lzo_uintptr_t       size_t

			




	
	
	
		
 
#  endif

			




	
	
	
		
 
#endif

			




	
	
	
		
 
//LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uintptr_t) >= sizeof(lzo_voidp))

			




	
	
	
		
 

			




	
	
	
		
 
#if 1 && !defined(LZO_CFG_FREESTANDING)

			




	
	
	
		
 
#if 1 && !defined(HAVE_STRING_H)

			




	
	
	
		
 
#define HAVE_STRING_H 1

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if 1 && !defined(HAVE_MEMCMP)

			




	
	
	
		
 
#define HAVE_MEMCMP 1

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if 1 && !defined(HAVE_MEMCPY)

			




	
	
	
		
 
#define HAVE_MEMCPY 1

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if 1 && !defined(HAVE_MEMMOVE)

			




	
	
	
		
 
#define HAVE_MEMMOVE 1

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if 1 && !defined(HAVE_MEMSET)

			




	
	
	
		
 
#define HAVE_MEMSET 1

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#if 1 && defined(HAVE_STRING_H)

			




	
	
	
		
 
#include <string.h>

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#if defined(LZO_CFG_FREESTANDING)

			




	
	
	
		
 
#  undef HAVE_MEMCMP

			




	
	
	
		
 
#  undef HAVE_MEMCPY

			




	
	
	
		
 
#  undef HAVE_MEMMOVE

			




	
	
	
		
 
#  undef HAVE_MEMSET

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#if !defined(HAVE_MEMCMP)

			




	
	
	
		
 
#  undef memcmp

			




	
	
	
		
 
#  define memcmp(a,b,c)         lzo_memcmp(a,b,c)

			




	
	
	
		
 
#elif !defined(__LZO_MMODEL_HUGE)

			




	
	
	
		
 
#  define lzo_memcmp(a,b,c)     memcmp(a,b,c)

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if !defined(HAVE_MEMCPY)

			




	
	
	
		
 
#  undef memcpy

			




	
	
	
		
 
#  define memcpy(a,b,c)         lzo_memcpy(a,b,c)

			




	
	
	
		
 
#elif !defined(__LZO_MMODEL_HUGE)

			




	
	
	
		
 
#  define lzo_memcpy(a,b,c)     memcpy(a,b,c)

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if !defined(HAVE_MEMMOVE)

			




	
	
	
		
 
#  undef memmove

			




	
	
	
		
 
#  define memmove(a,b,c)        lzo_memmove(a,b,c)

			




	
	
	
		
 
#elif !defined(__LZO_MMODEL_HUGE)

			




	
	
	
		
 
#  define lzo_memmove(a,b,c)    memmove(a,b,c)

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if !defined(HAVE_MEMSET)

			




	
	
	
		
 
#  undef memset

			




	
	
	
		
 
#  define memset(a,b,c)         lzo_memset(a,b,c)

			




	
	
	
		
 
#elif !defined(__LZO_MMODEL_HUGE)

			




	
	
	
		
 
#  define lzo_memset(a,b,c)     memset(a,b,c)

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#undef NDEBUG

			




	
	
	
		
 
#if defined(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 !defined(__lzo_inline)

			




	
	
	
		
 
#  define __lzo_inline

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if !defined(__lzo_forceinline)

			




	
	
	
		
 
#  define __lzo_forceinline

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if !defined(__lzo_noinline)

			




	
	
	
		
 
#  define __lzo_noinline

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




	
	
	
		
 
#define LZO_SIZE(bits)      (1u << (bits))

			




	
	
	
		
 
#define LZO_MASK(bits)      (LZO_SIZE(bits) - 1)

			




	
	
	
		
 

			




	
	
	
		
 
#define LZO_LSIZE(bits)     (1ul << (bits))

			




	
	
	
		
 
#define LZO_LMASK(bits)     (LZO_LSIZE(bits) - 1)

			




	
	
	
		
 

			




	
	
	
		
 
#define LZO_USIZE(bits)     ((lzo_uint) 1 << (bits))

			




	
	
	
		
 
#define LZO_UMASK(bits)     (LZO_USIZE(bits) - 1)

			




	
	
	
		
 

			




	
	
	
		
 
#if !defined(DMUL)

			




	
	
	
		
 
#if 0

			




	
	
	
		
 

			




	
	
	
		
 
#  define DMUL(a,b) ((lzo_xint) ((lzo_uint32)(a) * (lzo_uint32)(b)))

			




	
	
	
		
 
#else

			




	
	
	
		
 
#  define DMUL(a,b) ((lzo_xint) ((a) * (b)))

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#if 1 && !defined(LZO_CFG_NO_UNALIGNED)

			




	
	
	
		
 
#if 1 && defined(LZO_ARCH_AMD64) || defined(LZO_ARCH_I386)

			




	
	
	
		
 
#  if (LZO_SIZEOF_SHORT == 2)

			




	
	
	
		
 
#    define LZO_UNALIGNED_OK_2

			




	
	
	
		
 
#  endif

			




	
	
	
		
 
#  if (LZO_SIZEOF_INT == 4)

			




	
	
	
		
 
#    define LZO_UNALIGNED_OK_4

			




	
	
	
		
 
#  endif

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#if defined(LZO_UNALIGNED_OK_2)

			




	
	
	
		
 
//  LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(short) == 2)

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if defined(LZO_UNALIGNED_OK_4)

			




	
	
	
		
 
//  LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint32) == 4)

			




	
	
	
		
 
#elif defined(LZO_ALIGNED_OK_4)

			




	
	
	
		
 
//  LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint32) == 4)

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#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_C int __lzo_init_done;

			




	
	
	
		
 
__LZO_EXTERN_C const char __lzo_copyright[];

			




	
	
	
		
 
LZO_EXTERN(const lzo_bytep) lzo_copyright(void);

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef __LZO_PTR_H

			




	
	
	
		
 
#define __LZO_PTR_H

			




	
	
	
		
 

			




	
	
	
		
 
#ifdef __cplusplus

			




	
	
	
		
 
extern "C" {

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#if !defined(lzo_uintptr_t)

			




	
	
	
		
 
#  if defined(__LZO_MMODEL_HUGE)

			




	
	
	
		
 
#    define lzo_uintptr_t   unsigned long

			




	
	
	
		
 
#  else

			




	
	
	
		
 
#    define lzo_uintptr_t   acc_uintptr_t

			




	
	
	
		
 
#    ifdef __ACC_INTPTR_T_IS_POINTER

			




	
	
	
		
 
#      define __LZO_UINTPTR_T_IS_POINTER 1

			




	
	
	
		
 
#    endif

			




	
	
	
		
 
#  endif

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#if defined(LZO_ARCH_I086)

			




	
	
	
		
 
#define PTR(a)              ((lzo_bytep) (a))

			




	
	
	
		
 
#define PTR_ALIGNED_4(a)    ((ACC_PTR_FP_OFF(a) & 3) == 0)

			




	
	
	
		
 
#define PTR_ALIGNED2_4(a,b) (((ACC_PTR_FP_OFF(a) | ACC_PTR_FP_OFF(b)) & 3) == 0)

			




	
	
	
		
 
#elif defined(LZO_MM_PVP)

			




	
	
	
		
 
#define PTR(a)              ((lzo_bytep) (a))

			




	
	
	
		
 
#define PTR_ALIGNED_8(a)    ((((lzo_uintptr_t)(a)) >> 61) == 0)

			




	
	
	
		
 
#define PTR_ALIGNED2_8(a,b) ((((lzo_uintptr_t)(a)|(lzo_uintptr_t)(b)) >> 61) == 0)

			




	
	
	
		
 
#else

			




	
	
	
		
 
#define PTR(a)              ((lzo_uintptr_t) (a))

			




	
	
	
		
 
#define PTR_LINEAR(a)       PTR(a)

			




	
	
	
		
 
#define PTR_ALIGNED_4(a)    ((PTR_LINEAR(a) & 3) == 0)

			




	
	
	
		
 
#define PTR_ALIGNED_8(a)    ((PTR_LINEAR(a) & 7) == 0)

			




	
	
	
		
 
#define PTR_ALIGNED2_4(a,b) (((PTR_LINEAR(a) | PTR_LINEAR(b)) & 3) == 0)

			




	
	
	
		
 
#define PTR_ALIGNED2_8(a,b) (((PTR_LINEAR(a) | PTR_LINEAR(b)) & 7) == 0)

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
		
 
@@ -2292,385 +2292,385 @@ lzo_adler32(lzo_uint32 adler, const lzo_

			




	
	
	
		
 
    unsigned k;

			




	
	
	
		
 

			




	
	
	
		
 
    if (buf == NULL)

			




	
	
	
		
 
        return 1;

			




	
	
	
		
 

			




	
	
	
		
 
    while (len > 0)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        k = len < LZO_NMAX ? (unsigned) len : LZO_NMAX;

			




	
	
	
		
 
        len -= k;

			




	
	
	
		
 
        if (k >= 16) do

			




	
	
	
		
 
        {

			




	
	
	
		
 
            LZO_DO16(buf,0);

			




	
	
	
		
 
            buf += 16;

			




	
	
	
		
 
            k -= 16;

			




	
	
	
		
 
        } while (k >= 16);

			




	
	
	
		
 
        if (k != 0) do

			




	
	
	
		
 
        {

			




	
	
	
		
 
            s1 += *buf++;

			




	
	
	
		
 
            s2 += s1;

			




	
	
	
		
 
        } while (--k > 0);

			




	
	
	
		
 
        s1 %= LZO_BASE;

			




	
	
	
		
 
        s2 %= LZO_BASE;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    return (s2 << 16) | s1;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#undef LZO_DO1

			




	
	
	
		
 
#undef LZO_DO2

			




	
	
	
		
 
#undef LZO_DO4

			




	
	
	
		
 
#undef LZO_DO8

			




	
	
	
		
 
#undef LZO_DO16

			




	
	
	
		
 

			




	
	
	
		
 
#if !defined(MINILZO_CFG_SKIP_LZO_STRING)

			




	
	
	
		
 
#undef lzo_memcmp

			




	
	
	
		
 
#undef lzo_memcpy

			




	
	
	
		
 
#undef lzo_memmove

			




	
	
	
		
 
#undef lzo_memset

			




	
	
	
		
 
#if !defined(__LZO_MMODEL_HUGE)

			




	
	
	
		
 
#  undef LZO_HAVE_MM_HUGE_PTR

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#define lzo_hsize_t             lzo_uint

			




	
	
	
		
 
#define lzo_hvoid_p             lzo_voidp

			




	
	
	
		
 
#define lzo_hbyte_p             lzo_bytep

			




	
	
	
		
 
#define LZOLIB_PUBLIC(r,f)      LZO_PUBLIC(r) f

			




	
	
	
		
 
#define lzo_hmemcmp             lzo_memcmp

			




	
	
	
		
 
#define lzo_hmemcpy             lzo_memcpy

			




	
	
	
		
 
#define lzo_hmemmove            lzo_memmove

			




	
	
	
		
 
#define lzo_hmemset             lzo_memset

			




	
	
	
		
 
#define __LZOLIB_HMEMCPY_CH_INCLUDED 1

			




	
	
	
		
 
#if !defined(LZOLIB_PUBLIC)

			




	
	
	
		
 
#  define LZOLIB_PUBLIC(r,f)    r __LZOLIB_FUNCNAME(f)

			




	
	
	
		
 
#endif

			




	
	
	
		
 
LZOLIB_PUBLIC(int, lzo_hmemcmp) (const lzo_hvoid_p s1, const lzo_hvoid_p s2, lzo_hsize_t len)

			




	
	
	
		
 
{

			




	
	
	
		
 
#if defined(LZO_HAVE_MM_HUGE_PTR) || !defined(HAVE_MEMCMP)

			




	
	
	
		
 
    const lzo_hbyte_p p1 = (const lzo_hbyte_p) s1;

			




	
	
	
		
 
    const lzo_hbyte_p p2 = (const lzo_hbyte_p) s2;

			




	
	
	
		
 
    if __lzo_likely(len > 0) do

			




	
	
	
		
 
    {

			




	
	
	
		
 
        int d = *p1 - *p2;

			




	
	
	
		
 
        if (d != 0)

			




	
	
	
		
 
            return d;

			




	
	
	
		
 
        p1++; p2++;

			




	
	
	
		
 
    } while __lzo_likely(--len > 0);

			




	
	
	
		
 
    return 0;

			




	
	
	
		
 
#else

			




	
	
	
		
 
    return memcmp(s1, s2, len);

			




	
	
	
		
 
#endif

			




	
	
	
		
 
}

			




	
	
	
		
 
LZOLIB_PUBLIC(lzo_hvoid_p, lzo_hmemcpy) (lzo_hvoid_p dest, const lzo_hvoid_p src, lzo_hsize_t len)

			




	
	
	
		
 
{

			




	
	
	
		
 
#if defined(LZO_HAVE_MM_HUGE_PTR) || !defined(HAVE_MEMCPY)

			




	
	
	
		
 
    lzo_hbyte_p p1 = (lzo_hbyte_p) dest;

			




	
	
	
		
 
    const lzo_hbyte_p p2 = (const lzo_hbyte_p) src;

			




	
	
	
		
 
    if (!(len > 0) || p1 == p2)

			




	
	
	
		
 
        return dest;

			




	
	
	
		
 
    do

			




	
	
	
		
 
        *p1++ = *p2++;

			




	
	
	
		
 
    while __lzo_likely(--len > 0);

			




	
	
	
		
 
    return dest;

			




	
	
	
		
 
#else

			




	
	
	
		
 
    return memcpy(dest, src, len);

			




	
	
	
		
 
#endif

			




	
	
	
		
 
}

			




	
	
	
		
 
LZOLIB_PUBLIC(lzo_hvoid_p, lzo_hmemmove) (lzo_hvoid_p dest, const lzo_hvoid_p src, lzo_hsize_t len)

			




	
	
	
		
 
{

			




	
	
	
		
 
#if defined(LZO_HAVE_MM_HUGE_PTR) || !defined(HAVE_MEMMOVE)

			




	
	
	
		
 
    lzo_hbyte_p p1 = (lzo_hbyte_p) dest;

			




	
	
	
		
 
    const lzo_hbyte_p p2 = (const lzo_hbyte_p) src;

			




	
	
	
		
 
    if (!(len > 0) || p1 == p2)

			




	
	
	
		
 
        return dest;

			




	
	
	
		
 
    if (p1 < p2)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        do

			




	
	
	
		
 
            *p1++ = *p2++;

			




	
	
	
		
 
        while __lzo_likely(--len > 0);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        p1 += len;

			




	
	
	
		
 
        p2 += len;

			




	
	
	
		
 
        do

			




	
	
	
		
 
            *--p1 = *--p2;

			




	
	
	
		
 
        while __lzo_likely(--len > 0);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    return dest;

			




	
	
	
		
 
#else

			




	
	
	
		
 
    return memmove(dest, src, len);

			




	
	
	
		
 
#endif

			




	
	
	
		
 
}

			




	
	
	
		
 
LZOLIB_PUBLIC(lzo_hvoid_p, lzo_hmemset) (lzo_hvoid_p s, int c, lzo_hsize_t len)

			




	
	
	
		
 
{

			




	
	
	
		
 
#if defined(LZO_HAVE_MM_HUGE_PTR) || !defined(HAVE_MEMSET)

			




	
	
	
		
 
    lzo_hbyte_p p = (lzo_hbyte_p) s;

			




	
	
	
		
 
    if __lzo_likely(len > 0) do

			




	
	
	
		
 
        *p++ = (unsigned char) c;

			




	
	
	
		
 
    while __lzo_likely(--len > 0);

			




	
	
	
		
 
    return s;

			




	
	
	
		
 
#else

			




	
	
	
		
 
    return memset(s, c, len);

			




	
	
	
		
 
#endif

			




	
	
	
		
 
}

			




	
	
	
		
 
#undef LZOLIB_PUBLIC

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#if !defined(__LZO_IN_MINILZO)

			




	
	
	
		
 

			




	
	
	
		
 
#define ACC_WANT_ACC_CHK_CH 1

			




	
	
	
		
 
#undef ACCCHK_ASSERT

			




	
	
	
		
 

			




	
	
	
		
 
    ACCCHK_ASSERT_IS_SIGNED_T(lzo_int)

			




	
	
	
		
 
    ACCCHK_ASSERT_IS_UNSIGNED_T(lzo_uint)

			




	
	
	
		
 

			




	
	
	
		
 
    ACCCHK_ASSERT_IS_SIGNED_T(lzo_int32)

			




	
	
	
		
 
    ACCCHK_ASSERT_IS_UNSIGNED_T(lzo_uint32)

			




	
	
	
		
 
    ACCCHK_ASSERT((LZO_UINT32_C(1) << (int)(8*sizeof(LZO_UINT32_C(1))-1)) > 0)

			




	
	
	
		
 
    ACCCHK_ASSERT(sizeof(lzo_uint32) >= 4)

			




	
	
	
		
 

			




	
	
	
		
 
#if !defined(__LZO_UINTPTR_T_IS_POINTER)

			




	
	
	
		
 
    ACCCHK_ASSERT_IS_UNSIGNED_T(lzo_uintptr_t)

			




	
	
	
		
 
#endif

			




	
	
	
		
 
    ACCCHK_ASSERT(sizeof(lzo_uintptr_t) >= sizeof(lzo_voidp))

			




	
	
	
		
 

			




	
	
	
		
 
    ACCCHK_ASSERT_IS_UNSIGNED_T(lzo_xint)

			




	
	
	
		
 
    ACCCHK_ASSERT(sizeof(lzo_xint) >= sizeof(lzo_uint32))

			




	
	
	
		
 
    ACCCHK_ASSERT(sizeof(lzo_xint) >= sizeof(lzo_uint))

			




	
	
	
		
 
    ACCCHK_ASSERT(sizeof(lzo_xint) == sizeof(lzo_uint32) || sizeof(lzo_xint) == sizeof(lzo_uint))

			




	
	
	
		
 

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#undef ACCCHK_ASSERT

			




	
	
	
		
 

			




	
	
	
		
 
LZO_PUBLIC(int)

			




	
	
	
		
 
_lzo_config_check(void)

			




	
	
	
		
 
{

			




	
	
	
		
 
    lzo_bool r = 1;

			




	
	
	
		
 
    union { unsigned char c[2*sizeof(lzo_xint)]; lzo_xint l[2]; } u;

			




	
	
	
		
 
    lzo_uintptr_t p;

			




	
	
	
		
 

			




	
	
	
		
 
#if !defined(LZO_CFG_NO_CONFIG_CHECK)

			




	
	
	
		
 
#if defined(LZO_ABI_BIG_ENDIAN)

			




	
	
	
		
 
    u.l[0] = u.l[1] = 0; u.c[sizeof(lzo_xint) - 1] = 128;

			




	
	
	
		
 
    r &= (u.l[0] == 128);

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if defined(LZO_ABI_LITTLE_ENDIAN)

			




	
	
	
		
 
    u.l[0] = u.l[1] = 0; u.c[0] = 128;

			




	
	
	
		
 
    r &= (u.l[0] == 128);

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if defined(LZO_UNALIGNED_OK_2)

			




	
	
	
		
 
    p = (lzo_uintptr_t) (const lzo_voidp) &u.c[0];

			




	
	
	
		
 
    u.l[0] = u.l[1] = 0;

			




	
	
	
		
 
    r &= ((* (const lzo_ushortp) (p+1)) == 0);

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if defined(LZO_UNALIGNED_OK_4)

			




	
	
	
		
 
    p = (lzo_uintptr_t) (const lzo_voidp) &u.c[0];

			




	
	
	
		
 
    u.l[0] = u.l[1] = 0;

			




	
	
	
		
 
    r &= ((* (const lzo_uint32p) (p+1)) == 0);

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
    LZO_UNUSED(u); LZO_UNUSED(p);

			




	
	
	
		
 
    return r == 1 ? LZO_E_OK : LZO_E_ERROR;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
int __lzo_init_done = 0;

			




	
	
	
		
 

			




	
	
	
		
 
LZO_PUBLIC(int)

			




	
	
	
		
 
__lzo_init_v2(unsigned v, int s1, int s2, int s3, int s4, int s5,

			




	
	
	
		
 
                          int s6, int s7, int s8, int s9)

			




	
	
	
		
 
{

			




	
	
	
		
 
    int r;

			




	
	
	
		
 

			




	
	
	
		
 
#if defined(__LZO_IN_MINILZO)

			




	
	
	
		
 
#elif (LZO_CC_MSC && ((_MSC_VER) < 700))

			




	
	
	
		
 
#elif defined(LZO_CC_MSC) && ((_MSC_VER) < 700)

			




	
	
	
		
 
#else

			




	
	
	
		
 
#define ACC_WANT_ACC_CHK_CH 1

			




	
	
	
		
 
#undef ACCCHK_ASSERT

			




	
	
	
		
 
#define ACCCHK_ASSERT(expr)  LZO_COMPILE_TIME_ASSERT(expr)

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#undef ACCCHK_ASSERT

			




	
	
	
		
 

			




	
	
	
		
 
    __lzo_init_done = 1;

			




	
	
	
		
 

			




	
	
	
		
 
    if (v == 0)

			




	
	
	
		
 
        return LZO_E_ERROR;

			




	
	
	
		
 

			




	
	
	
		
 
    r = (s1 == -1 || s1 == (int) sizeof(short)) &&

			




	
	
	
		
 
        (s2 == -1 || s2 == (int) sizeof(int)) &&

			




	
	
	
		
 
        (s3 == -1 || s3 == (int) sizeof(long)) &&

			




	
	
	
		
 
        (s4 == -1 || s4 == (int) sizeof(lzo_uint32)) &&

			




	
	
	
		
 
        (s5 == -1 || s5 == (int) sizeof(lzo_uint)) &&

			




	
	
	
		
 
        (s6 == -1 || s6 == (int) lzo_sizeof_dict_t) &&

			




	
	
	
		
 
        (s7 == -1 || s7 == (int) sizeof(char *)) &&

			




	
	
	
		
 
        (s8 == -1 || s8 == (int) sizeof(lzo_voidp)) &&

			




	
	
	
		
 
        (s9 == -1 || s9 == (int) sizeof(lzo_callback_t));

			




	
	
	
		
 
    if (!r)

			




	
	
	
		
 
        return LZO_E_ERROR;

			




	
	
	
		
 

			




	
	
	
		
 
    r = _lzo_config_check();

			




	
	
	
		
 
    if (r != LZO_E_OK)

			




	
	
	
		
 
        return r;

			




	
	
	
		
 

			




	
	
	
		
 
    return r;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#if !defined(__LZO_IN_MINILZO)

			




	
	
	
		
 

			




	
	
	
		
 
#if (LZO_OS_WIN16 && LZO_CC_WATCOMC) && defined(__SW_BD)

			




	
	
	
		
 

			




	
	
	
		
 
#if 0

			




	
	
	
		
 
BOOL FAR PASCAL LibMain ( HANDLE hInstance, WORD wDataSegment,

			




	
	
	
		
 
                          WORD wHeapSize, LPSTR lpszCmdLine )

			




	
	
	
		
 
#else

			




	
	
	
		
 
int __far __pascal LibMain ( int a, short b, short c, long d )

			




	
	
	
		
 
#endif

			




	
	
	
		
 
{

			




	
	
	
		
 
    LZO_UNUSED(a); LZO_UNUSED(b); LZO_UNUSED(c); LZO_UNUSED(d);

			




	
	
	
		
 
    return 1;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#define do_compress         _lzo1x_1_do_compress

			




	
	
	
		
 

			




	
	
	
		
 
#if !defined(MINILZO_CFG_SKIP_LZO1X_1_COMPRESS)

			




	
	
	
		
 

			




	
	
	
		
 
#define LZO_NEED_DICT_H

			




	
	
	
		
 
#define D_BITS          14

			




	
	
	
		
 
#define D_INDEX1(d,p)       d = DM(DMUL(0x21,DX3(p,5,5,6)) >> 5)

			




	
	
	
		
 
#define D_INDEX2(d,p)       d = (d & (D_MASK & 0x7ff)) ^ (D_HIGH | 0x1f)

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef __LZO_CONFIG1X_H

			




	
	
	
		
 
#define __LZO_CONFIG1X_H

			




	
	
	
		
 

			




	
	
	
		
 
#if !defined(LZO1X) && !defined(LZO1Y) && !defined(LZO1Z)

			




	
	
	
		
 
#  define LZO1X

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#if !defined(__LZO_IN_MINILZO)

			




	
	
	
		
 
#include "lzo/lzo1x.h"

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#define LZO_EOF_CODE

			




	
	
	
		
 
#undef LZO_DETERMINISTIC

			




	
	
	
		
 

			




	
	
	
		
 
#define M1_MAX_OFFSET   0x0400

			




	
	
	
		
 
#ifndef M2_MAX_OFFSET

			




	
	
	
		
 
#define M2_MAX_OFFSET   0x0800

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#define M3_MAX_OFFSET   0x4000

			




	
	
	
		
 
#define M4_MAX_OFFSET   0xbfff

			




	
	
	
		
 

			




	
	
	
		
 
#define MX_MAX_OFFSET   (M1_MAX_OFFSET + M2_MAX_OFFSET)

			




	
	
	
		
 

			




	
	
	
		
 
#define M1_MIN_LEN      2

			




	
	
	
		
 
#define M1_MAX_LEN      2

			




	
	
	
		
 
#define M2_MIN_LEN      3

			




	
	
	
		
 
#ifndef M2_MAX_LEN

			




	
	
	
		
 
#define M2_MAX_LEN      8

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#define M3_MIN_LEN      3

			




	
	
	
		
 
#define M3_MAX_LEN      33

			




	
	
	
		
 
#define M4_MIN_LEN      3

			




	
	
	
		
 
#define M4_MAX_LEN      9

			




	
	
	
		
 

			




	
	
	
		
 
#define M1_MARKER       0

			




	
	
	
		
 
#define M2_MARKER       64

			




	
	
	
		
 
#define M3_MARKER       32

			




	
	
	
		
 
#define M4_MARKER       16

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef MIN_LOOKAHEAD

			




	
	
	
		
 
#define MIN_LOOKAHEAD       (M2_MAX_LEN + 1)

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#if defined(LZO_NEED_DICT_H)

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef LZO_HASH

			




	
	
	
		
 
#define LZO_HASH            LZO_HASH_LZO_INCREMENTAL_B

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#define DL_MIN_LEN          M2_MIN_LEN

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef __LZO_DICT_H

			




	
	
	
		
 
#define __LZO_DICT_H

			




	
	
	
		
 

			




	
	
	
		
 
#ifdef __cplusplus

			




	
	
	
		
 
extern "C" {

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#if !defined(D_BITS) && defined(DBITS)

			




	
	
	
		
 
#  define D_BITS        DBITS

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if !defined(D_BITS)

			




	
	
	
		
 
#  error "D_BITS is not defined"

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if (D_BITS < 16)

			




	
	
	
		
 
#  define D_SIZE        LZO_SIZE(D_BITS)

			




	
	
	
		
 
#  define D_MASK        LZO_MASK(D_BITS)

			




	
	
	
		
 
#else

			




	
	
	
		
 
#  define D_SIZE        LZO_USIZE(D_BITS)

			




	
	
	
		
 
#  define D_MASK        LZO_UMASK(D_BITS)

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#define D_HIGH          ((D_MASK >> 1) + 1)

			




	
	
	
		
 

			




	
	
	
		
 
#if !defined(DD_BITS)

			




	
	
	
		
 
#  define DD_BITS       0

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#define DD_SIZE         LZO_SIZE(DD_BITS)

			




	
	
	
		
 
#define DD_MASK         LZO_MASK(DD_BITS)

			




	
	
	
		
 

			




	
	
	
		
 
#if !defined(DL_BITS)

			




	
	
	
		
 
#  define DL_BITS       (D_BITS - DD_BITS)

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if (DL_BITS < 16)

			




	
	
	
		
 
#  define DL_SIZE       LZO_SIZE(DL_BITS)

			




	
	
	
		
 
#  define DL_MASK       LZO_MASK(DL_BITS)

			




	
	
	
		
 
#else

			




	
	
	
		
 
#  define DL_SIZE       LZO_USIZE(DL_BITS)

			




	
	
	
		
 
#  define DL_MASK       LZO_UMASK(DL_BITS)

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#if (D_BITS != DL_BITS + DD_BITS)

			




	
	
	
		
 
#  error "D_BITS does not match"

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if (D_BITS < 8 || D_BITS > 18)

			




	
	
	
		
 
#  error "invalid D_BITS"

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if (DL_BITS < 8 || DL_BITS > 20)

			




	
	
	
		
 
#  error "invalid DL_BITS"

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if (DD_BITS < 0 || DD_BITS > 6)

			




	
	
	
		
 
#  error "invalid DD_BITS"

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#if !defined(DL_MIN_LEN)

			




	
	
	
		
 
#  define DL_MIN_LEN    3

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#if !defined(DL_SHIFT)

			




	
	
	
		
 
#  define DL_SHIFT      ((DL_BITS + (DL_MIN_LEN - 1)) / DL_MIN_LEN)

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#define LZO_HASH_GZIP                   1

			




	
	
	
		
 
#define LZO_HASH_GZIP_INCREMENTAL       2

			




	
	
	
		
 
#define LZO_HASH_LZO_INCREMENTAL_A      3

			




	
	
	
		
 
#define LZO_HASH_LZO_INCREMENTAL_B      4

			




	
	
	
		
 

			




	
	
	
		
 
#if !defined(LZO_HASH)

			




	
	
	
		
 
#  error "choose a hashing strategy"

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#undef DM

			




	
	
	
		
 
#undef DX

			




	
	
	
		
 

			




	
	
	
		
 
#if (DL_MIN_LEN == 3)

			




	
	
	
		
 
#  define _DV2_A(p,shift1,shift2) \

			




	
	
	
		
 
        (((( (lzo_xint)((p)[0]) << shift1) ^ (p)[1]) << shift2) ^ (p)[2])

			




	
	
	
		
 
#  define _DV2_B(p,shift1,shift2) \

			




	
	
	
		
 
        (((( (lzo_xint)((p)[2]) << shift1) ^ (p)[1]) << shift2) ^ (p)[0])

			




	
	
	
		
 
#  define _DV3_B(p,shift1,shift2,shift3) \

			




	
	
	
		
 
        ((_DV2_B((p)+1,shift1,shift2) << (shift3)) ^ (p)[0])

			




	
	
	
		
 
#elif (DL_MIN_LEN == 2)

			




	
	
	
		
 
#  define _DV2_A(p,shift1,shift2) \

			




	
	
	
		
 
        (( (lzo_xint)(p[0]) << shift1) ^ p[1])

			




	
	
	
		
 
#  define _DV2_B(p,shift1,shift2) \

			




	
	
	
		
 
        (( (lzo_xint)(p[1]) << shift1) ^ p[2])

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: code.theleruby.com-48
    
    
        This site is powered by
            Kallithea,
        which is
        © 2010–2022 by various authors & licensed under GPLv3.
            – Support