|
1 /* $Id$ */ |
|
2 |
|
3 /* lzoconf.h -- configuration for the LZO real-time data compression library |
|
4 |
|
5 This file is part of the LZO real-time data compression library. |
|
6 |
|
7 Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer |
|
8 Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer |
|
9 Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer |
|
10 Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer |
|
11 Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer |
|
12 Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer |
|
13 Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer |
|
14 All Rights Reserved. |
|
15 |
|
16 The LZO library is free software; you can redistribute it and/or |
|
17 modify it under the terms of the GNU General Public License as |
|
18 published by the Free Software Foundation; either version 2 of |
|
19 the License, or (at your option) any later version. |
|
20 |
|
21 The LZO library is distributed in the hope that it will be useful, |
|
22 but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
24 GNU General Public License for more details. |
|
25 |
|
26 You should have received a copy of the GNU General Public License |
|
27 along with the LZO library; see the file COPYING. |
|
28 If not, write to the Free Software Foundation, Inc., |
|
29 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
|
30 |
|
31 Markus F.X.J. Oberhumer |
|
32 <markus@oberhumer.com> |
|
33 http://www.oberhumer.com/opensource/lzo/ |
|
34 */ |
|
35 |
|
36 |
|
37 #ifndef LZOCONF_H |
|
38 #define LZOCONF_H |
|
39 |
|
40 #define LZO_VERSION 0x1080 |
|
41 #define LZO_VERSION_STRING "1.08" |
|
42 #define LZO_VERSION_DATE "Jul 12 2002" |
|
43 |
|
44 /* internal Autoconf configuration file - only used when building LZO */ |
|
45 #if defined(LZO_HAVE_CONFIG_H) |
|
46 # include <config.h> |
|
47 #endif |
|
48 #include <limits.h> |
|
49 |
|
50 #ifdef __cplusplus |
|
51 extern "C" { |
|
52 #endif |
|
53 |
|
54 |
|
55 /*********************************************************************** |
|
56 * LZO requires a conforming <limits.h> |
|
57 ***********************************************************************/ |
|
58 |
|
59 #if !defined(CHAR_BIT) || (CHAR_BIT != 8) |
|
60 # error "invalid CHAR_BIT" |
|
61 #endif |
|
62 #if !defined(UCHAR_MAX) || !defined(UINT_MAX) || !defined(ULONG_MAX) |
|
63 # error "check your compiler installation" |
|
64 #endif |
|
65 #if (USHRT_MAX < 1) || (UINT_MAX < 1) || (ULONG_MAX < 1) |
|
66 # error "your limits.h macros are broken" |
|
67 #endif |
|
68 |
|
69 /* workaround a cpp bug under hpux 10.20 */ |
|
70 #define LZO_0xffffffffL 4294967295ul |
|
71 |
|
72 #if !defined(LZO_UINT32_C) |
|
73 # if (UINT_MAX < LZO_0xffffffffL) |
|
74 # define LZO_UINT32_C(c) c ## UL |
|
75 # else |
|
76 # define LZO_UINT32_C(c) c ## U |
|
77 # endif |
|
78 #endif |
|
79 |
|
80 |
|
81 /*********************************************************************** |
|
82 * architecture defines |
|
83 ***********************************************************************/ |
|
84 |
|
85 #if !defined(__LZO_WIN) && !defined(__LZO_DOS) && !defined(__LZO_OS2) |
|
86 # if defined(__WINDOWS__) || defined(_WINDOWS) || defined(_Windows) |
|
87 # define __LZO_WIN |
|
88 # elif defined(__WIN32__) || defined(_WIN32) || defined(WIN32) |
|
89 # define __LZO_WIN |
|
90 # elif defined(__NT__) || defined(__NT_DLL__) || defined(__WINDOWS_386__) |
|
91 # define __LZO_WIN |
|
92 # elif defined(__DOS__) || defined(__MSDOS__) || defined(MSDOS) |
|
93 # define __LZO_DOS |
|
94 # elif defined(__OS2__) || defined(__OS2V2__) || defined(OS2) |
|
95 # define __LZO_OS2 |
|
96 # elif defined(__palmos__) |
|
97 # define __LZO_PALMOS |
|
98 # elif defined(__TOS__) || defined(__atarist__) |
|
99 # define __LZO_TOS |
|
100 # endif |
|
101 #endif |
|
102 |
|
103 #if (UINT_MAX < LZO_0xffffffffL) |
|
104 # if defined(__LZO_WIN) |
|
105 # define __LZO_WIN16 |
|
106 # elif defined(__LZO_DOS) |
|
107 # define __LZO_DOS16 |
|
108 # elif defined(__LZO_PALMOS) |
|
109 # define __LZO_PALMOS16 |
|
110 # elif defined(__LZO_TOS) |
|
111 # define __LZO_TOS16 |
|
112 # elif defined(__C166__) |
|
113 # else |
|
114 /* porting hint: for pure 16-bit architectures try compiling |
|
115 * everything with -D__LZO_STRICT_16BIT */ |
|
116 # error "16-bit target not supported - contact me for porting hints" |
|
117 # endif |
|
118 #endif |
|
119 |
|
120 #if !defined(__LZO_i386) |
|
121 # if defined(__LZO_DOS) || defined(__LZO_WIN16) |
|
122 # define __LZO_i386 |
|
123 # elif defined(__i386__) || defined(__386__) || defined(_M_IX86) |
|
124 # define __LZO_i386 |
|
125 # endif |
|
126 #endif |
|
127 |
|
128 #if defined(__LZO_STRICT_16BIT) |
|
129 # if (UINT_MAX < LZO_0xffffffffL) |
|
130 # include <lzo16bit.h> |
|
131 # endif |
|
132 #endif |
|
133 |
|
134 /* memory checkers */ |
|
135 #if !defined(__LZO_CHECKER) |
|
136 # if defined(__BOUNDS_CHECKING_ON) |
|
137 # define __LZO_CHECKER |
|
138 # elif defined(__CHECKER__) |
|
139 # define __LZO_CHECKER |
|
140 # elif defined(__INSURE__) |
|
141 # define __LZO_CHECKER |
|
142 # elif defined(__PURIFY__) |
|
143 # define __LZO_CHECKER |
|
144 # endif |
|
145 #endif |
|
146 |
|
147 |
|
148 /*********************************************************************** |
|
149 * integral and pointer types |
|
150 ***********************************************************************/ |
|
151 |
|
152 /* Integral types with 32 bits or more */ |
|
153 #if !defined(LZO_UINT32_MAX) |
|
154 # if (UINT_MAX >= LZO_0xffffffffL) |
|
155 typedef unsigned int lzo_uint32; |
|
156 typedef int lzo_int32; |
|
157 # define LZO_UINT32_MAX UINT_MAX |
|
158 # define LZO_INT32_MAX INT_MAX |
|
159 # define LZO_INT32_MIN INT_MIN |
|
160 # elif (ULONG_MAX >= LZO_0xffffffffL) |
|
161 typedef unsigned long lzo_uint32; |
|
162 typedef long lzo_int32; |
|
163 # define LZO_UINT32_MAX ULONG_MAX |
|
164 # define LZO_INT32_MAX LONG_MAX |
|
165 # define LZO_INT32_MIN LONG_MIN |
|
166 # else |
|
167 # error "lzo_uint32" |
|
168 # endif |
|
169 #endif |
|
170 |
|
171 /* lzo_uint is used like size_t */ |
|
172 #if !defined(LZO_UINT_MAX) |
|
173 # if (UINT_MAX >= LZO_0xffffffffL) |
|
174 typedef unsigned int lzo_uint; |
|
175 typedef int lzo_int; |
|
176 # define LZO_UINT_MAX UINT_MAX |
|
177 # define LZO_INT_MAX INT_MAX |
|
178 # define LZO_INT_MIN INT_MIN |
|
179 # elif (ULONG_MAX >= LZO_0xffffffffL) |
|
180 typedef unsigned long lzo_uint; |
|
181 typedef long lzo_int; |
|
182 # define LZO_UINT_MAX ULONG_MAX |
|
183 # define LZO_INT_MAX LONG_MAX |
|
184 # define LZO_INT_MIN LONG_MIN |
|
185 # else |
|
186 # error "lzo_uint" |
|
187 # endif |
|
188 #endif |
|
189 |
|
190 typedef int lzo_bool; |
|
191 |
|
192 |
|
193 /*********************************************************************** |
|
194 * memory models |
|
195 ***********************************************************************/ |
|
196 |
|
197 /* Memory model for the public code segment. */ |
|
198 #if !defined(__LZO_CMODEL) |
|
199 # if defined(__LZO_DOS16) || defined(__LZO_WIN16) |
|
200 # define __LZO_CMODEL __far |
|
201 # elif defined(__LZO_i386) && defined(__WATCOMC__) |
|
202 # define __LZO_CMODEL __near |
|
203 # else |
|
204 # define __LZO_CMODEL |
|
205 # endif |
|
206 #endif |
|
207 |
|
208 /* Memory model for the public data segment. */ |
|
209 #if !defined(__LZO_DMODEL) |
|
210 # if defined(__LZO_DOS16) || defined(__LZO_WIN16) |
|
211 # define __LZO_DMODEL __far |
|
212 # elif defined(__LZO_i386) && defined(__WATCOMC__) |
|
213 # define __LZO_DMODEL __near |
|
214 # else |
|
215 # define __LZO_DMODEL |
|
216 # endif |
|
217 #endif |
|
218 |
|
219 /* Memory model that allows to access memory at offsets of lzo_uint. */ |
|
220 #if !defined(__LZO_MMODEL) |
|
221 # if (LZO_UINT_MAX <= UINT_MAX) |
|
222 # define __LZO_MMODEL |
|
223 # elif defined(__LZO_DOS16) || defined(__LZO_WIN16) |
|
224 # define __LZO_MMODEL __huge |
|
225 # define LZO_999_UNSUPPORTED |
|
226 # elif defined(__LZO_PALMOS16) || defined(__LZO_TOS16) |
|
227 # define __LZO_MMODEL |
|
228 # else |
|
229 # error "__LZO_MMODEL" |
|
230 # endif |
|
231 #endif |
|
232 |
|
233 /* no typedef here because of const-pointer issues */ |
|
234 #define lzo_byte unsigned char __LZO_MMODEL |
|
235 #define lzo_bytep unsigned char __LZO_MMODEL * |
|
236 #define lzo_charp char __LZO_MMODEL * |
|
237 #define lzo_voidp void __LZO_MMODEL * |
|
238 #define lzo_shortp short __LZO_MMODEL * |
|
239 #define lzo_ushortp unsigned short __LZO_MMODEL * |
|
240 #define lzo_uint32p lzo_uint32 __LZO_MMODEL * |
|
241 #define lzo_int32p lzo_int32 __LZO_MMODEL * |
|
242 #define lzo_uintp lzo_uint __LZO_MMODEL * |
|
243 #define lzo_intp lzo_int __LZO_MMODEL * |
|
244 #define lzo_voidpp lzo_voidp __LZO_MMODEL * |
|
245 #define lzo_bytepp lzo_bytep __LZO_MMODEL * |
|
246 |
|
247 #ifndef lzo_sizeof_dict_t |
|
248 # define lzo_sizeof_dict_t sizeof(lzo_bytep) |
|
249 #endif |
|
250 |
|
251 |
|
252 /*********************************************************************** |
|
253 * calling conventions and function types |
|
254 ***********************************************************************/ |
|
255 |
|
256 /* linkage */ |
|
257 #if !defined(__LZO_EXTERN_C) |
|
258 # ifdef __cplusplus |
|
259 # define __LZO_EXTERN_C extern "C" |
|
260 # else |
|
261 # define __LZO_EXTERN_C extern |
|
262 # endif |
|
263 #endif |
|
264 |
|
265 /* calling convention */ |
|
266 #if !defined(__LZO_CDECL) |
|
267 # if defined(__LZO_DOS16) || defined(__LZO_WIN16) |
|
268 # define __LZO_CDECL __LZO_CMODEL __cdecl |
|
269 # elif defined(__LZO_i386) && defined(_MSC_VER) |
|
270 # define __LZO_CDECL __LZO_CMODEL __cdecl |
|
271 # elif defined(__LZO_i386) && defined(__WATCOMC__) |
|
272 # define __LZO_CDECL __LZO_CMODEL __cdecl |
|
273 # else |
|
274 # define __LZO_CDECL __LZO_CMODEL |
|
275 # endif |
|
276 #endif |
|
277 #if !defined(__LZO_ENTRY) |
|
278 # define __LZO_ENTRY __LZO_CDECL |
|
279 #endif |
|
280 |
|
281 /* C++ exception specification for extern "C" function types */ |
|
282 #if !defined(__cplusplus) |
|
283 # undef LZO_NOTHROW |
|
284 # define LZO_NOTHROW |
|
285 #elif !defined(LZO_NOTHROW) |
|
286 # define LZO_NOTHROW |
|
287 #endif |
|
288 |
|
289 |
|
290 typedef int |
|
291 (__LZO_ENTRY *lzo_compress_t) ( const lzo_byte *src, lzo_uint src_len, |
|
292 lzo_byte *dst, lzo_uintp dst_len, |
|
293 lzo_voidp wrkmem ); |
|
294 |
|
295 typedef int |
|
296 (__LZO_ENTRY *lzo_decompress_t) ( const lzo_byte *src, lzo_uint src_len, |
|
297 lzo_byte *dst, lzo_uintp dst_len, |
|
298 lzo_voidp wrkmem ); |
|
299 |
|
300 typedef int |
|
301 (__LZO_ENTRY *lzo_optimize_t) ( lzo_byte *src, lzo_uint src_len, |
|
302 lzo_byte *dst, lzo_uintp dst_len, |
|
303 lzo_voidp wrkmem ); |
|
304 |
|
305 typedef int |
|
306 (__LZO_ENTRY *lzo_compress_dict_t)(const lzo_byte *src, lzo_uint src_len, |
|
307 lzo_byte *dst, lzo_uintp dst_len, |
|
308 lzo_voidp wrkmem, |
|
309 const lzo_byte *dict, lzo_uint dict_len ); |
|
310 |
|
311 typedef int |
|
312 (__LZO_ENTRY *lzo_decompress_dict_t)(const lzo_byte *src, lzo_uint src_len, |
|
313 lzo_byte *dst, lzo_uintp dst_len, |
|
314 lzo_voidp wrkmem, |
|
315 const lzo_byte *dict, lzo_uint dict_len ); |
|
316 |
|
317 |
|
318 /* assembler versions always use __cdecl */ |
|
319 typedef int |
|
320 (__LZO_CDECL *lzo_compress_asm_t)( const lzo_byte *src, lzo_uint src_len, |
|
321 lzo_byte *dst, lzo_uintp dst_len, |
|
322 lzo_voidp wrkmem ); |
|
323 |
|
324 typedef int |
|
325 (__LZO_CDECL *lzo_decompress_asm_t)( const lzo_byte *src, lzo_uint src_len, |
|
326 lzo_byte *dst, lzo_uintp dst_len, |
|
327 lzo_voidp wrkmem ); |
|
328 |
|
329 |
|
330 /* a progress indicator callback function */ |
|
331 typedef void (__LZO_ENTRY *lzo_progress_callback_t) (lzo_uint, lzo_uint); |
|
332 |
|
333 |
|
334 /*********************************************************************** |
|
335 * export information |
|
336 ***********************************************************************/ |
|
337 |
|
338 /* DLL export information */ |
|
339 #if !defined(__LZO_EXPORT1) |
|
340 # define __LZO_EXPORT1 |
|
341 #endif |
|
342 #if !defined(__LZO_EXPORT2) |
|
343 # define __LZO_EXPORT2 |
|
344 #endif |
|
345 |
|
346 /* exported calling convention for C functions */ |
|
347 #if !defined(LZO_PUBLIC) |
|
348 # define LZO_PUBLIC(_rettype) \ |
|
349 __LZO_EXPORT1 _rettype __LZO_EXPORT2 __LZO_ENTRY |
|
350 #endif |
|
351 #if !defined(LZO_EXTERN) |
|
352 # define LZO_EXTERN(_rettype) __LZO_EXTERN_C LZO_PUBLIC(_rettype) |
|
353 #endif |
|
354 #if !defined(LZO_PRIVATE) |
|
355 # define LZO_PRIVATE(_rettype) static _rettype __LZO_ENTRY |
|
356 #endif |
|
357 |
|
358 /* exported __cdecl calling convention for assembler functions */ |
|
359 #if !defined(LZO_PUBLIC_CDECL) |
|
360 # define LZO_PUBLIC_CDECL(_rettype) \ |
|
361 __LZO_EXPORT1 _rettype __LZO_EXPORT2 __LZO_CDECL |
|
362 #endif |
|
363 #if !defined(LZO_EXTERN_CDECL) |
|
364 # define LZO_EXTERN_CDECL(_rettype) __LZO_EXTERN_C LZO_PUBLIC_CDECL(_rettype) |
|
365 #endif |
|
366 |
|
367 /* exported global variables (LZO currently uses no static variables and |
|
368 * is fully thread safe) */ |
|
369 #if !defined(LZO_PUBLIC_VAR) |
|
370 # define LZO_PUBLIC_VAR(_type) \ |
|
371 __LZO_EXPORT1 _type __LZO_EXPORT2 __LZO_DMODEL |
|
372 #endif |
|
373 #if !defined(LZO_EXTERN_VAR) |
|
374 # define LZO_EXTERN_VAR(_type) extern LZO_PUBLIC_VAR(_type) |
|
375 #endif |
|
376 |
|
377 |
|
378 /*********************************************************************** |
|
379 * error codes and prototypes |
|
380 ***********************************************************************/ |
|
381 |
|
382 /* Error codes for the compression/decompression functions. Negative |
|
383 * values are errors, positive values will be used for special but |
|
384 * normal events. |
|
385 */ |
|
386 #define LZO_E_OK 0 |
|
387 #define LZO_E_ERROR (-1) |
|
388 #define LZO_E_OUT_OF_MEMORY (-2) /* not used right now */ |
|
389 #define LZO_E_NOT_COMPRESSIBLE (-3) /* not used right now */ |
|
390 #define LZO_E_INPUT_OVERRUN (-4) |
|
391 #define LZO_E_OUTPUT_OVERRUN (-5) |
|
392 #define LZO_E_LOOKBEHIND_OVERRUN (-6) |
|
393 #define LZO_E_EOF_NOT_FOUND (-7) |
|
394 #define LZO_E_INPUT_NOT_CONSUMED (-8) |
|
395 |
|
396 |
|
397 /* lzo_init() should be the first function you call. |
|
398 * Check the return code ! |
|
399 * |
|
400 * lzo_init() is a macro to allow checking that the library and the |
|
401 * compiler's view of various types are consistent. |
|
402 */ |
|
403 #define lzo_init() __lzo_init2(LZO_VERSION,(int)sizeof(short),(int)sizeof(int),\ |
|
404 (int)sizeof(long),(int)sizeof(lzo_uint32),(int)sizeof(lzo_uint),\ |
|
405 (int)lzo_sizeof_dict_t,(int)sizeof(char *),(int)sizeof(lzo_voidp),\ |
|
406 (int)sizeof(lzo_compress_t)) |
|
407 LZO_EXTERN(int) __lzo_init2(unsigned,int,int,int,int,int,int,int,int,int); |
|
408 |
|
409 /* version functions (useful for shared libraries) */ |
|
410 LZO_EXTERN(unsigned) lzo_version(void); |
|
411 LZO_EXTERN(const char *) lzo_version_string(void); |
|
412 LZO_EXTERN(const char *) lzo_version_date(void); |
|
413 LZO_EXTERN(const lzo_charp) _lzo_version_string(void); |
|
414 LZO_EXTERN(const lzo_charp) _lzo_version_date(void); |
|
415 |
|
416 /* string functions */ |
|
417 LZO_EXTERN(int) |
|
418 lzo_memcmp(const lzo_voidp _s1, const lzo_voidp _s2, lzo_uint _len); |
|
419 LZO_EXTERN(lzo_voidp) |
|
420 lzo_memcpy(lzo_voidp _dest, const lzo_voidp _src, lzo_uint _len); |
|
421 LZO_EXTERN(lzo_voidp) |
|
422 lzo_memmove(lzo_voidp _dest, const lzo_voidp _src, lzo_uint _len); |
|
423 LZO_EXTERN(lzo_voidp) |
|
424 lzo_memset(lzo_voidp _s, int _c, lzo_uint _len); |
|
425 |
|
426 /* checksum functions */ |
|
427 LZO_EXTERN(lzo_uint32) |
|
428 lzo_adler32(lzo_uint32 _adler, const lzo_byte *_buf, lzo_uint _len); |
|
429 LZO_EXTERN(lzo_uint32) |
|
430 lzo_crc32(lzo_uint32 _c, const lzo_byte *_buf, lzo_uint _len); |
|
431 |
|
432 /* misc. */ |
|
433 LZO_EXTERN(lzo_bool) lzo_assert(int _expr); |
|
434 LZO_EXTERN(int) _lzo_config_check(void); |
|
435 typedef union { lzo_bytep p; lzo_uint u; } __lzo_pu_u; |
|
436 typedef union { lzo_bytep p; lzo_uint32 u32; } __lzo_pu32_u; |
|
437 typedef union { void *vp; lzo_bytep bp; lzo_uint32 u32; long l; } lzo_align_t; |
|
438 |
|
439 /* align a char pointer on a boundary that is a multiple of `size' */ |
|
440 LZO_EXTERN(unsigned) __lzo_align_gap(const lzo_voidp _ptr, lzo_uint _size); |
|
441 #define LZO_PTR_ALIGN_UP(_ptr,_size) \ |
|
442 ((_ptr) + (lzo_uint) __lzo_align_gap((const lzo_voidp)(_ptr),(lzo_uint)(_size))) |
|
443 |
|
444 /* deprecated - only for backward compatibility */ |
|
445 #define LZO_ALIGN(_ptr,_size) LZO_PTR_ALIGN_UP(_ptr,_size) |
|
446 |
|
447 |
|
448 #ifdef __cplusplus |
|
449 } /* extern "C" */ |
|
450 #endif |
|
451 |
|
452 #endif /* LZOCONF_H */ |