source: trunk/src/minilzo.c @ 452

Last change on this file since 452 was 1, checked in by katerina, 16 years ago

Initial import

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