Mercurial > mplayer.hg
comparison minilzo.c @ 3803:b081763865d4
used by NuppelVideo
author | alex |
---|---|
date | Thu, 27 Dec 2001 21:27:59 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
3802:bf37d5cd3e6e | 3803:b081763865d4 |
---|---|
1 /* minilzo.c -- mini subset of the LZO real-time data compression library | |
2 | |
3 This file is part of the LZO real-time data compression library. | |
4 | |
5 Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer | |
6 Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer | |
7 Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer | |
8 Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer | |
9 Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer | |
10 | |
11 The LZO library is free software; you can redistribute it and/or | |
12 modify it under the terms of the GNU General Public License as | |
13 published by the Free Software Foundation; either version 2 of | |
14 the License, or (at your option) any later version. | |
15 | |
16 The LZO library is distributed in the hope that it will be useful, | |
17 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
19 GNU General Public License for more details. | |
20 | |
21 You should have received a copy of the GNU General Public License | |
22 along with the LZO library; see the file COPYING. | |
23 If not, write to the Free Software Foundation, Inc., | |
24 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
25 | |
26 Markus F.X.J. Oberhumer | |
27 <markus.oberhumer@jk.uni-linz.ac.at> | |
28 http://wildsau.idv.uni-linz.ac.at/mfx/lzo.html | |
29 */ | |
30 | |
31 /* | |
32 * NOTE: | |
33 * the full LZO package can be found at | |
34 * http://wildsau.idv.uni-linz.ac.at/mfx/lzo.html | |
35 */ | |
36 | |
37 #define __LZO_IN_MINILZO | |
38 | |
39 #ifdef MINILZO_HAVE_CONFIG_H | |
40 # include <config.h> | |
41 #endif | |
42 | |
43 #undef LZO_HAVE_CONFIG_H | |
44 #include "minilzo.h" | |
45 | |
46 #if !defined(MINILZO_VERSION) || (MINILZO_VERSION != 0x1070) | |
47 # error "version mismatch in miniLZO source files" | |
48 #endif | |
49 | |
50 #ifdef MINILZO_HAVE_CONFIG_H | |
51 # define LZO_HAVE_CONFIG_H | |
52 #endif | |
53 | |
54 #if !defined(LZO_NO_SYS_TYPES_H) | |
55 # include <sys/types.h> | |
56 #endif | |
57 #include <stdio.h> | |
58 | |
59 #ifndef __LZO_CONF_H | |
60 #define __LZO_CONF_H | |
61 | |
62 #if !defined(__LZO_IN_MINILZO) | |
63 # ifndef __LZOCONF_H | |
64 # include <lzoconf.h> | |
65 # endif | |
66 #endif | |
67 | |
68 #if defined(__BOUNDS_CHECKING_ON) | |
69 # include <unchecked.h> | |
70 #else | |
71 # define BOUNDS_CHECKING_OFF_DURING(stmt) stmt | |
72 # define BOUNDS_CHECKING_OFF_IN_EXPR(expr) (expr) | |
73 #endif | |
74 | |
75 #if !defined(LZO_HAVE_CONFIG_H) | |
76 # include <stddef.h> | |
77 # include <string.h> | |
78 # if !defined(NO_STDLIB_H) | |
79 # include <stdlib.h> | |
80 # endif | |
81 # define HAVE_MEMCMP | |
82 # define HAVE_MEMCPY | |
83 # define HAVE_MEMMOVE | |
84 # define HAVE_MEMSET | |
85 #else | |
86 # include <sys/types.h> | |
87 # if defined(STDC_HEADERS) | |
88 # include <string.h> | |
89 # include <stdlib.h> | |
90 # endif | |
91 # if defined(HAVE_STDDEF_H) | |
92 # include <stddef.h> | |
93 # endif | |
94 # if defined(HAVE_MEMORY_H) | |
95 # include <memory.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_UNUSED) | |
116 # define LZO_UNUSED(parm) (parm = parm) | |
117 #endif | |
118 | |
119 #if !defined(__inline__) && !defined(__GNUC__) | |
120 # if defined(__cplusplus) | |
121 # define __inline__ inline | |
122 # else | |
123 # define __inline__ | |
124 # endif | |
125 #endif | |
126 | |
127 #if defined(NO_MEMCMP) | |
128 # undef HAVE_MEMCMP | |
129 #endif | |
130 | |
131 #if !defined(HAVE_MEMCMP) | |
132 # undef memcmp | |
133 # define memcmp lzo_memcmp | |
134 #endif | |
135 #if !defined(HAVE_MEMCPY) | |
136 # undef memcpy | |
137 # define memcpy lzo_memcpy | |
138 #endif | |
139 #if !defined(HAVE_MEMMOVE) | |
140 # undef memmove | |
141 # define memmove lzo_memmove | |
142 #endif | |
143 #if !defined(HAVE_MEMSET) | |
144 # undef memset | |
145 # define memset lzo_memset | |
146 #endif | |
147 | |
148 #if 1 | |
149 # define LZO_BYTE(x) ((unsigned char) (x)) | |
150 #else | |
151 # define LZO_BYTE(x) ((unsigned char) ((x) & 0xff)) | |
152 #endif | |
153 #if 0 | |
154 # define LZO_USHORT(x) ((unsigned short) (x)) | |
155 #else | |
156 # define LZO_USHORT(x) ((unsigned short) ((x) & 0xffff)) | |
157 #endif | |
158 | |
159 #define LZO_MAX(a,b) ((a) >= (b) ? (a) : (b)) | |
160 #define LZO_MIN(a,b) ((a) <= (b) ? (a) : (b)) | |
161 #define LZO_MAX3(a,b,c) ((a) >= (b) ? LZO_MAX(a,c) : LZO_MAX(b,c)) | |
162 #define LZO_MIN3(a,b,c) ((a) <= (b) ? LZO_MIN(a,c) : LZO_MIN(b,c)) | |
163 | |
164 #define lzo_sizeof(type) ((lzo_uint) (sizeof(type))) | |
165 | |
166 #define LZO_HIGH(array) ((lzo_uint) (sizeof(array)/sizeof(*(array)))) | |
167 | |
168 #define LZO_SIZE(bits) (1u << (bits)) | |
169 #define LZO_MASK(bits) (LZO_SIZE(bits) - 1) | |
170 | |
171 #define LZO_LSIZE(bits) (1ul << (bits)) | |
172 #define LZO_LMASK(bits) (LZO_LSIZE(bits) - 1) | |
173 | |
174 #define LZO_USIZE(bits) ((lzo_uint) 1 << (bits)) | |
175 #define LZO_UMASK(bits) (LZO_USIZE(bits) - 1) | |
176 | |
177 #define LZO_STYPE_MAX(b) (((1l << (8*(b)-2)) - 1l) + (1l << (8*(b)-2))) | |
178 #define LZO_UTYPE_MAX(b) (((1ul << (8*(b)-1)) - 1ul) + (1ul << (8*(b)-1))) | |
179 | |
180 #if !defined(SIZEOF_UNSIGNED) | |
181 # if (UINT_MAX == 0xffff) | |
182 # define SIZEOF_UNSIGNED 2 | |
183 # elif (UINT_MAX == LZO_0xffffffffL) | |
184 # define SIZEOF_UNSIGNED 4 | |
185 # elif (UINT_MAX >= LZO_0xffffffffL) | |
186 # define SIZEOF_UNSIGNED 8 | |
187 # else | |
188 # error SIZEOF_UNSIGNED | |
189 # endif | |
190 #endif | |
191 | |
192 #if !defined(SIZEOF_UNSIGNED_LONG) | |
193 # if (ULONG_MAX == LZO_0xffffffffL) | |
194 # define SIZEOF_UNSIGNED_LONG 4 | |
195 # elif (ULONG_MAX >= LZO_0xffffffffL) | |
196 # define SIZEOF_UNSIGNED_LONG 8 | |
197 # else | |
198 # error SIZEOF_UNSIGNED_LONG | |
199 # endif | |
200 #endif | |
201 | |
202 #if !defined(SIZEOF_SIZE_T) | |
203 # define SIZEOF_SIZE_T SIZEOF_UNSIGNED | |
204 #endif | |
205 #if !defined(SIZE_T_MAX) | |
206 # define SIZE_T_MAX LZO_UTYPE_MAX(SIZEOF_SIZE_T) | |
207 #endif | |
208 | |
209 #if 1 && defined(__LZO_i386) && (UINT_MAX == LZO_0xffffffffL) | |
210 # if !defined(LZO_UNALIGNED_OK_2) && (USHRT_MAX == 0xffff) | |
211 # define LZO_UNALIGNED_OK_2 | |
212 # endif | |
213 # if !defined(LZO_UNALIGNED_OK_4) && (LZO_UINT32_MAX == LZO_0xffffffffL) | |
214 # define LZO_UNALIGNED_OK_4 | |
215 # endif | |
216 #endif | |
217 | |
218 #if defined(LZO_UNALIGNED_OK_2) || defined(LZO_UNALIGNED_OK_4) | |
219 # if !defined(LZO_UNALIGNED_OK) | |
220 # define LZO_UNALIGNED_OK | |
221 # endif | |
222 #endif | |
223 | |
224 #if defined(__LZO_NO_UNALIGNED) | |
225 # undef LZO_UNALIGNED_OK | |
226 # undef LZO_UNALIGNED_OK_2 | |
227 # undef LZO_UNALIGNED_OK_4 | |
228 #endif | |
229 | |
230 #if defined(LZO_UNALIGNED_OK_2) && (USHRT_MAX != 0xffff) | |
231 # error "LZO_UNALIGNED_OK_2 must not be defined on this system" | |
232 #endif | |
233 #if defined(LZO_UNALIGNED_OK_4) && (LZO_UINT32_MAX != LZO_0xffffffffL) | |
234 # error "LZO_UNALIGNED_OK_4 must not be defined on this system" | |
235 #endif | |
236 | |
237 #if defined(__LZO_NO_ALIGNED) | |
238 # undef LZO_ALIGNED_OK_4 | |
239 #endif | |
240 | |
241 #if defined(LZO_ALIGNED_OK_4) && (LZO_UINT32_MAX != LZO_0xffffffffL) | |
242 # error "LZO_ALIGNED_OK_4 must not be defined on this system" | |
243 #endif | |
244 | |
245 #define LZO_LITTLE_ENDIAN 1234 | |
246 #define LZO_BIG_ENDIAN 4321 | |
247 #define LZO_PDP_ENDIAN 3412 | |
248 | |
249 #if !defined(LZO_BYTE_ORDER) | |
250 # if defined(MFX_BYTE_ORDER) | |
251 # define LZO_BYTE_ORDER MFX_BYTE_ORDER | |
252 # elif defined(__LZO_i386) | |
253 # define LZO_BYTE_ORDER LZO_LITTLE_ENDIAN | |
254 # elif defined(BYTE_ORDER) | |
255 # define LZO_BYTE_ORDER BYTE_ORDER | |
256 # elif defined(__BYTE_ORDER) | |
257 # define LZO_BYTE_ORDER __BYTE_ORDER | |
258 # endif | |
259 #endif | |
260 | |
261 #if defined(LZO_BYTE_ORDER) | |
262 # if (LZO_BYTE_ORDER != LZO_LITTLE_ENDIAN) && \ | |
263 (LZO_BYTE_ORDER != LZO_BIG_ENDIAN) | |
264 # error "invalid LZO_BYTE_ORDER" | |
265 # endif | |
266 #endif | |
267 | |
268 #if defined(LZO_UNALIGNED_OK) && !defined(LZO_BYTE_ORDER) | |
269 # error "LZO_BYTE_ORDER is not defined" | |
270 #endif | |
271 | |
272 #define LZO_OPTIMIZE_GNUC_i386_IS_BUGGY | |
273 | |
274 #if defined(NDEBUG) && !defined(LZO_DEBUG) && !defined(__LZO_CHECKER) | |
275 # if defined(__GNUC__) && defined(__i386__) | |
276 # if !defined(LZO_OPTIMIZE_GNUC_i386_IS_BUGGY) | |
277 # define LZO_OPTIMIZE_GNUC_i386 | |
278 # endif | |
279 # endif | |
280 #endif | |
281 | |
282 __LZO_EXTERN_C int __lzo_init_done; | |
283 __LZO_EXTERN_C const lzo_byte __lzo_copyright[]; | |
284 LZO_EXTERN(const lzo_byte *) lzo_copyright(void); | |
285 __LZO_EXTERN_C const lzo_uint32 _lzo_crc32_table[256]; | |
286 | |
287 #define _LZO_STRINGIZE(x) #x | |
288 #define _LZO_MEXPAND(x) _LZO_STRINGIZE(x) | |
289 | |
290 #define _LZO_CONCAT2(a,b) a ## b | |
291 #define _LZO_CONCAT3(a,b,c) a ## b ## c | |
292 #define _LZO_CONCAT4(a,b,c,d) a ## b ## c ## d | |
293 #define _LZO_CONCAT5(a,b,c,d,e) a ## b ## c ## d ## e | |
294 | |
295 #define _LZO_ECONCAT2(a,b) _LZO_CONCAT2(a,b) | |
296 #define _LZO_ECONCAT3(a,b,c) _LZO_CONCAT3(a,b,c) | |
297 #define _LZO_ECONCAT4(a,b,c,d) _LZO_CONCAT4(a,b,c,d) | |
298 #define _LZO_ECONCAT5(a,b,c,d,e) _LZO_CONCAT5(a,b,c,d,e) | |
299 | |
300 #if 0 | |
301 | |
302 #define __LZO_IS_COMPRESS_QUERY(i,il,o,ol,w) ((lzo_voidp)(o) == (w)) | |
303 #define __LZO_QUERY_COMPRESS(i,il,o,ol,w,n,s) \ | |
304 (*ol = (n)*(s), LZO_E_OK) | |
305 | |
306 #define __LZO_IS_DECOMPRESS_QUERY(i,il,o,ol,w) ((lzo_voidp)(o) == (w)) | |
307 #define __LZO_QUERY_DECOMPRESS(i,il,o,ol,w,n,s) \ | |
308 (*ol = (n)*(s), LZO_E_OK) | |
309 | |
310 #define __LZO_IS_OPTIMIZE_QUERY(i,il,o,ol,w) ((lzo_voidp)(o) == (w)) | |
311 #define __LZO_QUERY_OPTIMIZE(i,il,o,ol,w,n,s) \ | |
312 (*ol = (n)*(s), LZO_E_OK) | |
313 | |
314 #endif | |
315 | |
316 #ifndef __LZO_PTR_H | |
317 #define __LZO_PTR_H | |
318 | |
319 #ifdef __cplusplus | |
320 extern "C" { | |
321 #endif | |
322 | |
323 #if defined(__LZO_DOS16) || defined(__LZO_WIN16) | |
324 # include <dos.h> | |
325 # if 1 && defined(__WATCOMC__) | |
326 # include <i86.h> | |
327 __LZO_EXTERN_C unsigned char _HShift; | |
328 # define __LZO_HShift _HShift | |
329 # elif 1 && defined(_MSC_VER) | |
330 __LZO_EXTERN_C unsigned short __near _AHSHIFT; | |
331 # define __LZO_HShift ((unsigned) &_AHSHIFT) | |
332 # elif defined(__LZO_WIN16) | |
333 # define __LZO_HShift 3 | |
334 # else | |
335 # define __LZO_HShift 12 | |
336 # endif | |
337 # if !defined(_FP_SEG) && defined(FP_SEG) | |
338 # define _FP_SEG FP_SEG | |
339 # endif | |
340 # if !defined(_FP_OFF) && defined(FP_OFF) | |
341 # define _FP_OFF FP_OFF | |
342 # endif | |
343 #endif | |
344 | |
345 #if (UINT_MAX >= LZO_0xffffffffL) | |
346 typedef ptrdiff_t lzo_ptrdiff_t; | |
347 #else | |
348 typedef long lzo_ptrdiff_t; | |
349 #endif | |
350 | |
351 #if !defined(__LZO_HAVE_PTR_T) | |
352 # if defined(lzo_ptr_t) | |
353 # define __LZO_HAVE_PTR_T | |
354 # endif | |
355 #endif | |
356 #if !defined(__LZO_HAVE_PTR_T) | |
357 # if defined(SIZEOF_CHAR_P) && defined(SIZEOF_UNSIGNED_LONG) | |
358 # if (SIZEOF_CHAR_P == SIZEOF_UNSIGNED_LONG) | |
359 typedef unsigned long lzo_ptr_t; | |
360 typedef long 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(SIZEOF_CHAR_P) && defined(SIZEOF_UNSIGNED) | |
367 # if (SIZEOF_CHAR_P == SIZEOF_UNSIGNED) | |
368 typedef unsigned int lzo_ptr_t; | |
369 typedef int lzo_sptr_t; | |
370 # define __LZO_HAVE_PTR_T | |
371 # endif | |
372 # endif | |
373 #endif | |
374 #if !defined(__LZO_HAVE_PTR_T) | |
375 # if defined(SIZEOF_CHAR_P) && defined(SIZEOF_UNSIGNED_SHORT) | |
376 # if (SIZEOF_CHAR_P == SIZEOF_UNSIGNED_SHORT) | |
377 typedef unsigned short lzo_ptr_t; | |
378 typedef short lzo_sptr_t; | |
379 # define __LZO_HAVE_PTR_T | |
380 # endif | |
381 # endif | |
382 #endif | |
383 #if !defined(__LZO_HAVE_PTR_T) | |
384 # if defined(LZO_HAVE_CONFIG_H) || defined(SIZEOF_CHAR_P) | |
385 # error "no suitable type for lzo_ptr_t" | |
386 # else | |
387 typedef unsigned long lzo_ptr_t; | |
388 typedef long lzo_sptr_t; | |
389 # define __LZO_HAVE_PTR_T | |
390 # endif | |
391 #endif | |
392 | |
393 #if defined(__LZO_DOS16) || defined(__LZO_WIN16) | |
394 #define PTR(a) ((lzo_bytep) (a)) | |
395 #define PTR_ALIGNED_4(a) ((_FP_OFF(a) & 3) == 0) | |
396 #define PTR_ALIGNED2_4(a,b) (((_FP_OFF(a) | _FP_OFF(b)) & 3) == 0) | |
397 #else | |
398 #define PTR(a) ((lzo_ptr_t) (a)) | |
399 #define PTR_LINEAR(a) PTR(a) | |
400 #define PTR_ALIGNED_4(a) ((PTR_LINEAR(a) & 3) == 0) | |
401 #define PTR_ALIGNED_8(a) ((PTR_LINEAR(a) & 7) == 0) | |
402 #define PTR_ALIGNED2_4(a,b) (((PTR_LINEAR(a) | PTR_LINEAR(b)) & 3) == 0) | |
403 #define PTR_ALIGNED2_8(a,b) (((PTR_LINEAR(a) | PTR_LINEAR(b)) & 7) == 0) | |
404 #endif | |
405 | |
406 #define PTR_LT(a,b) (PTR(a) < PTR(b)) | |
407 #define PTR_GE(a,b) (PTR(a) >= PTR(b)) | |
408 #define PTR_DIFF(a,b) ((lzo_ptrdiff_t) (PTR(a) - PTR(b))) | |
409 | |
410 LZO_EXTERN(lzo_ptr_t) | |
411 __lzo_ptr_linear(const lzo_voidp ptr); | |
412 | |
413 typedef union | |
414 { | |
415 char a_char; | |
416 unsigned char a_uchar; | |
417 short a_short; | |
418 unsigned short a_ushort; | |
419 int a_int; | |
420 unsigned int a_uint; | |
421 long a_long; | |
422 unsigned long a_ulong; | |
423 lzo_int a_lzo_int; | |
424 lzo_uint a_lzo_uint; | |
425 lzo_int32 a_lzo_int32; | |
426 lzo_uint32 a_lzo_uint32; | |
427 ptrdiff_t a_ptrdiff_t; | |
428 lzo_ptrdiff_t a_lzo_ptrdiff_t; | |
429 lzo_ptr_t a_lzo_ptr_t; | |
430 char * a_charp; | |
431 lzo_bytep a_lzo_bytep; | |
432 lzo_bytepp a_lzo_bytepp; | |
433 } | |
434 lzo_align_t; | |
435 | |
436 #ifdef __cplusplus | |
437 } | |
438 #endif | |
439 | |
440 #endif | |
441 | |
442 #define LZO_DETERMINISTIC | |
443 | |
444 #define LZO_DICT_USE_PTR | |
445 #if defined(__LZO_DOS16) || defined(__LZO_WIN16) || defined(__LZO_STRICT_16BIT) | |
446 # undef LZO_DICT_USE_PTR | |
447 #endif | |
448 | |
449 #if defined(LZO_DICT_USE_PTR) | |
450 # define lzo_dict_t const lzo_bytep | |
451 # define lzo_dict_p lzo_dict_t __LZO_MMODEL * | |
452 #else | |
453 # define lzo_dict_t lzo_uint | |
454 # define lzo_dict_p lzo_dict_t __LZO_MMODEL * | |
455 #endif | |
456 | |
457 #if !defined(lzo_moff_t) | |
458 #define lzo_moff_t lzo_uint | |
459 #endif | |
460 | |
461 #endif | |
462 | |
463 LZO_PUBLIC(lzo_ptr_t) | |
464 __lzo_ptr_linear(const lzo_voidp ptr) | |
465 { | |
466 lzo_ptr_t p; | |
467 | |
468 #if defined(__LZO_DOS16) || defined(__LZO_WIN16) | |
469 p = (((lzo_ptr_t)(_FP_SEG(ptr))) << (16 - __LZO_HShift)) + (_FP_OFF(ptr)); | |
470 #else | |
471 p = PTR_LINEAR(ptr); | |
472 #endif | |
473 | |
474 return p; | |
475 } | |
476 | |
477 LZO_PUBLIC(unsigned) | |
478 __lzo_align_gap(const lzo_voidp ptr, lzo_uint size) | |
479 { | |
480 lzo_ptr_t p, s, n; | |
481 | |
482 assert(size > 0); | |
483 | |
484 p = __lzo_ptr_linear(ptr); | |
485 s = (lzo_ptr_t) (size - 1); | |
486 #if 0 | |
487 assert((size & (size - 1)) == 0); | |
488 n = ((p + s) & ~s) - p; | |
489 #else | |
490 n = (((p + s) / size) * size) - p; | |
491 #endif | |
492 | |
493 assert((long)n >= 0); | |
494 assert(n <= s); | |
495 | |
496 return (unsigned)n; | |
497 } | |
498 | |
499 #ifndef __LZO_UTIL_H | |
500 #define __LZO_UTIL_H | |
501 | |
502 #ifndef __LZO_CONF_H | |
503 #endif | |
504 | |
505 #ifdef __cplusplus | |
506 extern "C" { | |
507 #endif | |
508 | |
509 #if 1 && defined(HAVE_MEMCPY) | |
510 #if !defined(__LZO_DOS16) && !defined(__LZO_WIN16) | |
511 | |
512 #define MEMCPY8_DS(dest,src,len) \ | |
513 memcpy(dest,src,len); \ | |
514 dest += len; \ | |
515 src += len | |
516 | |
517 #endif | |
518 #endif | |
519 | |
520 #if 0 && !defined(MEMCPY8_DS) | |
521 | |
522 #define MEMCPY8_DS(dest,src,len) \ | |
523 { do { \ | |
524 *dest++ = *src++; \ | |
525 *dest++ = *src++; \ | |
526 *dest++ = *src++; \ | |
527 *dest++ = *src++; \ | |
528 *dest++ = *src++; \ | |
529 *dest++ = *src++; \ | |
530 *dest++ = *src++; \ | |
531 *dest++ = *src++; \ | |
532 len -= 8; \ | |
533 } while (len > 0); } | |
534 | |
535 #endif | |
536 | |
537 #if !defined(MEMCPY8_DS) | |
538 | |
539 #define MEMCPY8_DS(dest,src,len) \ | |
540 { register lzo_uint __l = (len) / 8; \ | |
541 do { \ | |
542 *dest++ = *src++; \ | |
543 *dest++ = *src++; \ | |
544 *dest++ = *src++; \ | |
545 *dest++ = *src++; \ | |
546 *dest++ = *src++; \ | |
547 *dest++ = *src++; \ | |
548 *dest++ = *src++; \ | |
549 *dest++ = *src++; \ | |
550 } while (--__l > 0); } | |
551 | |
552 #endif | |
553 | |
554 #define MEMCPY_DS(dest,src,len) \ | |
555 do *dest++ = *src++; \ | |
556 while (--len > 0) | |
557 | |
558 #define MEMMOVE_DS(dest,src,len) \ | |
559 do *dest++ = *src++; \ | |
560 while (--len > 0) | |
561 | |
562 #if 0 && defined(LZO_OPTIMIZE_GNUC_i386) | |
563 | |
564 #define BZERO8_PTR(s,l,n) \ | |
565 __asm__ __volatile__( \ | |
566 "movl %0,%%eax \n" \ | |
567 "movl %1,%%edi \n" \ | |
568 "movl %2,%%ecx \n" \ | |
569 "cld \n" \ | |
570 "rep \n" \ | |
571 "stosl %%eax,(%%edi) \n" \ | |
572 : \ | |
573 :"g" (0),"g" (s),"g" (n) \ | |
574 :"eax","edi","ecx", "memory", "cc" \ | |
575 ) | |
576 | |
577 #elif (LZO_UINT_MAX <= SIZE_T_MAX) && defined(HAVE_MEMSET) | |
578 | |
579 #if 1 | |
580 #define BZERO8_PTR(s,l,n) memset((s),0,(lzo_uint)(l)*(n)) | |
581 #else | |
582 #define BZERO8_PTR(s,l,n) memset((lzo_voidp)(s),0,(lzo_uint)(l)*(n)) | |
583 #endif | |
584 | |
585 #else | |
586 | |
587 #define BZERO8_PTR(s,l,n) \ | |
588 lzo_memset((lzo_voidp)(s),0,(lzo_uint)(l)*(n)) | |
589 | |
590 #endif | |
591 | |
592 #if 0 | |
593 #if defined(__GNUC__) && defined(__i386__) | |
594 | |
595 unsigned char lzo_rotr8(unsigned char value, int shift); | |
596 extern __inline__ unsigned char lzo_rotr8(unsigned char value, int shift) | |
597 { | |
598 unsigned char result; | |
599 | |
600 __asm__ __volatile__ ("movb %b1, %b0; rorb %b2, %b0" | |
601 : "=a"(result) : "g"(value), "c"(shift)); | |
602 return result; | |
603 } | |
604 | |
605 unsigned short lzo_rotr16(unsigned short value, int shift); | |
606 extern __inline__ unsigned short lzo_rotr16(unsigned short value, int shift) | |
607 { | |
608 unsigned short result; | |
609 | |
610 __asm__ __volatile__ ("movw %b1, %b0; rorw %b2, %b0" | |
611 : "=a"(result) : "g"(value), "c"(shift)); | |
612 return result; | |
613 } | |
614 | |
615 #endif | |
616 #endif | |
617 | |
618 #ifdef __cplusplus | |
619 } | |
620 #endif | |
621 | |
622 #endif | |
623 | |
624 LZO_PUBLIC(lzo_bool) | |
625 lzo_assert(int expr) | |
626 { | |
627 return (expr) ? 1 : 0; | |
628 } | |
629 | |
630 /* If you use the LZO library in a product, you *must* keep this | |
631 * copyright string in the executable of your product. | |
632 */ | |
633 | |
634 const lzo_byte __lzo_copyright[] = | |
635 #if !defined(__LZO_IN_MINLZO) | |
636 LZO_VERSION_STRING; | |
637 #else | |
638 "\n\n\n" | |
639 "LZO real-time data compression library.\n" | |
640 "Copyright (C) 1996, 1997, 1998, 1999, 2000 Markus Franz Xaver Johannes Oberhumer\n" | |
641 "<markus.oberhumer@jk.uni-linz.ac.at>\n" | |
642 "http://wildsau.idv.uni-linz.ac.at/mfx/lzo.html\n" | |
643 "\n" | |
644 "LZO version: v" LZO_VERSION_STRING ", " LZO_VERSION_DATE "\n" | |
645 "LZO build date: " __DATE__ " " __TIME__ "\n\n" | |
646 "LZO special compilation options:\n" | |
647 #ifdef __cplusplus | |
648 " __cplusplus\n" | |
649 #endif | |
650 #if defined(__PIC__) | |
651 " __PIC__\n" | |
652 #elif defined(__pic__) | |
653 " __pic__\n" | |
654 #endif | |
655 #if (UINT_MAX < LZO_0xffffffffL) | |
656 " 16BIT\n" | |
657 #endif | |
658 #if defined(__LZO_STRICT_16BIT) | |
659 " __LZO_STRICT_16BIT\n" | |
660 #endif | |
661 #if (UINT_MAX > LZO_0xffffffffL) | |
662 " UINT_MAX=" _LZO_MEXPAND(UINT_MAX) "\n" | |
663 #endif | |
664 #if (ULONG_MAX > LZO_0xffffffffL) | |
665 " ULONG_MAX=" _LZO_MEXPAND(ULONG_MAX) "\n" | |
666 #endif | |
667 #if defined(LZO_BYTE_ORDER) | |
668 " LZO_BYTE_ORDER=" _LZO_MEXPAND(LZO_BYTE_ORDER) "\n" | |
669 #endif | |
670 #if defined(LZO_UNALIGNED_OK_2) | |
671 " LZO_UNALIGNED_OK_2\n" | |
672 #endif | |
673 #if defined(LZO_UNALIGNED_OK_4) | |
674 " LZO_UNALIGNED_OK_4\n" | |
675 #endif | |
676 #if defined(LZO_ALIGNED_OK_4) | |
677 " LZO_ALIGNED_OK_4\n" | |
678 #endif | |
679 #if defined(LZO_DICT_USE_PTR) | |
680 " LZO_DICT_USE_PTR\n" | |
681 #endif | |
682 #if defined(__LZO_QUERY_COMPRESS) | |
683 " __LZO_QUERY_COMPRESS\n" | |
684 #endif | |
685 #if defined(__LZO_QUERY_DECOMPRESS) | |
686 " __LZO_QUERY_DECOMPRESS\n" | |
687 #endif | |
688 #if defined(__LZO_IN_MINILZO) | |
689 " __LZO_IN_MINILZO\n" | |
690 #endif | |
691 "\n\n" | |
692 "$Id: LZO " LZO_VERSION_STRING " built " __DATE__ " " __TIME__ | |
693 #if defined(__GNUC__) && defined(__VERSION__) | |
694 " by gcc " __VERSION__ | |
695 #elif defined(__BORLANDC__) | |
696 " by Borland C " _LZO_MEXPAND(__BORLANDC__) | |
697 #elif defined(_MSC_VER) | |
698 " by Microsoft C " _LZO_MEXPAND(_MSC_VER) | |
699 #elif defined(__PUREC__) | |
700 " by Pure C " _LZO_MEXPAND(__PUREC__) | |
701 #elif defined(__SC__) | |
702 " by Symantec C " _LZO_MEXPAND(__SC__) | |
703 #elif defined(__TURBOC__) | |
704 " by Turbo C " _LZO_MEXPAND(__TURBOC__) | |
705 #elif defined(__WATCOMC__) | |
706 " by Watcom C " _LZO_MEXPAND(__WATCOMC__) | |
707 #endif | |
708 " $\n" | |
709 "$Copyright: LZO (C) 1996, 1997, 1998, 1999, 2000 Markus Franz Xaver Johannes Oberhumer $\n"; | |
710 #endif | |
711 | |
712 LZO_PUBLIC(const lzo_byte *) | |
713 lzo_copyright(void) | |
714 { | |
715 return __lzo_copyright; | |
716 } | |
717 | |
718 LZO_PUBLIC(unsigned) | |
719 lzo_version(void) | |
720 { | |
721 return LZO_VERSION; | |
722 } | |
723 | |
724 LZO_PUBLIC(const char *) | |
725 lzo_version_string(void) | |
726 { | |
727 return LZO_VERSION_STRING; | |
728 } | |
729 | |
730 LZO_PUBLIC(const char *) | |
731 lzo_version_date(void) | |
732 { | |
733 return LZO_VERSION_DATE; | |
734 } | |
735 | |
736 LZO_PUBLIC(const lzo_charp) | |
737 _lzo_version_string(void) | |
738 { | |
739 return LZO_VERSION_STRING; | |
740 } | |
741 | |
742 LZO_PUBLIC(const lzo_charp) | |
743 _lzo_version_date(void) | |
744 { | |
745 return LZO_VERSION_DATE; | |
746 } | |
747 | |
748 #define LZO_BASE 65521u | |
749 #define LZO_NMAX 5552 | |
750 | |
751 #define LZO_DO1(buf,i) {s1 += buf[i]; s2 += s1;} | |
752 #define LZO_DO2(buf,i) LZO_DO1(buf,i); LZO_DO1(buf,i+1); | |
753 #define LZO_DO4(buf,i) LZO_DO2(buf,i); LZO_DO2(buf,i+2); | |
754 #define LZO_DO8(buf,i) LZO_DO4(buf,i); LZO_DO4(buf,i+4); | |
755 #define LZO_DO16(buf,i) LZO_DO8(buf,i); LZO_DO8(buf,i+8); | |
756 | |
757 LZO_PUBLIC(lzo_uint32) | |
758 lzo_adler32(lzo_uint32 adler, const lzo_byte *buf, lzo_uint len) | |
759 { | |
760 lzo_uint32 s1 = adler & 0xffff; | |
761 lzo_uint32 s2 = (adler >> 16) & 0xffff; | |
762 int k; | |
763 | |
764 if (buf == NULL) | |
765 return 1; | |
766 | |
767 while (len > 0) | |
768 { | |
769 k = len < LZO_NMAX ? (int) len : LZO_NMAX; | |
770 len -= k; | |
771 if (k >= 16) do | |
772 { | |
773 LZO_DO16(buf,0); | |
774 buf += 16; | |
775 k -= 16; | |
776 } while (k >= 16); | |
777 if (k != 0) do | |
778 { | |
779 s1 += *buf++; | |
780 s2 += s1; | |
781 } while (--k > 0); | |
782 s1 %= LZO_BASE; | |
783 s2 %= LZO_BASE; | |
784 } | |
785 return (s2 << 16) | s1; | |
786 } | |
787 | |
788 LZO_PUBLIC(int) | |
789 lzo_memcmp(const lzo_voidp s1, const lzo_voidp s2, lzo_uint len) | |
790 { | |
791 #if (LZO_UINT_MAX <= SIZE_T_MAX) && defined(HAVE_MEMCMP) | |
792 return memcmp(s1,s2,len); | |
793 #else | |
794 const lzo_byte *p1 = (const lzo_byte *) s1; | |
795 const lzo_byte *p2 = (const lzo_byte *) s2; | |
796 int d; | |
797 | |
798 if (len > 0) do | |
799 { | |
800 d = *p1 - *p2; | |
801 if (d != 0) | |
802 return d; | |
803 p1++; | |
804 p2++; | |
805 } | |
806 while (--len > 0); | |
807 return 0; | |
808 #endif | |
809 } | |
810 | |
811 LZO_PUBLIC(lzo_voidp) | |
812 lzo_memcpy(lzo_voidp dest, const lzo_voidp src, lzo_uint len) | |
813 { | |
814 #if (LZO_UINT_MAX <= SIZE_T_MAX) && defined(HAVE_MEMCPY) | |
815 return memcpy(dest,src,len); | |
816 #else | |
817 lzo_byte *p1 = (lzo_byte *) dest; | |
818 const lzo_byte *p2 = (const lzo_byte *) src; | |
819 | |
820 if (len <= 0 || p1 == p2) | |
821 return dest; | |
822 do | |
823 *p1++ = *p2++; | |
824 while (--len > 0); | |
825 return dest; | |
826 #endif | |
827 } | |
828 | |
829 LZO_PUBLIC(lzo_voidp) | |
830 lzo_memmove(lzo_voidp dest, const lzo_voidp src, lzo_uint len) | |
831 { | |
832 #if (LZO_UINT_MAX <= SIZE_T_MAX) && defined(HAVE_MEMMOVE) | |
833 return memmove(dest,src,len); | |
834 #else | |
835 lzo_byte *p1 = (lzo_byte *) dest; | |
836 const lzo_byte *p2 = (const lzo_byte *) src; | |
837 | |
838 if (len <= 0 || p1 == p2) | |
839 return dest; | |
840 | |
841 if (p1 < p2) | |
842 { | |
843 do | |
844 *p1++ = *p2++; | |
845 while (--len > 0); | |
846 } | |
847 else | |
848 { | |
849 p1 += len; | |
850 p2 += len; | |
851 do | |
852 *--p1 = *--p2; | |
853 while (--len > 0); | |
854 } | |
855 return dest; | |
856 #endif | |
857 } | |
858 | |
859 LZO_PUBLIC(lzo_voidp) | |
860 lzo_memset(lzo_voidp s, int c, lzo_uint len) | |
861 { | |
862 #if (LZO_UINT_MAX <= SIZE_T_MAX) && defined(HAVE_MEMSET) | |
863 return memset(s,c,len); | |
864 #else | |
865 lzo_byte *p = (lzo_byte *) s; | |
866 | |
867 if (len > 0) do | |
868 *p++ = LZO_BYTE(c); | |
869 while (--len > 0); | |
870 return s; | |
871 #endif | |
872 } | |
873 | |
874 #include <stdio.h> | |
875 | |
876 #if 0 | |
877 # define IS_SIGNED(type) (((type) (1ul << (8 * sizeof(type) - 1))) < 0) | |
878 # define IS_UNSIGNED(type) (((type) (1ul << (8 * sizeof(type) - 1))) > 0) | |
879 #else | |
880 # define IS_SIGNED(type) (((type) (-1)) < ((type) 0)) | |
881 # define IS_UNSIGNED(type) (((type) (-1)) > ((type) 0)) | |
882 #endif | |
883 | |
884 static lzo_bool schedule_insns_bug(void); | |
885 static lzo_bool strength_reduce_bug(int *); | |
886 | |
887 #if 0 || defined(LZO_DEBUG) | |
888 static lzo_bool __lzo_assert_fail(const char *s, unsigned line) | |
889 { | |
890 #if defined(__palmos__) | |
891 printf("LZO assertion failed in line %u: '%s'\n",line,s); | |
892 #else | |
893 fprintf(stderr,"LZO assertion failed in line %u: '%s'\n",line,s); | |
894 #endif | |
895 return 0; | |
896 } | |
897 # define __lzo_assert(x) ((x) ? 1 : __lzo_assert_fail(#x,__LINE__)) | |
898 #else | |
899 # define __lzo_assert(x) ((x) ? 1 : 0) | |
900 #endif | |
901 | |
902 static lzo_bool basic_integral_check(void) | |
903 { | |
904 lzo_bool r = 1; | |
905 lzo_bool sanity; | |
906 | |
907 r &= __lzo_assert(CHAR_BIT == 8); | |
908 r &= __lzo_assert(sizeof(char) == 1); | |
909 r &= __lzo_assert(sizeof(short) >= 2); | |
910 r &= __lzo_assert(sizeof(long) >= 4); | |
911 r &= __lzo_assert(sizeof(int) >= sizeof(short)); | |
912 r &= __lzo_assert(sizeof(long) >= sizeof(int)); | |
913 | |
914 r &= __lzo_assert(sizeof(lzo_uint32) >= 4); | |
915 r &= __lzo_assert(sizeof(lzo_uint32) >= sizeof(unsigned)); | |
916 #if defined(__LZO_STRICT_16BIT) | |
917 r &= __lzo_assert(sizeof(lzo_uint) == 2); | |
918 #else | |
919 r &= __lzo_assert(sizeof(lzo_uint) >= 4); | |
920 r &= __lzo_assert(sizeof(lzo_uint) >= sizeof(unsigned)); | |
921 #endif | |
922 | |
923 #if defined(SIZEOF_UNSIGNED) | |
924 r &= __lzo_assert(SIZEOF_UNSIGNED == sizeof(unsigned)); | |
925 #endif | |
926 #if defined(SIZEOF_UNSIGNED_LONG) | |
927 r &= __lzo_assert(SIZEOF_UNSIGNED_LONG == sizeof(unsigned long)); | |
928 #endif | |
929 #if defined(SIZEOF_UNSIGNED_SHORT) | |
930 r &= __lzo_assert(SIZEOF_UNSIGNED_SHORT == sizeof(unsigned short)); | |
931 #endif | |
932 #if !defined(__LZO_IN_MINILZO) | |
933 #if defined(SIZEOF_SIZE_T) | |
934 r &= __lzo_assert(SIZEOF_SIZE_T == sizeof(size_t)); | |
935 #endif | |
936 #endif | |
937 | |
938 sanity = IS_UNSIGNED(unsigned short) && IS_UNSIGNED(unsigned) && | |
939 IS_UNSIGNED(unsigned long) && | |
940 IS_SIGNED(short) && IS_SIGNED(int) && IS_SIGNED(long); | |
941 if (sanity) | |
942 { | |
943 r &= __lzo_assert(IS_UNSIGNED(lzo_uint32)); | |
944 r &= __lzo_assert(IS_UNSIGNED(lzo_uint)); | |
945 r &= __lzo_assert(IS_SIGNED(lzo_int32)); | |
946 r &= __lzo_assert(IS_SIGNED(lzo_int)); | |
947 | |
948 r &= __lzo_assert(INT_MAX == LZO_STYPE_MAX(sizeof(int))); | |
949 r &= __lzo_assert(UINT_MAX == LZO_UTYPE_MAX(sizeof(unsigned))); | |
950 r &= __lzo_assert(LONG_MAX == LZO_STYPE_MAX(sizeof(long))); | |
951 r &= __lzo_assert(ULONG_MAX == LZO_UTYPE_MAX(sizeof(unsigned long))); | |
952 r &= __lzo_assert(SHRT_MAX == LZO_STYPE_MAX(sizeof(short))); | |
953 r &= __lzo_assert(USHRT_MAX == LZO_UTYPE_MAX(sizeof(unsigned short))); | |
954 r &= __lzo_assert(LZO_UINT32_MAX == LZO_UTYPE_MAX(sizeof(lzo_uint32))); | |
955 r &= __lzo_assert(LZO_UINT_MAX == LZO_UTYPE_MAX(sizeof(lzo_uint))); | |
956 #if !defined(__LZO_IN_MINILZO) | |
957 r &= __lzo_assert(SIZE_T_MAX == LZO_UTYPE_MAX(sizeof(size_t))); | |
958 #endif | |
959 } | |
960 | |
961 #if 0 | |
962 r &= __lzo_assert(LZO_BYTE(257) == 1); | |
963 r &= __lzo_assert(LZO_USHORT(65537L) == 1); | |
964 #endif | |
965 | |
966 return r; | |
967 } | |
968 | |
969 static lzo_bool basic_ptr_check(void) | |
970 { | |
971 lzo_bool r = 1; | |
972 lzo_bool sanity; | |
973 | |
974 r &= __lzo_assert(sizeof(char *) >= sizeof(int)); | |
975 r &= __lzo_assert(sizeof(lzo_byte *) >= sizeof(char *)); | |
976 | |
977 r &= __lzo_assert(sizeof(lzo_voidp) == sizeof(lzo_byte *)); | |
978 r &= __lzo_assert(sizeof(lzo_voidp) == sizeof(lzo_voidpp)); | |
979 r &= __lzo_assert(sizeof(lzo_voidp) == sizeof(lzo_bytepp)); | |
980 r &= __lzo_assert(sizeof(lzo_voidp) >= sizeof(lzo_uint)); | |
981 | |
982 r &= __lzo_assert(sizeof(lzo_ptr_t) == sizeof(lzo_voidp)); | |
983 r &= __lzo_assert(sizeof(lzo_ptr_t) >= sizeof(lzo_uint)); | |
984 | |
985 r &= __lzo_assert(sizeof(lzo_ptrdiff_t) >= 4); | |
986 r &= __lzo_assert(sizeof(lzo_ptrdiff_t) >= sizeof(ptrdiff_t)); | |
987 | |
988 #if defined(SIZEOF_CHAR_P) | |
989 r &= __lzo_assert(SIZEOF_CHAR_P == sizeof(char *)); | |
990 #endif | |
991 #if defined(SIZEOF_PTRDIFF_T) | |
992 r &= __lzo_assert(SIZEOF_PTRDIFF_T == sizeof(ptrdiff_t)); | |
993 #endif | |
994 | |
995 sanity = IS_UNSIGNED(unsigned short) && IS_UNSIGNED(unsigned) && | |
996 IS_UNSIGNED(unsigned long) && | |
997 IS_SIGNED(short) && IS_SIGNED(int) && IS_SIGNED(long); | |
998 if (sanity) | |
999 { | |
1000 r &= __lzo_assert(IS_UNSIGNED(lzo_ptr_t)); | |
1001 r &= __lzo_assert(IS_UNSIGNED(lzo_moff_t)); | |
1002 r &= __lzo_assert(IS_SIGNED(lzo_ptrdiff_t)); | |
1003 r &= __lzo_assert(IS_SIGNED(lzo_sptr_t)); | |
1004 } | |
1005 | |
1006 return r; | |
1007 } | |
1008 | |
1009 static lzo_bool ptr_check(void) | |
1010 { | |
1011 lzo_bool r = 1; | |
1012 int i; | |
1013 char _wrkmem[10 * sizeof(lzo_byte *) + sizeof(lzo_align_t)]; | |
1014 lzo_byte *wrkmem; | |
1015 lzo_bytepp dict; | |
1016 unsigned char x[4 * sizeof(lzo_align_t)]; | |
1017 long d; | |
1018 lzo_align_t a; | |
1019 | |
1020 for (i = 0; i < (int) sizeof(x); i++) | |
1021 x[i] = LZO_BYTE(i); | |
1022 | |
1023 wrkmem = LZO_PTR_ALIGN_UP((lzo_byte *)_wrkmem,sizeof(lzo_align_t)); | |
1024 dict = (lzo_bytepp) wrkmem; | |
1025 | |
1026 d = (long) ((const lzo_bytep) dict - (const lzo_bytep) _wrkmem); | |
1027 r &= __lzo_assert(d >= 0); | |
1028 r &= __lzo_assert(d < (long) sizeof(lzo_align_t)); | |
1029 | |
1030 memset(&a,0xff,sizeof(a)); | |
1031 r &= __lzo_assert(a.a_ushort == USHRT_MAX); | |
1032 r &= __lzo_assert(a.a_uint == UINT_MAX); | |
1033 r &= __lzo_assert(a.a_ulong == ULONG_MAX); | |
1034 r &= __lzo_assert(a.a_lzo_uint == LZO_UINT_MAX); | |
1035 | |
1036 if (r == 1) | |
1037 { | |
1038 for (i = 0; i < 8; i++) | |
1039 r &= __lzo_assert((const lzo_voidp) (&dict[i]) == (const lzo_voidp) (&wrkmem[i * sizeof(lzo_byte *)])); | |
1040 } | |
1041 | |
1042 memset(&a,0,sizeof(a)); | |
1043 r &= __lzo_assert(a.a_charp == NULL); | |
1044 r &= __lzo_assert(a.a_lzo_bytep == NULL); | |
1045 //r &= __lzo_assert(NULL == 0); | |
1046 if (r == 1) | |
1047 { | |
1048 for (i = 0; i < 10; i++) | |
1049 dict[i] = wrkmem; | |
1050 BZERO8_PTR(dict+1,sizeof(dict[0]),8); | |
1051 r &= __lzo_assert(dict[0] == wrkmem); | |
1052 for (i = 1; i < 9; i++) | |
1053 r &= __lzo_assert(dict[i] == NULL); | |
1054 r &= __lzo_assert(dict[9] == wrkmem); | |
1055 } | |
1056 | |
1057 if (r == 1) | |
1058 { | |
1059 unsigned k = 1; | |
1060 const unsigned n = (unsigned) sizeof(lzo_uint32); | |
1061 lzo_byte *p0; | |
1062 lzo_byte *p1; | |
1063 | |
1064 k += __lzo_align_gap(&x[k],n); | |
1065 p0 = (lzo_bytep) &x[k]; | |
1066 #if defined(PTR_LINEAR) | |
1067 r &= __lzo_assert((PTR_LINEAR(p0) & (n-1)) == 0); | |
1068 #else | |
1069 r &= __lzo_assert(n == 4); | |
1070 r &= __lzo_assert(PTR_ALIGNED_4(p0)); | |
1071 #endif | |
1072 | |
1073 r &= __lzo_assert(k >= 1); | |
1074 p1 = (lzo_bytep) &x[1]; | |
1075 r &= __lzo_assert(PTR_GE(p0,p1)); | |
1076 | |
1077 r &= __lzo_assert(k < 1+n); | |
1078 p1 = (lzo_bytep) &x[1+n]; | |
1079 r &= __lzo_assert(PTR_LT(p0,p1)); | |
1080 | |
1081 if (r == 1) | |
1082 { | |
1083 lzo_uint32 v0 = * (lzo_uint32 *) &x[k]; | |
1084 lzo_uint32 v1 = * (lzo_uint32 *) &x[k+n]; | |
1085 | |
1086 r &= __lzo_assert(v0 > 0); | |
1087 r &= __lzo_assert(v1 > 0); | |
1088 } | |
1089 } | |
1090 | |
1091 return r; | |
1092 } | |
1093 | |
1094 LZO_PUBLIC(int) | |
1095 _lzo_config_check(void) | |
1096 { | |
1097 lzo_bool r = 1; | |
1098 int i; | |
1099 union { | |
1100 lzo_uint32 a; | |
1101 unsigned short b; | |
1102 lzo_uint32 aa[4]; | |
1103 unsigned char x[4*sizeof(lzo_align_t)]; | |
1104 } u; | |
1105 | |
1106 #if 0 | |
1107 r &= __lzo_assert((const void *)&u == (const void *)&u.a); | |
1108 r &= __lzo_assert((const void *)&u == (const void *)&u.b); | |
1109 r &= __lzo_assert((const void *)&u == (const void *)&u.x[0]); | |
1110 r &= __lzo_assert((const void *)&u == (const void *)&u.aa[0]); | |
1111 #endif | |
1112 | |
1113 r &= basic_integral_check(); | |
1114 r &= basic_ptr_check(); | |
1115 if (r != 1) | |
1116 return LZO_E_ERROR; | |
1117 | |
1118 u.a = 0; u.b = 0; | |
1119 for (i = 0; i < (int) sizeof(u.x); i++) | |
1120 u.x[i] = LZO_BYTE(i); | |
1121 | |
1122 #if 0 | |
1123 r &= __lzo_assert( (int) (unsigned char) ((char) -1) == 255); | |
1124 #endif | |
1125 | |
1126 #if defined(LZO_BYTE_ORDER) | |
1127 if (r == 1) | |
1128 { | |
1129 # if (LZO_BYTE_ORDER == LZO_LITTLE_ENDIAN) | |
1130 lzo_uint32 a = (lzo_uint32) (u.a & LZO_0xffffffffL); | |
1131 unsigned short b = (unsigned short) (u.b & 0xffff); | |
1132 r &= __lzo_assert(a == 0x03020100L); | |
1133 r &= __lzo_assert(b == 0x0100); | |
1134 # elif (LZO_BYTE_ORDER == LZO_BIG_ENDIAN) | |
1135 lzo_uint32 a = u.a >> (8 * sizeof(u.a) - 32); | |
1136 unsigned short b = u.b >> (8 * sizeof(u.b) - 16); | |
1137 r &= __lzo_assert(a == 0x00010203L); | |
1138 r &= __lzo_assert(b == 0x0001); | |
1139 # else | |
1140 # error invalid LZO_BYTE_ORDER | |
1141 # endif | |
1142 } | |
1143 #endif | |
1144 | |
1145 #if defined(LZO_UNALIGNED_OK_2) | |
1146 r &= __lzo_assert(sizeof(short) == 2); | |
1147 if (r == 1) | |
1148 { | |
1149 unsigned short b[4]; | |
1150 | |
1151 for (i = 0; i < 4; i++) | |
1152 b[i] = * (const unsigned short *) &u.x[i]; | |
1153 | |
1154 # if (LZO_BYTE_ORDER == LZO_LITTLE_ENDIAN) | |
1155 r &= __lzo_assert(b[0] == 0x0100); | |
1156 r &= __lzo_assert(b[1] == 0x0201); | |
1157 r &= __lzo_assert(b[2] == 0x0302); | |
1158 r &= __lzo_assert(b[3] == 0x0403); | |
1159 # elif (LZO_BYTE_ORDER == LZO_BIG_ENDIAN) | |
1160 r &= __lzo_assert(b[0] == 0x0001); | |
1161 r &= __lzo_assert(b[1] == 0x0102); | |
1162 r &= __lzo_assert(b[2] == 0x0203); | |
1163 r &= __lzo_assert(b[3] == 0x0304); | |
1164 # endif | |
1165 } | |
1166 #endif | |
1167 | |
1168 #if defined(LZO_UNALIGNED_OK_4) | |
1169 r &= __lzo_assert(sizeof(lzo_uint32) == 4); | |
1170 if (r == 1) | |
1171 { | |
1172 lzo_uint32 a[4]; | |
1173 | |
1174 for (i = 0; i < 4; i++) | |
1175 a[i] = * (const lzo_uint32 *) &u.x[i]; | |
1176 | |
1177 # if (LZO_BYTE_ORDER == LZO_LITTLE_ENDIAN) | |
1178 r &= __lzo_assert(a[0] == 0x03020100L); | |
1179 r &= __lzo_assert(a[1] == 0x04030201L); | |
1180 r &= __lzo_assert(a[2] == 0x05040302L); | |
1181 r &= __lzo_assert(a[3] == 0x06050403L); | |
1182 # elif (LZO_BYTE_ORDER == LZO_BIG_ENDIAN) | |
1183 r &= __lzo_assert(a[0] == 0x00010203L); | |
1184 r &= __lzo_assert(a[1] == 0x01020304L); | |
1185 r &= __lzo_assert(a[2] == 0x02030405L); | |
1186 r &= __lzo_assert(a[3] == 0x03040506L); | |
1187 # endif | |
1188 } | |
1189 #endif | |
1190 | |
1191 #if defined(LZO_ALIGNED_OK_4) | |
1192 r &= __lzo_assert(sizeof(lzo_uint32) == 4); | |
1193 #endif | |
1194 | |
1195 r &= __lzo_assert(lzo_sizeof_dict_t == sizeof(lzo_dict_t)); | |
1196 | |
1197 #if defined(__LZO_IN_MINLZO) | |
1198 if (r == 1) | |
1199 { | |
1200 lzo_uint32 adler; | |
1201 adler = lzo_adler32(0, NULL, 0); | |
1202 adler = lzo_adler32(adler, lzo_copyright(), 200); | |
1203 r &= __lzo_assert(adler == 0x7ea34377L); | |
1204 } | |
1205 #endif | |
1206 | |
1207 if (r == 1) | |
1208 { | |
1209 r &= __lzo_assert(!schedule_insns_bug()); | |
1210 } | |
1211 | |
1212 if (r == 1) | |
1213 { | |
1214 static int x[3]; | |
1215 static unsigned xn = 3; | |
1216 register unsigned j; | |
1217 | |
1218 for (j = 0; j < xn; j++) | |
1219 x[j] = (int)j - 3; | |
1220 r &= __lzo_assert(!strength_reduce_bug(x)); | |
1221 } | |
1222 | |
1223 if (r == 1) | |
1224 { | |
1225 r &= ptr_check(); | |
1226 } | |
1227 | |
1228 return r == 1 ? LZO_E_OK : LZO_E_ERROR; | |
1229 } | |
1230 | |
1231 static lzo_bool schedule_insns_bug(void) | |
1232 { | |
1233 #if defined(__LZO_CHECKER) | |
1234 return 0; | |
1235 #else | |
1236 const int clone[] = {1, 2, 0}; | |
1237 const int *q; | |
1238 q = clone; | |
1239 return (*q) ? 0 : 1; | |
1240 #endif | |
1241 } | |
1242 | |
1243 static lzo_bool strength_reduce_bug(int *x) | |
1244 { | |
1245 return x[0] != -3 || x[1] != -2 || x[2] != -1; | |
1246 } | |
1247 | |
1248 int __lzo_init_done = 0; | |
1249 | |
1250 LZO_PUBLIC(int) | |
1251 __lzo_init2(unsigned v, int s1, int s2, int s3, int s4, int s5, | |
1252 int s6, int s7, int s8, int s9) | |
1253 { | |
1254 int r; | |
1255 | |
1256 __lzo_init_done = 1; | |
1257 | |
1258 if (v == 0) | |
1259 return LZO_E_ERROR; | |
1260 | |
1261 r = (s1 == -1 || s1 == (int) sizeof(short)) && | |
1262 (s2 == -1 || s2 == (int) sizeof(int)) && | |
1263 (s3 == -1 || s3 == (int) sizeof(long)) && | |
1264 (s4 == -1 || s4 == (int) sizeof(lzo_uint32)) && | |
1265 (s5 == -1 || s5 == (int) sizeof(lzo_uint)) && | |
1266 (s6 == -1 || s6 == (int) lzo_sizeof_dict_t) && | |
1267 (s7 == -1 || s7 == (int) sizeof(char *)) && | |
1268 (s8 == -1 || s8 == (int) sizeof(lzo_voidp)) && | |
1269 (s9 == -1 || s9 == (int) sizeof(lzo_compress_t)); | |
1270 if (!r) | |
1271 return LZO_E_ERROR; | |
1272 | |
1273 r = _lzo_config_check(); | |
1274 if (r != LZO_E_OK) | |
1275 return r; | |
1276 | |
1277 return r; | |
1278 } | |
1279 | |
1280 #if !defined(__LZO_IN_MINILZO) | |
1281 | |
1282 LZO_EXTERN(int) | |
1283 __lzo_init(unsigned v,int s1,int s2,int s3,int s4,int s5,int s6,int s7); | |
1284 | |
1285 LZO_PUBLIC(int) | |
1286 __lzo_init(unsigned v,int s1,int s2,int s3,int s4,int s5,int s6,int s7) | |
1287 { | |
1288 if (v == 0 || v > 0x1010) | |
1289 return LZO_E_ERROR; | |
1290 return __lzo_init2(v,s1,s2,s3,s4,s5,-1,-1,s6,s7); | |
1291 } | |
1292 | |
1293 #endif | |
1294 | |
1295 #define do_compress _lzo1x_1_do_compress | |
1296 | |
1297 #define LZO_NEED_DICT_H | |
1298 #define D_BITS 14 | |
1299 #define D_INDEX1(d,p) d = DM((0x21*DX3(p,5,5,6)) >> 5) | |
1300 #define D_INDEX2(d,p) d = (d & (D_MASK & 0x7ff)) ^ (D_HIGH | 0x1f) | |
1301 | |
1302 #ifndef __LZO_CONFIG1X_H | |
1303 #define __LZO_CONFIG1X_H | |
1304 | |
1305 #if !defined(LZO1X) && !defined(LZO1Y) && !defined(LZO1Z) | |
1306 # define LZO1X | |
1307 #endif | |
1308 | |
1309 #if !defined(__LZO_IN_MINILZO) | |
1310 #include <lzo1x.h> | |
1311 #endif | |
1312 | |
1313 #define LZO_EOF_CODE | |
1314 #undef LZO_DETERMINISTIC | |
1315 | |
1316 #define M1_MAX_OFFSET 0x0400 | |
1317 #ifndef M2_MAX_OFFSET | |
1318 #define M2_MAX_OFFSET 0x0800 | |
1319 #endif | |
1320 #define M3_MAX_OFFSET 0x4000 | |
1321 #define M4_MAX_OFFSET 0xbfff | |
1322 | |
1323 #define MX_MAX_OFFSET (M1_MAX_OFFSET + M2_MAX_OFFSET) | |
1324 | |
1325 #define M1_MIN_LEN 2 | |
1326 #define M1_MAX_LEN 2 | |
1327 #define M2_MIN_LEN 3 | |
1328 #ifndef M2_MAX_LEN | |
1329 #define M2_MAX_LEN 8 | |
1330 #endif | |
1331 #define M3_MIN_LEN 3 | |
1332 #define M3_MAX_LEN 33 | |
1333 #define M4_MIN_LEN 3 | |
1334 #define M4_MAX_LEN 9 | |
1335 | |
1336 #define M1_MARKER 0 | |
1337 #define M2_MARKER 64 | |
1338 #define M3_MARKER 32 | |
1339 #define M4_MARKER 16 | |
1340 | |
1341 #ifndef MIN_LOOKAHEAD | |
1342 #define MIN_LOOKAHEAD (M2_MAX_LEN + 1) | |
1343 #endif | |
1344 | |
1345 #if defined(LZO_NEED_DICT_H) | |
1346 | |
1347 #ifndef LZO_HASH | |
1348 #define LZO_HASH LZO_HASH_LZO_INCREMENTAL_B | |
1349 #endif | |
1350 #define DL_MIN_LEN M2_MIN_LEN | |
1351 | |
1352 #ifndef __LZO_DICT_H | |
1353 #define __LZO_DICT_H | |
1354 | |
1355 #ifdef __cplusplus | |
1356 extern "C" { | |
1357 #endif | |
1358 | |
1359 #if !defined(D_BITS) && defined(DBITS) | |
1360 # define D_BITS DBITS | |
1361 #endif | |
1362 #if !defined(D_BITS) | |
1363 # error D_BITS is not defined | |
1364 #endif | |
1365 #if (D_BITS < 16) | |
1366 # define D_SIZE LZO_SIZE(D_BITS) | |
1367 # define D_MASK LZO_MASK(D_BITS) | |
1368 #else | |
1369 # define D_SIZE LZO_USIZE(D_BITS) | |
1370 # define D_MASK LZO_UMASK(D_BITS) | |
1371 #endif | |
1372 #define D_HIGH ((D_MASK >> 1) + 1) | |
1373 | |
1374 #if !defined(DD_BITS) | |
1375 # define DD_BITS 0 | |
1376 #endif | |
1377 #define DD_SIZE LZO_SIZE(DD_BITS) | |
1378 #define DD_MASK LZO_MASK(DD_BITS) | |
1379 | |
1380 #if !defined(DL_BITS) | |
1381 # define DL_BITS (D_BITS - DD_BITS) | |
1382 #endif | |
1383 #if (DL_BITS < 16) | |
1384 # define DL_SIZE LZO_SIZE(DL_BITS) | |
1385 # define DL_MASK LZO_MASK(DL_BITS) | |
1386 #else | |
1387 # define DL_SIZE LZO_USIZE(DL_BITS) | |
1388 # define DL_MASK LZO_UMASK(DL_BITS) | |
1389 #endif | |
1390 | |
1391 #if (D_BITS != DL_BITS + DD_BITS) | |
1392 # error D_BITS does not match | |
1393 #endif | |
1394 #if (D_BITS < 8 || D_BITS > 18) | |
1395 # error invalid D_BITS | |
1396 #endif | |
1397 #if (DL_BITS < 8 || DL_BITS > 20) | |
1398 # error invalid DL_BITS | |
1399 #endif | |
1400 #if (DD_BITS < 0 || DD_BITS > 6) | |
1401 # error invalid DD_BITS | |
1402 #endif | |
1403 | |
1404 #if !defined(DL_MIN_LEN) | |
1405 # define DL_MIN_LEN 3 | |
1406 #endif | |
1407 #if !defined(DL_SHIFT) | |
1408 # define DL_SHIFT ((DL_BITS + (DL_MIN_LEN - 1)) / DL_MIN_LEN) | |
1409 #endif | |
1410 | |
1411 #define LZO_HASH_GZIP 1 | |
1412 #define LZO_HASH_GZIP_INCREMENTAL 2 | |
1413 #define LZO_HASH_LZO_INCREMENTAL_A 3 | |
1414 #define LZO_HASH_LZO_INCREMENTAL_B 4 | |
1415 | |
1416 #if !defined(LZO_HASH) | |
1417 # error choose a hashing strategy | |
1418 #endif | |
1419 | |
1420 #if (DL_MIN_LEN == 3) | |
1421 # define _DV2_A(p,shift1,shift2) \ | |
1422 (((( (lzo_uint32)((p)[0]) << shift1) ^ (p)[1]) << shift2) ^ (p)[2]) | |
1423 # define _DV2_B(p,shift1,shift2) \ | |
1424 (((( (lzo_uint32)((p)[2]) << shift1) ^ (p)[1]) << shift2) ^ (p)[0]) | |
1425 # define _DV3_B(p,shift1,shift2,shift3) \ | |
1426 ((_DV2_B((p)+1,shift1,shift2) << (shift3)) ^ (p)[0]) | |
1427 #elif (DL_MIN_LEN == 2) | |
1428 # define _DV2_A(p,shift1,shift2) \ | |
1429 (( (lzo_uint32)(p[0]) << shift1) ^ p[1]) | |
1430 # define _DV2_B(p,shift1,shift2) \ | |
1431 (( (lzo_uint32)(p[1]) << shift1) ^ p[2]) | |
1432 #else | |
1433 # error invalid DL_MIN_LEN | |
1434 #endif | |
1435 #define _DV_A(p,shift) _DV2_A(p,shift,shift) | |
1436 #define _DV_B(p,shift) _DV2_B(p,shift,shift) | |
1437 #define DA2(p,s1,s2) \ | |
1438 (((((lzo_uint32)((p)[2]) << (s2)) + (p)[1]) << (s1)) + (p)[0]) | |
1439 #define DS2(p,s1,s2) \ | |
1440 (((((lzo_uint32)((p)[2]) << (s2)) - (p)[1]) << (s1)) - (p)[0]) | |
1441 #define DX2(p,s1,s2) \ | |
1442 (((((lzo_uint32)((p)[2]) << (s2)) ^ (p)[1]) << (s1)) ^ (p)[0]) | |
1443 #define DA3(p,s1,s2,s3) ((DA2((p)+1,s2,s3) << (s1)) + (p)[0]) | |
1444 #define DS3(p,s1,s2,s3) ((DS2((p)+1,s2,s3) << (s1)) - (p)[0]) | |
1445 #define DX3(p,s1,s2,s3) ((DX2((p)+1,s2,s3) << (s1)) ^ (p)[0]) | |
1446 #define DMS(v,s) ((lzo_uint) (((v) & (D_MASK >> (s))) << (s))) | |
1447 #define DM(v) DMS(v,0) | |
1448 | |
1449 #if (LZO_HASH == LZO_HASH_GZIP) | |
1450 # define _DINDEX(dv,p) (_DV_A((p),DL_SHIFT)) | |
1451 | |
1452 #elif (LZO_HASH == LZO_HASH_GZIP_INCREMENTAL) | |
1453 # define __LZO_HASH_INCREMENTAL | |
1454 # define DVAL_FIRST(dv,p) dv = _DV_A((p),DL_SHIFT) | |
1455 # define DVAL_NEXT(dv,p) dv = (((dv) << DL_SHIFT) ^ p[2]) | |
1456 # define _DINDEX(dv,p) (dv) | |
1457 # define DVAL_LOOKAHEAD DL_MIN_LEN | |
1458 | |
1459 #elif (LZO_HASH == LZO_HASH_LZO_INCREMENTAL_A) | |
1460 # define __LZO_HASH_INCREMENTAL | |
1461 # define DVAL_FIRST(dv,p) dv = _DV_A((p),5) | |
1462 # define DVAL_NEXT(dv,p) \ | |
1463 dv ^= (lzo_uint32)(p[-1]) << (2*5); dv = (((dv) << 5) ^ p[2]) | |
1464 # define _DINDEX(dv,p) ((0x9f5f * (dv)) >> 5) | |
1465 # define DVAL_LOOKAHEAD DL_MIN_LEN | |
1466 | |
1467 #elif (LZO_HASH == LZO_HASH_LZO_INCREMENTAL_B) | |
1468 # define __LZO_HASH_INCREMENTAL | |
1469 # define DVAL_FIRST(dv,p) dv = _DV_B((p),5) | |
1470 # define DVAL_NEXT(dv,p) \ | |
1471 dv ^= p[-1]; dv = (((dv) >> 5) ^ ((lzo_uint32)(p[2]) << (2*5))) | |
1472 # define _DINDEX(dv,p) ((0x9f5f * (dv)) >> 5) | |
1473 # define DVAL_LOOKAHEAD DL_MIN_LEN | |
1474 | |
1475 #else | |
1476 # error choose a hashing strategy | |
1477 #endif | |
1478 | |
1479 #ifndef DINDEX | |
1480 #define DINDEX(dv,p) ((lzo_uint)((_DINDEX(dv,p)) & DL_MASK) << DD_BITS) | |
1481 #endif | |
1482 #if !defined(DINDEX1) && defined(D_INDEX1) | |
1483 #define DINDEX1 D_INDEX1 | |
1484 #endif | |
1485 #if !defined(DINDEX2) && defined(D_INDEX2) | |
1486 #define DINDEX2 D_INDEX2 | |
1487 #endif | |
1488 | |
1489 #if !defined(__LZO_HASH_INCREMENTAL) | |
1490 # define DVAL_FIRST(dv,p) ((void) 0) | |
1491 # define DVAL_NEXT(dv,p) ((void) 0) | |
1492 # define DVAL_LOOKAHEAD 0 | |
1493 #endif | |
1494 | |
1495 #if !defined(DVAL_ASSERT) | |
1496 #if defined(__LZO_HASH_INCREMENTAL) && !defined(NDEBUG) | |
1497 static void DVAL_ASSERT(lzo_uint32 dv, const lzo_byte *p) | |
1498 { | |
1499 lzo_uint32 df; | |
1500 DVAL_FIRST(df,(p)); | |
1501 assert(DINDEX(dv,p) == DINDEX(df,p)); | |
1502 } | |
1503 #else | |
1504 # define DVAL_ASSERT(dv,p) ((void) 0) | |
1505 #endif | |
1506 #endif | |
1507 | |
1508 #if defined(LZO_DICT_USE_PTR) | |
1509 # define DENTRY(p,in) (p) | |
1510 # define GINDEX(m_pos,m_off,dict,dindex,in) m_pos = dict[dindex] | |
1511 #else | |
1512 # define DENTRY(p,in) ((lzo_uint) ((p)-(in))) | |
1513 # define GINDEX(m_pos,m_off,dict,dindex,in) m_off = dict[dindex] | |
1514 #endif | |
1515 | |
1516 #if (DD_BITS == 0) | |
1517 | |
1518 # define UPDATE_D(dict,drun,dv,p,in) dict[ DINDEX(dv,p) ] = DENTRY(p,in) | |
1519 # define UPDATE_I(dict,drun,index,p,in) dict[index] = DENTRY(p,in) | |
1520 # define UPDATE_P(ptr,drun,p,in) (ptr)[0] = DENTRY(p,in) | |
1521 | |
1522 #else | |
1523 | |
1524 # define UPDATE_D(dict,drun,dv,p,in) \ | |
1525 dict[ DINDEX(dv,p) + drun++ ] = DENTRY(p,in); drun &= DD_MASK | |
1526 # define UPDATE_I(dict,drun,index,p,in) \ | |
1527 dict[ (index) + drun++ ] = DENTRY(p,in); drun &= DD_MASK | |
1528 # define UPDATE_P(ptr,drun,p,in) \ | |
1529 (ptr) [ drun++ ] = DENTRY(p,in); drun &= DD_MASK | |
1530 | |
1531 #endif | |
1532 | |
1533 #if defined(LZO_DICT_USE_PTR) | |
1534 | |
1535 #define LZO_CHECK_MPOS_DET(m_pos,m_off,in,ip,max_offset) \ | |
1536 (m_pos == NULL || (m_off = (lzo_moff_t) (ip - m_pos)) > max_offset) | |
1537 | |
1538 #define LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,max_offset) \ | |
1539 (BOUNDS_CHECKING_OFF_IN_EXPR( \ | |
1540 (PTR_LT(m_pos,in) || \ | |
1541 (m_off = (lzo_moff_t) PTR_DIFF(ip,m_pos)) <= 0 || \ | |
1542 m_off > max_offset) )) | |
1543 | |
1544 #else | |
1545 | |
1546 #define LZO_CHECK_MPOS_DET(m_pos,m_off,in,ip,max_offset) \ | |
1547 (m_off == 0 || \ | |
1548 ((m_off = (lzo_moff_t) ((ip)-(in)) - m_off) > max_offset) || \ | |
1549 (m_pos = (ip) - (m_off), 0) ) | |
1550 | |
1551 #define LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,max_offset) \ | |
1552 ((lzo_moff_t) ((ip)-(in)) <= m_off || \ | |
1553 ((m_off = (lzo_moff_t) ((ip)-(in)) - m_off) > max_offset) || \ | |
1554 (m_pos = (ip) - (m_off), 0) ) | |
1555 | |
1556 #endif | |
1557 | |
1558 #if defined(LZO_DETERMINISTIC) | |
1559 # define LZO_CHECK_MPOS LZO_CHECK_MPOS_DET | |
1560 #else | |
1561 # define LZO_CHECK_MPOS LZO_CHECK_MPOS_NON_DET | |
1562 #endif | |
1563 | |
1564 #ifdef __cplusplus | |
1565 } | |
1566 #endif | |
1567 | |
1568 #endif | |
1569 | |
1570 #endif | |
1571 | |
1572 #endif | |
1573 | |
1574 #define DO_COMPRESS lzo1x_1_compress | |
1575 | |
1576 static | |
1577 lzo_uint do_compress ( const lzo_byte *in , lzo_uint in_len, | |
1578 lzo_byte *out, lzo_uint *out_len, | |
1579 lzo_voidp wrkmem ) | |
1580 { | |
1581 #if 0 && defined(__GNUC__) && defined(__i386__) | |
1582 register const lzo_byte *ip __asm__("%esi"); | |
1583 #else | |
1584 register const lzo_byte *ip; | |
1585 #endif | |
1586 lzo_byte *op; | |
1587 const lzo_byte * const in_end = in + in_len; | |
1588 const lzo_byte * const ip_end = in + in_len - M2_MAX_LEN - 5; | |
1589 const lzo_byte *ii; | |
1590 lzo_dict_p const dict = (lzo_dict_p) wrkmem; | |
1591 | |
1592 op = out; | |
1593 ip = in; | |
1594 ii = ip; | |
1595 | |
1596 ip += 4; | |
1597 for (;;) | |
1598 { | |
1599 #if 0 && defined(__GNUC__) && defined(__i386__) | |
1600 register const lzo_byte *m_pos __asm__("%edi"); | |
1601 #else | |
1602 register const lzo_byte *m_pos; | |
1603 #endif | |
1604 lzo_moff_t m_off; | |
1605 lzo_uint m_len; | |
1606 lzo_uint dindex; | |
1607 | |
1608 DINDEX1(dindex,ip); | |
1609 GINDEX(m_pos,m_off,dict,dindex,in); | |
1610 if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M4_MAX_OFFSET)) | |
1611 goto literal; | |
1612 #if 1 | |
1613 if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3]) | |
1614 goto try_match; | |
1615 DINDEX2(dindex,ip); | |
1616 #endif | |
1617 GINDEX(m_pos,m_off,dict,dindex,in); | |
1618 if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M4_MAX_OFFSET)) | |
1619 goto literal; | |
1620 if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3]) | |
1621 goto try_match; | |
1622 goto literal; | |
1623 | |
1624 try_match: | |
1625 #if 1 && defined(LZO_UNALIGNED_OK_2) | |
1626 if (* (const lzo_ushortp) m_pos != * (const lzo_ushortp) ip) | |
1627 #else | |
1628 if (m_pos[0] != ip[0] || m_pos[1] != ip[1]) | |
1629 #endif | |
1630 { | |
1631 } | |
1632 else | |
1633 { | |
1634 if (m_pos[2] == ip[2]) | |
1635 { | |
1636 #if 0 | |
1637 if (m_off <= M2_MAX_OFFSET) | |
1638 goto match; | |
1639 if (lit <= 3) | |
1640 goto match; | |
1641 if (lit == 3) | |
1642 { | |
1643 assert(op - 2 > out); op[-2] |= LZO_BYTE(3); | |
1644 *op++ = *ii++; *op++ = *ii++; *op++ = *ii++; | |
1645 goto code_match; | |
1646 } | |
1647 if (m_pos[3] == ip[3]) | |
1648 #endif | |
1649 goto match; | |
1650 } | |
1651 else | |
1652 { | |
1653 #if 0 | |
1654 #if 0 | |
1655 if (m_off <= M1_MAX_OFFSET && lit > 0 && lit <= 3) | |
1656 #else | |
1657 if (m_off <= M1_MAX_OFFSET && lit == 3) | |
1658 #endif | |
1659 { | |
1660 register lzo_uint t; | |
1661 | |
1662 t = lit; | |
1663 assert(op - 2 > out); op[-2] |= LZO_BYTE(t); | |
1664 do *op++ = *ii++; while (--t > 0); | |
1665 assert(ii == ip); | |
1666 m_off -= 1; | |
1667 *op++ = LZO_BYTE(M1_MARKER | ((m_off & 3) << 2)); | |
1668 *op++ = LZO_BYTE(m_off >> 2); | |
1669 ip += 2; | |
1670 goto match_done; | |
1671 } | |
1672 #endif | |
1673 } | |
1674 } | |
1675 | |
1676 literal: | |
1677 UPDATE_I(dict,0,dindex,ip,in); | |
1678 ++ip; | |
1679 if (ip >= ip_end) | |
1680 break; | |
1681 continue; | |
1682 | |
1683 match: | |
1684 UPDATE_I(dict,0,dindex,ip,in); | |
1685 if (ip - ii > 0) | |
1686 { | |
1687 register lzo_uint t = ip - ii; | |
1688 | |
1689 if (t <= 3) | |
1690 { | |
1691 assert(op - 2 > out); | |
1692 op[-2] |= LZO_BYTE(t); | |
1693 } | |
1694 else if (t <= 18) | |
1695 *op++ = LZO_BYTE(t - 3); | |
1696 else | |
1697 { | |
1698 register lzo_uint tt = t - 18; | |
1699 | |
1700 *op++ = 0; | |
1701 while (tt > 255) | |
1702 { | |
1703 tt -= 255; | |
1704 *op++ = 0; | |
1705 } | |
1706 assert(tt > 0); | |
1707 *op++ = LZO_BYTE(tt); | |
1708 } | |
1709 do *op++ = *ii++; while (--t > 0); | |
1710 } | |
1711 | |
1712 assert(ii == ip); | |
1713 ip += 3; | |
1714 if (m_pos[3] != *ip++ || m_pos[4] != *ip++ || m_pos[5] != *ip++ || | |
1715 m_pos[6] != *ip++ || m_pos[7] != *ip++ || m_pos[8] != *ip++ | |
1716 #ifdef LZO1Y | |
1717 || m_pos[ 9] != *ip++ || m_pos[10] != *ip++ || m_pos[11] != *ip++ | |
1718 || m_pos[12] != *ip++ || m_pos[13] != *ip++ || m_pos[14] != *ip++ | |
1719 #endif | |
1720 ) | |
1721 { | |
1722 --ip; | |
1723 m_len = ip - ii; | |
1724 assert(m_len >= 3); assert(m_len <= M2_MAX_LEN); | |
1725 | |
1726 if (m_off <= M2_MAX_OFFSET) | |
1727 { | |
1728 m_off -= 1; | |
1729 #if defined(LZO1X) | |
1730 *op++ = LZO_BYTE(((m_len - 1) << 5) | ((m_off & 7) << 2)); | |
1731 *op++ = LZO_BYTE(m_off >> 3); | |
1732 #elif defined(LZO1Y) | |
1733 *op++ = LZO_BYTE(((m_len + 1) << 4) | ((m_off & 3) << 2)); | |
1734 *op++ = LZO_BYTE(m_off >> 2); | |
1735 #endif | |
1736 } | |
1737 else if (m_off <= M3_MAX_OFFSET) | |
1738 { | |
1739 m_off -= 1; | |
1740 *op++ = LZO_BYTE(M3_MARKER | (m_len - 2)); | |
1741 goto m3_m4_offset; | |
1742 } | |
1743 else | |
1744 #if defined(LZO1X) | |
1745 { | |
1746 m_off -= 0x4000; | |
1747 assert(m_off > 0); assert(m_off <= 0x7fff); | |
1748 *op++ = LZO_BYTE(M4_MARKER | | |
1749 ((m_off & 0x4000) >> 11) | (m_len - 2)); | |
1750 goto m3_m4_offset; | |
1751 } | |
1752 #elif defined(LZO1Y) | |
1753 goto m4_match; | |
1754 #endif | |
1755 } | |
1756 else | |
1757 { | |
1758 { | |
1759 const lzo_byte *end = in_end; | |
1760 const lzo_byte *m = m_pos + M2_MAX_LEN + 1; | |
1761 while (ip < end && *m == *ip) | |
1762 m++, ip++; | |
1763 m_len = (ip - ii); | |
1764 } | |
1765 assert(m_len > M2_MAX_LEN); | |
1766 | |
1767 if (m_off <= M3_MAX_OFFSET) | |
1768 { | |
1769 m_off -= 1; | |
1770 if (m_len <= 33) | |
1771 *op++ = LZO_BYTE(M3_MARKER | (m_len - 2)); | |
1772 else | |
1773 { | |
1774 m_len -= 33; | |
1775 *op++ = M3_MARKER | 0; | |
1776 goto m3_m4_len; | |
1777 } | |
1778 } | |
1779 else | |
1780 { | |
1781 #if defined(LZO1Y) | |
1782 m4_match: | |
1783 #endif | |
1784 m_off -= 0x4000; | |
1785 assert(m_off > 0); assert(m_off <= 0x7fff); | |
1786 if (m_len <= M4_MAX_LEN) | |
1787 *op++ = LZO_BYTE(M4_MARKER | | |
1788 ((m_off & 0x4000) >> 11) | (m_len - 2)); | |
1789 else | |
1790 { | |
1791 m_len -= M4_MAX_LEN; | |
1792 *op++ = LZO_BYTE(M4_MARKER | ((m_off & 0x4000) >> 11)); | |
1793 m3_m4_len: | |
1794 while (m_len > 255) | |
1795 { | |
1796 m_len -= 255; | |
1797 *op++ = 0; | |
1798 } | |
1799 assert(m_len > 0); | |
1800 *op++ = LZO_BYTE(m_len); | |
1801 } | |
1802 } | |
1803 | |
1804 m3_m4_offset: | |
1805 *op++ = LZO_BYTE((m_off & 63) << 2); | |
1806 *op++ = LZO_BYTE(m_off >> 6); | |
1807 } | |
1808 | |
1809 #if 0 | |
1810 match_done: | |
1811 #endif | |
1812 ii = ip; | |
1813 if (ip >= ip_end) | |
1814 break; | |
1815 } | |
1816 | |
1817 *out_len = op - out; | |
1818 return (lzo_uint) (in_end - ii); | |
1819 } | |
1820 | |
1821 LZO_PUBLIC(int) | |
1822 DO_COMPRESS ( const lzo_byte *in , lzo_uint in_len, | |
1823 lzo_byte *out, lzo_uint *out_len, | |
1824 lzo_voidp wrkmem ) | |
1825 { | |
1826 lzo_byte *op = out; | |
1827 lzo_uint t; | |
1828 | |
1829 #if defined(__LZO_QUERY_COMPRESS) | |
1830 if (__LZO_IS_COMPRESS_QUERY(in,in_len,out,out_len,wrkmem)) | |
1831 return __LZO_QUERY_COMPRESS(in,in_len,out,out_len,wrkmem,D_SIZE,lzo_sizeof(lzo_dict_t)); | |
1832 #endif | |
1833 | |
1834 if (in_len <= M2_MAX_LEN + 5) | |
1835 t = in_len; | |
1836 else | |
1837 { | |
1838 t = do_compress(in,in_len,op,out_len,wrkmem); | |
1839 op += *out_len; | |
1840 } | |
1841 | |
1842 if (t > 0) | |
1843 { | |
1844 const lzo_byte *ii = in + in_len - t; | |
1845 | |
1846 if (op == out && t <= 238) | |
1847 *op++ = LZO_BYTE(17 + t); | |
1848 else if (t <= 3) | |
1849 op[-2] |= LZO_BYTE(t); | |
1850 else if (t <= 18) | |
1851 *op++ = LZO_BYTE(t - 3); | |
1852 else | |
1853 { | |
1854 lzo_uint tt = t - 18; | |
1855 | |
1856 *op++ = 0; | |
1857 while (tt > 255) | |
1858 { | |
1859 tt -= 255; | |
1860 *op++ = 0; | |
1861 } | |
1862 assert(tt > 0); | |
1863 *op++ = LZO_BYTE(tt); | |
1864 } | |
1865 do *op++ = *ii++; while (--t > 0); | |
1866 } | |
1867 | |
1868 *op++ = M4_MARKER | 1; | |
1869 *op++ = 0; | |
1870 *op++ = 0; | |
1871 | |
1872 *out_len = op - out; | |
1873 return LZO_E_OK; | |
1874 } | |
1875 | |
1876 #undef do_compress | |
1877 #undef DO_COMPRESS | |
1878 #undef LZO_HASH | |
1879 | |
1880 #undef LZO_TEST_DECOMPRESS_OVERRUN | |
1881 #undef LZO_TEST_DECOMPRESS_OVERRUN_INPUT | |
1882 #undef LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT | |
1883 #undef LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND | |
1884 #undef DO_DECOMPRESS | |
1885 #define DO_DECOMPRESS lzo1x_decompress | |
1886 | |
1887 #if defined(LZO_TEST_DECOMPRESS_OVERRUN) | |
1888 # if !defined(LZO_TEST_DECOMPRESS_OVERRUN_INPUT) | |
1889 # define LZO_TEST_DECOMPRESS_OVERRUN_INPUT 2 | |
1890 # endif | |
1891 # if !defined(LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT) | |
1892 # define LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT 2 | |
1893 # endif | |
1894 # if !defined(LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND) | |
1895 # define LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND | |
1896 # endif | |
1897 #endif | |
1898 | |
1899 #undef TEST_IP | |
1900 #undef TEST_OP | |
1901 #undef TEST_LOOKBEHIND | |
1902 #undef NEED_IP | |
1903 #undef NEED_OP | |
1904 #undef HAVE_TEST_IP | |
1905 #undef HAVE_TEST_OP | |
1906 #undef HAVE_NEED_IP | |
1907 #undef HAVE_NEED_OP | |
1908 #undef HAVE_ANY_IP | |
1909 #undef HAVE_ANY_OP | |
1910 | |
1911 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_INPUT) | |
1912 # if (LZO_TEST_DECOMPRESS_OVERRUN_INPUT >= 1) | |
1913 # define TEST_IP (ip < ip_end) | |
1914 # endif | |
1915 # if (LZO_TEST_DECOMPRESS_OVERRUN_INPUT >= 2) | |
1916 # define NEED_IP(x) \ | |
1917 if ((lzo_uint)(ip_end - ip) < (lzo_uint)(x)) goto input_overrun | |
1918 # endif | |
1919 #endif | |
1920 | |
1921 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT) | |
1922 # if (LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT >= 1) | |
1923 # define TEST_OP (op <= op_end) | |
1924 # endif | |
1925 # if (LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT >= 2) | |
1926 # undef TEST_OP | |
1927 # define NEED_OP(x) \ | |
1928 if ((lzo_uint)(op_end - op) < (lzo_uint)(x)) goto output_overrun | |
1929 # endif | |
1930 #endif | |
1931 | |
1932 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND) | |
1933 # define TEST_LOOKBEHIND(m_pos,out) if (m_pos < out) goto lookbehind_overrun | |
1934 #else | |
1935 # define TEST_LOOKBEHIND(m_pos,op) ((void) 0) | |
1936 #endif | |
1937 | |
1938 #if !defined(LZO_EOF_CODE) && !defined(TEST_IP) | |
1939 # define TEST_IP (ip < ip_end) | |
1940 #endif | |
1941 | |
1942 #if defined(TEST_IP) | |
1943 # define HAVE_TEST_IP | |
1944 #else | |
1945 # define TEST_IP 1 | |
1946 #endif | |
1947 #if defined(TEST_OP) | |
1948 # define HAVE_TEST_OP | |
1949 #else | |
1950 # define TEST_OP 1 | |
1951 #endif | |
1952 | |
1953 #if defined(NEED_IP) | |
1954 # define HAVE_NEED_IP | |
1955 #else | |
1956 # define NEED_IP(x) ((void) 0) | |
1957 #endif | |
1958 #if defined(NEED_OP) | |
1959 # define HAVE_NEED_OP | |
1960 #else | |
1961 # define NEED_OP(x) ((void) 0) | |
1962 #endif | |
1963 | |
1964 #if defined(HAVE_TEST_IP) || defined(HAVE_NEED_IP) | |
1965 # define HAVE_ANY_IP | |
1966 #endif | |
1967 #if defined(HAVE_TEST_OP) || defined(HAVE_NEED_OP) | |
1968 # define HAVE_ANY_OP | |
1969 #endif | |
1970 | |
1971 #if defined(DO_DECOMPRESS) | |
1972 LZO_PUBLIC(int) | |
1973 DO_DECOMPRESS ( const lzo_byte *in , lzo_uint in_len, | |
1974 lzo_byte *out, lzo_uint *out_len, | |
1975 lzo_voidp wrkmem ) | |
1976 #endif | |
1977 { | |
1978 register lzo_byte *op; | |
1979 register const lzo_byte *ip; | |
1980 register lzo_uint t; | |
1981 #if defined(COPY_DICT) | |
1982 lzo_uint m_off; | |
1983 const lzo_byte *dict_end; | |
1984 #else | |
1985 register const lzo_byte *m_pos; | |
1986 #endif | |
1987 | |
1988 const lzo_byte * const ip_end = in + in_len; | |
1989 #if defined(HAVE_ANY_OP) | |
1990 lzo_byte * const op_end = out + *out_len; | |
1991 #endif | |
1992 #if defined(LZO1Z) | |
1993 lzo_uint last_m_off = 0; | |
1994 #endif | |
1995 | |
1996 LZO_UNUSED(wrkmem); | |
1997 | |
1998 #if defined(__LZO_QUERY_DECOMPRESS) | |
1999 if (__LZO_IS_DECOMPRESS_QUERY(in,in_len,out,out_len,wrkmem)) | |
2000 return __LZO_QUERY_DECOMPRESS(in,in_len,out,out_len,wrkmem,0,0); | |
2001 #endif | |
2002 | |
2003 #if defined(COPY_DICT) | |
2004 if (dict) | |
2005 { | |
2006 if (dict_len > M4_MAX_OFFSET) | |
2007 { | |
2008 dict += dict_len - M4_MAX_OFFSET; | |
2009 dict_len = M4_MAX_OFFSET; | |
2010 } | |
2011 dict_end = dict + dict_len; | |
2012 } | |
2013 else | |
2014 { | |
2015 dict_len = 0; | |
2016 dict_end = NULL; | |
2017 } | |
2018 #endif | |
2019 | |
2020 *out_len = 0; | |
2021 | |
2022 op = out; | |
2023 ip = in; | |
2024 | |
2025 if (*ip > 17) | |
2026 { | |
2027 t = *ip++ - 17; | |
2028 if (t < 4) | |
2029 goto match_next; | |
2030 assert(t > 0); NEED_OP(t); NEED_IP(t+1); | |
2031 do *op++ = *ip++; while (--t > 0); | |
2032 goto first_literal_run; | |
2033 } | |
2034 | |
2035 while (TEST_IP && TEST_OP) | |
2036 { | |
2037 t = *ip++; | |
2038 if (t >= 16) | |
2039 goto match; | |
2040 if (t == 0) | |
2041 { | |
2042 NEED_IP(1); | |
2043 while (*ip == 0) | |
2044 { | |
2045 t += 255; | |
2046 ip++; | |
2047 NEED_IP(1); | |
2048 } | |
2049 t += 15 + *ip++; | |
2050 } | |
2051 assert(t > 0); NEED_OP(t+3); NEED_IP(t+4); | |
2052 #if defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4) | |
2053 #if !defined(LZO_UNALIGNED_OK_4) | |
2054 if (PTR_ALIGNED2_4(op,ip)) | |
2055 { | |
2056 #endif | |
2057 * (lzo_uint32p) op = * (const lzo_uint32p) ip; | |
2058 op += 4; ip += 4; | |
2059 if (--t > 0) | |
2060 { | |
2061 if (t >= 4) | |
2062 { | |
2063 do { | |
2064 * (lzo_uint32p) op = * (const lzo_uint32p) ip; | |
2065 op += 4; ip += 4; t -= 4; | |
2066 } while (t >= 4); | |
2067 if (t > 0) do *op++ = *ip++; while (--t > 0); | |
2068 } | |
2069 else | |
2070 do *op++ = *ip++; while (--t > 0); | |
2071 } | |
2072 #if !defined(LZO_UNALIGNED_OK_4) | |
2073 } | |
2074 else | |
2075 #endif | |
2076 #endif | |
2077 #if !defined(LZO_UNALIGNED_OK_4) | |
2078 { | |
2079 *op++ = *ip++; *op++ = *ip++; *op++ = *ip++; | |
2080 do *op++ = *ip++; while (--t > 0); | |
2081 } | |
2082 #endif | |
2083 | |
2084 first_literal_run: | |
2085 | |
2086 t = *ip++; | |
2087 if (t >= 16) | |
2088 goto match; | |
2089 #if defined(COPY_DICT) | |
2090 #if defined(LZO1Z) | |
2091 m_off = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2); | |
2092 last_m_off = m_off; | |
2093 #else | |
2094 m_off = (1 + M2_MAX_OFFSET) + (t >> 2) + (*ip++ << 2); | |
2095 #endif | |
2096 NEED_OP(3); | |
2097 t = 3; COPY_DICT(t,m_off) | |
2098 #else | |
2099 #if defined(LZO1Z) | |
2100 t = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2); | |
2101 m_pos = op - t; | |
2102 last_m_off = t; | |
2103 #else | |
2104 m_pos = op - (1 + M2_MAX_OFFSET); | |
2105 m_pos -= t >> 2; | |
2106 m_pos -= *ip++ << 2; | |
2107 #endif | |
2108 TEST_LOOKBEHIND(m_pos,out); NEED_OP(3); | |
2109 *op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos; | |
2110 #endif | |
2111 goto match_done; | |
2112 | |
2113 while (TEST_IP && TEST_OP) | |
2114 { | |
2115 match: | |
2116 if (t >= 64) | |
2117 { | |
2118 #if defined(COPY_DICT) | |
2119 #if defined(LZO1X) | |
2120 m_off = 1 + ((t >> 2) & 7) + (*ip++ << 3); | |
2121 t = (t >> 5) - 1; | |
2122 #elif defined(LZO1Y) | |
2123 m_off = 1 + ((t >> 2) & 3) + (*ip++ << 2); | |
2124 t = (t >> 4) - 3; | |
2125 #elif defined(LZO1Z) | |
2126 m_off = t & 0x1f; | |
2127 if (m_off >= 0x1c) | |
2128 m_off = last_m_off; | |
2129 else | |
2130 { | |
2131 m_off = 1 + (m_off << 6) + (*ip++ >> 2); | |
2132 last_m_off = m_off; | |
2133 } | |
2134 t = (t >> 5) - 1; | |
2135 #endif | |
2136 #else | |
2137 #if defined(LZO1X) | |
2138 m_pos = op - 1; | |
2139 m_pos -= (t >> 2) & 7; | |
2140 m_pos -= *ip++ << 3; | |
2141 t = (t >> 5) - 1; | |
2142 #elif defined(LZO1Y) | |
2143 m_pos = op - 1; | |
2144 m_pos -= (t >> 2) & 3; | |
2145 m_pos -= *ip++ << 2; | |
2146 t = (t >> 4) - 3; | |
2147 #elif defined(LZO1Z) | |
2148 { | |
2149 lzo_uint off = t & 0x1f; | |
2150 m_pos = op; | |
2151 if (off >= 0x1c) | |
2152 { | |
2153 assert(last_m_off > 0); | |
2154 m_pos -= last_m_off; | |
2155 } | |
2156 else | |
2157 { | |
2158 off = 1 + (off << 6) + (*ip++ >> 2); | |
2159 m_pos -= off; | |
2160 last_m_off = off; | |
2161 } | |
2162 } | |
2163 t = (t >> 5) - 1; | |
2164 #endif | |
2165 TEST_LOOKBEHIND(m_pos,out); assert(t > 0); NEED_OP(t+3-1); | |
2166 goto copy_match; | |
2167 #endif | |
2168 } | |
2169 else if (t >= 32) | |
2170 { | |
2171 t &= 31; | |
2172 if (t == 0) | |
2173 { | |
2174 NEED_IP(1); | |
2175 while (*ip == 0) | |
2176 { | |
2177 t += 255; | |
2178 ip++; | |
2179 NEED_IP(1); | |
2180 } | |
2181 t += 31 + *ip++; | |
2182 } | |
2183 #if defined(COPY_DICT) | |
2184 #if defined(LZO1Z) | |
2185 m_off = 1 + (ip[0] << 6) + (ip[1] >> 2); | |
2186 last_m_off = m_off; | |
2187 #else | |
2188 m_off = 1 + (ip[0] >> 2) + (ip[1] << 6); | |
2189 #endif | |
2190 #else | |
2191 #if defined(LZO1Z) | |
2192 { | |
2193 lzo_uint off = 1 + (ip[0] << 6) + (ip[1] >> 2); | |
2194 m_pos = op - off; | |
2195 last_m_off = off; | |
2196 } | |
2197 #elif defined(LZO_UNALIGNED_OK_2) && (LZO_BYTE_ORDER == LZO_LITTLE_ENDIAN) | |
2198 m_pos = op - 1; | |
2199 m_pos -= (* (const lzo_ushortp) ip) >> 2; | |
2200 #else | |
2201 m_pos = op - 1; | |
2202 m_pos -= (ip[0] >> 2) + (ip[1] << 6); | |
2203 #endif | |
2204 #endif | |
2205 ip += 2; | |
2206 } | |
2207 else if (t >= 16) | |
2208 { | |
2209 #if defined(COPY_DICT) | |
2210 m_off = (t & 8) << 11; | |
2211 #else | |
2212 m_pos = op; | |
2213 m_pos -= (t & 8) << 11; | |
2214 #endif | |
2215 t &= 7; | |
2216 if (t == 0) | |
2217 { | |
2218 NEED_IP(1); | |
2219 while (*ip == 0) | |
2220 { | |
2221 t += 255; | |
2222 ip++; | |
2223 NEED_IP(1); | |
2224 } | |
2225 t += 7 + *ip++; | |
2226 } | |
2227 #if defined(COPY_DICT) | |
2228 #if defined(LZO1Z) | |
2229 m_off += (ip[0] << 6) + (ip[1] >> 2); | |
2230 #else | |
2231 m_off += (ip[0] >> 2) + (ip[1] << 6); | |
2232 #endif | |
2233 ip += 2; | |
2234 if (m_off == 0) | |
2235 goto eof_found; | |
2236 m_off += 0x4000; | |
2237 #if defined(LZO1Z) | |
2238 last_m_off = m_off; | |
2239 #endif | |
2240 #else | |
2241 #if defined(LZO1Z) | |
2242 m_pos -= (ip[0] << 6) + (ip[1] >> 2); | |
2243 #elif defined(LZO_UNALIGNED_OK_2) && (LZO_BYTE_ORDER == LZO_LITTLE_ENDIAN) | |
2244 m_pos -= (* (const lzo_ushortp) ip) >> 2; | |
2245 #else | |
2246 m_pos -= (ip[0] >> 2) + (ip[1] << 6); | |
2247 #endif | |
2248 ip += 2; | |
2249 if (m_pos == op) | |
2250 goto eof_found; | |
2251 m_pos -= 0x4000; | |
2252 #if defined(LZO1Z) | |
2253 last_m_off = op - m_pos; | |
2254 #endif | |
2255 #endif | |
2256 } | |
2257 else | |
2258 { | |
2259 #if defined(COPY_DICT) | |
2260 #if defined(LZO1Z) | |
2261 m_off = 1 + (t << 6) + (*ip++ >> 2); | |
2262 last_m_off = m_off; | |
2263 #else | |
2264 m_off = 1 + (t >> 2) + (*ip++ << 2); | |
2265 #endif | |
2266 NEED_OP(2); | |
2267 t = 2; COPY_DICT(t,m_off) | |
2268 #else | |
2269 #if defined(LZO1Z) | |
2270 t = 1 + (t << 6) + (*ip++ >> 2); | |
2271 m_pos = op - t; | |
2272 last_m_off = t; | |
2273 #else | |
2274 m_pos = op - 1; | |
2275 m_pos -= t >> 2; | |
2276 m_pos -= *ip++ << 2; | |
2277 #endif | |
2278 TEST_LOOKBEHIND(m_pos,out); NEED_OP(2); | |
2279 *op++ = *m_pos++; *op++ = *m_pos; | |
2280 #endif | |
2281 goto match_done; | |
2282 } | |
2283 | |
2284 #if defined(COPY_DICT) | |
2285 | |
2286 NEED_OP(t+3-1); | |
2287 t += 3-1; COPY_DICT(t,m_off) | |
2288 | |
2289 #else | |
2290 | |
2291 TEST_LOOKBEHIND(m_pos,out); assert(t > 0); NEED_OP(t+3-1); | |
2292 #if defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4) | |
2293 #if !defined(LZO_UNALIGNED_OK_4) | |
2294 if (t >= 2 * 4 - (3 - 1) && PTR_ALIGNED2_4(op,m_pos)) | |
2295 { | |
2296 assert((op - m_pos) >= 4); | |
2297 #else | |
2298 if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4) | |
2299 { | |
2300 #endif | |
2301 * (lzo_uint32p) op = * (const lzo_uint32p) m_pos; | |
2302 op += 4; m_pos += 4; t -= 4 - (3 - 1); | |
2303 do { | |
2304 * (lzo_uint32p) op = * (const lzo_uint32p) m_pos; | |
2305 op += 4; m_pos += 4; t -= 4; | |
2306 } while (t >= 4); | |
2307 if (t > 0) do *op++ = *m_pos++; while (--t > 0); | |
2308 } | |
2309 else | |
2310 #endif | |
2311 { | |
2312 copy_match: | |
2313 *op++ = *m_pos++; *op++ = *m_pos++; | |
2314 do *op++ = *m_pos++; while (--t > 0); | |
2315 } | |
2316 | |
2317 #endif | |
2318 | |
2319 match_done: | |
2320 #if defined(LZO1Z) | |
2321 t = ip[-1] & 3; | |
2322 #else | |
2323 t = ip[-2] & 3; | |
2324 #endif | |
2325 if (t == 0) | |
2326 break; | |
2327 | |
2328 match_next: | |
2329 assert(t > 0); NEED_OP(t); NEED_IP(t+1); | |
2330 do *op++ = *ip++; while (--t > 0); | |
2331 t = *ip++; | |
2332 } | |
2333 } | |
2334 | |
2335 #if defined(HAVE_TEST_IP) || defined(HAVE_TEST_OP) | |
2336 *out_len = op - out; | |
2337 return LZO_E_EOF_NOT_FOUND; | |
2338 #endif | |
2339 | |
2340 eof_found: | |
2341 assert(t == 1); | |
2342 *out_len = op - out; | |
2343 return (ip == ip_end ? LZO_E_OK : | |
2344 (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); | |
2345 | |
2346 #if defined(HAVE_NEED_IP) | |
2347 input_overrun: | |
2348 *out_len = op - out; | |
2349 return LZO_E_INPUT_OVERRUN; | |
2350 #endif | |
2351 | |
2352 #if defined(HAVE_NEED_OP) | |
2353 output_overrun: | |
2354 *out_len = op - out; | |
2355 return LZO_E_OUTPUT_OVERRUN; | |
2356 #endif | |
2357 | |
2358 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND) | |
2359 lookbehind_overrun: | |
2360 *out_len = op - out; | |
2361 return LZO_E_LOOKBEHIND_OVERRUN; | |
2362 #endif | |
2363 } | |
2364 | |
2365 #define LZO_TEST_DECOMPRESS_OVERRUN | |
2366 #undef DO_DECOMPRESS | |
2367 #define DO_DECOMPRESS lzo1x_decompress_safe | |
2368 | |
2369 #if defined(LZO_TEST_DECOMPRESS_OVERRUN) | |
2370 # if !defined(LZO_TEST_DECOMPRESS_OVERRUN_INPUT) | |
2371 # define LZO_TEST_DECOMPRESS_OVERRUN_INPUT 2 | |
2372 # endif | |
2373 # if !defined(LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT) | |
2374 # define LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT 2 | |
2375 # endif | |
2376 # if !defined(LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND) | |
2377 # define LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND | |
2378 # endif | |
2379 #endif | |
2380 | |
2381 #undef TEST_IP | |
2382 #undef TEST_OP | |
2383 #undef TEST_LOOKBEHIND | |
2384 #undef NEED_IP | |
2385 #undef NEED_OP | |
2386 #undef HAVE_TEST_IP | |
2387 #undef HAVE_TEST_OP | |
2388 #undef HAVE_NEED_IP | |
2389 #undef HAVE_NEED_OP | |
2390 #undef HAVE_ANY_IP | |
2391 #undef HAVE_ANY_OP | |
2392 | |
2393 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_INPUT) | |
2394 # if (LZO_TEST_DECOMPRESS_OVERRUN_INPUT >= 1) | |
2395 # define TEST_IP (ip < ip_end) | |
2396 # endif | |
2397 # if (LZO_TEST_DECOMPRESS_OVERRUN_INPUT >= 2) | |
2398 # define NEED_IP(x) \ | |
2399 if ((lzo_uint)(ip_end - ip) < (lzo_uint)(x)) goto input_overrun | |
2400 # endif | |
2401 #endif | |
2402 | |
2403 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT) | |
2404 # if (LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT >= 1) | |
2405 # define TEST_OP (op <= op_end) | |
2406 # endif | |
2407 # if (LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT >= 2) | |
2408 # undef TEST_OP | |
2409 # define NEED_OP(x) \ | |
2410 if ((lzo_uint)(op_end - op) < (lzo_uint)(x)) goto output_overrun | |
2411 # endif | |
2412 #endif | |
2413 | |
2414 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND) | |
2415 # define TEST_LOOKBEHIND(m_pos,out) if (m_pos < out) goto lookbehind_overrun | |
2416 #else | |
2417 # define TEST_LOOKBEHIND(m_pos,op) ((void) 0) | |
2418 #endif | |
2419 | |
2420 #if !defined(LZO_EOF_CODE) && !defined(TEST_IP) | |
2421 # define TEST_IP (ip < ip_end) | |
2422 #endif | |
2423 | |
2424 #if defined(TEST_IP) | |
2425 # define HAVE_TEST_IP | |
2426 #else | |
2427 # define TEST_IP 1 | |
2428 #endif | |
2429 #if defined(TEST_OP) | |
2430 # define HAVE_TEST_OP | |
2431 #else | |
2432 # define TEST_OP 1 | |
2433 #endif | |
2434 | |
2435 #if defined(NEED_IP) | |
2436 # define HAVE_NEED_IP | |
2437 #else | |
2438 # define NEED_IP(x) ((void) 0) | |
2439 #endif | |
2440 #if defined(NEED_OP) | |
2441 # define HAVE_NEED_OP | |
2442 #else | |
2443 # define NEED_OP(x) ((void) 0) | |
2444 #endif | |
2445 | |
2446 #if defined(HAVE_TEST_IP) || defined(HAVE_NEED_IP) | |
2447 # define HAVE_ANY_IP | |
2448 #endif | |
2449 #if defined(HAVE_TEST_OP) || defined(HAVE_NEED_OP) | |
2450 # define HAVE_ANY_OP | |
2451 #endif | |
2452 | |
2453 #if defined(DO_DECOMPRESS) | |
2454 LZO_PUBLIC(int) | |
2455 DO_DECOMPRESS ( const lzo_byte *in , lzo_uint in_len, | |
2456 lzo_byte *out, lzo_uint *out_len, | |
2457 lzo_voidp wrkmem ) | |
2458 #endif | |
2459 { | |
2460 register lzo_byte *op; | |
2461 register const lzo_byte *ip; | |
2462 register lzo_uint t; | |
2463 #if defined(COPY_DICT) | |
2464 lzo_uint m_off; | |
2465 const lzo_byte *dict_end; | |
2466 #else | |
2467 register const lzo_byte *m_pos; | |
2468 #endif | |
2469 | |
2470 const lzo_byte * const ip_end = in + in_len; | |
2471 #if defined(HAVE_ANY_OP) | |
2472 lzo_byte * const op_end = out + *out_len; | |
2473 #endif | |
2474 #if defined(LZO1Z) | |
2475 lzo_uint last_m_off = 0; | |
2476 #endif | |
2477 | |
2478 LZO_UNUSED(wrkmem); | |
2479 | |
2480 #if defined(__LZO_QUERY_DECOMPRESS) | |
2481 if (__LZO_IS_DECOMPRESS_QUERY(in,in_len,out,out_len,wrkmem)) | |
2482 return __LZO_QUERY_DECOMPRESS(in,in_len,out,out_len,wrkmem,0,0); | |
2483 #endif | |
2484 | |
2485 #if defined(COPY_DICT) | |
2486 if (dict) | |
2487 { | |
2488 if (dict_len > M4_MAX_OFFSET) | |
2489 { | |
2490 dict += dict_len - M4_MAX_OFFSET; | |
2491 dict_len = M4_MAX_OFFSET; | |
2492 } | |
2493 dict_end = dict + dict_len; | |
2494 } | |
2495 else | |
2496 { | |
2497 dict_len = 0; | |
2498 dict_end = NULL; | |
2499 } | |
2500 #endif | |
2501 | |
2502 *out_len = 0; | |
2503 | |
2504 op = out; | |
2505 ip = in; | |
2506 | |
2507 if (*ip > 17) | |
2508 { | |
2509 t = *ip++ - 17; | |
2510 if (t < 4) | |
2511 goto match_next; | |
2512 assert(t > 0); NEED_OP(t); NEED_IP(t+1); | |
2513 do *op++ = *ip++; while (--t > 0); | |
2514 goto first_literal_run; | |
2515 } | |
2516 | |
2517 while (TEST_IP && TEST_OP) | |
2518 { | |
2519 t = *ip++; | |
2520 if (t >= 16) | |
2521 goto match; | |
2522 if (t == 0) | |
2523 { | |
2524 NEED_IP(1); | |
2525 while (*ip == 0) | |
2526 { | |
2527 t += 255; | |
2528 ip++; | |
2529 NEED_IP(1); | |
2530 } | |
2531 t += 15 + *ip++; | |
2532 } | |
2533 assert(t > 0); NEED_OP(t+3); NEED_IP(t+4); | |
2534 #if defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4) | |
2535 #if !defined(LZO_UNALIGNED_OK_4) | |
2536 if (PTR_ALIGNED2_4(op,ip)) | |
2537 { | |
2538 #endif | |
2539 * (lzo_uint32p) op = * (const lzo_uint32p) ip; | |
2540 op += 4; ip += 4; | |
2541 if (--t > 0) | |
2542 { | |
2543 if (t >= 4) | |
2544 { | |
2545 do { | |
2546 * (lzo_uint32p) op = * (const lzo_uint32p) ip; | |
2547 op += 4; ip += 4; t -= 4; | |
2548 } while (t >= 4); | |
2549 if (t > 0) do *op++ = *ip++; while (--t > 0); | |
2550 } | |
2551 else | |
2552 do *op++ = *ip++; while (--t > 0); | |
2553 } | |
2554 #if !defined(LZO_UNALIGNED_OK_4) | |
2555 } | |
2556 else | |
2557 #endif | |
2558 #endif | |
2559 #if !defined(LZO_UNALIGNED_OK_4) | |
2560 { | |
2561 *op++ = *ip++; *op++ = *ip++; *op++ = *ip++; | |
2562 do *op++ = *ip++; while (--t > 0); | |
2563 } | |
2564 #endif | |
2565 | |
2566 first_literal_run: | |
2567 | |
2568 t = *ip++; | |
2569 if (t >= 16) | |
2570 goto match; | |
2571 #if defined(COPY_DICT) | |
2572 #if defined(LZO1Z) | |
2573 m_off = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2); | |
2574 last_m_off = m_off; | |
2575 #else | |
2576 m_off = (1 + M2_MAX_OFFSET) + (t >> 2) + (*ip++ << 2); | |
2577 #endif | |
2578 NEED_OP(3); | |
2579 t = 3; COPY_DICT(t,m_off) | |
2580 #else | |
2581 #if defined(LZO1Z) | |
2582 t = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2); | |
2583 m_pos = op - t; | |
2584 last_m_off = t; | |
2585 #else | |
2586 m_pos = op - (1 + M2_MAX_OFFSET); | |
2587 m_pos -= t >> 2; | |
2588 m_pos -= *ip++ << 2; | |
2589 #endif | |
2590 TEST_LOOKBEHIND(m_pos,out); NEED_OP(3); | |
2591 *op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos; | |
2592 #endif | |
2593 goto match_done; | |
2594 | |
2595 while (TEST_IP && TEST_OP) | |
2596 { | |
2597 match: | |
2598 if (t >= 64) | |
2599 { | |
2600 #if defined(COPY_DICT) | |
2601 #if defined(LZO1X) | |
2602 m_off = 1 + ((t >> 2) & 7) + (*ip++ << 3); | |
2603 t = (t >> 5) - 1; | |
2604 #elif defined(LZO1Y) | |
2605 m_off = 1 + ((t >> 2) & 3) + (*ip++ << 2); | |
2606 t = (t >> 4) - 3; | |
2607 #elif defined(LZO1Z) | |
2608 m_off = t & 0x1f; | |
2609 if (m_off >= 0x1c) | |
2610 m_off = last_m_off; | |
2611 else | |
2612 { | |
2613 m_off = 1 + (m_off << 6) + (*ip++ >> 2); | |
2614 last_m_off = m_off; | |
2615 } | |
2616 t = (t >> 5) - 1; | |
2617 #endif | |
2618 #else | |
2619 #if defined(LZO1X) | |
2620 m_pos = op - 1; | |
2621 m_pos -= (t >> 2) & 7; | |
2622 m_pos -= *ip++ << 3; | |
2623 t = (t >> 5) - 1; | |
2624 #elif defined(LZO1Y) | |
2625 m_pos = op - 1; | |
2626 m_pos -= (t >> 2) & 3; | |
2627 m_pos -= *ip++ << 2; | |
2628 t = (t >> 4) - 3; | |
2629 #elif defined(LZO1Z) | |
2630 { | |
2631 lzo_uint off = t & 0x1f; | |
2632 m_pos = op; | |
2633 if (off >= 0x1c) | |
2634 { | |
2635 assert(last_m_off > 0); | |
2636 m_pos -= last_m_off; | |
2637 } | |
2638 else | |
2639 { | |
2640 off = 1 + (off << 6) + (*ip++ >> 2); | |
2641 m_pos -= off; | |
2642 last_m_off = off; | |
2643 } | |
2644 } | |
2645 t = (t >> 5) - 1; | |
2646 #endif | |
2647 TEST_LOOKBEHIND(m_pos,out); assert(t > 0); NEED_OP(t+3-1); | |
2648 goto copy_match; | |
2649 #endif | |
2650 } | |
2651 else if (t >= 32) | |
2652 { | |
2653 t &= 31; | |
2654 if (t == 0) | |
2655 { | |
2656 NEED_IP(1); | |
2657 while (*ip == 0) | |
2658 { | |
2659 t += 255; | |
2660 ip++; | |
2661 NEED_IP(1); | |
2662 } | |
2663 t += 31 + *ip++; | |
2664 } | |
2665 #if defined(COPY_DICT) | |
2666 #if defined(LZO1Z) | |
2667 m_off = 1 + (ip[0] << 6) + (ip[1] >> 2); | |
2668 last_m_off = m_off; | |
2669 #else | |
2670 m_off = 1 + (ip[0] >> 2) + (ip[1] << 6); | |
2671 #endif | |
2672 #else | |
2673 #if defined(LZO1Z) | |
2674 { | |
2675 lzo_uint off = 1 + (ip[0] << 6) + (ip[1] >> 2); | |
2676 m_pos = op - off; | |
2677 last_m_off = off; | |
2678 } | |
2679 #elif defined(LZO_UNALIGNED_OK_2) && (LZO_BYTE_ORDER == LZO_LITTLE_ENDIAN) | |
2680 m_pos = op - 1; | |
2681 m_pos -= (* (const lzo_ushortp) ip) >> 2; | |
2682 #else | |
2683 m_pos = op - 1; | |
2684 m_pos -= (ip[0] >> 2) + (ip[1] << 6); | |
2685 #endif | |
2686 #endif | |
2687 ip += 2; | |
2688 } | |
2689 else if (t >= 16) | |
2690 { | |
2691 #if defined(COPY_DICT) | |
2692 m_off = (t & 8) << 11; | |
2693 #else | |
2694 m_pos = op; | |
2695 m_pos -= (t & 8) << 11; | |
2696 #endif | |
2697 t &= 7; | |
2698 if (t == 0) | |
2699 { | |
2700 NEED_IP(1); | |
2701 while (*ip == 0) | |
2702 { | |
2703 t += 255; | |
2704 ip++; | |
2705 NEED_IP(1); | |
2706 } | |
2707 t += 7 + *ip++; | |
2708 } | |
2709 #if defined(COPY_DICT) | |
2710 #if defined(LZO1Z) | |
2711 m_off += (ip[0] << 6) + (ip[1] >> 2); | |
2712 #else | |
2713 m_off += (ip[0] >> 2) + (ip[1] << 6); | |
2714 #endif | |
2715 ip += 2; | |
2716 if (m_off == 0) | |
2717 goto eof_found; | |
2718 m_off += 0x4000; | |
2719 #if defined(LZO1Z) | |
2720 last_m_off = m_off; | |
2721 #endif | |
2722 #else | |
2723 #if defined(LZO1Z) | |
2724 m_pos -= (ip[0] << 6) + (ip[1] >> 2); | |
2725 #elif defined(LZO_UNALIGNED_OK_2) && (LZO_BYTE_ORDER == LZO_LITTLE_ENDIAN) | |
2726 m_pos -= (* (const lzo_ushortp) ip) >> 2; | |
2727 #else | |
2728 m_pos -= (ip[0] >> 2) + (ip[1] << 6); | |
2729 #endif | |
2730 ip += 2; | |
2731 if (m_pos == op) | |
2732 goto eof_found; | |
2733 m_pos -= 0x4000; | |
2734 #if defined(LZO1Z) | |
2735 last_m_off = op - m_pos; | |
2736 #endif | |
2737 #endif | |
2738 } | |
2739 else | |
2740 { | |
2741 #if defined(COPY_DICT) | |
2742 #if defined(LZO1Z) | |
2743 m_off = 1 + (t << 6) + (*ip++ >> 2); | |
2744 last_m_off = m_off; | |
2745 #else | |
2746 m_off = 1 + (t >> 2) + (*ip++ << 2); | |
2747 #endif | |
2748 NEED_OP(2); | |
2749 t = 2; COPY_DICT(t,m_off) | |
2750 #else | |
2751 #if defined(LZO1Z) | |
2752 t = 1 + (t << 6) + (*ip++ >> 2); | |
2753 m_pos = op - t; | |
2754 last_m_off = t; | |
2755 #else | |
2756 m_pos = op - 1; | |
2757 m_pos -= t >> 2; | |
2758 m_pos -= *ip++ << 2; | |
2759 #endif | |
2760 TEST_LOOKBEHIND(m_pos,out); NEED_OP(2); | |
2761 *op++ = *m_pos++; *op++ = *m_pos; | |
2762 #endif | |
2763 goto match_done; | |
2764 } | |
2765 | |
2766 #if defined(COPY_DICT) | |
2767 | |
2768 NEED_OP(t+3-1); | |
2769 t += 3-1; COPY_DICT(t,m_off) | |
2770 | |
2771 #else | |
2772 | |
2773 TEST_LOOKBEHIND(m_pos,out); assert(t > 0); NEED_OP(t+3-1); | |
2774 #if defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4) | |
2775 #if !defined(LZO_UNALIGNED_OK_4) | |
2776 if (t >= 2 * 4 - (3 - 1) && PTR_ALIGNED2_4(op,m_pos)) | |
2777 { | |
2778 assert((op - m_pos) >= 4); | |
2779 #else | |
2780 if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4) | |
2781 { | |
2782 #endif | |
2783 * (lzo_uint32p) op = * (const lzo_uint32p) m_pos; | |
2784 op += 4; m_pos += 4; t -= 4 - (3 - 1); | |
2785 do { | |
2786 * (lzo_uint32p) op = * (const lzo_uint32p) m_pos; | |
2787 op += 4; m_pos += 4; t -= 4; | |
2788 } while (t >= 4); | |
2789 if (t > 0) do *op++ = *m_pos++; while (--t > 0); | |
2790 } | |
2791 else | |
2792 #endif | |
2793 { | |
2794 copy_match: | |
2795 *op++ = *m_pos++; *op++ = *m_pos++; | |
2796 do *op++ = *m_pos++; while (--t > 0); | |
2797 } | |
2798 | |
2799 #endif | |
2800 | |
2801 match_done: | |
2802 #if defined(LZO1Z) | |
2803 t = ip[-1] & 3; | |
2804 #else | |
2805 t = ip[-2] & 3; | |
2806 #endif | |
2807 if (t == 0) | |
2808 break; | |
2809 | |
2810 match_next: | |
2811 assert(t > 0); NEED_OP(t); NEED_IP(t+1); | |
2812 do *op++ = *ip++; while (--t > 0); | |
2813 t = *ip++; | |
2814 } | |
2815 } | |
2816 | |
2817 #if defined(HAVE_TEST_IP) || defined(HAVE_TEST_OP) | |
2818 *out_len = op - out; | |
2819 return LZO_E_EOF_NOT_FOUND; | |
2820 #endif | |
2821 | |
2822 eof_found: | |
2823 assert(t == 1); | |
2824 *out_len = op - out; | |
2825 return (ip == ip_end ? LZO_E_OK : | |
2826 (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); | |
2827 | |
2828 #if defined(HAVE_NEED_IP) | |
2829 input_overrun: | |
2830 *out_len = op - out; | |
2831 return LZO_E_INPUT_OVERRUN; | |
2832 #endif | |
2833 | |
2834 #if defined(HAVE_NEED_OP) | |
2835 output_overrun: | |
2836 *out_len = op - out; | |
2837 return LZO_E_OUTPUT_OVERRUN; | |
2838 #endif | |
2839 | |
2840 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND) | |
2841 lookbehind_overrun: | |
2842 *out_len = op - out; | |
2843 return LZO_E_LOOKBEHIND_OVERRUN; | |
2844 #endif | |
2845 } | |
2846 | |
2847 /***** End of minilzo.c *****/ | |
2848 |