1 /* lzoconf.h -- configuration of the LZO data compression library
3 This file is part of the LZO real-time data compression library.
5 Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
8 The LZO library is free software; you can redistribute it and/or
9 modify it under the terms of the GNU General Public License as
10 published by the Free Software Foundation; either version 2 of
11 the License, or (at your option) any later version.
13 The LZO library is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with the LZO library; see the file COPYING.
20 If not, write to the Free Software Foundation, Inc.,
21 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
23 Markus F.X.J. Oberhumer
24 <markus@oberhumer.com>
25 http://www.oberhumer.com/opensource/lzo/
29 #ifndef __LZOCONF_H_INCLUDED
30 #define __LZOCONF_H_INCLUDED 1
32 #define LZO_VERSION 0x20a0 /* 2.10 */
33 #define LZO_VERSION_STRING "2.10"
34 #define LZO_VERSION_DATE "Mar 01 2017"
36 /* internal Autoconf configuration file - only used when building LZO */
37 #if defined(LZO_HAVE_CONFIG_H)
42 #define LZO_CFG_NO_CONFIG_CHECK 1
44 /***********************************************************************
45 // LZO requires a conforming <limits.h>
46 ************************************************************************/
48 #if !defined(CHAR_BIT) || (CHAR_BIT != 8)
49 # error "invalid CHAR_BIT"
51 #if !defined(UCHAR_MAX) || !defined(USHRT_MAX) || !defined(UINT_MAX) || !defined(ULONG_MAX)
52 # error "check your compiler installation"
54 #if (USHRT_MAX < 1) || (UINT_MAX < 1) || (ULONG_MAX < 1)
55 # error "your limits.h macros are broken"
58 /* get OS and architecture defines */
59 #ifndef __LZODEFS_H_INCLUDED
60 #include <lzo/lzodefs.h>
69 /***********************************************************************
71 ************************************************************************/
74 #if !defined(__LZO_CHECKER)
75 # if defined(__BOUNDS_CHECKING_ON)
76 # define __LZO_CHECKER 1
77 # elif defined(__CHECKER__)
78 # define __LZO_CHECKER 1
79 # elif defined(__INSURE__)
80 # define __LZO_CHECKER 1
81 # elif defined(__PURIFY__)
82 # define __LZO_CHECKER 1
87 /***********************************************************************
88 // integral and pointer types
89 ************************************************************************/
91 /* lzo_uint must match size_t */
92 #if !defined(LZO_UINT_MAX)
95 typedef unsigned __int64 lzo_uint
;
96 typedef __int64 lzo_int
;
97 # define LZO_TYPEOF_LZO_INT LZO_TYPEOF___INT64
99 typedef lzo_ullong_t lzo_uint
;
100 typedef lzo_llong_t lzo_int
;
101 # define LZO_TYPEOF_LZO_INT LZO_TYPEOF_LONG_LONG
103 # define LZO_SIZEOF_LZO_INT 8
104 # define LZO_UINT_MAX 0xffffffffffffffffull
105 # define LZO_INT_MAX 9223372036854775807LL
106 # define LZO_INT_MIN (-1LL - LZO_INT_MAX)
107 # elif (LZO_ABI_IP32L64) /* MIPS R5900 */
108 typedef unsigned int lzo_uint
;
110 # define LZO_SIZEOF_LZO_INT LZO_SIZEOF_INT
111 # define LZO_TYPEOF_LZO_INT LZO_TYPEOF_INT
112 # define LZO_UINT_MAX UINT_MAX
113 # define LZO_INT_MAX INT_MAX
114 # define LZO_INT_MIN INT_MIN
115 # elif (ULONG_MAX >= LZO_0xffffffffL)
116 typedef unsigned long lzo_uint
;
117 typedef long lzo_int
;
118 # define LZO_SIZEOF_LZO_INT LZO_SIZEOF_LONG
119 # define LZO_TYPEOF_LZO_INT LZO_TYPEOF_LONG
120 # define LZO_UINT_MAX ULONG_MAX
121 # define LZO_INT_MAX LONG_MAX
122 # define LZO_INT_MIN LONG_MIN
128 /* The larger type of lzo_uint and lzo_uint32_t. */
129 #if (LZO_SIZEOF_LZO_INT >= 4)
130 # define lzo_xint lzo_uint
132 # define lzo_xint lzo_uint32_t
135 typedef int lzo_bool
;
138 LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int
) == LZO_SIZEOF_LZO_INT
)
139 LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint
) == LZO_SIZEOF_LZO_INT
)
140 LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_xint
) >= sizeof(lzo_uint
))
141 LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_xint
) >= sizeof(lzo_uint32_t
))
144 #define __LZO_MMODEL /*empty*/
147 /* no typedef here because of const-pointer issues */
148 #define lzo_bytep unsigned char __LZO_MMODEL *
149 #define lzo_charp char __LZO_MMODEL *
150 #define lzo_voidp void __LZO_MMODEL *
151 #define lzo_shortp short __LZO_MMODEL *
152 #define lzo_ushortp unsigned short __LZO_MMODEL *
153 #define lzo_intp lzo_int __LZO_MMODEL *
154 #define lzo_uintp lzo_uint __LZO_MMODEL *
155 #define lzo_xintp lzo_xint __LZO_MMODEL *
156 #define lzo_voidpp lzo_voidp __LZO_MMODEL *
157 #define lzo_bytepp lzo_bytep __LZO_MMODEL *
159 #define lzo_int8_tp lzo_int8_t __LZO_MMODEL *
160 #define lzo_uint8_tp lzo_uint8_t __LZO_MMODEL *
161 #define lzo_int16_tp lzo_int16_t __LZO_MMODEL *
162 #define lzo_uint16_tp lzo_uint16_t __LZO_MMODEL *
163 #define lzo_int32_tp lzo_int32_t __LZO_MMODEL *
164 #define lzo_uint32_tp lzo_uint32_t __LZO_MMODEL *
165 #if defined(lzo_int64_t)
166 #define lzo_int64_tp lzo_int64_t __LZO_MMODEL *
167 #define lzo_uint64_tp lzo_uint64_t __LZO_MMODEL *
170 /* Older LZO versions used to support ancient systems and memory models
171 * such as 16-bit MSDOS with __huge pointers or Cray PVP, but these
172 * obsolete configurations are not supported any longer.
174 #if defined(__LZO_MMODEL_HUGE)
175 #error "__LZO_MMODEL_HUGE memory model is unsupported"
178 #error "LZO_MM_PVP memory model is unsupported"
180 #if (LZO_SIZEOF_INT < 4)
181 #error "LZO_SIZEOF_INT < 4 is unsupported"
183 #if (__LZO_UINTPTR_T_IS_POINTER)
184 #error "__LZO_UINTPTR_T_IS_POINTER is unsupported"
186 LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(int) >= 4)
187 LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint
) >= 4)
188 /* Strange configurations where sizeof(lzo_uint) != sizeof(size_t) should
189 * work but have not received much testing lately, so be strict here.
191 LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint
) == sizeof(size_t))
192 LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint
) == sizeof(ptrdiff_t))
193 LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint
) == sizeof(lzo_uintptr_t
))
194 LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(void *) == sizeof(lzo_uintptr_t
))
195 LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(char *) == sizeof(lzo_uintptr_t
))
196 LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(long *) == sizeof(lzo_uintptr_t
))
197 LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(void *) == sizeof(lzo_voidp
))
198 LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(char *) == sizeof(lzo_bytep
))
201 /***********************************************************************
203 ************************************************************************/
206 #if !defined(__LZO_EXTERN_C)
208 # define __LZO_EXTERN_C extern "C"
210 # define __LZO_EXTERN_C extern
214 /* calling convention */
215 #if !defined(__LZO_CDECL)
216 # define __LZO_CDECL __lzo_cdecl
219 /* DLL export information */
220 #if !defined(__LZO_EXPORT1)
221 # define __LZO_EXPORT1 /*empty*/
223 #if !defined(__LZO_EXPORT2)
224 # define __LZO_EXPORT2 /*empty*/
227 /* __cdecl calling convention for public C and assembly functions */
228 #if !defined(LZO_PUBLIC)
229 # define LZO_PUBLIC(r) __LZO_EXPORT1 r __LZO_EXPORT2 __LZO_CDECL
231 #if !defined(LZO_EXTERN)
232 # define LZO_EXTERN(r) __LZO_EXTERN_C LZO_PUBLIC(r)
234 #if !defined(LZO_PRIVATE)
235 # define LZO_PRIVATE(r) static r __LZO_CDECL
240 (__LZO_CDECL
*lzo_compress_t
) ( const lzo_bytep src
, lzo_uint src_len
,
241 lzo_bytep dst
, lzo_uintp dst_len
,
245 (__LZO_CDECL
*lzo_decompress_t
) ( const lzo_bytep src
, lzo_uint src_len
,
246 lzo_bytep dst
, lzo_uintp dst_len
,
250 (__LZO_CDECL
*lzo_optimize_t
) ( lzo_bytep src
, lzo_uint src_len
,
251 lzo_bytep dst
, lzo_uintp dst_len
,
255 (__LZO_CDECL
*lzo_compress_dict_t
)(const lzo_bytep src
, lzo_uint src_len
,
256 lzo_bytep dst
, lzo_uintp dst_len
,
258 const lzo_bytep dict
, lzo_uint dict_len
);
261 (__LZO_CDECL
*lzo_decompress_dict_t
)(const lzo_bytep src
, lzo_uint src_len
,
262 lzo_bytep dst
, lzo_uintp dst_len
,
264 const lzo_bytep dict
, lzo_uint dict_len
);
267 /* Callback interface. Currently only the progress indicator ("nprogress")
268 * is used, but this may change in a future release. */
270 struct lzo_callback_t
;
271 typedef struct lzo_callback_t lzo_callback_t
;
272 #define lzo_callback_p lzo_callback_t __LZO_MMODEL *
274 /* malloc & free function types */
275 typedef lzo_voidp (__LZO_CDECL
*lzo_alloc_func_t
)
276 (lzo_callback_p self
, lzo_uint items
, lzo_uint size
);
277 typedef void (__LZO_CDECL
*lzo_free_func_t
)
278 (lzo_callback_p self
, lzo_voidp ptr
);
280 /* a progress indicator callback function */
281 typedef void (__LZO_CDECL
*lzo_progress_func_t
)
282 (lzo_callback_p
, lzo_uint
, lzo_uint
, int);
284 struct lzo_callback_t
286 /* custom allocators (set to 0 to disable) */
287 lzo_alloc_func_t nalloc
; /* [not used right now] */
288 lzo_free_func_t nfree
; /* [not used right now] */
290 /* a progress indicator callback function (set to 0 to disable) */
291 lzo_progress_func_t nprogress
;
293 /* INFO: the first parameter "self" of the nalloc/nfree/nprogress
294 * callbacks points back to this struct, so you are free to store
295 * some extra info in the following variables. */
302 /***********************************************************************
303 // error codes and prototypes
304 ************************************************************************/
306 /* Error codes for the compression/decompression functions. Negative
307 * values are errors, positive values will be used for special but
311 #define LZO_E_ERROR (-1)
312 #define LZO_E_OUT_OF_MEMORY (-2) /* [lzo_alloc_func_t failure] */
313 #define LZO_E_NOT_COMPRESSIBLE (-3) /* [not used right now] */
314 #define LZO_E_INPUT_OVERRUN (-4)
315 #define LZO_E_OUTPUT_OVERRUN (-5)
316 #define LZO_E_LOOKBEHIND_OVERRUN (-6)
317 #define LZO_E_EOF_NOT_FOUND (-7)
318 #define LZO_E_INPUT_NOT_CONSUMED (-8)
319 #define LZO_E_NOT_YET_IMPLEMENTED (-9) /* [not used right now] */
320 #define LZO_E_INVALID_ARGUMENT (-10)
321 #define LZO_E_INVALID_ALIGNMENT (-11) /* pointer argument is not properly aligned */
322 #define LZO_E_OUTPUT_NOT_CONSUMED (-12)
323 #define LZO_E_INTERNAL_ERROR (-99)
326 #ifndef lzo_sizeof_dict_t
327 # define lzo_sizeof_dict_t ((unsigned)sizeof(lzo_bytep))
330 /* lzo_init() should be the first function you call.
331 * Check the return code !
333 * lzo_init() is a macro to allow checking that the library and the
334 * compiler's view of various types are consistent.
336 #define lzo_init() __lzo_init_v2(LZO_VERSION,(int)sizeof(short),(int)sizeof(int),\
337 (int)sizeof(long),(int)sizeof(lzo_uint32_t),(int)sizeof(lzo_uint),\
338 (int)lzo_sizeof_dict_t,(int)sizeof(char *),(int)sizeof(lzo_voidp),\
339 (int)sizeof(lzo_callback_t))
340 LZO_EXTERN(int) __lzo_init_v2(unsigned,int,int,int,int,int,int,int,int,int);
342 /* version functions (useful for shared libraries) */
343 LZO_EXTERN(unsigned) lzo_version(void);
344 LZO_EXTERN(const char *) lzo_version_string(void);
345 LZO_EXTERN(const char *) lzo_version_date(void);
346 LZO_EXTERN(const lzo_charp
) _lzo_version_string(void);
347 LZO_EXTERN(const lzo_charp
) _lzo_version_date(void);
349 /* string functions */
351 lzo_memcmp(const lzo_voidp a
, const lzo_voidp b
, lzo_uint len
);
352 LZO_EXTERN(lzo_voidp
)
353 lzo_memcpy(lzo_voidp dst
, const lzo_voidp src
, lzo_uint len
);
354 LZO_EXTERN(lzo_voidp
)
355 lzo_memmove(lzo_voidp dst
, const lzo_voidp src
, lzo_uint len
);
356 LZO_EXTERN(lzo_voidp
)
357 lzo_memset(lzo_voidp buf
, int c
, lzo_uint len
);
359 /* checksum functions */
360 LZO_EXTERN(lzo_uint32_t
)
361 lzo_adler32(lzo_uint32_t c
, const lzo_bytep buf
, lzo_uint len
);
362 LZO_EXTERN(lzo_uint32_t
)
363 lzo_crc32(lzo_uint32_t c
, const lzo_bytep buf
, lzo_uint len
);
364 LZO_EXTERN(const lzo_uint32_tp
)
365 lzo_get_crc32_table(void);
368 LZO_EXTERN(int) _lzo_config_check(void);
370 lzo_voidp a00
; lzo_bytep a01
; lzo_uint a02
; lzo_xint a03
; lzo_uintptr_t a04
;
371 void *a05
; unsigned char *a06
; unsigned long a07
; size_t a08
; ptrdiff_t a09
;
372 #if defined(lzo_int64_t)
377 /* align a char pointer on a boundary that is a multiple of 'size' */
378 LZO_EXTERN(unsigned) __lzo_align_gap(const lzo_voidp p
, lzo_uint size
);
379 #define LZO_PTR_ALIGN_UP(p,size) \
380 ((p) + (lzo_uint) __lzo_align_gap((const lzo_voidp)(p),(lzo_uint)(size)))
383 /***********************************************************************
384 // deprecated macros - only for backward compatibility
385 ************************************************************************/
387 /* deprecated - use 'lzo_bytep' instead of 'lzo_byte *' */
388 #define lzo_byte unsigned char
389 /* deprecated type names */
390 #define lzo_int32 lzo_int32_t
391 #define lzo_uint32 lzo_uint32_t
392 #define lzo_int32p lzo_int32_t __LZO_MMODEL *
393 #define lzo_uint32p lzo_uint32_t __LZO_MMODEL *
394 #define LZO_INT32_MAX LZO_INT32_C(2147483647)
395 #define LZO_UINT32_MAX LZO_UINT32_C(4294967295)
396 #if defined(lzo_int64_t)
397 #define lzo_int64 lzo_int64_t
398 #define lzo_uint64 lzo_uint64_t
399 #define lzo_int64p lzo_int64_t __LZO_MMODEL *
400 #define lzo_uint64p lzo_uint64_t __LZO_MMODEL *
401 #define LZO_INT64_MAX LZO_INT64_C(9223372036854775807)
402 #define LZO_UINT64_MAX LZO_UINT64_C(18446744073709551615)
404 /* deprecated types */
405 typedef union { lzo_bytep a
; lzo_uint b
; } __lzo_pu_u
;
406 typedef union { lzo_bytep a
; lzo_uint32_t b
; } __lzo_pu32_u
;
407 /* deprecated defines */
408 #if !defined(LZO_SIZEOF_LZO_UINT)
409 # define LZO_SIZEOF_LZO_UINT LZO_SIZEOF_LZO_INT
412 #if defined(LZO_CFG_COMPAT)
414 #define __LZOCONF_H 1
416 #if defined(LZO_ARCH_I086)
417 # define __LZO_i386 1
418 #elif defined(LZO_ARCH_I386)
419 # define __LZO_i386 1
422 #if defined(LZO_OS_DOS16)
424 # define __LZO_DOS16 1
425 #elif defined(LZO_OS_DOS32)
427 #elif defined(LZO_OS_WIN16)
429 # define __LZO_WIN16 1
430 #elif defined(LZO_OS_WIN32)
434 #define __LZO_CMODEL /*empty*/
435 #define __LZO_DMODEL /*empty*/
436 #define __LZO_ENTRY __LZO_CDECL
437 #define LZO_EXTERN_CDECL LZO_EXTERN
438 #define LZO_ALIGN LZO_PTR_ALIGN_UP
440 #define lzo_compress_asm_t lzo_compress_t
441 #define lzo_decompress_asm_t lzo_decompress_t
443 #endif /* LZO_CFG_COMPAT */
450 #endif /* already included */
453 /* vim:set ts=4 sw=4 et: */