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