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