1 /* minilzo.c -- mini subset of the LZO real-time data compression library
3 This file is part of the LZO real-time data compression library.
5 Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer
6 Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer
7 Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer
8 Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer
9 Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer
10 Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer
11 Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer
14 The LZO library is free software; you can redistribute it and/or
15 modify it under the terms of the GNU General Public License as
16 published by the Free Software Foundation; either version 2 of
17 the License, or (at your option) any later version.
19 The LZO library is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with the LZO library; see the file COPYING.
26 If not, write to the Free Software Foundation, Inc.,
27 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
29 Markus F.X.J. Oberhumer
30 <markus@oberhumer.com>
31 http://www.oberhumer.com/opensource/lzo/
36 * the full LZO package can be found at
37 * http://www.oberhumer.com/opensource/lzo/
40 #define __LZO_IN_MINILZO
43 #ifdef MINILZO_HAVE_CONFIG_H
47 #undef LZO_HAVE_CONFIG_H
50 #if !defined(MINILZO_VERSION) || (MINILZO_VERSION != 0x1080)
51 # error "version mismatch in miniLZO source files"
54 #ifdef MINILZO_HAVE_CONFIG_H
55 # define LZO_HAVE_CONFIG_H
58 #if !defined(LZO_NO_SYS_TYPES_H)
59 # include <sys/types.h>
66 #if !defined(__LZO_IN_MINILZO)
72 #if defined(__BOUNDS_CHECKING_ON)
73 # include <unchecked.h>
75 # define BOUNDS_CHECKING_OFF_DURING(stmt) stmt
76 # define BOUNDS_CHECKING_OFF_IN_EXPR(expr) (expr)
79 #if !defined(LZO_HAVE_CONFIG_H)
82 # if !defined(NO_STDLIB_H)
90 # include <sys/types.h>
91 # if defined(HAVE_STDDEF_H)
94 # if defined(STDC_HEADERS)
100 #if defined(__LZO_DOS16) || defined(__LZO_WIN16)
101 # define HAVE_MALLOC_H
106 #if !defined(LZO_DEBUG)
109 #if defined(LZO_DEBUG) || !defined(NDEBUG)
110 # if !defined(NO_STDIO_H)
116 #if !defined(LZO_COMPILE_TIME_ASSERT)
117 # define LZO_COMPILE_TIME_ASSERT(expr) \
118 { typedef int __lzo_compile_time_assert_fail[1 - 2 * !(expr)]; }
121 #if !defined(LZO_UNUSED)
123 # define LZO_UNUSED(var) ((void)&var)
125 # define LZO_UNUSED(var) { typedef int __lzo_unused[sizeof(var) ? 2 : 1]; }
127 # define LZO_UNUSED(parm) (parm = parm)
131 #if !defined(__inline__) && !defined(__GNUC__)
132 # if defined(__cplusplus)
133 # define __inline__ inline
139 #if defined(NO_MEMCMP)
143 #if !defined(HAVE_MEMCMP)
145 # define memcmp lzo_memcmp
147 #if !defined(HAVE_MEMCPY)
149 # define memcpy lzo_memcpy
151 #if !defined(HAVE_MEMMOVE)
153 # define memmove lzo_memmove
155 #if !defined(HAVE_MEMSET)
157 # define memset lzo_memset
161 # define LZO_BYTE(x) ((unsigned char) (x))
163 # define LZO_BYTE(x) ((unsigned char) ((x) & 0xff))
166 #define LZO_MAX(a,b) ((a) >= (b) ? (a) : (b))
167 #define LZO_MIN(a,b) ((a) <= (b) ? (a) : (b))
168 #define LZO_MAX3(a,b,c) ((a) >= (b) ? LZO_MAX(a,c) : LZO_MAX(b,c))
169 #define LZO_MIN3(a,b,c) ((a) <= (b) ? LZO_MIN(a,c) : LZO_MIN(b,c))
171 #define lzo_sizeof(type) ((lzo_uint) (sizeof(type)))
173 #define LZO_HIGH(array) ((lzo_uint) (sizeof(array)/sizeof(*(array))))
175 #define LZO_SIZE(bits) (1u << (bits))
176 #define LZO_MASK(bits) (LZO_SIZE(bits) - 1)
178 #define LZO_LSIZE(bits) (1ul << (bits))
179 #define LZO_LMASK(bits) (LZO_LSIZE(bits) - 1)
181 #define LZO_USIZE(bits) ((lzo_uint) 1 << (bits))
182 #define LZO_UMASK(bits) (LZO_USIZE(bits) - 1)
184 #define LZO_STYPE_MAX(b) (((1l << (8*(b)-2)) - 1l) + (1l << (8*(b)-2)))
185 #define LZO_UTYPE_MAX(b) (((1ul << (8*(b)-1)) - 1ul) + (1ul << (8*(b)-1)))
187 #if !defined(SIZEOF_UNSIGNED)
188 # if (UINT_MAX == 0xffff)
189 # define SIZEOF_UNSIGNED 2
190 # elif (UINT_MAX == LZO_0xffffffffL)
191 # define SIZEOF_UNSIGNED 4
192 # elif (UINT_MAX >= LZO_0xffffffffL)
193 # define SIZEOF_UNSIGNED 8
195 # error "SIZEOF_UNSIGNED"
199 #if !defined(SIZEOF_UNSIGNED_LONG)
200 # if (ULONG_MAX == LZO_0xffffffffL)
201 # define SIZEOF_UNSIGNED_LONG 4
202 # elif (ULONG_MAX >= LZO_0xffffffffL)
203 # define SIZEOF_UNSIGNED_LONG 8
205 # error "SIZEOF_UNSIGNED_LONG"
209 #if !defined(SIZEOF_SIZE_T)
210 # define SIZEOF_SIZE_T SIZEOF_UNSIGNED
212 #if !defined(SIZE_T_MAX)
213 # define SIZE_T_MAX LZO_UTYPE_MAX(SIZEOF_SIZE_T)
216 #if 1 && defined(__LZO_i386) && (UINT_MAX == LZO_0xffffffffL)
217 # if !defined(LZO_UNALIGNED_OK_2) && (USHRT_MAX == 0xffff)
218 # define LZO_UNALIGNED_OK_2
220 # if !defined(LZO_UNALIGNED_OK_4) && (LZO_UINT32_MAX == LZO_0xffffffffL)
221 # define LZO_UNALIGNED_OK_4
225 #if defined(LZO_UNALIGNED_OK_2) || defined(LZO_UNALIGNED_OK_4)
226 # if !defined(LZO_UNALIGNED_OK)
227 # define LZO_UNALIGNED_OK
231 #if defined(__LZO_NO_UNALIGNED)
232 # undef LZO_UNALIGNED_OK
233 # undef LZO_UNALIGNED_OK_2
234 # undef LZO_UNALIGNED_OK_4
237 #if defined(LZO_UNALIGNED_OK_2) && (USHRT_MAX != 0xffff)
238 # error "LZO_UNALIGNED_OK_2 must not be defined on this system"
240 #if defined(LZO_UNALIGNED_OK_4) && (LZO_UINT32_MAX != LZO_0xffffffffL)
241 # error "LZO_UNALIGNED_OK_4 must not be defined on this system"
244 #if defined(__LZO_NO_ALIGNED)
245 # undef LZO_ALIGNED_OK_4
248 #if defined(LZO_ALIGNED_OK_4) && (LZO_UINT32_MAX != LZO_0xffffffffL)
249 # error "LZO_ALIGNED_OK_4 must not be defined on this system"
252 #define LZO_LITTLE_ENDIAN 1234
253 #define LZO_BIG_ENDIAN 4321
254 #define LZO_PDP_ENDIAN 3412
256 #if !defined(LZO_BYTE_ORDER)
257 # if defined(MFX_BYTE_ORDER)
258 # define LZO_BYTE_ORDER MFX_BYTE_ORDER
259 # elif defined(__LZO_i386)
260 # define LZO_BYTE_ORDER LZO_LITTLE_ENDIAN
261 # elif defined(BYTE_ORDER)
262 # define LZO_BYTE_ORDER BYTE_ORDER
263 # elif defined(__BYTE_ORDER)
264 # define LZO_BYTE_ORDER __BYTE_ORDER
268 #if defined(LZO_BYTE_ORDER)
269 # if (LZO_BYTE_ORDER != LZO_LITTLE_ENDIAN) && \
270 (LZO_BYTE_ORDER != LZO_BIG_ENDIAN)
271 # error "invalid LZO_BYTE_ORDER"
275 #if defined(LZO_UNALIGNED_OK) && !defined(LZO_BYTE_ORDER)
276 # error "LZO_BYTE_ORDER is not defined"
279 #define LZO_OPTIMIZE_GNUC_i386_IS_BUGGY
281 #if defined(NDEBUG) && !defined(LZO_DEBUG) && !defined(__LZO_CHECKER)
282 # if defined(__GNUC__) && defined(__i386__)
283 # if !defined(LZO_OPTIMIZE_GNUC_i386_IS_BUGGY)
284 # define LZO_OPTIMIZE_GNUC_i386
289 __LZO_EXTERN_C
int __lzo_init_done
;
290 __LZO_EXTERN_C
const lzo_byte __lzo_copyright
[];
291 LZO_EXTERN(const lzo_byte
*) lzo_copyright(void);
292 __LZO_EXTERN_C
const lzo_uint32 _lzo_crc32_table
[256];
294 #define _LZO_STRINGIZE(x) #x
295 #define _LZO_MEXPAND(x) _LZO_STRINGIZE(x)
297 #define _LZO_CONCAT2(a,b) a ## b
298 #define _LZO_CONCAT3(a,b,c) a ## b ## c
299 #define _LZO_CONCAT4(a,b,c,d) a ## b ## c ## d
300 #define _LZO_CONCAT5(a,b,c,d,e) a ## b ## c ## d ## e
302 #define _LZO_ECONCAT2(a,b) _LZO_CONCAT2(a,b)
303 #define _LZO_ECONCAT3(a,b,c) _LZO_CONCAT3(a,b,c)
304 #define _LZO_ECONCAT4(a,b,c,d) _LZO_CONCAT4(a,b,c,d)
305 #define _LZO_ECONCAT5(a,b,c,d,e) _LZO_CONCAT5(a,b,c,d,e)
309 #define __LZO_IS_COMPRESS_QUERY(i,il,o,ol,w) ((lzo_voidp)(o) == (w))
310 #define __LZO_QUERY_COMPRESS(i,il,o,ol,w,n,s) \
311 (*ol = (n)*(s), LZO_E_OK)
313 #define __LZO_IS_DECOMPRESS_QUERY(i,il,o,ol,w) ((lzo_voidp)(o) == (w))
314 #define __LZO_QUERY_DECOMPRESS(i,il,o,ol,w,n,s) \
315 (*ol = (n)*(s), LZO_E_OK)
317 #define __LZO_IS_OPTIMIZE_QUERY(i,il,o,ol,w) ((lzo_voidp)(o) == (w))
318 #define __LZO_QUERY_OPTIMIZE(i,il,o,ol,w,n,s) \
319 (*ol = (n)*(s), LZO_E_OK)
330 #if defined(__LZO_DOS16) || defined(__LZO_WIN16)
332 # if 1 && defined(__WATCOMC__)
334 __LZO_EXTERN_C
unsigned char _HShift
;
335 # define __LZO_HShift _HShift
336 # elif 1 && defined(_MSC_VER)
337 __LZO_EXTERN_C
unsigned short __near _AHSHIFT
;
338 # define __LZO_HShift ((unsigned) &_AHSHIFT)
339 # elif defined(__LZO_WIN16)
340 # define __LZO_HShift 3
342 # define __LZO_HShift 12
344 # if !defined(_FP_SEG) && defined(FP_SEG)
345 # define _FP_SEG FP_SEG
347 # if !defined(_FP_OFF) && defined(FP_OFF)
348 # define _FP_OFF FP_OFF
352 #if !defined(lzo_ptrdiff_t)
353 # if (UINT_MAX >= LZO_0xffffffffL)
354 typedef ptrdiff_t lzo_ptrdiff_t
;
356 typedef long lzo_ptrdiff_t
;
360 #if !defined(__LZO_HAVE_PTR_T)
361 # if defined(lzo_ptr_t)
362 # define __LZO_HAVE_PTR_T
365 #if !defined(__LZO_HAVE_PTR_T)
366 # if defined(SIZEOF_CHAR_P) && defined(SIZEOF_UNSIGNED_LONG)
367 # if (SIZEOF_CHAR_P == SIZEOF_UNSIGNED_LONG)
368 typedef unsigned long lzo_ptr_t
;
369 typedef long lzo_sptr_t
;
370 # define __LZO_HAVE_PTR_T
374 #if !defined(__LZO_HAVE_PTR_T)
375 # if defined(SIZEOF_CHAR_P) && defined(SIZEOF_UNSIGNED)
376 # if (SIZEOF_CHAR_P == SIZEOF_UNSIGNED)
377 typedef unsigned int lzo_ptr_t
;
378 typedef int lzo_sptr_t
;
379 # define __LZO_HAVE_PTR_T
383 #if !defined(__LZO_HAVE_PTR_T)
384 # if defined(SIZEOF_CHAR_P) && defined(SIZEOF_UNSIGNED_SHORT)
385 # if (SIZEOF_CHAR_P == SIZEOF_UNSIGNED_SHORT)
386 typedef unsigned short lzo_ptr_t
;
387 typedef short lzo_sptr_t
;
388 # define __LZO_HAVE_PTR_T
392 #if !defined(__LZO_HAVE_PTR_T)
393 # if defined(LZO_HAVE_CONFIG_H) || defined(SIZEOF_CHAR_P)
394 # error "no suitable type for lzo_ptr_t"
396 typedef unsigned long lzo_ptr_t
;
397 typedef long lzo_sptr_t
;
398 # define __LZO_HAVE_PTR_T
402 #if defined(__LZO_DOS16) || defined(__LZO_WIN16)
403 #define PTR(a) ((lzo_bytep) (a))
404 #define PTR_ALIGNED_4(a) ((_FP_OFF(a) & 3) == 0)
405 #define PTR_ALIGNED2_4(a,b) (((_FP_OFF(a) | _FP_OFF(b)) & 3) == 0)
407 #define PTR(a) ((lzo_ptr_t) (a))
408 #define PTR_LINEAR(a) PTR(a)
409 #define PTR_ALIGNED_4(a) ((PTR_LINEAR(a) & 3) == 0)
410 #define PTR_ALIGNED_8(a) ((PTR_LINEAR(a) & 7) == 0)
411 #define PTR_ALIGNED2_4(a,b) (((PTR_LINEAR(a) | PTR_LINEAR(b)) & 3) == 0)
412 #define PTR_ALIGNED2_8(a,b) (((PTR_LINEAR(a) | PTR_LINEAR(b)) & 7) == 0)
415 #define PTR_LT(a,b) (PTR(a) < PTR(b))
416 #define PTR_GE(a,b) (PTR(a) >= PTR(b))
417 #define PTR_DIFF(a,b) ((lzo_ptrdiff_t) (PTR(a) - PTR(b)))
418 #define pd(a,b) ((lzo_uint) ((a)-(b)))
420 LZO_EXTERN(lzo_ptr_t
)
421 __lzo_ptr_linear(const lzo_voidp ptr
);
426 unsigned char a_uchar
;
428 unsigned short a_ushort
;
432 unsigned long a_ulong
;
435 lzo_int32 a_lzo_int32
;
436 lzo_uint32 a_lzo_uint32
;
437 ptrdiff_t a_ptrdiff_t
;
438 lzo_ptrdiff_t a_lzo_ptrdiff_t
;
439 lzo_ptr_t a_lzo_ptr_t
;
440 lzo_voidp a_lzo_voidp
;
442 lzo_bytep a_lzo_bytep
;
443 lzo_bytepp a_lzo_bytepp
;
444 lzo_uintp a_lzo_uintp
;
445 lzo_uint
* a_lzo_uint_p
;
446 lzo_uint32p a_lzo_uint32p
;
447 lzo_uint32
* a_lzo_uint32_p
;
448 unsigned char * a_uchar_p
;
459 #define LZO_DETERMINISTIC
461 #define LZO_DICT_USE_PTR
462 #if defined(__LZO_DOS16) || defined(__LZO_WIN16) || defined(__LZO_STRICT_16BIT)
463 # undef LZO_DICT_USE_PTR
466 #if defined(LZO_DICT_USE_PTR)
467 # define lzo_dict_t const lzo_bytep
468 # define lzo_dict_p lzo_dict_t __LZO_MMODEL *
470 # define lzo_dict_t lzo_uint
471 # define lzo_dict_p lzo_dict_t __LZO_MMODEL *
474 #if !defined(lzo_moff_t)
475 #define lzo_moff_t lzo_uint
480 LZO_PUBLIC(lzo_ptr_t
)
481 __lzo_ptr_linear(const lzo_voidp ptr
)
485 #if defined(__LZO_DOS16) || defined(__LZO_WIN16)
486 p
= (((lzo_ptr_t
)(_FP_SEG(ptr
))) << (16 - __LZO_HShift
)) + (_FP_OFF(ptr
));
495 __lzo_align_gap(const lzo_voidp ptr
, lzo_uint size
)
501 p
= __lzo_ptr_linear(ptr
);
502 s
= (lzo_ptr_t
) (size
- 1);
504 assert((size
& (size
- 1)) == 0);
505 n
= ((p
+ s
) & ~s
) - p
;
507 n
= (((p
+ s
) / size
) * size
) - p
;
510 assert((long)n
>= 0);
526 #if 1 && defined(HAVE_MEMCPY)
527 #if !defined(__LZO_DOS16) && !defined(__LZO_WIN16)
529 #define MEMCPY8_DS(dest,src,len) \
530 memcpy(dest,src,len); \
537 #if 0 && !defined(MEMCPY8_DS)
539 #define MEMCPY8_DS(dest,src,len) \
554 #if !defined(MEMCPY8_DS)
556 #define MEMCPY8_DS(dest,src,len) \
557 { register lzo_uint __l = (len) / 8; \
567 } while (--__l > 0); }
571 #define MEMCPY_DS(dest,src,len) \
572 do *dest++ = *src++; \
575 #define MEMMOVE_DS(dest,src,len) \
576 do *dest++ = *src++; \
579 #if 0 && defined(LZO_OPTIMIZE_GNUC_i386)
581 #define BZERO8_PTR(s,l,n) \
582 __asm__ __volatile__( \
588 "stosl %%eax,(%%edi) \n" \
590 :"g" (0),"g" (s),"g" (n) \
591 :"eax","edi","ecx", "memory", "cc" \
594 #elif (LZO_UINT_MAX <= SIZE_T_MAX) && defined(HAVE_MEMSET)
597 #define BZERO8_PTR(s,l,n) memset((s),0,(lzo_uint)(l)*(n))
599 #define BZERO8_PTR(s,l,n) memset((lzo_voidp)(s),0,(lzo_uint)(l)*(n))
604 #define BZERO8_PTR(s,l,n) \
605 lzo_memset((lzo_voidp)(s),0,(lzo_uint)(l)*(n))
610 #if defined(__GNUC__) && defined(__i386__)
612 unsigned char lzo_rotr8(unsigned char value
, int shift
);
613 extern __inline__
unsigned char lzo_rotr8(unsigned char value
, int shift
)
615 unsigned char result
;
617 __asm__
__volatile__ ("movb %b1, %b0; rorb %b2, %b0"
618 : "=a"(result
) : "g"(value
), "c"(shift
));
622 unsigned short lzo_rotr16(unsigned short value
, int shift
);
623 extern __inline__
unsigned short lzo_rotr16(unsigned short value
, int shift
)
625 unsigned short result
;
627 __asm__
__volatile__ ("movw %b1, %b0; rorw %b2, %b0"
628 : "=a"(result
) : "g"(value
), "c"(shift
));
644 return (expr
) ? 1 : 0;
647 /* If you use the LZO library in a product, you *must* keep this
648 * copyright string in the executable of your product.
651 const lzo_byte __lzo_copyright
[] =
652 #if !defined(__LZO_IN_MINLZO)
656 "LZO real-time data compression library.\n"
657 "Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002 Markus Franz Xaver Johannes Oberhumer\n"
658 "<markus.oberhumer@jk.uni-linz.ac.at>\n"
659 "http://www.oberhumer.com/opensource/lzo/\n"
661 "LZO version: v" LZO_VERSION_STRING
", " LZO_VERSION_DATE
"\n"
662 "LZO build date: " __DATE__
" " __TIME__
"\n\n"
663 "LZO special compilation options:\n"
669 #elif defined(__pic__)
672 #if (UINT_MAX < LZO_0xffffffffL)
675 #if defined(__LZO_STRICT_16BIT)
676 " __LZO_STRICT_16BIT\n"
678 #if (UINT_MAX > LZO_0xffffffffL)
679 " UINT_MAX=" _LZO_MEXPAND(UINT_MAX
) "\n"
681 #if (ULONG_MAX > LZO_0xffffffffL)
682 " ULONG_MAX=" _LZO_MEXPAND(ULONG_MAX
) "\n"
684 #if defined(LZO_BYTE_ORDER)
685 " LZO_BYTE_ORDER=" _LZO_MEXPAND(LZO_BYTE_ORDER
) "\n"
687 #if defined(LZO_UNALIGNED_OK_2)
688 " LZO_UNALIGNED_OK_2\n"
690 #if defined(LZO_UNALIGNED_OK_4)
691 " LZO_UNALIGNED_OK_4\n"
693 #if defined(LZO_ALIGNED_OK_4)
694 " LZO_ALIGNED_OK_4\n"
696 #if defined(LZO_DICT_USE_PTR)
697 " LZO_DICT_USE_PTR\n"
699 #if defined(__LZO_QUERY_COMPRESS)
700 " __LZO_QUERY_COMPRESS\n"
702 #if defined(__LZO_QUERY_DECOMPRESS)
703 " __LZO_QUERY_DECOMPRESS\n"
705 #if defined(__LZO_IN_MINILZO)
706 " __LZO_IN_MINILZO\n"
709 "$Id: LZO " LZO_VERSION_STRING
" built " __DATE__
" " __TIME__
710 #if defined(__GNUC__) && defined(__VERSION__)
711 " by gcc " __VERSION__
712 #elif defined(__BORLANDC__)
713 " by Borland C " _LZO_MEXPAND(__BORLANDC__
)
714 #elif defined(_MSC_VER)
715 " by Microsoft C " _LZO_MEXPAND(_MSC_VER
)
716 #elif defined(__PUREC__)
717 " by Pure C " _LZO_MEXPAND(__PUREC__
)
718 #elif defined(__SC__)
719 " by Symantec C " _LZO_MEXPAND(__SC__
)
720 #elif defined(__TURBOC__)
721 " by Turbo C " _LZO_MEXPAND(__TURBOC__
)
722 #elif defined(__WATCOMC__)
723 " by Watcom C " _LZO_MEXPAND(__WATCOMC__
)
726 "$Copyright: LZO (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002 Markus Franz Xaver Johannes Oberhumer $\n";
729 LZO_PUBLIC(const lzo_byte
*)
732 return __lzo_copyright
;
741 LZO_PUBLIC(const char *)
742 lzo_version_string(void)
744 return LZO_VERSION_STRING
;
747 LZO_PUBLIC(const char *)
748 lzo_version_date(void)
750 return LZO_VERSION_DATE
;
753 LZO_PUBLIC(const lzo_charp
)
754 _lzo_version_string(void)
756 return LZO_VERSION_STRING
;
759 LZO_PUBLIC(const lzo_charp
)
760 _lzo_version_date(void)
762 return LZO_VERSION_DATE
;
765 #define LZO_BASE 65521u
766 #define LZO_NMAX 5552
768 #define LZO_DO1(buf,i) {s1 += buf[i]; s2 += s1;}
769 #define LZO_DO2(buf,i) LZO_DO1(buf,i); LZO_DO1(buf,i+1);
770 #define LZO_DO4(buf,i) LZO_DO2(buf,i); LZO_DO2(buf,i+2);
771 #define LZO_DO8(buf,i) LZO_DO4(buf,i); LZO_DO4(buf,i+4);
772 #define LZO_DO16(buf,i) LZO_DO8(buf,i); LZO_DO8(buf,i+8);
774 LZO_PUBLIC(lzo_uint32
)
775 lzo_adler32(lzo_uint32 adler
, const lzo_byte
*buf
, lzo_uint len
)
777 lzo_uint32 s1
= adler
& 0xffff;
778 lzo_uint32 s2
= (adler
>> 16) & 0xffff;
786 k
= len
< LZO_NMAX
? (int) len
: LZO_NMAX
;
802 return (s2
<< 16) | s1
;
806 lzo_memcmp(const lzo_voidp s1
, const lzo_voidp s2
, lzo_uint len
)
808 #if (LZO_UINT_MAX <= SIZE_T_MAX) && defined(HAVE_MEMCMP)
809 return memcmp(s1
,s2
,len
);
811 const lzo_byte
*p1
= (const lzo_byte
*) s1
;
812 const lzo_byte
*p2
= (const lzo_byte
*) s2
;
828 LZO_PUBLIC(lzo_voidp
)
829 lzo_memcpy(lzo_voidp dest
, const lzo_voidp src
, lzo_uint len
)
831 #if (LZO_UINT_MAX <= SIZE_T_MAX) && defined(HAVE_MEMCPY)
832 return memcpy(dest
,src
,len
);
834 lzo_byte
*p1
= (lzo_byte
*) dest
;
835 const lzo_byte
*p2
= (const lzo_byte
*) src
;
837 if (len
<= 0 || p1
== p2
)
846 LZO_PUBLIC(lzo_voidp
)
847 lzo_memmove(lzo_voidp dest
, const lzo_voidp src
, lzo_uint len
)
849 #if (LZO_UINT_MAX <= SIZE_T_MAX) && defined(HAVE_MEMMOVE)
850 return memmove(dest
,src
,len
);
852 lzo_byte
*p1
= (lzo_byte
*) dest
;
853 const lzo_byte
*p2
= (const lzo_byte
*) src
;
855 if (len
<= 0 || p1
== p2
)
876 LZO_PUBLIC(lzo_voidp
)
877 lzo_memset(lzo_voidp s
, int c
, lzo_uint len
)
879 #if (LZO_UINT_MAX <= SIZE_T_MAX) && defined(HAVE_MEMSET)
880 return memset(s
,c
,len
);
882 lzo_byte
*p
= (lzo_byte
*) s
;
892 # define IS_SIGNED(type) (((type) (1ul << (8 * sizeof(type) - 1))) < 0)
893 # define IS_UNSIGNED(type) (((type) (1ul << (8 * sizeof(type) - 1))) > 0)
895 # define IS_SIGNED(type) (((type) (-1)) < ((type) 0))
896 # define IS_UNSIGNED(type) (((type) (-1)) > ((type) 0))
899 #define IS_POWER_OF_2(x) (((x) & ((x) - 1)) == 0)
901 static lzo_bool
schedule_insns_bug(void);
902 static lzo_bool
strength_reduce_bug(int *);
904 #if 0 || defined(LZO_DEBUG)
906 static lzo_bool
__lzo_assert_fail(const char *s
, unsigned line
)
908 #if defined(__palmos__)
909 printf("LZO assertion failed in line %u: '%s'\n",line
,s
);
911 fprintf(stderr
,"LZO assertion failed in line %u: '%s'\n",line
,s
);
915 # define __lzo_assert(x) ((x) ? 1 : __lzo_assert_fail(#x,__LINE__))
917 # define __lzo_assert(x) ((x) ? 1 : 0)
920 #undef COMPILE_TIME_ASSERT
922 # define COMPILE_TIME_ASSERT(expr) r &= __lzo_assert(expr)
924 # define COMPILE_TIME_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr)
927 static lzo_bool
basic_integral_check(void)
931 COMPILE_TIME_ASSERT(CHAR_BIT
== 8);
932 COMPILE_TIME_ASSERT(sizeof(char) == 1);
933 COMPILE_TIME_ASSERT(sizeof(short) >= 2);
934 COMPILE_TIME_ASSERT(sizeof(long) >= 4);
935 COMPILE_TIME_ASSERT(sizeof(int) >= sizeof(short));
936 COMPILE_TIME_ASSERT(sizeof(long) >= sizeof(int));
938 COMPILE_TIME_ASSERT(sizeof(lzo_uint
) == sizeof(lzo_int
));
939 COMPILE_TIME_ASSERT(sizeof(lzo_uint32
) == sizeof(lzo_int32
));
941 COMPILE_TIME_ASSERT(sizeof(lzo_uint32
) >= 4);
942 COMPILE_TIME_ASSERT(sizeof(lzo_uint32
) >= sizeof(unsigned));
943 #if defined(__LZO_STRICT_16BIT)
944 COMPILE_TIME_ASSERT(sizeof(lzo_uint
) == 2);
946 COMPILE_TIME_ASSERT(sizeof(lzo_uint
) >= 4);
947 COMPILE_TIME_ASSERT(sizeof(lzo_uint
) >= sizeof(unsigned));
950 #if (USHRT_MAX == 65535u)
951 COMPILE_TIME_ASSERT(sizeof(short) == 2);
952 #elif (USHRT_MAX == LZO_0xffffffffL)
953 COMPILE_TIME_ASSERT(sizeof(short) == 4);
954 #elif (USHRT_MAX >= LZO_0xffffffffL)
955 COMPILE_TIME_ASSERT(sizeof(short) > 4);
957 #if (UINT_MAX == 65535u)
958 COMPILE_TIME_ASSERT(sizeof(int) == 2);
959 #elif (UINT_MAX == LZO_0xffffffffL)
960 COMPILE_TIME_ASSERT(sizeof(int) == 4);
961 #elif (UINT_MAX >= LZO_0xffffffffL)
962 COMPILE_TIME_ASSERT(sizeof(int) > 4);
964 #if (ULONG_MAX == 65535ul)
965 COMPILE_TIME_ASSERT(sizeof(long) == 2);
966 #elif (ULONG_MAX == LZO_0xffffffffL)
967 COMPILE_TIME_ASSERT(sizeof(long) == 4);
968 #elif (ULONG_MAX >= LZO_0xffffffffL)
969 COMPILE_TIME_ASSERT(sizeof(long) > 4);
972 #if defined(SIZEOF_UNSIGNED)
973 COMPILE_TIME_ASSERT(SIZEOF_UNSIGNED
== sizeof(unsigned));
975 #if defined(SIZEOF_UNSIGNED_LONG)
976 COMPILE_TIME_ASSERT(SIZEOF_UNSIGNED_LONG
== sizeof(unsigned long));
978 #if defined(SIZEOF_UNSIGNED_SHORT)
979 COMPILE_TIME_ASSERT(SIZEOF_UNSIGNED_SHORT
== sizeof(unsigned short));
981 #if !defined(__LZO_IN_MINILZO)
982 #if defined(SIZEOF_SIZE_T)
983 COMPILE_TIME_ASSERT(SIZEOF_SIZE_T
== sizeof(size_t));
987 COMPILE_TIME_ASSERT(IS_UNSIGNED(unsigned char));
988 COMPILE_TIME_ASSERT(IS_UNSIGNED(unsigned short));
989 COMPILE_TIME_ASSERT(IS_UNSIGNED(unsigned));
990 COMPILE_TIME_ASSERT(IS_UNSIGNED(unsigned long));
991 COMPILE_TIME_ASSERT(IS_SIGNED(short));
992 COMPILE_TIME_ASSERT(IS_SIGNED(int));
993 COMPILE_TIME_ASSERT(IS_SIGNED(long));
995 COMPILE_TIME_ASSERT(IS_UNSIGNED(lzo_uint32
));
996 COMPILE_TIME_ASSERT(IS_UNSIGNED(lzo_uint
));
997 COMPILE_TIME_ASSERT(IS_SIGNED(lzo_int32
));
998 COMPILE_TIME_ASSERT(IS_SIGNED(lzo_int
));
1000 COMPILE_TIME_ASSERT(INT_MAX
== LZO_STYPE_MAX(sizeof(int)));
1001 COMPILE_TIME_ASSERT(UINT_MAX
== LZO_UTYPE_MAX(sizeof(unsigned)));
1002 COMPILE_TIME_ASSERT(LONG_MAX
== LZO_STYPE_MAX(sizeof(long)));
1003 COMPILE_TIME_ASSERT(ULONG_MAX
== LZO_UTYPE_MAX(sizeof(unsigned long)));
1004 COMPILE_TIME_ASSERT(SHRT_MAX
== LZO_STYPE_MAX(sizeof(short)));
1005 COMPILE_TIME_ASSERT(USHRT_MAX
== LZO_UTYPE_MAX(sizeof(unsigned short)));
1006 COMPILE_TIME_ASSERT(LZO_UINT32_MAX
== LZO_UTYPE_MAX(sizeof(lzo_uint32
)));
1007 COMPILE_TIME_ASSERT(LZO_UINT_MAX
== LZO_UTYPE_MAX(sizeof(lzo_uint
)));
1008 #if !defined(__LZO_IN_MINILZO)
1009 COMPILE_TIME_ASSERT(SIZE_T_MAX
== LZO_UTYPE_MAX(sizeof(size_t)));
1012 r
&= __lzo_assert(LZO_BYTE(257) == 1);
1017 static lzo_bool
basic_ptr_check(void)
1021 COMPILE_TIME_ASSERT(sizeof(char *) >= sizeof(int));
1022 COMPILE_TIME_ASSERT(sizeof(lzo_byte
*) >= sizeof(char *));
1024 COMPILE_TIME_ASSERT(sizeof(lzo_voidp
) == sizeof(lzo_byte
*));
1025 COMPILE_TIME_ASSERT(sizeof(lzo_voidp
) == sizeof(lzo_voidpp
));
1026 COMPILE_TIME_ASSERT(sizeof(lzo_voidp
) == sizeof(lzo_bytepp
));
1027 COMPILE_TIME_ASSERT(sizeof(lzo_voidp
) >= sizeof(lzo_uint
));
1029 COMPILE_TIME_ASSERT(sizeof(lzo_ptr_t
) == sizeof(lzo_voidp
));
1030 COMPILE_TIME_ASSERT(sizeof(lzo_ptr_t
) == sizeof(lzo_sptr_t
));
1031 COMPILE_TIME_ASSERT(sizeof(lzo_ptr_t
) >= sizeof(lzo_uint
));
1033 COMPILE_TIME_ASSERT(sizeof(lzo_ptrdiff_t
) >= 4);
1034 COMPILE_TIME_ASSERT(sizeof(lzo_ptrdiff_t
) >= sizeof(ptrdiff_t));
1036 COMPILE_TIME_ASSERT(sizeof(ptrdiff_t) >= sizeof(size_t));
1037 COMPILE_TIME_ASSERT(sizeof(lzo_ptrdiff_t
) >= sizeof(lzo_uint
));
1039 #if defined(SIZEOF_CHAR_P)
1040 COMPILE_TIME_ASSERT(SIZEOF_CHAR_P
== sizeof(char *));
1042 #if defined(SIZEOF_PTRDIFF_T)
1043 COMPILE_TIME_ASSERT(SIZEOF_PTRDIFF_T
== sizeof(ptrdiff_t));
1046 COMPILE_TIME_ASSERT(IS_SIGNED(ptrdiff_t));
1047 COMPILE_TIME_ASSERT(IS_UNSIGNED(size_t));
1048 COMPILE_TIME_ASSERT(IS_SIGNED(lzo_ptrdiff_t
));
1049 COMPILE_TIME_ASSERT(IS_SIGNED(lzo_sptr_t
));
1050 COMPILE_TIME_ASSERT(IS_UNSIGNED(lzo_ptr_t
));
1051 COMPILE_TIME_ASSERT(IS_UNSIGNED(lzo_moff_t
));
1056 static lzo_bool
ptr_check(void)
1060 char _wrkmem
[10 * sizeof(lzo_byte
*) + sizeof(lzo_full_align_t
)];
1063 unsigned char x
[4 * sizeof(lzo_full_align_t
)];
1068 for (i
= 0; i
< (int) sizeof(x
); i
++)
1071 wrkmem
= LZO_PTR_ALIGN_UP((lzo_byte
*)_wrkmem
,sizeof(lzo_full_align_t
));
1074 dict
= (lzo_bytepp
) wrkmem
;
1077 u
.a_lzo_bytep
= wrkmem
; dict
= u
.a_lzo_bytepp
;
1080 d
= (long) ((const lzo_bytep
) dict
- (const lzo_bytep
) _wrkmem
);
1081 r
&= __lzo_assert(d
>= 0);
1082 r
&= __lzo_assert(d
< (long) sizeof(lzo_full_align_t
));
1084 memset(&a
,0,sizeof(a
));
1085 r
&= __lzo_assert(a
.a_lzo_voidp
== NULL
);
1087 memset(&a
,0xff,sizeof(a
));
1088 r
&= __lzo_assert(a
.a_ushort
== USHRT_MAX
);
1089 r
&= __lzo_assert(a
.a_uint
== UINT_MAX
);
1090 r
&= __lzo_assert(a
.a_ulong
== ULONG_MAX
);
1091 r
&= __lzo_assert(a
.a_lzo_uint
== LZO_UINT_MAX
);
1092 r
&= __lzo_assert(a
.a_lzo_uint32
== LZO_UINT32_MAX
);
1096 for (i
= 0; i
< 8; i
++)
1097 r
&= __lzo_assert((const lzo_voidp
) (&dict
[i
]) == (const lzo_voidp
) (&wrkmem
[i
* sizeof(lzo_byte
*)]));
1100 memset(&a
,0,sizeof(a
));
1101 r
&= __lzo_assert(a
.a_char_p
== NULL
);
1102 r
&= __lzo_assert(a
.a_lzo_bytep
== NULL
);
1103 r
&= __lzo_assert(NULL
== (void *)0);
1106 for (i
= 0; i
< 10; i
++)
1108 BZERO8_PTR(dict
+1,sizeof(dict
[0]),8);
1109 r
&= __lzo_assert(dict
[0] == wrkmem
);
1110 for (i
= 1; i
< 9; i
++)
1111 r
&= __lzo_assert(dict
[i
] == NULL
);
1112 r
&= __lzo_assert(dict
[9] == wrkmem
);
1118 const unsigned n
= (unsigned) sizeof(lzo_uint32
);
1122 k
+= __lzo_align_gap(&x
[k
],n
);
1123 p0
= (lzo_bytep
) &x
[k
];
1124 #if defined(PTR_LINEAR)
1125 r
&= __lzo_assert((PTR_LINEAR(p0
) & (n
-1)) == 0);
1127 r
&= __lzo_assert(n
== 4);
1128 r
&= __lzo_assert(PTR_ALIGNED_4(p0
));
1131 r
&= __lzo_assert(k
>= 1);
1132 p1
= (lzo_bytep
) &x
[1];
1133 r
&= __lzo_assert(PTR_GE(p0
,p1
));
1135 r
&= __lzo_assert(k
< 1+n
);
1136 p1
= (lzo_bytep
) &x
[1+n
];
1137 r
&= __lzo_assert(PTR_LT(p0
,p1
));
1143 v0
= * (lzo_uint32
*) &x
[k
];
1144 v1
= * (lzo_uint32
*) &x
[k
+n
];
1147 u
.a_uchar_p
= &x
[k
];
1148 v0
= *u
.a_lzo_uint32_p
;
1149 u
.a_uchar_p
= &x
[k
+n
];
1150 v1
= *u
.a_lzo_uint32_p
;
1152 r
&= __lzo_assert(v0
> 0);
1153 r
&= __lzo_assert(v1
> 0);
1161 _lzo_config_check(void)
1169 unsigned char x
[4*sizeof(lzo_full_align_t
)];
1172 COMPILE_TIME_ASSERT( (int) ((unsigned char) ((signed char) -1)) == 255);
1173 COMPILE_TIME_ASSERT( (((unsigned char)128) << (int)(8*sizeof(int)-8)) < 0);
1176 r
&= __lzo_assert((const void *)&u
== (const void *)&u
.a
);
1177 r
&= __lzo_assert((const void *)&u
== (const void *)&u
.b
);
1178 r
&= __lzo_assert((const void *)&u
== (const void *)&u
.x
[0]);
1179 r
&= __lzo_assert((const void *)&u
== (const void *)&u
.aa
[0]);
1182 r
&= basic_integral_check();
1183 r
&= basic_ptr_check();
1188 for (i
= 0; i
< (int) sizeof(u
.x
); i
++)
1189 u
.x
[i
] = LZO_BYTE(i
);
1191 #if defined(LZO_BYTE_ORDER)
1194 # if (LZO_BYTE_ORDER == LZO_LITTLE_ENDIAN)
1195 lzo_uint32 a
= (lzo_uint32
) (u
.a
& LZO_0xffffffffL
);
1196 unsigned short b
= (unsigned short) (u
.b
& 0xffff);
1197 r
&= __lzo_assert(a
== 0x03020100L
);
1198 r
&= __lzo_assert(b
== 0x0100);
1199 # elif (LZO_BYTE_ORDER == LZO_BIG_ENDIAN)
1200 lzo_uint32 a
= u
.a
>> (8 * sizeof(u
.a
) - 32);
1201 unsigned short b
= u
.b
>> (8 * sizeof(u
.b
) - 16);
1202 r
&= __lzo_assert(a
== 0x00010203L
);
1203 r
&= __lzo_assert(b
== 0x0001);
1205 # error "invalid LZO_BYTE_ORDER"
1210 #if defined(LZO_UNALIGNED_OK_2)
1211 COMPILE_TIME_ASSERT(sizeof(short) == 2);
1214 unsigned short b
[4];
1216 for (i
= 0; i
< 4; i
++)
1217 b
[i
] = * (const unsigned short *) &u
.x
[i
];
1219 # if (LZO_BYTE_ORDER == LZO_LITTLE_ENDIAN)
1220 r
&= __lzo_assert(b
[0] == 0x0100);
1221 r
&= __lzo_assert(b
[1] == 0x0201);
1222 r
&= __lzo_assert(b
[2] == 0x0302);
1223 r
&= __lzo_assert(b
[3] == 0x0403);
1224 # elif (LZO_BYTE_ORDER == LZO_BIG_ENDIAN)
1225 r
&= __lzo_assert(b
[0] == 0x0001);
1226 r
&= __lzo_assert(b
[1] == 0x0102);
1227 r
&= __lzo_assert(b
[2] == 0x0203);
1228 r
&= __lzo_assert(b
[3] == 0x0304);
1233 #if defined(LZO_UNALIGNED_OK_4)
1234 COMPILE_TIME_ASSERT(sizeof(lzo_uint32
) == 4);
1239 for (i
= 0; i
< 4; i
++)
1240 a
[i
] = * (const lzo_uint32
*) &u
.x
[i
];
1242 # if (LZO_BYTE_ORDER == LZO_LITTLE_ENDIAN)
1243 r
&= __lzo_assert(a
[0] == 0x03020100L
);
1244 r
&= __lzo_assert(a
[1] == 0x04030201L
);
1245 r
&= __lzo_assert(a
[2] == 0x05040302L
);
1246 r
&= __lzo_assert(a
[3] == 0x06050403L
);
1247 # elif (LZO_BYTE_ORDER == LZO_BIG_ENDIAN)
1248 r
&= __lzo_assert(a
[0] == 0x00010203L
);
1249 r
&= __lzo_assert(a
[1] == 0x01020304L
);
1250 r
&= __lzo_assert(a
[2] == 0x02030405L
);
1251 r
&= __lzo_assert(a
[3] == 0x03040506L
);
1256 #if defined(LZO_ALIGNED_OK_4)
1257 COMPILE_TIME_ASSERT(sizeof(lzo_uint32
) == 4);
1260 COMPILE_TIME_ASSERT(lzo_sizeof_dict_t
== sizeof(lzo_dict_t
));
1262 #if defined(__LZO_IN_MINLZO)
1266 adler
= lzo_adler32(0, NULL
, 0);
1267 adler
= lzo_adler32(adler
, lzo_copyright(), 200);
1268 r
&= __lzo_assert(adler
== 0xc76f1751L
);
1274 r
&= __lzo_assert(!schedule_insns_bug());
1280 static unsigned xn
= 3;
1281 register unsigned j
;
1283 for (j
= 0; j
< xn
; j
++)
1285 r
&= __lzo_assert(!strength_reduce_bug(x
));
1293 return r
== 1 ? LZO_E_OK
: LZO_E_ERROR
;
1296 static lzo_bool
schedule_insns_bug(void)
1298 #if defined(__LZO_CHECKER)
1301 const int clone
[] = {1, 2, 0};
1304 return (*q
) ? 0 : 1;
1308 static lzo_bool
strength_reduce_bug(int *x
)
1310 return x
[0] != -3 || x
[1] != -2 || x
[2] != -1;
1313 #undef COMPILE_TIME_ASSERT
1315 int __lzo_init_done
= 0;
1318 __lzo_init2(unsigned v
, int s1
, int s2
, int s3
, int s4
, int s5
,
1319 int s6
, int s7
, int s8
, int s9
)
1323 __lzo_init_done
= 1;
1328 r
= (s1
== -1 || s1
== (int) sizeof(short)) &&
1329 (s2
== -1 || s2
== (int) sizeof(int)) &&
1330 (s3
== -1 || s3
== (int) sizeof(long)) &&
1331 (s4
== -1 || s4
== (int) sizeof(lzo_uint32
)) &&
1332 (s5
== -1 || s5
== (int) sizeof(lzo_uint
)) &&
1333 (s6
== -1 || s6
== (int) lzo_sizeof_dict_t
) &&
1334 (s7
== -1 || s7
== (int) sizeof(char *)) &&
1335 (s8
== -1 || s8
== (int) sizeof(lzo_voidp
)) &&
1336 (s9
== -1 || s9
== (int) sizeof(lzo_compress_t
));
1340 r
= _lzo_config_check();
1347 #if !defined(__LZO_IN_MINILZO)
1350 __lzo_init(unsigned v
,int s1
,int s2
,int s3
,int s4
,int s5
,int s6
,int s7
);
1353 __lzo_init(unsigned v
,int s1
,int s2
,int s3
,int s4
,int s5
,int s6
,int s7
)
1355 if (v
== 0 || v
> 0x1010)
1357 return __lzo_init2(v
,s1
,s2
,s3
,s4
,s5
,-1,-1,s6
,s7
);
1362 #define do_compress _lzo1x_1_do_compress
1364 #define LZO_NEED_DICT_H
1366 #define D_INDEX1(d,p) d = DM((0x21*DX3(p,5,5,6)) >> 5)
1367 #define D_INDEX2(d,p) d = (d & (D_MASK & 0x7ff)) ^ (D_HIGH | 0x1f)
1369 #ifndef __LZO_CONFIG1X_H
1370 #define __LZO_CONFIG1X_H
1372 #if !defined(LZO1X) && !defined(LZO1Y) && !defined(LZO1Z)
1376 #if !defined(__LZO_IN_MINILZO)
1380 #define LZO_EOF_CODE
1381 #undef LZO_DETERMINISTIC
1383 #define M1_MAX_OFFSET 0x0400
1384 #ifndef M2_MAX_OFFSET
1385 #define M2_MAX_OFFSET 0x0800
1387 #define M3_MAX_OFFSET 0x4000
1388 #define M4_MAX_OFFSET 0xbfff
1390 #define MX_MAX_OFFSET (M1_MAX_OFFSET + M2_MAX_OFFSET)
1392 #define M1_MIN_LEN 2
1393 #define M1_MAX_LEN 2
1394 #define M2_MIN_LEN 3
1396 #define M2_MAX_LEN 8
1398 #define M3_MIN_LEN 3
1399 #define M3_MAX_LEN 33
1400 #define M4_MIN_LEN 3
1401 #define M4_MAX_LEN 9
1404 #define M2_MARKER 64
1405 #define M3_MARKER 32
1406 #define M4_MARKER 16
1408 #ifndef MIN_LOOKAHEAD
1409 #define MIN_LOOKAHEAD (M2_MAX_LEN + 1)
1412 #if defined(LZO_NEED_DICT_H)
1415 #define LZO_HASH LZO_HASH_LZO_INCREMENTAL_B
1417 #define DL_MIN_LEN M2_MIN_LEN
1419 #ifndef __LZO_DICT_H
1420 #define __LZO_DICT_H
1426 #if !defined(D_BITS) && defined(DBITS)
1427 # define D_BITS DBITS
1429 #if !defined(D_BITS)
1430 # error "D_BITS is not defined"
1433 # define D_SIZE LZO_SIZE(D_BITS)
1434 # define D_MASK LZO_MASK(D_BITS)
1436 # define D_SIZE LZO_USIZE(D_BITS)
1437 # define D_MASK LZO_UMASK(D_BITS)
1439 #define D_HIGH ((D_MASK >> 1) + 1)
1441 #if !defined(DD_BITS)
1444 #define DD_SIZE LZO_SIZE(DD_BITS)
1445 #define DD_MASK LZO_MASK(DD_BITS)
1447 #if !defined(DL_BITS)
1448 # define DL_BITS (D_BITS - DD_BITS)
1451 # define DL_SIZE LZO_SIZE(DL_BITS)
1452 # define DL_MASK LZO_MASK(DL_BITS)
1454 # define DL_SIZE LZO_USIZE(DL_BITS)
1455 # define DL_MASK LZO_UMASK(DL_BITS)
1458 #if (D_BITS != DL_BITS + DD_BITS)
1459 # error "D_BITS does not match"
1461 #if (D_BITS < 8 || D_BITS > 18)
1462 # error "invalid D_BITS"
1464 #if (DL_BITS < 8 || DL_BITS > 20)
1465 # error "invalid DL_BITS"
1467 #if (DD_BITS < 0 || DD_BITS > 6)
1468 # error "invalid DD_BITS"
1471 #if !defined(DL_MIN_LEN)
1472 # define DL_MIN_LEN 3
1474 #if !defined(DL_SHIFT)
1475 # define DL_SHIFT ((DL_BITS + (DL_MIN_LEN - 1)) / DL_MIN_LEN)
1478 #define LZO_HASH_GZIP 1
1479 #define LZO_HASH_GZIP_INCREMENTAL 2
1480 #define LZO_HASH_LZO_INCREMENTAL_A 3
1481 #define LZO_HASH_LZO_INCREMENTAL_B 4
1483 #if !defined(LZO_HASH)
1484 # error "choose a hashing strategy"
1487 #if (DL_MIN_LEN == 3)
1488 # define _DV2_A(p,shift1,shift2) \
1489 (((( (lzo_uint32)((p)[0]) << shift1) ^ (p)[1]) << shift2) ^ (p)[2])
1490 # define _DV2_B(p,shift1,shift2) \
1491 (((( (lzo_uint32)((p)[2]) << shift1) ^ (p)[1]) << shift2) ^ (p)[0])
1492 # define _DV3_B(p,shift1,shift2,shift3) \
1493 ((_DV2_B((p)+1,shift1,shift2) << (shift3)) ^ (p)[0])
1494 #elif (DL_MIN_LEN == 2)
1495 # define _DV2_A(p,shift1,shift2) \
1496 (( (lzo_uint32)(p[0]) << shift1) ^ p[1])
1497 # define _DV2_B(p,shift1,shift2) \
1498 (( (lzo_uint32)(p[1]) << shift1) ^ p[2])
1500 # error "invalid DL_MIN_LEN"
1502 #define _DV_A(p,shift) _DV2_A(p,shift,shift)
1503 #define _DV_B(p,shift) _DV2_B(p,shift,shift)
1504 #define DA2(p,s1,s2) \
1505 (((((lzo_uint32)((p)[2]) << (s2)) + (p)[1]) << (s1)) + (p)[0])
1506 #define DS2(p,s1,s2) \
1507 (((((lzo_uint32)((p)[2]) << (s2)) - (p)[1]) << (s1)) - (p)[0])
1508 #define DX2(p,s1,s2) \
1509 (((((lzo_uint32)((p)[2]) << (s2)) ^ (p)[1]) << (s1)) ^ (p)[0])
1510 #define DA3(p,s1,s2,s3) ((DA2((p)+1,s2,s3) << (s1)) + (p)[0])
1511 #define DS3(p,s1,s2,s3) ((DS2((p)+1,s2,s3) << (s1)) - (p)[0])
1512 #define DX3(p,s1,s2,s3) ((DX2((p)+1,s2,s3) << (s1)) ^ (p)[0])
1513 #define DMS(v,s) ((lzo_uint) (((v) & (D_MASK >> (s))) << (s)))
1514 #define DM(v) DMS(v,0)
1516 #if (LZO_HASH == LZO_HASH_GZIP)
1517 # define _DINDEX(dv,p) (_DV_A((p),DL_SHIFT))
1519 #elif (LZO_HASH == LZO_HASH_GZIP_INCREMENTAL)
1520 # define __LZO_HASH_INCREMENTAL
1521 # define DVAL_FIRST(dv,p) dv = _DV_A((p),DL_SHIFT)
1522 # define DVAL_NEXT(dv,p) dv = (((dv) << DL_SHIFT) ^ p[2])
1523 # define _DINDEX(dv,p) (dv)
1524 # define DVAL_LOOKAHEAD DL_MIN_LEN
1526 #elif (LZO_HASH == LZO_HASH_LZO_INCREMENTAL_A)
1527 # define __LZO_HASH_INCREMENTAL
1528 # define DVAL_FIRST(dv,p) dv = _DV_A((p),5)
1529 # define DVAL_NEXT(dv,p) \
1530 dv ^= (lzo_uint32)(p[-1]) << (2*5); dv = (((dv) << 5) ^ p[2])
1531 # define _DINDEX(dv,p) ((0x9f5f * (dv)) >> 5)
1532 # define DVAL_LOOKAHEAD DL_MIN_LEN
1534 #elif (LZO_HASH == LZO_HASH_LZO_INCREMENTAL_B)
1535 # define __LZO_HASH_INCREMENTAL
1536 # define DVAL_FIRST(dv,p) dv = _DV_B((p),5)
1537 # define DVAL_NEXT(dv,p) \
1538 dv ^= p[-1]; dv = (((dv) >> 5) ^ ((lzo_uint32)(p[2]) << (2*5)))
1539 # define _DINDEX(dv,p) ((0x9f5f * (dv)) >> 5)
1540 # define DVAL_LOOKAHEAD DL_MIN_LEN
1543 # error "choose a hashing strategy"
1547 #define DINDEX(dv,p) ((lzo_uint)((_DINDEX(dv,p)) & DL_MASK) << DD_BITS)
1549 #if !defined(DINDEX1) && defined(D_INDEX1)
1550 #define DINDEX1 D_INDEX1
1552 #if !defined(DINDEX2) && defined(D_INDEX2)
1553 #define DINDEX2 D_INDEX2
1556 #if !defined(__LZO_HASH_INCREMENTAL)
1557 # define DVAL_FIRST(dv,p) ((void) 0)
1558 # define DVAL_NEXT(dv,p) ((void) 0)
1559 # define DVAL_LOOKAHEAD 0
1562 #if !defined(DVAL_ASSERT)
1563 #if defined(__LZO_HASH_INCREMENTAL) && !defined(NDEBUG)
1564 static void DVAL_ASSERT(lzo_uint32 dv
, const lzo_byte
*p
)
1568 assert(DINDEX(dv
,p
) == DINDEX(df
,p
));
1571 # define DVAL_ASSERT(dv,p) ((void) 0)
1575 #if defined(LZO_DICT_USE_PTR)
1576 # define DENTRY(p,in) (p)
1577 # define GINDEX(m_pos,m_off,dict,dindex,in) m_pos = dict[dindex]
1579 # define DENTRY(p,in) ((lzo_uint) ((p)-(in)))
1580 # define GINDEX(m_pos,m_off,dict,dindex,in) m_off = dict[dindex]
1585 # define UPDATE_D(dict,drun,dv,p,in) dict[ DINDEX(dv,p) ] = DENTRY(p,in)
1586 # define UPDATE_I(dict,drun,index,p,in) dict[index] = DENTRY(p,in)
1587 # define UPDATE_P(ptr,drun,p,in) (ptr)[0] = DENTRY(p,in)
1591 # define UPDATE_D(dict,drun,dv,p,in) \
1592 dict[ DINDEX(dv,p) + drun++ ] = DENTRY(p,in); drun &= DD_MASK
1593 # define UPDATE_I(dict,drun,index,p,in) \
1594 dict[ (index) + drun++ ] = DENTRY(p,in); drun &= DD_MASK
1595 # define UPDATE_P(ptr,drun,p,in) \
1596 (ptr) [ drun++ ] = DENTRY(p,in); drun &= DD_MASK
1600 #if defined(LZO_DICT_USE_PTR)
1602 #define LZO_CHECK_MPOS_DET(m_pos,m_off,in,ip,max_offset) \
1603 (m_pos == NULL || (m_off = (lzo_moff_t) (ip - m_pos)) > max_offset)
1605 #define LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,max_offset) \
1606 (BOUNDS_CHECKING_OFF_IN_EXPR( \
1607 (PTR_LT(m_pos,in) || \
1608 (m_off = (lzo_moff_t) PTR_DIFF(ip,m_pos)) <= 0 || \
1609 m_off > max_offset) ))
1613 #define LZO_CHECK_MPOS_DET(m_pos,m_off,in,ip,max_offset) \
1615 ((m_off = (lzo_moff_t) ((ip)-(in)) - m_off) > max_offset) || \
1616 (m_pos = (ip) - (m_off), 0) )
1618 #define LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,max_offset) \
1619 ((lzo_moff_t) ((ip)-(in)) <= m_off || \
1620 ((m_off = (lzo_moff_t) ((ip)-(in)) - m_off) > max_offset) || \
1621 (m_pos = (ip) - (m_off), 0) )
1625 #if defined(LZO_DETERMINISTIC)
1626 # define LZO_CHECK_MPOS LZO_CHECK_MPOS_DET
1628 # define LZO_CHECK_MPOS LZO_CHECK_MPOS_NON_DET
1641 #define DO_COMPRESS lzo1x_1_compress
1644 lzo_uint
do_compress ( const lzo_byte
*in
, lzo_uint in_len
,
1645 lzo_byte
*out
, lzo_uintp out_len
,
1648 #if 0 && defined(__GNUC__) && defined(__i386__)
1649 register const lzo_byte
*ip
__asm__("%esi");
1651 register const lzo_byte
*ip
;
1654 const lzo_byte
* const in_end
= in
+ in_len
;
1655 const lzo_byte
* const ip_end
= in
+ in_len
- M2_MAX_LEN
- 5;
1657 lzo_dict_p
const dict
= (lzo_dict_p
) wrkmem
;
1666 #if 0 && defined(__GNUC__) && defined(__i386__)
1667 register const lzo_byte
*m_pos
__asm__("%edi");
1669 register const lzo_byte
*m_pos
;
1676 GINDEX(m_pos
,m_off
,dict
,dindex
,in
);
1677 if (LZO_CHECK_MPOS_NON_DET(m_pos
,m_off
,in
,ip
,M4_MAX_OFFSET
))
1680 if (m_off
<= M2_MAX_OFFSET
|| m_pos
[3] == ip
[3])
1684 GINDEX(m_pos
,m_off
,dict
,dindex
,in
);
1685 if (LZO_CHECK_MPOS_NON_DET(m_pos
,m_off
,in
,ip
,M4_MAX_OFFSET
))
1687 if (m_off
<= M2_MAX_OFFSET
|| m_pos
[3] == ip
[3])
1692 #if 1 && defined(LZO_UNALIGNED_OK_2)
1693 if (* (const lzo_ushortp
) m_pos
!= * (const lzo_ushortp
) ip
)
1695 if (m_pos
[0] != ip
[0] || m_pos
[1] != ip
[1])
1701 if (m_pos
[2] == ip
[2])
1704 if (m_off
<= M2_MAX_OFFSET
)
1710 assert(op
- 2 > out
); op
[-2] |= LZO_BYTE(3);
1711 *op
++ = *ii
++; *op
++ = *ii
++; *op
++ = *ii
++;
1714 if (m_pos
[3] == ip
[3])
1722 if (m_off
<= M1_MAX_OFFSET
&& lit
> 0 && lit
<= 3)
1724 if (m_off
<= M1_MAX_OFFSET
&& lit
== 3)
1727 register lzo_uint t
;
1730 assert(op
- 2 > out
); op
[-2] |= LZO_BYTE(t
);
1731 do *op
++ = *ii
++; while (--t
> 0);
1734 *op
++ = LZO_BYTE(M1_MARKER
| ((m_off
& 3) << 2));
1735 *op
++ = LZO_BYTE(m_off
>> 2);
1744 UPDATE_I(dict
,0,dindex
,ip
,in
);
1751 UPDATE_I(dict
,0,dindex
,ip
,in
);
1754 register lzo_uint t
= pd(ip
,ii
);
1758 assert(op
- 2 > out
);
1759 op
[-2] |= LZO_BYTE(t
);
1762 *op
++ = LZO_BYTE(t
- 3);
1765 register lzo_uint tt
= t
- 18;
1774 *op
++ = LZO_BYTE(tt
);
1776 do *op
++ = *ii
++; while (--t
> 0);
1781 if (m_pos
[3] != *ip
++ || m_pos
[4] != *ip
++ || m_pos
[5] != *ip
++ ||
1782 m_pos
[6] != *ip
++ || m_pos
[7] != *ip
++ || m_pos
[8] != *ip
++
1784 || m_pos
[ 9] != *ip
++ || m_pos
[10] != *ip
++ || m_pos
[11] != *ip
++
1785 || m_pos
[12] != *ip
++ || m_pos
[13] != *ip
++ || m_pos
[14] != *ip
++
1791 assert(m_len
>= 3); assert(m_len
<= M2_MAX_LEN
);
1793 if (m_off
<= M2_MAX_OFFSET
)
1797 *op
++ = LZO_BYTE(((m_len
- 1) << 5) | ((m_off
& 7) << 2));
1798 *op
++ = LZO_BYTE(m_off
>> 3);
1799 #elif defined(LZO1Y)
1800 *op
++ = LZO_BYTE(((m_len
+ 1) << 4) | ((m_off
& 3) << 2));
1801 *op
++ = LZO_BYTE(m_off
>> 2);
1804 else if (m_off
<= M3_MAX_OFFSET
)
1807 *op
++ = LZO_BYTE(M3_MARKER
| (m_len
- 2));
1814 assert(m_off
> 0); assert(m_off
<= 0x7fff);
1815 *op
++ = LZO_BYTE(M4_MARKER
|
1816 ((m_off
& 0x4000) >> 11) | (m_len
- 2));
1819 #elif defined(LZO1Y)
1826 const lzo_byte
*end
= in_end
;
1827 const lzo_byte
*m
= m_pos
+ M2_MAX_LEN
+ 1;
1828 while (ip
< end
&& *m
== *ip
)
1832 assert(m_len
> M2_MAX_LEN
);
1834 if (m_off
<= M3_MAX_OFFSET
)
1838 *op
++ = LZO_BYTE(M3_MARKER
| (m_len
- 2));
1842 *op
++ = M3_MARKER
| 0;
1852 assert(m_off
> 0); assert(m_off
<= 0x7fff);
1853 if (m_len
<= M4_MAX_LEN
)
1854 *op
++ = LZO_BYTE(M4_MARKER
|
1855 ((m_off
& 0x4000) >> 11) | (m_len
- 2));
1858 m_len
-= M4_MAX_LEN
;
1859 *op
++ = LZO_BYTE(M4_MARKER
| ((m_off
& 0x4000) >> 11));
1867 *op
++ = LZO_BYTE(m_len
);
1872 *op
++ = LZO_BYTE((m_off
& 63) << 2);
1873 *op
++ = LZO_BYTE(m_off
>> 6);
1884 *out_len
= op
- out
;
1885 return pd(in_end
,ii
);
1889 DO_COMPRESS ( const lzo_byte
*in
, lzo_uint in_len
,
1890 lzo_byte
*out
, lzo_uintp out_len
,
1896 #if defined(__LZO_QUERY_COMPRESS)
1897 if (__LZO_IS_COMPRESS_QUERY(in
,in_len
,out
,out_len
,wrkmem
))
1898 return __LZO_QUERY_COMPRESS(in
,in_len
,out
,out_len
,wrkmem
,D_SIZE
,lzo_sizeof(lzo_dict_t
));
1901 if (in_len
<= M2_MAX_LEN
+ 5)
1905 t
= do_compress(in
,in_len
,op
,out_len
,wrkmem
);
1911 const lzo_byte
*ii
= in
+ in_len
- t
;
1913 if (op
== out
&& t
<= 238)
1914 *op
++ = LZO_BYTE(17 + t
);
1916 op
[-2] |= LZO_BYTE(t
);
1918 *op
++ = LZO_BYTE(t
- 3);
1921 lzo_uint tt
= t
- 18;
1930 *op
++ = LZO_BYTE(tt
);
1932 do *op
++ = *ii
++; while (--t
> 0);
1935 *op
++ = M4_MARKER
| 1;
1939 *out_len
= op
- out
;
1947 #undef LZO_TEST_DECOMPRESS_OVERRUN
1948 #undef LZO_TEST_DECOMPRESS_OVERRUN_INPUT
1949 #undef LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT
1950 #undef LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND
1951 #undef DO_DECOMPRESS
1952 #define DO_DECOMPRESS lzo1x_decompress
1954 #if defined(LZO_TEST_DECOMPRESS_OVERRUN)
1955 # if !defined(LZO_TEST_DECOMPRESS_OVERRUN_INPUT)
1956 # define LZO_TEST_DECOMPRESS_OVERRUN_INPUT 2
1958 # if !defined(LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT)
1959 # define LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT 2
1961 # if !defined(LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND)
1962 # define LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND
1968 #undef TEST_LOOKBEHIND
1978 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_INPUT)
1979 # if (LZO_TEST_DECOMPRESS_OVERRUN_INPUT >= 1)
1980 # define TEST_IP (ip < ip_end)
1982 # if (LZO_TEST_DECOMPRESS_OVERRUN_INPUT >= 2)
1983 # define NEED_IP(x) \
1984 if ((lzo_uint)(ip_end - ip) < (lzo_uint)(x)) goto input_overrun
1988 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT)
1989 # if (LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT >= 1)
1990 # define TEST_OP (op <= op_end)
1992 # if (LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT >= 2)
1994 # define NEED_OP(x) \
1995 if ((lzo_uint)(op_end - op) < (lzo_uint)(x)) goto output_overrun
1999 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND)
2000 # define TEST_LOOKBEHIND(m_pos,out) if (m_pos < out) goto lookbehind_overrun
2002 # define TEST_LOOKBEHIND(m_pos,op) ((void) 0)
2005 #if !defined(LZO_EOF_CODE) && !defined(TEST_IP)
2006 # define TEST_IP (ip < ip_end)
2009 #if defined(TEST_IP)
2010 # define HAVE_TEST_IP
2014 #if defined(TEST_OP)
2015 # define HAVE_TEST_OP
2020 #if defined(NEED_IP)
2021 # define HAVE_NEED_IP
2023 # define NEED_IP(x) ((void) 0)
2025 #if defined(NEED_OP)
2026 # define HAVE_NEED_OP
2028 # define NEED_OP(x) ((void) 0)
2031 #if defined(HAVE_TEST_IP) || defined(HAVE_NEED_IP)
2032 # define HAVE_ANY_IP
2034 #if defined(HAVE_TEST_OP) || defined(HAVE_NEED_OP)
2035 # define HAVE_ANY_OP
2039 #define __COPY4(dst,src) * (lzo_uint32p)(dst) = * (const lzo_uint32p)(src)
2042 #if defined(LZO_UNALIGNED_OK_4)
2043 # define COPY4(dst,src) __COPY4(dst,src)
2044 #elif defined(LZO_ALIGNED_OK_4)
2045 # define COPY4(dst,src) __COPY4((lzo_ptr_t)(dst),(lzo_ptr_t)(src))
2048 #if defined(DO_DECOMPRESS)
2050 DO_DECOMPRESS ( const lzo_byte
*in
, lzo_uint in_len
,
2051 lzo_byte
*out
, lzo_uintp out_len
,
2055 register lzo_byte
*op
;
2056 register const lzo_byte
*ip
;
2057 register lzo_uint t
;
2058 #if defined(COPY_DICT)
2060 const lzo_byte
*dict_end
;
2062 register const lzo_byte
*m_pos
;
2065 const lzo_byte
* const ip_end
= in
+ in_len
;
2066 #if defined(HAVE_ANY_OP)
2067 lzo_byte
* const op_end
= out
+ *out_len
;
2070 lzo_uint last_m_off
= 0;
2075 #if defined(__LZO_QUERY_DECOMPRESS)
2076 if (__LZO_IS_DECOMPRESS_QUERY(in
,in_len
,out
,out_len
,wrkmem
))
2077 return __LZO_QUERY_DECOMPRESS(in
,in_len
,out
,out_len
,wrkmem
,0,0);
2080 #if defined(COPY_DICT)
2083 if (dict_len
> M4_MAX_OFFSET
)
2085 dict
+= dict_len
- M4_MAX_OFFSET
;
2086 dict_len
= M4_MAX_OFFSET
;
2088 dict_end
= dict
+ dict_len
;
2107 assert(t
> 0); NEED_OP(t
); NEED_IP(t
+1);
2108 do *op
++ = *ip
++; while (--t
> 0);
2109 goto first_literal_run
;
2112 while (TEST_IP
&& TEST_OP
)
2128 assert(t
> 0); NEED_OP(t
+3); NEED_IP(t
+4);
2129 #if defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4)
2130 #if !defined(LZO_UNALIGNED_OK_4)
2131 if (PTR_ALIGNED2_4(op
,ip
))
2142 op
+= 4; ip
+= 4; t
-= 4;
2144 if (t
> 0) do *op
++ = *ip
++; while (--t
> 0);
2147 do *op
++ = *ip
++; while (--t
> 0);
2149 #if !defined(LZO_UNALIGNED_OK_4)
2154 #if !defined(LZO_UNALIGNED_OK_4)
2156 *op
++ = *ip
++; *op
++ = *ip
++; *op
++ = *ip
++;
2157 do *op
++ = *ip
++; while (--t
> 0);
2166 #if defined(COPY_DICT)
2168 m_off
= (1 + M2_MAX_OFFSET
) + (t
<< 6) + (*ip
++ >> 2);
2171 m_off
= (1 + M2_MAX_OFFSET
) + (t
>> 2) + (*ip
++ << 2);
2174 t
= 3; COPY_DICT(t
,m_off
)
2177 t
= (1 + M2_MAX_OFFSET
) + (t
<< 6) + (*ip
++ >> 2);
2181 m_pos
= op
- (1 + M2_MAX_OFFSET
);
2183 m_pos
-= *ip
++ << 2;
2185 TEST_LOOKBEHIND(m_pos
,out
); NEED_OP(3);
2186 *op
++ = *m_pos
++; *op
++ = *m_pos
++; *op
++ = *m_pos
;
2190 while (TEST_IP
&& TEST_OP
)
2195 #if defined(COPY_DICT)
2197 m_off
= 1 + ((t
>> 2) & 7) + (*ip
++ << 3);
2199 #elif defined(LZO1Y)
2200 m_off
= 1 + ((t
>> 2) & 3) + (*ip
++ << 2);
2202 #elif defined(LZO1Z)
2208 m_off
= 1 + (m_off
<< 6) + (*ip
++ >> 2);
2216 m_pos
-= (t
>> 2) & 7;
2217 m_pos
-= *ip
++ << 3;
2219 #elif defined(LZO1Y)
2221 m_pos
-= (t
>> 2) & 3;
2222 m_pos
-= *ip
++ << 2;
2224 #elif defined(LZO1Z)
2226 lzo_uint off
= t
& 0x1f;
2230 assert(last_m_off
> 0);
2231 m_pos
-= last_m_off
;
2235 off
= 1 + (off
<< 6) + (*ip
++ >> 2);
2242 TEST_LOOKBEHIND(m_pos
,out
); assert(t
> 0); NEED_OP(t
+3-1);
2260 #if defined(COPY_DICT)
2262 m_off
= 1 + (ip
[0] << 6) + (ip
[1] >> 2);
2265 m_off
= 1 + (ip
[0] >> 2) + (ip
[1] << 6);
2270 lzo_uint off
= 1 + (ip
[0] << 6) + (ip
[1] >> 2);
2274 #elif defined(LZO_UNALIGNED_OK_2) && (LZO_BYTE_ORDER == LZO_LITTLE_ENDIAN)
2276 m_pos
-= (* (const lzo_ushortp
) ip
) >> 2;
2279 m_pos
-= (ip
[0] >> 2) + (ip
[1] << 6);
2286 #if defined(COPY_DICT)
2287 m_off
= (t
& 8) << 11;
2290 m_pos
-= (t
& 8) << 11;
2304 #if defined(COPY_DICT)
2306 m_off
+= (ip
[0] << 6) + (ip
[1] >> 2);
2308 m_off
+= (ip
[0] >> 2) + (ip
[1] << 6);
2319 m_pos
-= (ip
[0] << 6) + (ip
[1] >> 2);
2320 #elif defined(LZO_UNALIGNED_OK_2) && (LZO_BYTE_ORDER == LZO_LITTLE_ENDIAN)
2321 m_pos
-= (* (const lzo_ushortp
) ip
) >> 2;
2323 m_pos
-= (ip
[0] >> 2) + (ip
[1] << 6);
2330 last_m_off
= op
- m_pos
;
2336 #if defined(COPY_DICT)
2338 m_off
= 1 + (t
<< 6) + (*ip
++ >> 2);
2341 m_off
= 1 + (t
>> 2) + (*ip
++ << 2);
2344 t
= 2; COPY_DICT(t
,m_off
)
2347 t
= 1 + (t
<< 6) + (*ip
++ >> 2);
2353 m_pos
-= *ip
++ << 2;
2355 TEST_LOOKBEHIND(m_pos
,out
); NEED_OP(2);
2356 *op
++ = *m_pos
++; *op
++ = *m_pos
;
2361 #if defined(COPY_DICT)
2364 t
+= 3-1; COPY_DICT(t
,m_off
)
2368 TEST_LOOKBEHIND(m_pos
,out
); assert(t
> 0); NEED_OP(t
+3-1);
2369 #if defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4)
2370 #if !defined(LZO_UNALIGNED_OK_4)
2371 if (t
>= 2 * 4 - (3 - 1) && PTR_ALIGNED2_4(op
,m_pos
))
2373 assert((op
- m_pos
) >= 4);
2375 if (t
>= 2 * 4 - (3 - 1) && (op
- m_pos
) >= 4)
2379 op
+= 4; m_pos
+= 4; t
-= 4 - (3 - 1);
2382 op
+= 4; m_pos
+= 4; t
-= 4;
2384 if (t
> 0) do *op
++ = *m_pos
++; while (--t
> 0);
2390 *op
++ = *m_pos
++; *op
++ = *m_pos
++;
2391 do *op
++ = *m_pos
++; while (--t
> 0);
2406 assert(t
> 0); NEED_OP(t
); NEED_IP(t
+1);
2407 do *op
++ = *ip
++; while (--t
> 0);
2412 #if defined(HAVE_TEST_IP) || defined(HAVE_TEST_OP)
2413 *out_len
= op
- out
;
2414 return LZO_E_EOF_NOT_FOUND
;
2419 *out_len
= op
- out
;
2420 return (ip
== ip_end
? LZO_E_OK
:
2421 (ip
< ip_end
? LZO_E_INPUT_NOT_CONSUMED
: LZO_E_INPUT_OVERRUN
));
2423 #if defined(HAVE_NEED_IP)
2425 *out_len
= op
- out
;
2426 return LZO_E_INPUT_OVERRUN
;
2429 #if defined(HAVE_NEED_OP)
2431 *out_len
= op
- out
;
2432 return LZO_E_OUTPUT_OVERRUN
;
2435 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND)
2437 *out_len
= op
- out
;
2438 return LZO_E_LOOKBEHIND_OVERRUN
;
2442 #define LZO_TEST_DECOMPRESS_OVERRUN
2443 #undef DO_DECOMPRESS
2444 #define DO_DECOMPRESS lzo1x_decompress_safe
2446 #if defined(LZO_TEST_DECOMPRESS_OVERRUN)
2447 # if !defined(LZO_TEST_DECOMPRESS_OVERRUN_INPUT)
2448 # define LZO_TEST_DECOMPRESS_OVERRUN_INPUT 2
2450 # if !defined(LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT)
2451 # define LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT 2
2453 # if !defined(LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND)
2454 # define LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND
2460 #undef TEST_LOOKBEHIND
2470 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_INPUT)
2471 # if (LZO_TEST_DECOMPRESS_OVERRUN_INPUT >= 1)
2472 # define TEST_IP (ip < ip_end)
2474 # if (LZO_TEST_DECOMPRESS_OVERRUN_INPUT >= 2)
2475 # define NEED_IP(x) \
2476 if ((lzo_uint)(ip_end - ip) < (lzo_uint)(x)) goto input_overrun
2480 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT)
2481 # if (LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT >= 1)
2482 # define TEST_OP (op <= op_end)
2484 # if (LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT >= 2)
2486 # define NEED_OP(x) \
2487 if ((lzo_uint)(op_end - op) < (lzo_uint)(x)) goto output_overrun
2491 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND)
2492 # define TEST_LOOKBEHIND(m_pos,out) if (m_pos < out) goto lookbehind_overrun
2494 # define TEST_LOOKBEHIND(m_pos,op) ((void) 0)
2497 #if !defined(LZO_EOF_CODE) && !defined(TEST_IP)
2498 # define TEST_IP (ip < ip_end)
2501 #if defined(TEST_IP)
2502 # define HAVE_TEST_IP
2506 #if defined(TEST_OP)
2507 # define HAVE_TEST_OP
2512 #if defined(NEED_IP)
2513 # define HAVE_NEED_IP
2515 # define NEED_IP(x) ((void) 0)
2517 #if defined(NEED_OP)
2518 # define HAVE_NEED_OP
2520 # define NEED_OP(x) ((void) 0)
2523 #if defined(HAVE_TEST_IP) || defined(HAVE_NEED_IP)
2524 # define HAVE_ANY_IP
2526 #if defined(HAVE_TEST_OP) || defined(HAVE_NEED_OP)
2527 # define HAVE_ANY_OP
2531 #define __COPY4(dst,src) * (lzo_uint32p)(dst) = * (const lzo_uint32p)(src)
2534 #if defined(LZO_UNALIGNED_OK_4)
2535 # define COPY4(dst,src) __COPY4(dst,src)
2536 #elif defined(LZO_ALIGNED_OK_4)
2537 # define COPY4(dst,src) __COPY4((lzo_ptr_t)(dst),(lzo_ptr_t)(src))
2540 #if defined(DO_DECOMPRESS)
2542 DO_DECOMPRESS ( const lzo_byte
*in
, lzo_uint in_len
,
2543 lzo_byte
*out
, lzo_uintp out_len
,
2547 register lzo_byte
*op
;
2548 register const lzo_byte
*ip
;
2549 register lzo_uint t
;
2550 #if defined(COPY_DICT)
2552 const lzo_byte
*dict_end
;
2554 register const lzo_byte
*m_pos
;
2557 const lzo_byte
* const ip_end
= in
+ in_len
;
2558 #if defined(HAVE_ANY_OP)
2559 lzo_byte
* const op_end
= out
+ *out_len
;
2562 lzo_uint last_m_off
= 0;
2567 #if defined(__LZO_QUERY_DECOMPRESS)
2568 if (__LZO_IS_DECOMPRESS_QUERY(in
,in_len
,out
,out_len
,wrkmem
))
2569 return __LZO_QUERY_DECOMPRESS(in
,in_len
,out
,out_len
,wrkmem
,0,0);
2572 #if defined(COPY_DICT)
2575 if (dict_len
> M4_MAX_OFFSET
)
2577 dict
+= dict_len
- M4_MAX_OFFSET
;
2578 dict_len
= M4_MAX_OFFSET
;
2580 dict_end
= dict
+ dict_len
;
2599 assert(t
> 0); NEED_OP(t
); NEED_IP(t
+1);
2600 do *op
++ = *ip
++; while (--t
> 0);
2601 goto first_literal_run
;
2604 while (TEST_IP
&& TEST_OP
)
2620 assert(t
> 0); NEED_OP(t
+3); NEED_IP(t
+4);
2621 #if defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4)
2622 #if !defined(LZO_UNALIGNED_OK_4)
2623 if (PTR_ALIGNED2_4(op
,ip
))
2634 op
+= 4; ip
+= 4; t
-= 4;
2636 if (t
> 0) do *op
++ = *ip
++; while (--t
> 0);
2639 do *op
++ = *ip
++; while (--t
> 0);
2641 #if !defined(LZO_UNALIGNED_OK_4)
2646 #if !defined(LZO_UNALIGNED_OK_4)
2648 *op
++ = *ip
++; *op
++ = *ip
++; *op
++ = *ip
++;
2649 do *op
++ = *ip
++; while (--t
> 0);
2658 #if defined(COPY_DICT)
2660 m_off
= (1 + M2_MAX_OFFSET
) + (t
<< 6) + (*ip
++ >> 2);
2663 m_off
= (1 + M2_MAX_OFFSET
) + (t
>> 2) + (*ip
++ << 2);
2666 t
= 3; COPY_DICT(t
,m_off
)
2669 t
= (1 + M2_MAX_OFFSET
) + (t
<< 6) + (*ip
++ >> 2);
2673 m_pos
= op
- (1 + M2_MAX_OFFSET
);
2675 m_pos
-= *ip
++ << 2;
2677 TEST_LOOKBEHIND(m_pos
,out
); NEED_OP(3);
2678 *op
++ = *m_pos
++; *op
++ = *m_pos
++; *op
++ = *m_pos
;
2682 while (TEST_IP
&& TEST_OP
)
2687 #if defined(COPY_DICT)
2689 m_off
= 1 + ((t
>> 2) & 7) + (*ip
++ << 3);
2691 #elif defined(LZO1Y)
2692 m_off
= 1 + ((t
>> 2) & 3) + (*ip
++ << 2);
2694 #elif defined(LZO1Z)
2700 m_off
= 1 + (m_off
<< 6) + (*ip
++ >> 2);
2708 m_pos
-= (t
>> 2) & 7;
2709 m_pos
-= *ip
++ << 3;
2711 #elif defined(LZO1Y)
2713 m_pos
-= (t
>> 2) & 3;
2714 m_pos
-= *ip
++ << 2;
2716 #elif defined(LZO1Z)
2718 lzo_uint off
= t
& 0x1f;
2722 assert(last_m_off
> 0);
2723 m_pos
-= last_m_off
;
2727 off
= 1 + (off
<< 6) + (*ip
++ >> 2);
2734 TEST_LOOKBEHIND(m_pos
,out
); assert(t
> 0); NEED_OP(t
+3-1);
2752 #if defined(COPY_DICT)
2754 m_off
= 1 + (ip
[0] << 6) + (ip
[1] >> 2);
2757 m_off
= 1 + (ip
[0] >> 2) + (ip
[1] << 6);
2762 lzo_uint off
= 1 + (ip
[0] << 6) + (ip
[1] >> 2);
2766 #elif defined(LZO_UNALIGNED_OK_2) && (LZO_BYTE_ORDER == LZO_LITTLE_ENDIAN)
2768 m_pos
-= (* (const lzo_ushortp
) ip
) >> 2;
2771 m_pos
-= (ip
[0] >> 2) + (ip
[1] << 6);
2778 #if defined(COPY_DICT)
2779 m_off
= (t
& 8) << 11;
2782 m_pos
-= (t
& 8) << 11;
2796 #if defined(COPY_DICT)
2798 m_off
+= (ip
[0] << 6) + (ip
[1] >> 2);
2800 m_off
+= (ip
[0] >> 2) + (ip
[1] << 6);
2811 m_pos
-= (ip
[0] << 6) + (ip
[1] >> 2);
2812 #elif defined(LZO_UNALIGNED_OK_2) && (LZO_BYTE_ORDER == LZO_LITTLE_ENDIAN)
2813 m_pos
-= (* (const lzo_ushortp
) ip
) >> 2;
2815 m_pos
-= (ip
[0] >> 2) + (ip
[1] << 6);
2822 last_m_off
= op
- m_pos
;
2828 #if defined(COPY_DICT)
2830 m_off
= 1 + (t
<< 6) + (*ip
++ >> 2);
2833 m_off
= 1 + (t
>> 2) + (*ip
++ << 2);
2836 t
= 2; COPY_DICT(t
,m_off
)
2839 t
= 1 + (t
<< 6) + (*ip
++ >> 2);
2845 m_pos
-= *ip
++ << 2;
2847 TEST_LOOKBEHIND(m_pos
,out
); NEED_OP(2);
2848 *op
++ = *m_pos
++; *op
++ = *m_pos
;
2853 #if defined(COPY_DICT)
2856 t
+= 3-1; COPY_DICT(t
,m_off
)
2860 TEST_LOOKBEHIND(m_pos
,out
); assert(t
> 0); NEED_OP(t
+3-1);
2861 #if defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4)
2862 #if !defined(LZO_UNALIGNED_OK_4)
2863 if (t
>= 2 * 4 - (3 - 1) && PTR_ALIGNED2_4(op
,m_pos
))
2865 assert((op
- m_pos
) >= 4);
2867 if (t
>= 2 * 4 - (3 - 1) && (op
- m_pos
) >= 4)
2871 op
+= 4; m_pos
+= 4; t
-= 4 - (3 - 1);
2874 op
+= 4; m_pos
+= 4; t
-= 4;
2876 if (t
> 0) do *op
++ = *m_pos
++; while (--t
> 0);
2882 *op
++ = *m_pos
++; *op
++ = *m_pos
++;
2883 do *op
++ = *m_pos
++; while (--t
> 0);
2898 assert(t
> 0); NEED_OP(t
); NEED_IP(t
+1);
2899 do *op
++ = *ip
++; while (--t
> 0);
2904 #if defined(HAVE_TEST_IP) || defined(HAVE_TEST_OP)
2905 *out_len
= op
- out
;
2906 return LZO_E_EOF_NOT_FOUND
;
2911 *out_len
= op
- out
;
2912 return (ip
== ip_end
? LZO_E_OK
:
2913 (ip
< ip_end
? LZO_E_INPUT_NOT_CONSUMED
: LZO_E_INPUT_OVERRUN
));
2915 #if defined(HAVE_NEED_IP)
2917 *out_len
= op
- out
;
2918 return LZO_E_INPUT_OVERRUN
;
2921 #if defined(HAVE_NEED_OP)
2923 *out_len
= op
- out
;
2924 return LZO_E_OUTPUT_OVERRUN
;
2927 #if defined(LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND)
2929 *out_len
= op
- out
;
2930 return LZO_E_LOOKBEHIND_OVERRUN
;
2934 /***** End of minilzo.c *****/