|
1 /* $Id$ */ |
|
2 |
|
3 /* minilzo.c -- mini subset of 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 * NOTE: |
|
38 * the full LZO package can be found at |
|
39 * http://www.oberhumer.com/opensource/lzo/ |
|
40 */ |
|
41 |
|
42 #define LZO_DISABLE_CHECKS |
|
43 #define LZO1X |
|
44 |
|
45 #define __LZO_IN_MINILZO |
|
46 #define LZO_BUILD |
|
47 |
|
48 #ifdef MINILZO_HAVE_CONFIG_H |
|
49 # include <config.h> |
|
50 #endif |
|
51 |
|
52 #undef LZO_HAVE_CONFIG_H |
|
53 #include "minilzo.h" |
|
54 |
|
55 #if !defined(MINILZO_VERSION) || (MINILZO_VERSION != 0x1080) |
|
56 # error "version mismatch in miniLZO source files" |
|
57 #endif |
|
58 |
|
59 #ifdef MINILZO_HAVE_CONFIG_H |
|
60 # define LZO_HAVE_CONFIG_H |
|
61 #endif |
|
62 |
|
63 #if !defined(LZO_NO_SYS_TYPES_H) |
|
64 # include <sys/types.h> |
|
65 #endif |
|
66 #include <stdio.h> |
|
67 |
|
68 #ifndef __LZO_CONF_H |
|
69 #define __LZO_CONF_H |
|
70 |
|
71 #if defined(__BOUNDS_CHECKING_ON) |
|
72 # include <unchecked.h> |
|
73 #else |
|
74 # define BOUNDS_CHECKING_OFF_DURING(stmt) stmt |
|
75 # define BOUNDS_CHECKING_OFF_IN_EXPR(expr) (expr) |
|
76 #endif |
|
77 |
|
78 #if !defined(LZO_HAVE_CONFIG_H) |
|
79 # include <stddef.h> |
|
80 # include <string.h> |
|
81 # if !defined(NO_STDLIB_H) |
|
82 # include <stdlib.h> |
|
83 # endif |
|
84 # define HAVE_MEMCMP |
|
85 # define HAVE_MEMCPY |
|
86 # define HAVE_MEMMOVE |
|
87 # define HAVE_MEMSET |
|
88 #else |
|
89 # include <sys/types.h> |
|
90 # if defined(HAVE_STDDEF_H) |
|
91 # include <stddef.h> |
|
92 # endif |
|
93 # if defined(STDC_HEADERS) |
|
94 # include <string.h> |
|
95 # include <stdlib.h> |
|
96 # endif |
|
97 #endif |
|
98 |
|
99 #if defined(__LZO_DOS16) || defined(__LZO_WIN16) |
|
100 # define HAVE_MALLOC_H |
|
101 # define HAVE_HALLOC |
|
102 #endif |
|
103 |
|
104 #undef NDEBUG |
|
105 #if !defined(LZO_DEBUG) |
|
106 # define NDEBUG |
|
107 #endif |
|
108 #if defined(LZO_DEBUG) || !defined(NDEBUG) |
|
109 # if !defined(NO_STDIO_H) |
|
110 # include <stdio.h> |
|
111 # endif |
|
112 #endif |
|
113 #include <assert.h> |
|
114 |
|
115 #if !defined(LZO_COMPILE_TIME_ASSERT) |
|
116 # define LZO_COMPILE_TIME_ASSERT(expr) \ |
|
117 { typedef int __lzo_compile_time_assert_fail[1 - 2 * !(expr)]; } |
|
118 #endif |
|
119 |
|
120 #if !defined(LZO_UNUSED) |
|
121 # if 1 |
|
122 # define LZO_UNUSED(var) ((void)&var) |
|
123 # elif 0 |
|
124 # define LZO_UNUSED(var) { typedef int __lzo_unused[sizeof(var) ? 2 : 1]; } |
|
125 # else |
|
126 # define LZO_UNUSED(parm) (parm = parm) |
|
127 # endif |
|
128 #endif |
|
129 |
|
130 #if !defined(__inline__) && !defined(__GNUC__) |
|
131 # if defined(__cplusplus) |
|
132 # define __inline__ inline |
|
133 # else |
|
134 # define __inline__ |
|
135 # endif |
|
136 #endif |
|
137 |
|
138 #if defined(NO_MEMCMP) |
|
139 # undef HAVE_MEMCMP |
|
140 #endif |
|
141 |
|
142 #if 0 |
|
143 # define LZO_BYTE(x) ((unsigned char) (x)) |
|
144 #else |
|
145 # define LZO_BYTE(x) ((unsigned char) ((x) & 0xff)) |
|
146 #endif |
|
147 |
|
148 #define LZO_MAX(a,b) ((a) >= (b) ? (a) : (b)) |
|
149 #define LZO_MIN(a,b) ((a) <= (b) ? (a) : (b)) |
|
150 #define LZO_MAX3(a,b,c) ((a) >= (b) ? LZO_MAX(a,c) : LZO_MAX(b,c)) |
|
151 #define LZO_MIN3(a,b,c) ((a) <= (b) ? LZO_MIN(a,c) : LZO_MIN(b,c)) |
|
152 |
|
153 #define lzo_sizeof(type) ((lzo_uint) (sizeof(type))) |
|
154 |
|
155 #define LZO_HIGH(array) ((lzo_uint) (sizeof(array)/sizeof(*(array)))) |
|
156 |
|
157 #define LZO_SIZE(bits) (1u << (bits)) |
|
158 #define LZO_MASK(bits) (LZO_SIZE(bits) - 1) |
|
159 |
|
160 #define LZO_LSIZE(bits) (1ul << (bits)) |
|
161 #define LZO_LMASK(bits) (LZO_LSIZE(bits) - 1) |
|
162 |
|
163 #define LZO_USIZE(bits) ((lzo_uint) 1 << (bits)) |
|
164 #define LZO_UMASK(bits) (LZO_USIZE(bits) - 1) |
|
165 |
|
166 #define LZO_STYPE_MAX(b) (((1l << (8*(b)-2)) - 1l) + (1l << (8*(b)-2))) |
|
167 #define LZO_UTYPE_MAX(b) (((1ul << (8*(b)-1)) - 1ul) + (1ul << (8*(b)-1))) |
|
168 |
|
169 #if !defined(SIZEOF_UNSIGNED) |
|
170 # if (UINT_MAX == 0xffff) |
|
171 # define SIZEOF_UNSIGNED 2 |
|
172 # elif (UINT_MAX == LZO_0xffffffffL) |
|
173 # define SIZEOF_UNSIGNED 4 |
|
174 # elif (UINT_MAX >= LZO_0xffffffffL) |
|
175 # define SIZEOF_UNSIGNED 8 |
|
176 # else |
|
177 # error "SIZEOF_UNSIGNED" |
|
178 # endif |
|
179 #endif |
|
180 |
|
181 #if !defined(SIZEOF_UNSIGNED_LONG) |
|
182 # if (ULONG_MAX == LZO_0xffffffffL) |
|
183 # define SIZEOF_UNSIGNED_LONG 4 |
|
184 # elif (ULONG_MAX >= LZO_0xffffffffL) |
|
185 # define SIZEOF_UNSIGNED_LONG 8 |
|
186 # else |
|
187 # error "SIZEOF_UNSIGNED_LONG" |
|
188 # endif |
|
189 #endif |
|
190 |
|
191 #if !defined(SIZEOF_SIZE_T) |
|
192 # define SIZEOF_SIZE_T SIZEOF_UNSIGNED |
|
193 #endif |
|
194 #if !defined(SIZE_T_MAX) |
|
195 # define SIZE_T_MAX LZO_UTYPE_MAX(SIZEOF_SIZE_T) |
|
196 #endif |
|
197 |
|
198 #if 1 && defined(__LZO_i386) && (UINT_MAX == LZO_0xffffffffL) |
|
199 # if !defined(LZO_UNALIGNED_OK_2) && (USHRT_MAX == 0xffff) |
|
200 # define LZO_UNALIGNED_OK_2 |
|
201 # endif |
|
202 # if !defined(LZO_UNALIGNED_OK_4) && (LZO_UINT32_MAX == LZO_0xffffffffL) |
|
203 # define LZO_UNALIGNED_OK_4 |
|
204 # endif |
|
205 #endif |
|
206 |
|
207 #if defined(LZO_UNALIGNED_OK_2) || defined(LZO_UNALIGNED_OK_4) |
|
208 # if !defined(LZO_UNALIGNED_OK) |
|
209 # define LZO_UNALIGNED_OK |
|
210 # endif |
|
211 #endif |
|
212 |
|
213 #if defined(__LZO_NO_UNALIGNED) |
|
214 # undef LZO_UNALIGNED_OK |
|
215 # undef LZO_UNALIGNED_OK_2 |
|
216 # undef LZO_UNALIGNED_OK_4 |
|
217 #endif |
|
218 |
|
219 #if defined(LZO_UNALIGNED_OK_2) && (USHRT_MAX != 0xffff) |
|
220 # error "LZO_UNALIGNED_OK_2 must not be defined on this system" |
|
221 #endif |
|
222 #if defined(LZO_UNALIGNED_OK_4) && (LZO_UINT32_MAX != LZO_0xffffffffL) |
|
223 # error "LZO_UNALIGNED_OK_4 must not be defined on this system" |
|
224 #endif |
|
225 |
|
226 #if defined(__LZO_NO_ALIGNED) |
|
227 # undef LZO_ALIGNED_OK_4 |
|
228 #endif |
|
229 |
|
230 #if defined(LZO_ALIGNED_OK_4) && (LZO_UINT32_MAX != LZO_0xffffffffL) |
|
231 # error "LZO_ALIGNED_OK_4 must not be defined on this system" |
|
232 #endif |
|
233 |
|
234 #define LZO_LITTLE_ENDIAN 1234 |
|
235 #define LZO_BIG_ENDIAN 4321 |
|
236 #define LZO_PDP_ENDIAN 3412 |
|
237 |
|
238 #if !defined(LZO_BYTE_ORDER) |
|
239 # if defined(MFX_BYTE_ORDER) |
|
240 # define LZO_BYTE_ORDER MFX_BYTE_ORDER |
|
241 # elif defined(__LZO_i386) |
|
242 # define LZO_BYTE_ORDER LZO_LITTLE_ENDIAN |
|
243 # elif defined(BYTE_ORDER) |
|
244 # define LZO_BYTE_ORDER BYTE_ORDER |
|
245 # elif defined(__BYTE_ORDER) |
|
246 # define LZO_BYTE_ORDER __BYTE_ORDER |
|
247 # endif |
|
248 #endif |
|
249 |
|
250 #if defined(LZO_BYTE_ORDER) |
|
251 # if (LZO_BYTE_ORDER != LZO_LITTLE_ENDIAN) && \ |
|
252 (LZO_BYTE_ORDER != LZO_BIG_ENDIAN) |
|
253 # error "invalid LZO_BYTE_ORDER" |
|
254 # endif |
|
255 #endif |
|
256 |
|
257 #if defined(LZO_UNALIGNED_OK) && !defined(LZO_BYTE_ORDER) |
|
258 # error "LZO_BYTE_ORDER is not defined" |
|
259 #endif |
|
260 |
|
261 #define LZO_OPTIMIZE_GNUC_i386_IS_BUGGY |
|
262 |
|
263 #if defined(NDEBUG) && !defined(LZO_DEBUG) && !defined(__LZO_CHECKER) |
|
264 # if defined(__GNUC__) && defined(__i386__) |
|
265 # if !defined(LZO_OPTIMIZE_GNUC_i386_IS_BUGGY) |
|
266 # define LZO_OPTIMIZE_GNUC_i386 |
|
267 # endif |
|
268 # endif |
|
269 #endif |
|
270 |
|
271 __LZO_EXTERN_C int __lzo_init_done; |
|
272 __LZO_EXTERN_C const lzo_byte __lzo_copyright[]; |
|
273 LZO_EXTERN(const lzo_byte *) lzo_copyright(void); |
|
274 __LZO_EXTERN_C const lzo_uint32 _lzo_crc32_table[256]; |
|
275 |
|
276 #define _LZO_STRINGIZE(x) #x |
|
277 #define _LZO_MEXPAND(x) _LZO_STRINGIZE(x) |
|
278 |
|
279 #define _LZO_CONCAT2(a,b) a ## b |
|
280 #define _LZO_CONCAT3(a,b,c) a ## b ## c |
|
281 #define _LZO_CONCAT4(a,b,c,d) a ## b ## c ## d |
|
282 #define _LZO_CONCAT5(a,b,c,d,e) a ## b ## c ## d ## e |
|
283 |
|
284 #define _LZO_ECONCAT2(a,b) _LZO_CONCAT2(a,b) |
|
285 #define _LZO_ECONCAT3(a,b,c) _LZO_CONCAT3(a,b,c) |
|
286 #define _LZO_ECONCAT4(a,b,c,d) _LZO_CONCAT4(a,b,c,d) |
|
287 #define _LZO_ECONCAT5(a,b,c,d,e) _LZO_CONCAT5(a,b,c,d,e) |
|
288 |
|
289 #ifndef __LZO_PTR_H |
|
290 #define __LZO_PTR_H |
|
291 |
|
292 #ifdef __cplusplus |
|
293 extern "C" { |
|
294 #endif |
|
295 |
|
296 #if defined(__LZO_DOS16) || defined(__LZO_WIN16) |
|
297 # include <dos.h> |
|
298 # if 1 && defined(__WATCOMC__) |
|
299 # include <i86.h> |
|
300 __LZO_EXTERN_C unsigned char _HShift; |
|
301 # define __LZO_HShift _HShift |
|
302 # elif 1 && defined(_MSC_VER) |
|
303 __LZO_EXTERN_C unsigned short __near _AHSHIFT; |
|
304 # define __LZO_HShift ((unsigned) &_AHSHIFT) |
|
305 # elif defined(__LZO_WIN16) |
|
306 # define __LZO_HShift 3 |
|
307 # else |
|
308 # define __LZO_HShift 12 |
|
309 # endif |
|
310 # if !defined(_FP_SEG) && defined(FP_SEG) |
|
311 # define _FP_SEG FP_SEG |
|
312 # endif |
|
313 # if !defined(_FP_OFF) && defined(FP_OFF) |
|
314 # define _FP_OFF FP_OFF |
|
315 # endif |
|
316 #endif |
|
317 |
|
318 #if !defined(lzo_ptrdiff_t) |
|
319 # if (UINT_MAX >= LZO_0xffffffffL) |
|
320 typedef ptrdiff_t lzo_ptrdiff_t; |
|
321 # else |
|
322 typedef long lzo_ptrdiff_t; |
|
323 # endif |
|
324 #endif |
|
325 |
|
326 #if !defined(__LZO_HAVE_PTR_T) |
|
327 # if defined(lzo_ptr_t) |
|
328 # define __LZO_HAVE_PTR_T |
|
329 # endif |
|
330 #endif |
|
331 #if !defined(__LZO_HAVE_PTR_T) |
|
332 # if defined(_WIN64) |
|
333 typedef unsigned __int64 lzo_ptr_t; |
|
334 typedef signed __int64 lzo_sptr_r; |
|
335 # define __LZO_HAVE_PTR_T |
|
336 # endif |
|
337 #endif |
|
338 #if !defined(__LZO_HAVE_PTR_T) |
|
339 # if defined(SIZEOF_CHAR_P) && defined(SIZEOF_UNSIGNED_LONG) |
|
340 # if (SIZEOF_CHAR_P == SIZEOF_UNSIGNED_LONG) |
|
341 typedef unsigned long lzo_ptr_t; |
|
342 typedef long lzo_sptr_t; |
|
343 # define __LZO_HAVE_PTR_T |
|
344 # endif |
|
345 # endif |
|
346 #endif |
|
347 #if !defined(__LZO_HAVE_PTR_T) |
|
348 # if defined(SIZEOF_CHAR_P) && defined(SIZEOF_UNSIGNED) |
|
349 # if (SIZEOF_CHAR_P == SIZEOF_UNSIGNED) |
|
350 typedef unsigned int lzo_ptr_t; |
|
351 typedef int lzo_sptr_t; |
|
352 # define __LZO_HAVE_PTR_T |
|
353 # endif |
|
354 # endif |
|
355 #endif |
|
356 #if !defined(__LZO_HAVE_PTR_T) |
|
357 # if defined(SIZEOF_CHAR_P) && defined(SIZEOF_UNSIGNED_SHORT) |
|
358 # if (SIZEOF_CHAR_P == SIZEOF_UNSIGNED_SHORT) |
|
359 typedef unsigned short lzo_ptr_t; |
|
360 typedef short lzo_sptr_t; |
|
361 # define __LZO_HAVE_PTR_T |
|
362 # endif |
|
363 # endif |
|
364 #endif |
|
365 #if !defined(__LZO_HAVE_PTR_T) |
|
366 # if defined(LZO_HAVE_CONFIG_H) || defined(SIZEOF_CHAR_P) |
|
367 # error "no suitable type for lzo_ptr_t" |
|
368 # else |
|
369 typedef unsigned long lzo_ptr_t; |
|
370 typedef long lzo_sptr_t; |
|
371 # define __LZO_HAVE_PTR_T |
|
372 # endif |
|
373 #endif |
|
374 |
|
375 #if defined(__LZO_DOS16) || defined(__LZO_WIN16) |
|
376 #define PTR(a) ((lzo_bytep) (a)) |
|
377 #define PTR_ALIGNED_4(a) ((_FP_OFF(a) & 3) == 0) |
|
378 #define PTR_ALIGNED2_4(a,b) (((_FP_OFF(a) | _FP_OFF(b)) & 3) == 0) |
|
379 #else |
|
380 #define PTR(a) ((lzo_ptr_t) (a)) |
|
381 #define PTR_LINEAR(a) PTR(a) |
|
382 #define PTR_ALIGNED_4(a) ((PTR_LINEAR(a) & 3) == 0) |
|
383 #define PTR_ALIGNED_8(a) ((PTR_LINEAR(a) & 7) == 0) |
|
384 #define PTR_ALIGNED2_4(a,b) (((PTR_LINEAR(a) | PTR_LINEAR(b)) & 3) == 0) |
|
385 #define PTR_ALIGNED2_8(a,b) (((PTR_LINEAR(a) | PTR_LINEAR(b)) & 7) == 0) |
|
386 #endif |
|
387 |
|
388 #define PTR_LT(a,b) (PTR(a) < PTR(b)) |
|
389 #define PTR_GE(a,b) (PTR(a) >= PTR(b)) |
|
390 #define PTR_DIFF(a,b) ((lzo_ptrdiff_t) (PTR(a) - PTR(b))) |
|
391 #define pd(a,b) ((lzo_uint) ((a)-(b))) |
|
392 |
|
393 LZO_EXTERN(lzo_ptr_t) |
|
394 __lzo_ptr_linear(const lzo_voidp ptr); |
|
395 |
|
396 typedef union |
|
397 { |
|
398 char a_char; |
|
399 unsigned char a_uchar; |
|
400 short a_short; |
|
401 unsigned short a_ushort; |
|
402 int a_int; |
|
403 unsigned int a_uint; |
|
404 long a_long; |
|
405 unsigned long a_ulong; |
|
406 lzo_int a_lzo_int; |
|
407 lzo_uint a_lzo_uint; |
|
408 lzo_int32 a_lzo_int32; |
|
409 lzo_uint32 a_lzo_uint32; |
|
410 ptrdiff_t a_ptrdiff_t; |
|
411 lzo_ptrdiff_t a_lzo_ptrdiff_t; |
|
412 lzo_ptr_t a_lzo_ptr_t; |
|
413 lzo_voidp a_lzo_voidp; |
|
414 void * a_void_p; |
|
415 lzo_bytep a_lzo_bytep; |
|
416 lzo_bytepp a_lzo_bytepp; |
|
417 lzo_uintp a_lzo_uintp; |
|
418 lzo_uint * a_lzo_uint_p; |
|
419 lzo_uint32p a_lzo_uint32p; |
|
420 lzo_uint32 * a_lzo_uint32_p; |
|
421 unsigned char * a_uchar_p; |
|
422 char * a_char_p; |
|
423 } |
|
424 lzo_full_align_t; |
|
425 |
|
426 #ifdef __cplusplus |
|
427 } |
|
428 #endif |
|
429 |
|
430 #endif |
|
431 |
|
432 #define LZO_DETERMINISTIC |
|
433 |
|
434 #define LZO_DICT_USE_PTR |
|
435 #if defined(__LZO_DOS16) || defined(__LZO_WIN16) || defined(__LZO_STRICT_16BIT) |
|
436 # undef LZO_DICT_USE_PTR |
|
437 #endif |
|
438 |
|
439 #if defined(LZO_DICT_USE_PTR) |
|
440 # define lzo_dict_t const lzo_bytep |
|
441 # define lzo_dict_p lzo_dict_t __LZO_MMODEL * |
|
442 #else |
|
443 # define lzo_dict_t lzo_uint |
|
444 # define lzo_dict_p lzo_dict_t __LZO_MMODEL * |
|
445 #endif |
|
446 |
|
447 #if !defined(lzo_moff_t) |
|
448 #define lzo_moff_t lzo_uint |
|
449 #endif |
|
450 |
|
451 #endif |
|
452 |
|
453 |
|
454 #ifndef __LZO_UTIL_H |
|
455 #define __LZO_UTIL_H |
|
456 |
|
457 #ifndef __LZO_CONF_H |
|
458 #endif |
|
459 |
|
460 #ifdef __cplusplus |
|
461 extern "C" { |
|
462 #endif |
|
463 |
|
464 #if 1 && defined(HAVE_MEMCPY) |
|
465 #if !defined(__LZO_DOS16) && !defined(__LZO_WIN16) |
|
466 |
|
467 #define MEMCPY8_DS(dest,src,len) \ |
|
468 memcpy(dest,src,len); \ |
|
469 dest += len; \ |
|
470 src += len |
|
471 |
|
472 #endif |
|
473 #endif |
|
474 |
|
475 #if 0 && !defined(MEMCPY8_DS) |
|
476 |
|
477 #define MEMCPY8_DS(dest,src,len) \ |
|
478 { do { \ |
|
479 *dest++ = *src++; \ |
|
480 *dest++ = *src++; \ |
|
481 *dest++ = *src++; \ |
|
482 *dest++ = *src++; \ |
|
483 *dest++ = *src++; \ |
|
484 *dest++ = *src++; \ |
|
485 *dest++ = *src++; \ |
|
486 *dest++ = *src++; \ |
|
487 len -= 8; \ |
|
488 } while (len > 0); } |
|
489 |
|
490 #endif |
|
491 |
|
492 #if !defined(MEMCPY8_DS) |
|
493 |
|
494 #define MEMCPY8_DS(dest,src,len) \ |
|
495 { register lzo_uint __l = (len) / 8; \ |
|
496 do { \ |
|
497 *dest++ = *src++; \ |
|
498 *dest++ = *src++; \ |
|
499 *dest++ = *src++; \ |
|
500 *dest++ = *src++; \ |
|
501 *dest++ = *src++; \ |
|
502 *dest++ = *src++; \ |
|
503 *dest++ = *src++; \ |
|
504 *dest++ = *src++; \ |
|
505 } while (--__l > 0); } |
|
506 |
|
507 #endif |
|
508 |
|
509 #define MEMCPY_DS(dest,src,len) \ |
|
510 do *dest++ = *src++; \ |
|
511 while (--len > 0) |
|
512 |
|
513 #define MEMMOVE_DS(dest,src,len) \ |
|
514 do *dest++ = *src++; \ |
|
515 while (--len > 0) |
|
516 |
|
517 #if 0 && defined(LZO_OPTIMIZE_GNUC_i386) |
|
518 |
|
519 #define BZERO8_PTR(s,l,n) \ |
|
520 __asm__ __volatile__( \ |
|
521 "movl %0,%%eax \n" \ |
|
522 "movl %1,%%edi \n" \ |
|
523 "movl %2,%%ecx \n" \ |
|
524 "cld \n" \ |
|
525 "rep \n" \ |
|
526 "stosl %%eax,(%%edi) \n" \ |
|
527 : \ |
|
528 :"g" (0),"g" (s),"g" (n) \ |
|
529 :"eax","edi","ecx", "memory", "cc" \ |
|
530 ) |
|
531 |
|
532 #elif (LZO_UINT_MAX <= SIZE_T_MAX) && defined(HAVE_MEMSET) |
|
533 |
|
534 #if 1 |
|
535 #define BZERO8_PTR(s,l,n) memset((s),0,(lzo_uint)(l)*(n)) |
|
536 #else |
|
537 #define BZERO8_PTR(s,l,n) memset((lzo_voidp)(s),0,(lzo_uint)(l)*(n)) |
|
538 #endif |
|
539 |
|
540 #else |
|
541 |
|
542 #define BZERO8_PTR(s,l,n) \ |
|
543 lzo_memset((lzo_voidp)(s),0,(lzo_uint)(l)*(n)) |
|
544 |
|
545 #endif |
|
546 |
|
547 #if 0 |
|
548 #if defined(__GNUC__) && defined(__i386__) |
|
549 |
|
550 unsigned char lzo_rotr8(unsigned char value, int shift); |
|
551 extern __inline__ unsigned char lzo_rotr8(unsigned char value, int shift) |
|
552 { |
|
553 unsigned char result; |
|
554 |
|
555 __asm__ __volatile__ ("movb %b1, %b0; rorb %b2, %b0" |
|
556 : "=a"(result) : "g"(value), "c"(shift)); |
|
557 return result; |
|
558 } |
|
559 |
|
560 unsigned short lzo_rotr16(unsigned short value, int shift); |
|
561 extern __inline__ unsigned short lzo_rotr16(unsigned short value, int shift) |
|
562 { |
|
563 unsigned short result; |
|
564 |
|
565 __asm__ __volatile__ ("movw %b1, %b0; rorw %b2, %b0" |
|
566 : "=a"(result) : "g"(value), "c"(shift)); |
|
567 return result; |
|
568 } |
|
569 |
|
570 #endif |
|
571 #endif |
|
572 |
|
573 #ifdef __cplusplus |
|
574 } |
|
575 #endif |
|
576 |
|
577 #endif |
|
578 |
|
579 |
|
580 /* If you use the LZO library in a product, you *must* keep this |
|
581 * copyright string in the executable of your product. |
|
582 */ |
|
583 |
|
584 const lzo_byte __lzo_copyright[] = |
|
585 #if !defined(__LZO_IN_MINLZO) |
|
586 LZO_VERSION_STRING; |
|
587 #else |
|
588 "\n\n\n" |
|
589 "LZO real-time data compression library.\n" |
|
590 "Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002 Markus Franz Xaver Johannes Oberhumer\n" |
|
591 "<markus.oberhumer@jk.uni-linz.ac.at>\n" |
|
592 "http://www.oberhumer.com/opensource/lzo/\n" |
|
593 "\n" |
|
594 "LZO version: v" LZO_VERSION_STRING ", " LZO_VERSION_DATE "\n" |
|
595 "LZO build date: " __DATE__ " " __TIME__ "\n\n" |
|
596 "LZO special compilation options:\n" |
|
597 #ifdef __cplusplus |
|
598 " __cplusplus\n" |
|
599 #endif |
|
600 #if defined(__PIC__) |
|
601 " __PIC__\n" |
|
602 #elif defined(__pic__) |
|
603 " __pic__\n" |
|
604 #endif |
|
605 #if (UINT_MAX < LZO_0xffffffffL) |
|
606 " 16BIT\n" |
|
607 #endif |
|
608 #if defined(__LZO_STRICT_16BIT) |
|
609 " __LZO_STRICT_16BIT\n" |
|
610 #endif |
|
611 #if (UINT_MAX > LZO_0xffffffffL) |
|
612 " UINT_MAX=" _LZO_MEXPAND(UINT_MAX) "\n" |
|
613 #endif |
|
614 #if (ULONG_MAX > LZO_0xffffffffL) |
|
615 " ULONG_MAX=" _LZO_MEXPAND(ULONG_MAX) "\n" |
|
616 #endif |
|
617 #if defined(LZO_BYTE_ORDER) |
|
618 " LZO_BYTE_ORDER=" _LZO_MEXPAND(LZO_BYTE_ORDER) "\n" |
|
619 #endif |
|
620 #if defined(LZO_UNALIGNED_OK_2) |
|
621 " LZO_UNALIGNED_OK_2\n" |
|
622 #endif |
|
623 #if defined(LZO_UNALIGNED_OK_4) |
|
624 " LZO_UNALIGNED_OK_4\n" |
|
625 #endif |
|
626 #if defined(LZO_ALIGNED_OK_4) |
|
627 " LZO_ALIGNED_OK_4\n" |
|
628 #endif |
|
629 #if defined(LZO_DICT_USE_PTR) |
|
630 " LZO_DICT_USE_PTR\n" |
|
631 #endif |
|
632 #if defined(__LZO_QUERY_COMPRESS) |
|
633 " __LZO_QUERY_COMPRESS\n" |
|
634 #endif |
|
635 #if defined(__LZO_QUERY_DECOMPRESS) |
|
636 " __LZO_QUERY_DECOMPRESS\n" |
|
637 #endif |
|
638 #if defined(__LZO_IN_MINILZO) |
|
639 " __LZO_IN_MINILZO\n" |
|
640 #endif |
|
641 "\n\n" |
|
642 "$Id: LZO " LZO_VERSION_STRING " built " __DATE__ " " __TIME__ |
|
643 #if defined(__GNUC__) && defined(__VERSION__) |
|
644 " by gcc " __VERSION__ |
|
645 #elif defined(__BORLANDC__) |
|
646 " by Borland C " _LZO_MEXPAND(__BORLANDC__) |
|
647 #elif defined(_MSC_VER) |
|
648 " by Microsoft C " _LZO_MEXPAND(_MSC_VER) |
|
649 #elif defined(__PUREC__) |
|
650 " by Pure C " _LZO_MEXPAND(__PUREC__) |
|
651 #elif defined(__SC__) |
|
652 " by Symantec C " _LZO_MEXPAND(__SC__) |
|
653 #elif defined(__TURBOC__) |
|
654 " by Turbo C " _LZO_MEXPAND(__TURBOC__) |
|
655 #elif defined(__WATCOMC__) |
|
656 " by Watcom C " _LZO_MEXPAND(__WATCOMC__) |
|
657 #endif |
|
658 " $\n" |
|
659 "$Copyright: LZO (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002 Markus Franz Xaver Johannes Oberhumer $\n"; |
|
660 #endif |
|
661 |
|
662 #define LZO_BASE 65521u |
|
663 #define LZO_NMAX 5552 |
|
664 |
|
665 #define LZO_DO1(buf,i) {s1 += buf[i]; s2 += s1;} |
|
666 #define LZO_DO2(buf,i) LZO_DO1(buf,i); LZO_DO1(buf,i+1); |
|
667 #define LZO_DO4(buf,i) LZO_DO2(buf,i); LZO_DO2(buf,i+2); |
|
668 #define LZO_DO8(buf,i) LZO_DO4(buf,i); LZO_DO4(buf,i+4); |
|
669 #define LZO_DO16(buf,i) LZO_DO8(buf,i); LZO_DO8(buf,i+8); |
|
670 |
|
671 LZO_PUBLIC(lzo_uint32) |
|
672 lzo_adler32(lzo_uint32 adler, const lzo_byte *buf, lzo_uint len) |
|
673 { |
|
674 lzo_uint32 s1 = adler & 0xffff; |
|
675 lzo_uint32 s2 = (adler >> 16) & 0xffff; |
|
676 int k; |
|
677 |
|
678 if (buf == NULL) |
|
679 return 1; |
|
680 |
|
681 while (len > 0) |
|
682 { |
|
683 k = len < LZO_NMAX ? (int) len : LZO_NMAX; |
|
684 len -= k; |
|
685 if (k >= 16) do |
|
686 { |
|
687 LZO_DO16(buf,0); |
|
688 buf += 16; |
|
689 k -= 16; |
|
690 } while (k >= 16); |
|
691 if (k != 0) do |
|
692 { |
|
693 s1 += *buf++; |
|
694 s2 += s1; |
|
695 } while (--k > 0); |
|
696 s1 %= LZO_BASE; |
|
697 s2 %= LZO_BASE; |
|
698 } |
|
699 return (s2 << 16) | s1; |
|
700 } |
|
701 |
|
702 #if 0 |
|
703 # define IS_SIGNED(type) (((type) (1ul << (8 * sizeof(type) - 1))) < 0) |
|
704 # define IS_UNSIGNED(type) (((type) (1ul << (8 * sizeof(type) - 1))) > 0) |
|
705 #else |
|
706 # define IS_SIGNED(type) (((type) (-1)) < ((type) 0)) |
|
707 # define IS_UNSIGNED(type) (((type) (-1)) > ((type) 0)) |
|
708 #endif |
|
709 |
|
710 #define IS_POWER_OF_2(x) (((x) & ((x) - 1)) == 0) |
|
711 |
|
712 // static lzo_bool schedule_insns_bug(void); |
|
713 // static lzo_bool strength_reduce_bug(int *); |
|
714 |
|
715 #if 0 || defined(LZO_DEBUG) |
|
716 #include <stdio.h> |
|
717 static lzo_bool __lzo_assert_fail(const char *s, unsigned line) |
|
718 { |
|
719 #if defined(__palmos__) |
|
720 printf("LZO assertion failed in line %u: '%s'\n",line,s); |
|
721 #else |
|
722 fprintf(stderr,"LZO assertion failed in line %u: '%s'\n",line,s); |
|
723 #endif |
|
724 return 0; |
|
725 } |
|
726 # define __lzo_assert(x) ((x) ? 1 : __lzo_assert_fail(#x,__LINE__)) |
|
727 #else |
|
728 # define __lzo_assert(x) ((x) ? 1 : 0) |
|
729 #endif |
|
730 |
|
731 #undef COMPILE_TIME_ASSERT |
|
732 #if 0 |
|
733 # define COMPILE_TIME_ASSERT(expr) r &= __lzo_assert(expr) |
|
734 #else |
|
735 # define COMPILE_TIME_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) |
|
736 #endif |
|
737 |
|
738 |
|
739 #define do_compress _lzo1x_1_do_compress |
|
740 |
|
741 #define LZO_NEED_DICT_H |
|
742 #define D_BITS 12 |
|
743 #define D_INDEX1(d,p) d = DM((0x21*DX3(p,5,5,6)) >> 5) |
|
744 #define D_INDEX2(d,p) d = (d & (D_MASK & 0x7ff)) ^ (D_HIGH | 0x1f) |
|
745 |
|
746 #ifndef __LZO_CONFIG1X_H |
|
747 #define __LZO_CONFIG1X_H |
|
748 |
|
749 #define LZO_EOF_CODE |
|
750 #undef LZO_DETERMINISTIC |
|
751 |
|
752 #define M1_MAX_OFFSET 0x0400 |
|
753 #ifndef M2_MAX_OFFSET |
|
754 #define M2_MAX_OFFSET 0x0800 |
|
755 #endif |
|
756 #define M3_MAX_OFFSET 0x4000 |
|
757 #define M4_MAX_OFFSET 0xbfff |
|
758 |
|
759 #define MX_MAX_OFFSET (M1_MAX_OFFSET + M2_MAX_OFFSET) |
|
760 |
|
761 #define M1_MIN_LEN 2 |
|
762 #define M1_MAX_LEN 2 |
|
763 #define M2_MIN_LEN 3 |
|
764 #ifndef M2_MAX_LEN |
|
765 #define M2_MAX_LEN 8 |
|
766 #endif |
|
767 #define M3_MIN_LEN 3 |
|
768 #define M3_MAX_LEN 33 |
|
769 #define M4_MIN_LEN 3 |
|
770 #define M4_MAX_LEN 9 |
|
771 |
|
772 #define M1_MARKER 0 |
|
773 #define M2_MARKER 64 |
|
774 #define M3_MARKER 32 |
|
775 #define M4_MARKER 16 |
|
776 |
|
777 #ifndef MIN_LOOKAHEAD |
|
778 #define MIN_LOOKAHEAD (M2_MAX_LEN + 1) |
|
779 #endif |
|
780 |
|
781 #if defined(LZO_NEED_DICT_H) |
|
782 |
|
783 #ifndef LZO_HASH |
|
784 #define LZO_HASH LZO_HASH_LZO_INCREMENTAL_B |
|
785 #endif |
|
786 #define DL_MIN_LEN M2_MIN_LEN |
|
787 |
|
788 #ifndef __LZO_DICT_H |
|
789 #define __LZO_DICT_H |
|
790 |
|
791 #ifdef __cplusplus |
|
792 extern "C" { |
|
793 #endif |
|
794 |
|
795 #if !defined(D_BITS) && defined(DBITS) |
|
796 # define D_BITS DBITS |
|
797 #endif |
|
798 #if !defined(D_BITS) |
|
799 # error "D_BITS is not defined" |
|
800 #endif |
|
801 #if (D_BITS < 16) |
|
802 # define D_SIZE LZO_SIZE(D_BITS) |
|
803 # define D_MASK LZO_MASK(D_BITS) |
|
804 #else |
|
805 # define D_SIZE LZO_USIZE(D_BITS) |
|
806 # define D_MASK LZO_UMASK(D_BITS) |
|
807 #endif |
|
808 #define D_HIGH ((D_MASK >> 1) + 1) |
|
809 |
|
810 #if !defined(DD_BITS) |
|
811 # define DD_BITS 0 |
|
812 #endif |
|
813 #define DD_SIZE LZO_SIZE(DD_BITS) |
|
814 #define DD_MASK LZO_MASK(DD_BITS) |
|
815 |
|
816 #if !defined(DL_BITS) |
|
817 # define DL_BITS (D_BITS - DD_BITS) |
|
818 #endif |
|
819 #if (DL_BITS < 16) |
|
820 # define DL_SIZE LZO_SIZE(DL_BITS) |
|
821 # define DL_MASK LZO_MASK(DL_BITS) |
|
822 #else |
|
823 # define DL_SIZE LZO_USIZE(DL_BITS) |
|
824 # define DL_MASK LZO_UMASK(DL_BITS) |
|
825 #endif |
|
826 |
|
827 #if (D_BITS != DL_BITS + DD_BITS) |
|
828 # error "D_BITS does not match" |
|
829 #endif |
|
830 #if (D_BITS < 8 || D_BITS > 18) |
|
831 # error "invalid D_BITS" |
|
832 #endif |
|
833 #if (DL_BITS < 8 || DL_BITS > 20) |
|
834 # error "invalid DL_BITS" |
|
835 #endif |
|
836 #if (DD_BITS < 0 || DD_BITS > 6) |
|
837 # error "invalid DD_BITS" |
|
838 #endif |
|
839 |
|
840 #if !defined(DL_MIN_LEN) |
|
841 # define DL_MIN_LEN 3 |
|
842 #endif |
|
843 #if !defined(DL_SHIFT) |
|
844 # define DL_SHIFT ((DL_BITS + (DL_MIN_LEN - 1)) / DL_MIN_LEN) |
|
845 #endif |
|
846 |
|
847 #define LZO_HASH_GZIP 1 |
|
848 #define LZO_HASH_GZIP_INCREMENTAL 2 |
|
849 #define LZO_HASH_LZO_INCREMENTAL_A 3 |
|
850 #define LZO_HASH_LZO_INCREMENTAL_B 4 |
|
851 |
|
852 #if !defined(LZO_HASH) |
|
853 # error "choose a hashing strategy" |
|
854 #endif |
|
855 |
|
856 #if (DL_MIN_LEN == 3) |
|
857 # define _DV2_A(p,shift1,shift2) \ |
|
858 (((( (lzo_uint32)((p)[0]) << shift1) ^ (p)[1]) << shift2) ^ (p)[2]) |
|
859 # define _DV2_B(p,shift1,shift2) \ |
|
860 (((( (lzo_uint32)((p)[2]) << shift1) ^ (p)[1]) << shift2) ^ (p)[0]) |
|
861 # define _DV3_B(p,shift1,shift2,shift3) \ |
|
862 ((_DV2_B((p)+1,shift1,shift2) << (shift3)) ^ (p)[0]) |
|
863 #elif (DL_MIN_LEN == 2) |
|
864 # define _DV2_A(p,shift1,shift2) \ |
|
865 (( (lzo_uint32)(p[0]) << shift1) ^ p[1]) |
|
866 # define _DV2_B(p,shift1,shift2) \ |
|
867 (( (lzo_uint32)(p[1]) << shift1) ^ p[2]) |
|
868 #else |
|
869 # error "invalid DL_MIN_LEN" |
|
870 #endif |
|
871 #define _DV_A(p,shift) _DV2_A(p,shift,shift) |
|
872 #define _DV_B(p,shift) _DV2_B(p,shift,shift) |
|
873 #define DA2(p,s1,s2) \ |
|
874 (((((lzo_uint32)((p)[2]) << (s2)) + (p)[1]) << (s1)) + (p)[0]) |
|
875 #define DS2(p,s1,s2) \ |
|
876 (((((lzo_uint32)((p)[2]) << (s2)) - (p)[1]) << (s1)) - (p)[0]) |
|
877 #define DX2(p,s1,s2) \ |
|
878 (((((lzo_uint32)((p)[2]) << (s2)) ^ (p)[1]) << (s1)) ^ (p)[0]) |
|
879 #define DA3(p,s1,s2,s3) ((DA2((p)+1,s2,s3) << (s1)) + (p)[0]) |
|
880 #define DS3(p,s1,s2,s3) ((DS2((p)+1,s2,s3) << (s1)) - (p)[0]) |
|
881 #define DX3(p,s1,s2,s3) ((DX2((p)+1,s2,s3) << (s1)) ^ (p)[0]) |
|
882 #define DMS(v,s) ((lzo_uint) (((v) & (D_MASK >> (s))) << (s))) |
|
883 #define DM(v) DMS(v,0) |
|
884 |
|
885 #if (LZO_HASH == LZO_HASH_GZIP) |
|
886 # define _DINDEX(dv,p) (_DV_A((p),DL_SHIFT)) |
|
887 |
|
888 #elif (LZO_HASH == LZO_HASH_GZIP_INCREMENTAL) |
|
889 # define __LZO_HASH_INCREMENTAL |
|
890 # define DVAL_FIRST(dv,p) dv = _DV_A((p),DL_SHIFT) |
|
891 # define DVAL_NEXT(dv,p) dv = (((dv) << DL_SHIFT) ^ p[2]) |
|
892 # define _DINDEX(dv,p) (dv) |
|
893 # define DVAL_LOOKAHEAD DL_MIN_LEN |
|
894 |
|
895 #elif (LZO_HASH == LZO_HASH_LZO_INCREMENTAL_A) |
|
896 # define __LZO_HASH_INCREMENTAL |
|
897 # define DVAL_FIRST(dv,p) dv = _DV_A((p),5) |
|
898 # define DVAL_NEXT(dv,p) \ |
|
899 dv ^= (lzo_uint32)(p[-1]) << (2*5); dv = (((dv) << 5) ^ p[2]) |
|
900 # define _DINDEX(dv,p) ((0x9f5f * (dv)) >> 5) |
|
901 # define DVAL_LOOKAHEAD DL_MIN_LEN |
|
902 |
|
903 #elif (LZO_HASH == LZO_HASH_LZO_INCREMENTAL_B) |
|
904 # define __LZO_HASH_INCREMENTAL |
|
905 # define DVAL_FIRST(dv,p) dv = _DV_B((p),5) |
|
906 # define DVAL_NEXT(dv,p) \ |
|
907 dv ^= p[-1]; dv = (((dv) >> 5) ^ ((lzo_uint32)(p[2]) << (2*5))) |
|
908 # define _DINDEX(dv,p) ((0x9f5f * (dv)) >> 5) |
|
909 # define DVAL_LOOKAHEAD DL_MIN_LEN |
|
910 |
|
911 #else |
|
912 # error "choose a hashing strategy" |
|
913 #endif |
|
914 |
|
915 #ifndef DINDEX |
|
916 #define DINDEX(dv,p) ((lzo_uint)((_DINDEX(dv,p)) & DL_MASK) << DD_BITS) |
|
917 #endif |
|
918 #if !defined(DINDEX1) && defined(D_INDEX1) |
|
919 #define DINDEX1 D_INDEX1 |
|
920 #endif |
|
921 #if !defined(DINDEX2) && defined(D_INDEX2) |
|
922 #define DINDEX2 D_INDEX2 |
|
923 #endif |
|
924 |
|
925 #if !defined(__LZO_HASH_INCREMENTAL) |
|
926 # define DVAL_FIRST(dv,p) ((void) 0) |
|
927 # define DVAL_NEXT(dv,p) ((void) 0) |
|
928 # define DVAL_LOOKAHEAD 0 |
|
929 #endif |
|
930 |
|
931 #if !defined(DVAL_ASSERT) |
|
932 #if defined(__LZO_HASH_INCREMENTAL) && !defined(NDEBUG) |
|
933 static void DVAL_ASSERT(lzo_uint32 dv, const lzo_byte *p) |
|
934 { |
|
935 lzo_uint32 df; |
|
936 DVAL_FIRST(df,(p)); |
|
937 assert(DINDEX(dv,p) == DINDEX(df,p)); |
|
938 } |
|
939 #else |
|
940 # define DVAL_ASSERT(dv,p) ((void) 0) |
|
941 #endif |
|
942 #endif |
|
943 |
|
944 #if defined(LZO_DICT_USE_PTR) |
|
945 # define DENTRY(p,in) (p) |
|
946 # define GINDEX(m_pos,m_off,dict,dindex,in) m_pos = dict[dindex] |
|
947 #else |
|
948 # define DENTRY(p,in) ((lzo_uint) ((p)-(in))) |
|
949 # define GINDEX(m_pos,m_off,dict,dindex,in) m_off = dict[dindex] |
|
950 #endif |
|
951 |
|
952 #if (DD_BITS == 0) |
|
953 |
|
954 # define UPDATE_D(dict,drun,dv,p,in) dict[ DINDEX(dv,p) ] = DENTRY(p,in) |
|
955 # define UPDATE_I(dict,drun,index,p,in) dict[index] = DENTRY(p,in) |
|
956 # define UPDATE_P(ptr,drun,p,in) (ptr)[0] = DENTRY(p,in) |
|
957 |
|
958 #else |
|
959 |
|
960 # define UPDATE_D(dict,drun,dv,p,in) \ |
|
961 dict[ DINDEX(dv,p) + drun++ ] = DENTRY(p,in); drun &= DD_MASK |
|
962 # define UPDATE_I(dict,drun,index,p,in) \ |
|
963 dict[ (index) + drun++ ] = DENTRY(p,in); drun &= DD_MASK |
|
964 # define UPDATE_P(ptr,drun,p,in) \ |
|
965 (ptr) [ drun++ ] = DENTRY(p,in); drun &= DD_MASK |
|
966 |
|
967 #endif |
|
968 |
|
969 #if defined(LZO_DICT_USE_PTR) |
|
970 |
|
971 #define LZO_CHECK_MPOS_DET(m_pos,m_off,in,ip,max_offset) \ |
|
972 (m_pos == NULL || (m_off = (lzo_moff_t) (ip - m_pos)) > max_offset) |
|
973 |
|
974 #define LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,max_offset) \ |
|
975 (BOUNDS_CHECKING_OFF_IN_EXPR( \ |
|
976 (PTR_LT(m_pos,in) || \ |
|
977 (m_off = (lzo_moff_t) PTR_DIFF(ip,m_pos)) <= 0 || \ |
|
978 m_off > max_offset) )) |
|
979 |
|
980 #else |
|
981 |
|
982 #define LZO_CHECK_MPOS_DET(m_pos,m_off,in,ip,max_offset) \ |
|
983 (m_off == 0 || \ |
|
984 ((m_off = (lzo_moff_t) ((ip)-(in)) - m_off) > max_offset) || \ |
|
985 (m_pos = (ip) - (m_off), 0) ) |
|
986 |
|
987 #define LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,max_offset) \ |
|
988 ((lzo_moff_t) ((ip)-(in)) <= m_off || \ |
|
989 ((m_off = (lzo_moff_t) ((ip)-(in)) - m_off) > max_offset) || \ |
|
990 (m_pos = (ip) - (m_off), 0) ) |
|
991 |
|
992 #endif |
|
993 |
|
994 #if defined(LZO_DETERMINISTIC) |
|
995 # define LZO_CHECK_MPOS LZO_CHECK_MPOS_DET |
|
996 #else |
|
997 # define LZO_CHECK_MPOS LZO_CHECK_MPOS_NON_DET |
|
998 #endif |
|
999 |
|
1000 #ifdef __cplusplus |
|
1001 } |
|
1002 #endif |
|
1003 |
|
1004 #endif |
|
1005 |
|
1006 #endif |
|
1007 |
|
1008 #endif |
|
1009 |
|
1010 #define DO_COMPRESS lzo1x_1_compress |
|
1011 |
|
1012 static |
|
1013 lzo_uint do_compress ( const lzo_byte *in , lzo_uint in_len, |
|
1014 lzo_byte *out, lzo_uintp out_len, |
|
1015 lzo_voidp wrkmem ) |
|
1016 { |
|
1017 register const lzo_byte *ip; |
|
1018 lzo_byte *op; |
|
1019 const lzo_byte * const in_end = in + in_len; |
|
1020 const lzo_byte * const ip_end = in + in_len - M2_MAX_LEN - 5; |
|
1021 const lzo_byte *ii; |
|
1022 lzo_dict_p const dict = (lzo_dict_p) wrkmem; |
|
1023 |
|
1024 op = out; |
|
1025 ip = in; |
|
1026 ii = ip; |
|
1027 |
|
1028 ip += 4; |
|
1029 for (;;) |
|
1030 { |
|
1031 register const lzo_byte *m_pos; |
|
1032 lzo_moff_t m_off; |
|
1033 lzo_uint m_len; |
|
1034 lzo_uint dindex; |
|
1035 |
|
1036 DINDEX1(dindex,ip); |
|
1037 GINDEX(m_pos,m_off,dict,dindex,in); |
|
1038 if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M4_MAX_OFFSET)) |
|
1039 goto literal; |
|
1040 if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3]) |
|
1041 goto try_match; |
|
1042 DINDEX2(dindex,ip); |
|
1043 GINDEX(m_pos,m_off,dict,dindex,in); |
|
1044 if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M4_MAX_OFFSET)) |
|
1045 goto literal; |
|
1046 if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3]) |
|
1047 goto try_match; |
|
1048 goto literal; |
|
1049 |
|
1050 try_match: |
|
1051 #if 1 && defined(LZO_UNALIGNED_OK_2) |
|
1052 if (* (const lzo_ushortp) m_pos != * (const lzo_ushortp) ip) |
|
1053 #else |
|
1054 if (m_pos[0] != ip[0] || m_pos[1] != ip[1]) |
|
1055 #endif |
|
1056 { |
|
1057 } |
|
1058 else |
|
1059 { |
|
1060 if (m_pos[2] == ip[2]) |
|
1061 { |
|
1062 goto match; |
|
1063 } |
|
1064 } |
|
1065 |
|
1066 literal: |
|
1067 UPDATE_I(dict,0,dindex,ip,in); |
|
1068 ++ip; |
|
1069 if (ip >= ip_end) |
|
1070 break; |
|
1071 continue; |
|
1072 |
|
1073 match: |
|
1074 UPDATE_I(dict,0,dindex,ip,in); |
|
1075 if (pd(ip,ii) > 0) |
|
1076 { |
|
1077 register lzo_uint t = pd(ip,ii); |
|
1078 |
|
1079 if (t <= 3) |
|
1080 { |
|
1081 assert(op - 2 > out); |
|
1082 op[-2] |= LZO_BYTE(t); |
|
1083 } |
|
1084 else if (t <= 18) |
|
1085 *op++ = LZO_BYTE(t - 3); |
|
1086 else |
|
1087 { |
|
1088 register lzo_uint tt = t - 18; |
|
1089 |
|
1090 *op++ = 0; |
|
1091 while (tt > 255) |
|
1092 { |
|
1093 tt -= 255; |
|
1094 *op++ = 0; |
|
1095 } |
|
1096 assert(tt > 0); |
|
1097 *op++ = LZO_BYTE(tt); |
|
1098 } |
|
1099 do *op++ = *ii++; while (--t > 0); |
|
1100 } |
|
1101 |
|
1102 assert(ii == ip); |
|
1103 ip += 3; |
|
1104 if (m_pos[3] != *ip++ || m_pos[4] != *ip++ || m_pos[5] != *ip++ || |
|
1105 m_pos[6] != *ip++ || m_pos[7] != *ip++ || m_pos[8] != *ip++) { |
|
1106 |
|
1107 --ip; |
|
1108 m_len = ip - ii; |
|
1109 assert(m_len >= 3); assert(m_len <= M2_MAX_LEN); |
|
1110 |
|
1111 if (m_off <= M2_MAX_OFFSET) |
|
1112 { |
|
1113 m_off -= 1; |
|
1114 *op++ = LZO_BYTE(((m_len - 1) << 5) | ((m_off & 7) << 2)); |
|
1115 *op++ = LZO_BYTE(m_off >> 3); |
|
1116 } |
|
1117 else if (m_off <= M3_MAX_OFFSET) |
|
1118 { |
|
1119 m_off -= 1; |
|
1120 *op++ = LZO_BYTE(M3_MARKER | (m_len - 2)); |
|
1121 goto m3_m4_offset; |
|
1122 } |
|
1123 else |
|
1124 { |
|
1125 m_off -= 0x4000; |
|
1126 assert(m_off > 0); assert(m_off <= 0x7fff); |
|
1127 *op++ = LZO_BYTE(M4_MARKER | |
|
1128 ((m_off & 0x4000) >> 11) | (m_len - 2)); |
|
1129 goto m3_m4_offset; |
|
1130 } |
|
1131 } |
|
1132 else |
|
1133 { |
|
1134 { |
|
1135 const lzo_byte *end = in_end; |
|
1136 const lzo_byte *m = m_pos + M2_MAX_LEN + 1; |
|
1137 while (ip < end && *m == *ip) |
|
1138 m++, ip++; |
|
1139 m_len = (ip - ii); |
|
1140 } |
|
1141 assert(m_len > M2_MAX_LEN); |
|
1142 |
|
1143 if (m_off <= M3_MAX_OFFSET) |
|
1144 { |
|
1145 m_off -= 1; |
|
1146 if (m_len <= 33) |
|
1147 *op++ = LZO_BYTE(M3_MARKER | (m_len - 2)); |
|
1148 else |
|
1149 { |
|
1150 m_len -= 33; |
|
1151 *op++ = M3_MARKER | 0; |
|
1152 goto m3_m4_len; |
|
1153 } |
|
1154 } |
|
1155 else |
|
1156 { |
|
1157 m_off -= 0x4000; |
|
1158 assert(m_off > 0); assert(m_off <= 0x7fff); |
|
1159 if (m_len <= M4_MAX_LEN) |
|
1160 *op++ = LZO_BYTE(M4_MARKER | |
|
1161 ((m_off & 0x4000) >> 11) | (m_len - 2)); |
|
1162 else |
|
1163 { |
|
1164 m_len -= M4_MAX_LEN; |
|
1165 *op++ = LZO_BYTE(M4_MARKER | ((m_off & 0x4000) >> 11)); |
|
1166 m3_m4_len: |
|
1167 while (m_len > 255) |
|
1168 { |
|
1169 m_len -= 255; |
|
1170 *op++ = 0; |
|
1171 } |
|
1172 assert(m_len > 0); |
|
1173 *op++ = LZO_BYTE(m_len); |
|
1174 } |
|
1175 } |
|
1176 |
|
1177 m3_m4_offset: |
|
1178 *op++ = LZO_BYTE((m_off & 63) << 2); |
|
1179 *op++ = LZO_BYTE(m_off >> 6); |
|
1180 } |
|
1181 |
|
1182 ii = ip; |
|
1183 if (ip >= ip_end) |
|
1184 break; |
|
1185 } |
|
1186 |
|
1187 *out_len = op - out; |
|
1188 return pd(in_end,ii); |
|
1189 } |
|
1190 |
|
1191 LZO_PUBLIC(int) |
|
1192 DO_COMPRESS ( const lzo_byte *in , lzo_uint in_len, |
|
1193 lzo_byte *out, lzo_uintp out_len, |
|
1194 lzo_voidp wrkmem ) |
|
1195 { |
|
1196 lzo_byte *op = out; |
|
1197 lzo_uint t; |
|
1198 |
|
1199 if (in_len <= M2_MAX_LEN + 5) |
|
1200 t = in_len; |
|
1201 else |
|
1202 { |
|
1203 t = do_compress(in,in_len,op,out_len,wrkmem); |
|
1204 op += *out_len; |
|
1205 } |
|
1206 |
|
1207 if (t > 0) |
|
1208 { |
|
1209 const lzo_byte *ii = in + in_len - t; |
|
1210 |
|
1211 if (op == out && t <= 238) |
|
1212 *op++ = LZO_BYTE(17 + t); |
|
1213 else if (t <= 3) |
|
1214 op[-2] |= LZO_BYTE(t); |
|
1215 else if (t <= 18) |
|
1216 *op++ = LZO_BYTE(t - 3); |
|
1217 else |
|
1218 { |
|
1219 lzo_uint tt = t - 18; |
|
1220 |
|
1221 *op++ = 0; |
|
1222 while (tt > 255) |
|
1223 { |
|
1224 tt -= 255; |
|
1225 *op++ = 0; |
|
1226 } |
|
1227 assert(tt > 0); |
|
1228 *op++ = LZO_BYTE(tt); |
|
1229 } |
|
1230 do *op++ = *ii++; while (--t > 0); |
|
1231 } |
|
1232 |
|
1233 *op++ = M4_MARKER | 1; |
|
1234 *op++ = 0; |
|
1235 *op++ = 0; |
|
1236 |
|
1237 *out_len = op - out; |
|
1238 return LZO_E_OK; |
|
1239 } |
|
1240 |
|
1241 #undef do_compress |
|
1242 #undef DO_COMPRESS |
|
1243 #undef LZO_HASH |
|
1244 |
|
1245 #undef LZO_TEST_DECOMPRESS_OVERRUN |
|
1246 #undef LZO_TEST_DECOMPRESS_OVERRUN_INPUT |
|
1247 #undef LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT |
|
1248 #undef LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND |
|
1249 #undef DO_DECOMPRESS |
|
1250 #define DO_DECOMPRESS lzo1x_decompress |
|
1251 |
|
1252 #if defined(LZO_TEST_DECOMPRESS_OVERRUN) |
|
1253 # if !defined(LZO_TEST_DECOMPRESS_OVERRUN_INPUT) |
|
1254 # define LZO_TEST_DECOMPRESS_OVERRUN_INPUT 2 |
|
1255 # endif |
|
1256 # if !defined(LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT) |
|
1257 # define LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT 2 |
|
1258 # endif |
|
1259 # if !defined(LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND) |
|
1260 # define LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND |
|
1261 # endif |
|
1262 #endif |
|
1263 |
|
1264 #undef TEST_IP |
|
1265 #undef TEST_OP |
|
1266 #undef TEST_LOOKBEHIND |
|
1267 #undef NEED_IP |
|
1268 #undef NEED_OP |
|
1269 #undef HAVE_TEST_IP |
|
1270 #undef HAVE_TEST_OP |
|
1271 #undef HAVE_NEED_IP |
|
1272 #undef HAVE_NEED_OP |
|
1273 #undef HAVE_ANY_IP |
|
1274 #undef HAVE_ANY_OP |
|
1275 |
|
1276 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_INPUT) |
|
1277 # if (LZO_TEST_DECOMPRESS_OVERRUN_INPUT >= 1) |
|
1278 # define TEST_IP (ip < ip_end) |
|
1279 # endif |
|
1280 # if (LZO_TEST_DECOMPRESS_OVERRUN_INPUT >= 2) |
|
1281 # define NEED_IP(x) \ |
|
1282 if ((lzo_uint)(ip_end - ip) < (lzo_uint)(x)) goto input_overrun |
|
1283 # endif |
|
1284 #endif |
|
1285 |
|
1286 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT) |
|
1287 # if (LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT >= 1) |
|
1288 # define TEST_OP (op <= op_end) |
|
1289 # endif |
|
1290 # if (LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT >= 2) |
|
1291 # undef TEST_OP |
|
1292 # define NEED_OP(x) \ |
|
1293 if ((lzo_uint)(op_end - op) < (lzo_uint)(x)) goto output_overrun |
|
1294 # endif |
|
1295 #endif |
|
1296 |
|
1297 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND) |
|
1298 # define TEST_LOOKBEHIND(m_pos,out) if (m_pos < out) goto lookbehind_overrun |
|
1299 #else |
|
1300 # define TEST_LOOKBEHIND(m_pos,op) ((void) 0) |
|
1301 #endif |
|
1302 |
|
1303 #if !defined(LZO_EOF_CODE) && !defined(TEST_IP) |
|
1304 # define TEST_IP (ip < ip_end) |
|
1305 #endif |
|
1306 |
|
1307 #if defined(TEST_IP) |
|
1308 # define HAVE_TEST_IP |
|
1309 #else |
|
1310 # define TEST_IP 1 |
|
1311 #endif |
|
1312 #if defined(TEST_OP) |
|
1313 # define HAVE_TEST_OP |
|
1314 #else |
|
1315 # define TEST_OP 1 |
|
1316 #endif |
|
1317 |
|
1318 #if defined(NEED_IP) |
|
1319 # define HAVE_NEED_IP |
|
1320 #else |
|
1321 # define NEED_IP(x) ((void) 0) |
|
1322 #endif |
|
1323 #if defined(NEED_OP) |
|
1324 # define HAVE_NEED_OP |
|
1325 #else |
|
1326 # define NEED_OP(x) ((void) 0) |
|
1327 #endif |
|
1328 |
|
1329 #if defined(HAVE_TEST_IP) || defined(HAVE_NEED_IP) |
|
1330 # define HAVE_ANY_IP |
|
1331 #endif |
|
1332 #if defined(HAVE_TEST_OP) || defined(HAVE_NEED_OP) |
|
1333 # define HAVE_ANY_OP |
|
1334 #endif |
|
1335 |
|
1336 #undef __COPY4 |
|
1337 #define __COPY4(dst,src) * (lzo_uint32p)(dst) = * (const lzo_uint32p)(src) |
|
1338 |
|
1339 #undef COPY4 |
|
1340 #if defined(LZO_UNALIGNED_OK_4) |
|
1341 # define COPY4(dst,src) __COPY4(dst,src) |
|
1342 #elif defined(LZO_ALIGNED_OK_4) |
|
1343 # define COPY4(dst,src) __COPY4((lzo_ptr_t)(dst),(lzo_ptr_t)(src)) |
|
1344 #endif |
|
1345 |
|
1346 #if defined(DO_DECOMPRESS) |
|
1347 LZO_PUBLIC(int) |
|
1348 DO_DECOMPRESS ( const lzo_byte *in , lzo_uint in_len, |
|
1349 lzo_byte *out, lzo_uintp out_len, |
|
1350 lzo_voidp wrkmem ) |
|
1351 #endif |
|
1352 { |
|
1353 register lzo_byte *op; |
|
1354 register const lzo_byte *ip; |
|
1355 register lzo_uint t; |
|
1356 register const lzo_byte *m_pos; |
|
1357 |
|
1358 const lzo_byte * const ip_end = in + in_len; |
|
1359 #if defined(HAVE_ANY_OP) |
|
1360 lzo_byte * const op_end = out + *out_len; |
|
1361 #endif |
|
1362 |
|
1363 LZO_UNUSED(wrkmem); |
|
1364 |
|
1365 *out_len = 0; |
|
1366 |
|
1367 op = out; |
|
1368 ip = in; |
|
1369 |
|
1370 if (*ip > 17) |
|
1371 { |
|
1372 t = *ip++ - 17; |
|
1373 if (t < 4) |
|
1374 goto match_next; |
|
1375 assert(t > 0); NEED_OP(t); NEED_IP(t+1); |
|
1376 do *op++ = *ip++; while (--t > 0); |
|
1377 goto first_literal_run; |
|
1378 } |
|
1379 |
|
1380 while (TEST_IP && TEST_OP) |
|
1381 { |
|
1382 t = *ip++; |
|
1383 if (t >= 16) |
|
1384 goto match; |
|
1385 if (t == 0) |
|
1386 { |
|
1387 NEED_IP(1); |
|
1388 while (*ip == 0) |
|
1389 { |
|
1390 t += 255; |
|
1391 ip++; |
|
1392 NEED_IP(1); |
|
1393 } |
|
1394 t += 15 + *ip++; |
|
1395 } |
|
1396 assert(t > 0); NEED_OP(t+3); NEED_IP(t+4); |
|
1397 #if defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4) |
|
1398 #if !defined(LZO_UNALIGNED_OK_4) |
|
1399 if (PTR_ALIGNED2_4(op,ip)) |
|
1400 { |
|
1401 #endif |
|
1402 COPY4(op,ip); |
|
1403 op += 4; ip += 4; |
|
1404 if (--t > 0) |
|
1405 { |
|
1406 if (t >= 4) |
|
1407 { |
|
1408 do { |
|
1409 COPY4(op,ip); |
|
1410 op += 4; ip += 4; t -= 4; |
|
1411 } while (t >= 4); |
|
1412 if (t > 0) do *op++ = *ip++; while (--t > 0); |
|
1413 } |
|
1414 else |
|
1415 do *op++ = *ip++; while (--t > 0); |
|
1416 } |
|
1417 #if !defined(LZO_UNALIGNED_OK_4) |
|
1418 } |
|
1419 else |
|
1420 #endif |
|
1421 #endif |
|
1422 #if !defined(LZO_UNALIGNED_OK_4) |
|
1423 { |
|
1424 *op++ = *ip++; *op++ = *ip++; *op++ = *ip++; |
|
1425 do *op++ = *ip++; while (--t > 0); |
|
1426 } |
|
1427 #endif |
|
1428 |
|
1429 first_literal_run: |
|
1430 |
|
1431 t = *ip++; |
|
1432 if (t >= 16) |
|
1433 goto match; |
|
1434 m_pos = op - (1 + M2_MAX_OFFSET); |
|
1435 m_pos -= t >> 2; |
|
1436 m_pos -= *ip++ << 2; |
|
1437 TEST_LOOKBEHIND(m_pos,out); NEED_OP(3); |
|
1438 *op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos; |
|
1439 goto match_done; |
|
1440 |
|
1441 while (TEST_IP && TEST_OP) |
|
1442 { |
|
1443 match: |
|
1444 if (t >= 64) |
|
1445 { |
|
1446 #if defined(LZO1X) |
|
1447 m_pos = op - 1; |
|
1448 m_pos -= (t >> 2) & 7; |
|
1449 m_pos -= *ip++ << 3; |
|
1450 t = (t >> 5) - 1; |
|
1451 #endif |
|
1452 TEST_LOOKBEHIND(m_pos,out); assert(t > 0); NEED_OP(t+3-1); |
|
1453 goto copy_match; |
|
1454 } |
|
1455 else if (t >= 32) |
|
1456 { |
|
1457 t &= 31; |
|
1458 if (t == 0) |
|
1459 { |
|
1460 NEED_IP(1); |
|
1461 while (*ip == 0) |
|
1462 { |
|
1463 t += 255; |
|
1464 ip++; |
|
1465 NEED_IP(1); |
|
1466 } |
|
1467 t += 31 + *ip++; |
|
1468 } |
|
1469 #if defined(LZO_UNALIGNED_OK_2) && (LZO_BYTE_ORDER == LZO_LITTLE_ENDIAN) |
|
1470 m_pos = op - 1; |
|
1471 m_pos -= (* (const lzo_ushortp) ip) >> 2; |
|
1472 #else |
|
1473 m_pos = op - 1; |
|
1474 m_pos -= (ip[0] >> 2) + (ip[1] << 6); |
|
1475 #endif |
|
1476 ip += 2; |
|
1477 } |
|
1478 else if (t >= 16) |
|
1479 { |
|
1480 m_pos = op; |
|
1481 m_pos -= (t & 8) << 11; |
|
1482 t &= 7; |
|
1483 if (t == 0) |
|
1484 { |
|
1485 NEED_IP(1); |
|
1486 while (*ip == 0) |
|
1487 { |
|
1488 t += 255; |
|
1489 ip++; |
|
1490 NEED_IP(1); |
|
1491 } |
|
1492 t += 7 + *ip++; |
|
1493 } |
|
1494 #if defined(LZO_UNALIGNED_OK_2) && (LZO_BYTE_ORDER == LZO_LITTLE_ENDIAN) |
|
1495 m_pos -= (* (const lzo_ushortp) ip) >> 2; |
|
1496 #else |
|
1497 m_pos -= (ip[0] >> 2) + (ip[1] << 6); |
|
1498 #endif |
|
1499 ip += 2; |
|
1500 if (m_pos == op) |
|
1501 goto eof_found; |
|
1502 m_pos -= 0x4000; |
|
1503 } |
|
1504 else |
|
1505 { |
|
1506 m_pos = op - 1; |
|
1507 m_pos -= t >> 2; |
|
1508 m_pos -= *ip++ << 2; |
|
1509 TEST_LOOKBEHIND(m_pos,out); NEED_OP(2); |
|
1510 *op++ = *m_pos++; *op++ = *m_pos; |
|
1511 goto match_done; |
|
1512 } |
|
1513 |
|
1514 TEST_LOOKBEHIND(m_pos,out); assert(t > 0); NEED_OP(t+3-1); |
|
1515 #if defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4) |
|
1516 #if !defined(LZO_UNALIGNED_OK_4) |
|
1517 if (t >= 2 * 4 - (3 - 1) && PTR_ALIGNED2_4(op,m_pos)) |
|
1518 { |
|
1519 assert((op - m_pos) >= 4); |
|
1520 #else |
|
1521 if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4) |
|
1522 { |
|
1523 #endif |
|
1524 COPY4(op,m_pos); |
|
1525 op += 4; m_pos += 4; t -= 4 - (3 - 1); |
|
1526 do { |
|
1527 COPY4(op,m_pos); |
|
1528 op += 4; m_pos += 4; t -= 4; |
|
1529 } while (t >= 4); |
|
1530 if (t > 0) do *op++ = *m_pos++; while (--t > 0); |
|
1531 } |
|
1532 else |
|
1533 #endif |
|
1534 { |
|
1535 copy_match: |
|
1536 *op++ = *m_pos++; *op++ = *m_pos++; |
|
1537 do *op++ = *m_pos++; while (--t > 0); |
|
1538 } |
|
1539 |
|
1540 match_done: |
|
1541 t = ip[-2] & 3; |
|
1542 if (t == 0) |
|
1543 break; |
|
1544 |
|
1545 match_next: |
|
1546 assert(t > 0); NEED_OP(t); NEED_IP(t+1); |
|
1547 do *op++ = *ip++; while (--t > 0); |
|
1548 t = *ip++; |
|
1549 } |
|
1550 } |
|
1551 |
|
1552 #if defined(HAVE_TEST_IP) || defined(HAVE_TEST_OP) |
|
1553 *out_len = op - out; |
|
1554 return LZO_E_EOF_NOT_FOUND; |
|
1555 #endif |
|
1556 |
|
1557 eof_found: |
|
1558 assert(t == 1); |
|
1559 *out_len = op - out; |
|
1560 return (ip == ip_end ? LZO_E_OK : |
|
1561 (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); |
|
1562 |
|
1563 #if defined(HAVE_NEED_IP) |
|
1564 input_overrun: |
|
1565 *out_len = op - out; |
|
1566 return LZO_E_INPUT_OVERRUN; |
|
1567 #endif |
|
1568 |
|
1569 #if defined(HAVE_NEED_OP) |
|
1570 output_overrun: |
|
1571 *out_len = op - out; |
|
1572 return LZO_E_OUTPUT_OVERRUN; |
|
1573 #endif |
|
1574 |
|
1575 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND) |
|
1576 lookbehind_overrun: |
|
1577 *out_len = op - out; |
|
1578 return LZO_E_LOOKBEHIND_OVERRUN; |
|
1579 #endif |
|
1580 } |
|
1581 |
|
1582 #define LZO_TEST_DECOMPRESS_OVERRUN |
|
1583 #undef DO_DECOMPRESS |
|
1584 #define DO_DECOMPRESS lzo1x_decompress_safe |
|
1585 |
|
1586 #if defined(LZO_TEST_DECOMPRESS_OVERRUN) |
|
1587 # if !defined(LZO_TEST_DECOMPRESS_OVERRUN_INPUT) |
|
1588 # define LZO_TEST_DECOMPRESS_OVERRUN_INPUT 2 |
|
1589 # endif |
|
1590 # if !defined(LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT) |
|
1591 # define LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT 2 |
|
1592 # endif |
|
1593 # if !defined(LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND) |
|
1594 # define LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND |
|
1595 # endif |
|
1596 #endif |
|
1597 |
|
1598 #undef TEST_IP |
|
1599 #undef TEST_OP |
|
1600 #undef TEST_LOOKBEHIND |
|
1601 #undef NEED_IP |
|
1602 #undef NEED_OP |
|
1603 #undef HAVE_TEST_IP |
|
1604 #undef HAVE_TEST_OP |
|
1605 #undef HAVE_NEED_IP |
|
1606 #undef HAVE_NEED_OP |
|
1607 #undef HAVE_ANY_IP |
|
1608 #undef HAVE_ANY_OP |
|
1609 |
|
1610 |
|
1611 #if 0 |
|
1612 |
|
1613 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_INPUT) |
|
1614 # if (LZO_TEST_DECOMPRESS_OVERRUN_INPUT >= 1) |
|
1615 # define TEST_IP (ip < ip_end) |
|
1616 # endif |
|
1617 # if (LZO_TEST_DECOMPRESS_OVERRUN_INPUT >= 2) |
|
1618 # define NEED_IP(x) \ |
|
1619 if ((lzo_uint)(ip_end - ip) < (lzo_uint)(x)) goto input_overrun |
|
1620 # endif |
|
1621 #endif |
|
1622 |
|
1623 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT) |
|
1624 # if (LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT >= 1) |
|
1625 # define TEST_OP (op <= op_end) |
|
1626 # endif |
|
1627 # if (LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT >= 2) |
|
1628 # undef TEST_OP |
|
1629 # define NEED_OP(x) \ |
|
1630 if ((lzo_uint)(op_end - op) < (lzo_uint)(x)) goto output_overrun |
|
1631 # endif |
|
1632 #endif |
|
1633 |
|
1634 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND) |
|
1635 # define TEST_LOOKBEHIND(m_pos,out) if (m_pos < out) goto lookbehind_overrun |
|
1636 #else |
|
1637 # define TEST_LOOKBEHIND(m_pos,op) ((void) 0) |
|
1638 #endif |
|
1639 |
|
1640 #if !defined(LZO_EOF_CODE) && !defined(TEST_IP) |
|
1641 # define TEST_IP (ip < ip_end) |
|
1642 #endif |
|
1643 |
|
1644 #if defined(TEST_IP) |
|
1645 # define HAVE_TEST_IP |
|
1646 #else |
|
1647 # define TEST_IP 1 |
|
1648 #endif |
|
1649 #if defined(TEST_OP) |
|
1650 # define HAVE_TEST_OP |
|
1651 #else |
|
1652 # define TEST_OP 1 |
|
1653 #endif |
|
1654 |
|
1655 #if defined(NEED_IP) |
|
1656 # define HAVE_NEED_IP |
|
1657 #else |
|
1658 # define NEED_IP(x) ((void) 0) |
|
1659 #endif |
|
1660 #if defined(NEED_OP) |
|
1661 # define HAVE_NEED_OP |
|
1662 #else |
|
1663 # define NEED_OP(x) ((void) 0) |
|
1664 #endif |
|
1665 |
|
1666 #if defined(HAVE_TEST_IP) || defined(HAVE_NEED_IP) |
|
1667 # define HAVE_ANY_IP |
|
1668 #endif |
|
1669 #if defined(HAVE_TEST_OP) || defined(HAVE_NEED_OP) |
|
1670 # define HAVE_ANY_OP |
|
1671 #endif |
|
1672 |
|
1673 #undef __COPY4 |
|
1674 #define __COPY4(dst,src) * (lzo_uint32p)(dst) = * (const lzo_uint32p)(src) |
|
1675 |
|
1676 #undef COPY4 |
|
1677 #if defined(LZO_UNALIGNED_OK_4) |
|
1678 # define COPY4(dst,src) __COPY4(dst,src) |
|
1679 #elif defined(LZO_ALIGNED_OK_4) |
|
1680 # define COPY4(dst,src) __COPY4((lzo_ptr_t)(dst),(lzo_ptr_t)(src)) |
|
1681 #endif |
|
1682 |
|
1683 #if defined(DO_DECOMPRESS) |
|
1684 LZO_PUBLIC(int) |
|
1685 DO_DECOMPRESS ( const lzo_byte *in , lzo_uint in_len, |
|
1686 lzo_byte *out, lzo_uintp out_len, |
|
1687 lzo_voidp wrkmem ) |
|
1688 #endif |
|
1689 { |
|
1690 register lzo_byte *op; |
|
1691 register const lzo_byte *ip; |
|
1692 register lzo_uint t; |
|
1693 register const lzo_byte *m_pos; |
|
1694 |
|
1695 const lzo_byte * const ip_end = in + in_len; |
|
1696 #if defined(HAVE_ANY_OP) |
|
1697 lzo_byte * const op_end = out + *out_len; |
|
1698 #endif |
|
1699 |
|
1700 LZO_UNUSED(wrkmem); |
|
1701 |
|
1702 *out_len = 0; |
|
1703 |
|
1704 op = out; |
|
1705 ip = in; |
|
1706 |
|
1707 if (*ip > 17) |
|
1708 { |
|
1709 t = *ip++ - 17; |
|
1710 if (t < 4) |
|
1711 goto match_next; |
|
1712 assert(t > 0); NEED_OP(t); NEED_IP(t+1); |
|
1713 do *op++ = *ip++; while (--t > 0); |
|
1714 goto first_literal_run; |
|
1715 } |
|
1716 |
|
1717 while (TEST_IP && TEST_OP) |
|
1718 { |
|
1719 t = *ip++; |
|
1720 if (t >= 16) |
|
1721 goto match; |
|
1722 if (t == 0) |
|
1723 { |
|
1724 NEED_IP(1); |
|
1725 while (*ip == 0) |
|
1726 { |
|
1727 t += 255; |
|
1728 ip++; |
|
1729 NEED_IP(1); |
|
1730 } |
|
1731 t += 15 + *ip++; |
|
1732 } |
|
1733 assert(t > 0); NEED_OP(t+3); NEED_IP(t+4); |
|
1734 #if defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4) |
|
1735 #if !defined(LZO_UNALIGNED_OK_4) |
|
1736 if (PTR_ALIGNED2_4(op,ip)) |
|
1737 { |
|
1738 #endif |
|
1739 COPY4(op,ip); |
|
1740 op += 4; ip += 4; |
|
1741 if (--t > 0) |
|
1742 { |
|
1743 if (t >= 4) |
|
1744 { |
|
1745 do { |
|
1746 COPY4(op,ip); |
|
1747 op += 4; ip += 4; t -= 4; |
|
1748 } while (t >= 4); |
|
1749 if (t > 0) do *op++ = *ip++; while (--t > 0); |
|
1750 } |
|
1751 else |
|
1752 do *op++ = *ip++; while (--t > 0); |
|
1753 } |
|
1754 #if !defined(LZO_UNALIGNED_OK_4) |
|
1755 } |
|
1756 else |
|
1757 #endif |
|
1758 #endif |
|
1759 #if !defined(LZO_UNALIGNED_OK_4) |
|
1760 { |
|
1761 *op++ = *ip++; *op++ = *ip++; *op++ = *ip++; |
|
1762 do *op++ = *ip++; while (--t > 0); |
|
1763 } |
|
1764 #endif |
|
1765 |
|
1766 first_literal_run: |
|
1767 |
|
1768 t = *ip++; |
|
1769 if (t >= 16) |
|
1770 goto match; |
|
1771 #if defined(LZO1Z) |
|
1772 t = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2); |
|
1773 m_pos = op - t; |
|
1774 last_m_off = t; |
|
1775 #else |
|
1776 m_pos = op - (1 + M2_MAX_OFFSET); |
|
1777 m_pos -= t >> 2; |
|
1778 m_pos -= *ip++ << 2; |
|
1779 #endif |
|
1780 TEST_LOOKBEHIND(m_pos,out); NEED_OP(3); |
|
1781 *op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos; |
|
1782 goto match_done; |
|
1783 |
|
1784 while (TEST_IP && TEST_OP) |
|
1785 { |
|
1786 match: |
|
1787 if (t >= 64) |
|
1788 { |
|
1789 #if defined(LZO1X) |
|
1790 m_pos = op - 1; |
|
1791 m_pos -= (t >> 2) & 7; |
|
1792 m_pos -= *ip++ << 3; |
|
1793 t = (t >> 5) - 1; |
|
1794 #elif defined(LZO1Y) |
|
1795 m_pos = op - 1; |
|
1796 m_pos -= (t >> 2) & 3; |
|
1797 m_pos -= *ip++ << 2; |
|
1798 t = (t >> 4) - 3; |
|
1799 #elif defined(LZO1Z) |
|
1800 { |
|
1801 lzo_uint off = t & 0x1f; |
|
1802 m_pos = op; |
|
1803 if (off >= 0x1c) |
|
1804 { |
|
1805 assert(last_m_off > 0); |
|
1806 m_pos -= last_m_off; |
|
1807 } |
|
1808 else |
|
1809 { |
|
1810 off = 1 + (off << 6) + (*ip++ >> 2); |
|
1811 m_pos -= off; |
|
1812 last_m_off = off; |
|
1813 } |
|
1814 } |
|
1815 t = (t >> 5) - 1; |
|
1816 #endif |
|
1817 TEST_LOOKBEHIND(m_pos,out); assert(t > 0); NEED_OP(t+3-1); |
|
1818 goto copy_match; |
|
1819 } |
|
1820 else if (t >= 32) |
|
1821 { |
|
1822 t &= 31; |
|
1823 if (t == 0) |
|
1824 { |
|
1825 NEED_IP(1); |
|
1826 while (*ip == 0) |
|
1827 { |
|
1828 t += 255; |
|
1829 ip++; |
|
1830 NEED_IP(1); |
|
1831 } |
|
1832 t += 31 + *ip++; |
|
1833 } |
|
1834 #if defined(LZO1Z) |
|
1835 { |
|
1836 lzo_uint off = 1 + (ip[0] << 6) + (ip[1] >> 2); |
|
1837 m_pos = op - off; |
|
1838 last_m_off = off; |
|
1839 } |
|
1840 #elif defined(LZO_UNALIGNED_OK_2) && (LZO_BYTE_ORDER == LZO_LITTLE_ENDIAN) |
|
1841 m_pos = op - 1; |
|
1842 m_pos -= (* (const lzo_ushortp) ip) >> 2; |
|
1843 #else |
|
1844 m_pos = op - 1; |
|
1845 m_pos -= (ip[0] >> 2) + (ip[1] << 6); |
|
1846 #endif |
|
1847 ip += 2; |
|
1848 } |
|
1849 else if (t >= 16) |
|
1850 { |
|
1851 m_pos = op; |
|
1852 m_pos -= (t & 8) << 11; |
|
1853 t &= 7; |
|
1854 if (t == 0) |
|
1855 { |
|
1856 NEED_IP(1); |
|
1857 while (*ip == 0) |
|
1858 { |
|
1859 t += 255; |
|
1860 ip++; |
|
1861 NEED_IP(1); |
|
1862 } |
|
1863 t += 7 + *ip++; |
|
1864 } |
|
1865 #if defined(LZO1Z) |
|
1866 m_pos -= (ip[0] << 6) + (ip[1] >> 2); |
|
1867 #elif defined(LZO_UNALIGNED_OK_2) && (LZO_BYTE_ORDER == LZO_LITTLE_ENDIAN) |
|
1868 m_pos -= (* (const lzo_ushortp) ip) >> 2; |
|
1869 #else |
|
1870 m_pos -= (ip[0] >> 2) + (ip[1] << 6); |
|
1871 #endif |
|
1872 ip += 2; |
|
1873 if (m_pos == op) |
|
1874 goto eof_found; |
|
1875 m_pos -= 0x4000; |
|
1876 #if defined(LZO1Z) |
|
1877 last_m_off = op - m_pos; |
|
1878 #endif |
|
1879 } |
|
1880 else |
|
1881 { |
|
1882 #if defined(LZO1Z) |
|
1883 t = 1 + (t << 6) + (*ip++ >> 2); |
|
1884 m_pos = op - t; |
|
1885 last_m_off = t; |
|
1886 #else |
|
1887 m_pos = op - 1; |
|
1888 m_pos -= t >> 2; |
|
1889 m_pos -= *ip++ << 2; |
|
1890 #endif |
|
1891 TEST_LOOKBEHIND(m_pos,out); NEED_OP(2); |
|
1892 *op++ = *m_pos++; *op++ = *m_pos; |
|
1893 goto match_done; |
|
1894 } |
|
1895 |
|
1896 TEST_LOOKBEHIND(m_pos,out); assert(t > 0); NEED_OP(t+3-1); |
|
1897 #if defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4) |
|
1898 #if !defined(LZO_UNALIGNED_OK_4) |
|
1899 if (t >= 2 * 4 - (3 - 1) && PTR_ALIGNED2_4(op,m_pos)) |
|
1900 { |
|
1901 assert((op - m_pos) >= 4); |
|
1902 #else |
|
1903 if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4) |
|
1904 { |
|
1905 #endif |
|
1906 COPY4(op,m_pos); |
|
1907 op += 4; m_pos += 4; t -= 4 - (3 - 1); |
|
1908 do { |
|
1909 COPY4(op,m_pos); |
|
1910 op += 4; m_pos += 4; t -= 4; |
|
1911 } while (t >= 4); |
|
1912 if (t > 0) do *op++ = *m_pos++; while (--t > 0); |
|
1913 } |
|
1914 else |
|
1915 #endif |
|
1916 { |
|
1917 copy_match: |
|
1918 *op++ = *m_pos++; *op++ = *m_pos++; |
|
1919 do *op++ = *m_pos++; while (--t > 0); |
|
1920 } |
|
1921 |
|
1922 |
|
1923 match_done: |
|
1924 #if defined(LZO1Z) |
|
1925 t = ip[-1] & 3; |
|
1926 #else |
|
1927 t = ip[-2] & 3; |
|
1928 #endif |
|
1929 if (t == 0) |
|
1930 break; |
|
1931 |
|
1932 match_next: |
|
1933 assert(t > 0); NEED_OP(t); NEED_IP(t+1); |
|
1934 do *op++ = *ip++; while (--t > 0); |
|
1935 t = *ip++; |
|
1936 } |
|
1937 } |
|
1938 |
|
1939 #if defined(HAVE_TEST_IP) || defined(HAVE_TEST_OP) |
|
1940 *out_len = op - out; |
|
1941 return LZO_E_EOF_NOT_FOUND; |
|
1942 #endif |
|
1943 |
|
1944 eof_found: |
|
1945 assert(t == 1); |
|
1946 *out_len = op - out; |
|
1947 return (ip == ip_end ? LZO_E_OK : |
|
1948 (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); |
|
1949 |
|
1950 #if defined(HAVE_NEED_IP) |
|
1951 input_overrun: |
|
1952 *out_len = op - out; |
|
1953 return LZO_E_INPUT_OVERRUN; |
|
1954 #endif |
|
1955 |
|
1956 #if defined(HAVE_NEED_OP) |
|
1957 output_overrun: |
|
1958 *out_len = op - out; |
|
1959 return LZO_E_OUTPUT_OVERRUN; |
|
1960 #endif |
|
1961 |
|
1962 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND) |
|
1963 lookbehind_overrun: |
|
1964 *out_len = op - out; |
|
1965 return LZO_E_LOOKBEHIND_OVERRUN; |
|
1966 #endif |
|
1967 } |
|
1968 |
|
1969 #endif |
|
1970 |
|
1971 /***** End of minilzo.c *****/ |