diff options
Diffstat (limited to 'master/debian/lzo.patch')
-rw-r--r-- | master/debian/lzo.patch | 8643 |
1 files changed, 8643 insertions, 0 deletions
diff --git a/master/debian/lzo.patch b/master/debian/lzo.patch new file mode 100644 index 0000000..08be339 --- /dev/null +++ b/master/debian/lzo.patch @@ -0,0 +1,8643 @@ +Description: Add support for LZO compression in btrfs +Author: Szymon Janc <szymon@janc.net.pl> +Author: Vladimir Serbinenko <phcoder@gmail.com> +Origin: backport, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3436 +Origin: backport, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3446 +Origin: backport, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3459 +Origin: backport, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3551 +Origin: backport, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3804 +Bug-Ubuntu: https://bugs.launchpad.net/bugs/727535 +Forwarded: not-needed +Last-Update: 2012-03-12 + +Index: b/Makefile.util.def +=================================================================== +--- a/Makefile.util.def ++++ b/Makefile.util.def +@@ -24,8 +24,8 @@ + + library = { + name = libgrubmods.a; +- cflags = '$(CFLAGS_GCRY)'; +- cppflags = '$(CPPFLAGS_GCRY)'; ++ cflags = '$(CFLAGS_GCRY) $(CFLAGS_POSIX) -Wno-undef'; ++ cppflags = '$(CPPFLAGS_GCRY) -I$(srcdir)/lib/posix_wrap -I$(top_srcdir)/grub-core/lib/minilzo -DMINILZO_HAVE_CONFIG_H'; + + common_nodist = grub_script.tab.c; + common_nodist = grub_script.yy.c; +@@ -85,6 +85,7 @@ + common = grub-core/lib/LzmaEnc.c; + common = grub-core/lib/pbkdf2.c; + common = grub-core/lib/crc.c; ++ common = grub-core/lib/adler32.c; + common = grub-core/normal/datetime.c; + common = grub-core/normal/misc.c; + common = grub-core/partmap/acorn.c; +@@ -101,6 +102,8 @@ + common = grub-core/script/script.c; + common = grub-core/script/argv.c; + common = grub-core/io/gzio.c; ++ common = grub-core/io/lzopio.c; ++ common = grub-core/lib/minilzo/minilzo.c; + }; + + program = { +Index: b/configure.ac +=================================================================== +--- a/configure.ac ++++ b/configure.ac +@@ -483,6 +483,7 @@ + # Force 32-bit mode. + TARGET_CFLAGS="$TARGET_CFLAGS -m32" + TARGET_CCASFLAGS="$TARGET_CCASFLAGS -m32" ++ TARGET_CPPFLAGS="$TARGET_CPPFLAGS -m32" + TARGET_LDFLAGS="$TARGET_LDFLAGS -m32" + TARGET_MODULE_FORMAT="elf32" + fi +@@ -491,6 +492,7 @@ + # Force 64-bit mode. + TARGET_CFLAGS="$TARGET_CFLAGS -m64" + TARGET_CCASFLAGS="$TARGET_CCASFLAGS -m64" ++ TARGET_CPPFLAGS="$TARGET_CPPFLAGS -m64" + TARGET_LDFLAGS="$TARGET_LDFLAGS -m64" + TARGET_MODULE_FORMAT="elf64" + fi +@@ -607,7 +609,7 @@ + fi + + # Check for libgcc symbols +-AC_CHECK_FUNCS(__bswapsi2 __bswapdi2 __ashldi3 __ashrdi3 __lshrdi3 __trampoline_setup __ucmpdi2 _restgpr_14_x) ++AC_CHECK_FUNCS(__bswapsi2 __bswapdi2 __ashldi3 __ashrdi3 __lshrdi3 __trampoline_setup __ucmpdi2 _restgpr_14_x __ctzdi2 __ctzsi2) + + if test "x$TARGET_APPLE_CC" = x1 ; then + CFLAGS="$TARGET_CFLAGS -nostdlib" +Index: b/grub-core/Makefile.core.def +=================================================================== +--- a/grub-core/Makefile.core.def ++++ b/grub-core/Makefile.core.def +@@ -908,6 +908,8 @@ + name = btrfs; + common = fs/btrfs.c; + common = lib/crc.c; ++ cflags = '$(CFLAGS_POSIX) -Wno-undef'; ++ cppflags = '-I$(srcdir)/lib/posix_wrap -I$(srcdir)/lib/minilzo -DMINILZO_HAVE_CONFIG_H'; + }; + + module = { +@@ -1509,6 +1511,14 @@ + }; + + module = { ++ name = lzopio; ++ common = io/lzopio.c; ++ common = lib/minilzo/minilzo.c; ++ cflags = '$(CFLAGS_POSIX) -Wno-undef'; ++ cppflags = '-I$(srcdir)/lib/posix_wrap -I$(srcdir)/lib/minilzo -DMINILZO_HAVE_CONFIG_H'; ++}; ++ ++module = { + name = testload; + common = commands/testload.c; + }; +@@ -1524,3 +1534,8 @@ + common = commands/keylayouts.c; + enable = videomodules; + }; ++ ++module = { ++ name = adler32; ++ common = lib/adler32.c; ++}; +Index: b/grub-core/fs/btrfs.c +=================================================================== +--- a/grub-core/fs/btrfs.c ++++ b/grub-core/fs/btrfs.c +@@ -26,11 +26,23 @@ + #include <grub/types.h> + #include <grub/lib/crc.h> + #include <grub/deflate.h> ++#include <minilzo.h> + + GRUB_MOD_LICENSE ("GPLv3+"); + + #define GRUB_BTRFS_SIGNATURE "_BHRfS_M" + ++/* From http://www.oberhumer.com/opensource/lzo/lzofaq.php ++ * LZO will expand incompressible data by a little amount. I still haven't ++ * computed the exact values, but I suggest using these formulas for ++ * a worst-case expansion calculation: ++ * ++ * output_block_size = input_block_size + (input_block_size / 16) + 64 + 3 ++ * */ ++#define GRUB_BTRFS_LZO_BLOCK_SIZE 4096 ++#define GRUB_BTRFS_LZO_BLOCK_MAX_CSIZE (GRUB_BTRFS_LZO_BLOCK_SIZE + \ ++ (GRUB_BTRFS_LZO_BLOCK_SIZE / 16) + 64 + 3) ++ + typedef grub_uint8_t grub_btrfs_checksum_t[0x20]; + typedef grub_uint16_t grub_btrfs_uuid_t[8]; + +@@ -41,7 +53,7 @@ + } __attribute__ ((packed)); + + struct grub_btrfs_superblock +-{ ++{ + grub_btrfs_checksum_t checksum; + grub_btrfs_uuid_t uuid; + grub_uint8_t dummy[0x10]; +@@ -160,7 +172,8 @@ + { + unsigned depth; + unsigned allocated; +- struct { ++ struct ++ { + grub_disk_addr_t addr; + unsigned iter; + unsigned maxiter; +@@ -179,7 +192,7 @@ + { + grub_int64_t sec; + grub_uint32_t nanosec; +-} __attribute__ ((aligned(4))); ++} __attribute__ ((aligned (4))); + + struct grub_btrfs_inode + { +@@ -215,12 +228,13 @@ + + #define GRUB_BTRFS_COMPRESSION_NONE 0 + #define GRUB_BTRFS_COMPRESSION_ZLIB 1 ++#define GRUB_BTRFS_COMPRESSION_LZO 2 + + #define GRUB_BTRFS_OBJECT_ID_CHUNK 0x100 + + static grub_disk_addr_t superblock_sectors[] = { 64 * 2, 64 * 1024 * 2, +- 256 * 1048576 * 2, +- 1048576ULL * 1048576ULL * 2 }; ++ 256 * 1048576 * 2, 1048576ULL * 1048576ULL * 2 ++}; + + static grub_err_t + grub_btrfs_read_logical (struct grub_btrfs_data *data, +@@ -283,7 +297,7 @@ + } + + static grub_err_t +-save_ref (struct grub_btrfs_leaf_descriptor *desc, ++save_ref (struct grub_btrfs_leaf_descriptor *desc, + grub_disk_addr_t addr, unsigned i, unsigned m, int l) + { + desc->depth++; +@@ -307,7 +321,7 @@ + static int + next (struct grub_btrfs_data *data, + struct grub_btrfs_leaf_descriptor *desc, +- grub_disk_addr_t *outaddr, grub_size_t *outsize, ++ grub_disk_addr_t * outaddr, grub_size_t * outsize, + struct grub_btrfs_key *key_out) + { + grub_err_t err; +@@ -330,17 +344,17 @@ + err = grub_btrfs_read_logical (data, desc->data[desc->depth - 1].iter + * sizeof (node) + + sizeof (struct btrfs_header) +- + desc->data[desc->depth - 1].addr, &node, +- sizeof (node)); ++ + desc->data[desc->depth - 1].addr, ++ &node, sizeof (node)); + if (err) + return -err; + +- err = grub_btrfs_read_logical (data, grub_le_to_cpu64 (node.addr), &head, +- sizeof (head)); ++ err = grub_btrfs_read_logical (data, grub_le_to_cpu64 (node.addr), ++ &head, sizeof (head)); + if (err) + return -err; + +- save_ref (desc, grub_le_to_cpu64 (node.addr), 0, ++ save_ref (desc, grub_le_to_cpu64 (node.addr), 0, + grub_le_to_cpu32 (head.nitems), !head.level); + } + err = grub_btrfs_read_logical (data, desc->data[desc->depth - 1].iter +@@ -354,12 +368,12 @@ + *outaddr = desc->data[desc->depth - 1].addr + sizeof (struct btrfs_header) + + grub_le_to_cpu32 (leaf.offset); + *key_out = leaf.key; +- return 1; ++ return 1; + } + + static grub_err_t + lower_bound (struct grub_btrfs_data *data, +- const struct grub_btrfs_key *key_in, ++ const struct grub_btrfs_key *key_in, + struct grub_btrfs_key *key_out, + grub_disk_addr_t root, + grub_disk_addr_t *outaddr, grub_size_t *outsize, +@@ -410,8 +424,9 @@ + grub_dprintf ("btrfs", + "internal node (depth %d) %" PRIxGRUB_UINT64_T + " %x %" PRIxGRUB_UINT64_T "\n", depth, +- node.key.object_id, node.key.type, node.key.offset); +- ++ node.key.object_id, node.key.type, ++ node.key.offset); ++ + if (key_cmp (&node.key, key_in) == 0) + { + err = GRUB_ERR_NONE; +@@ -433,7 +448,7 @@ + err = GRUB_ERR_NONE; + if (desc) + err = save_ref (desc, addr - sizeof (head), i - 1, +- grub_le_to_cpu32 (head.nitems), 0); ++ grub_le_to_cpu32 (head.nitems), 0); + if (err) + return err; + addr = grub_le_to_cpu64 (node_last.addr); +@@ -457,7 +472,7 @@ + &leaf, sizeof (leaf)); + if (err) + return err; +- ++ + grub_dprintf ("btrfs", + "leaf (depth %d) %" PRIxGRUB_UINT64_T + " %x %" PRIxGRUB_UINT64_T "\n", depth, +@@ -465,31 +480,31 @@ + + if (key_cmp (&leaf.key, key_in) == 0) + { +- grub_memcpy (key_out, &leaf.key, sizeof(*key_out)); ++ grub_memcpy (key_out, &leaf.key, sizeof (*key_out)); + *outsize = grub_le_to_cpu32 (leaf.size); + *outaddr = addr + grub_le_to_cpu32 (leaf.offset); + if (desc) + return save_ref (desc, addr - sizeof (head), i, + grub_le_to_cpu32 (head.nitems), 1); +- return GRUB_ERR_NONE; ++ return GRUB_ERR_NONE; + } +- ++ + if (key_cmp (&leaf.key, key_in) > 0) + break; +- ++ + have_last = 1; + leaf_last = leaf; + } + + if (have_last) + { +- grub_memcpy (key_out, &leaf_last.key, sizeof(*key_out)); ++ grub_memcpy (key_out, &leaf_last.key, sizeof (*key_out)); + *outsize = grub_le_to_cpu32 (leaf_last.size); + *outaddr = addr + grub_le_to_cpu32 (leaf_last.offset); + if (desc) + return save_ref (desc, addr - sizeof (head), i - 1, + grub_le_to_cpu32 (head.nitems), 1); +- return GRUB_ERR_NONE; ++ return GRUB_ERR_NONE; + } + *outsize = 0; + *outaddr = 0; +@@ -503,8 +518,7 @@ + } + + static grub_device_t +-find_device (struct grub_btrfs_data *data, grub_uint64_t id, +- int do_rescan) ++find_device (struct grub_btrfs_data *data, grub_uint64_t id, int do_rescan) + { + grub_device_t dev_found = NULL; + auto int hook (const char *name); +@@ -540,7 +554,7 @@ + grub_device_close (dev); + return 0; + } +- ++ + dev_found = dev; + return 1; + } +@@ -579,17 +593,16 @@ + } + + static grub_err_t +-grub_btrfs_read_logical (struct grub_btrfs_data *data, +- grub_disk_addr_t addr, ++grub_btrfs_read_logical (struct grub_btrfs_data *data, grub_disk_addr_t addr, + void *buf, grub_size_t size) + { + while (size > 0) + { + grub_uint8_t *ptr; + struct grub_btrfs_key *key; +- struct grub_btrfs_chunk_item *chunk; ++ struct grub_btrfs_chunk_item *chunk; + grub_uint64_t csize; +- grub_err_t err; ++ grub_err_t err = 0; + struct grub_btrfs_key key_out; + int challoc = 0; + grub_device_t dev; +@@ -597,15 +610,15 @@ + addr); + for (ptr = data->sblock.bootstrap_mapping; + ptr < data->sblock.bootstrap_mapping +- + sizeof (data->sblock.bootstrap_mapping) +- - sizeof (struct grub_btrfs_key); +- ) ++ + sizeof (data->sblock.bootstrap_mapping) ++ - sizeof (struct grub_btrfs_key);) + { + key = (struct grub_btrfs_key *) ptr; + if (key->type != GRUB_BTRFS_ITEM_TYPE_CHUNK) + break; + chunk = (struct grub_btrfs_chunk_item *) (key + 1); +- grub_dprintf ("btrfs", "%" PRIxGRUB_UINT64_T " %" PRIxGRUB_UINT64_T " \n", ++ grub_dprintf ("btrfs", ++ "%" PRIxGRUB_UINT64_T " %" PRIxGRUB_UINT64_T " \n", + grub_le_to_cpu64 (key->offset), + grub_le_to_cpu64 (chunk->size)); + if (grub_le_to_cpu64 (key->offset) <= addr +@@ -702,11 +715,11 @@ + middle = grub_divmod64 (off, + grub_le_to_cpu64 (chunk->stripe_length), + &low); +- ++ + high = grub_divmod64 (middle, grub_le_to_cpu16 (chunk->nstripes), + &stripen); +- stripe_offset = low + grub_le_to_cpu64 (chunk->stripe_length) +- * high; ++ stripe_offset = ++ low + grub_le_to_cpu64 (chunk->stripe_length) * high; + csize = grub_le_to_cpu64 (chunk->stripe_length) - low; + break; + } +@@ -717,7 +730,7 @@ + middle = grub_divmod64 (off, + grub_le_to_cpu64 (chunk->stripe_length), + &low); +- ++ + high = grub_divmod64 (middle, + grub_le_to_cpu16 (chunk->nsubstripes), + &stripen); +@@ -757,7 +770,8 @@ + paddr = stripe->offset + stripe_offset; + + grub_dprintf ("btrfs", "chunk 0x%" PRIxGRUB_UINT64_T +- "+0x%" PRIxGRUB_UINT64_T " (%d stripes (%d substripes) of %" ++ "+0x%" PRIxGRUB_UINT64_T ++ " (%d stripes (%d substripes) of %" + PRIxGRUB_UINT64_T ") stripe %" PRIxGRUB_UINT32_T + " maps to 0x%" PRIxGRUB_UINT64_T "\n", + grub_le_to_cpu64 (key->offset), +@@ -767,7 +781,7 @@ + grub_le_to_cpu64 (chunk->stripe_length), + stripen, stripe->offset); + grub_dprintf ("btrfs", "reading paddr 0x%" PRIxGRUB_UINT64_T +- " for laddr 0x%" PRIxGRUB_UINT64_T"\n", paddr, ++ " for laddr 0x%" PRIxGRUB_UINT64_T "\n", paddr, + addr); + + dev = find_device (data, stripe->device_id, j); +@@ -813,7 +827,7 @@ + } + + data = grub_zalloc (sizeof (*data)); +- if (! data) ++ if (!data) + return NULL; + + err = read_sblock (dev->disk, &data->sblock); +@@ -864,8 +878,7 @@ + key_in.type = GRUB_BTRFS_ITEM_TYPE_INODE_ITEM; + key_in.offset = 0; + +- err = lower_bound (data, &key_in, &key_out, tree, +- &elemaddr, &elemsize, NULL); ++ err = lower_bound (data, &key_in, &key_out, tree, &elemaddr, &elemsize, NULL); + if (err) + return err; + if (num != key_out.object_id +@@ -876,6 +889,76 @@ + } + + static grub_ssize_t ++grub_btrfs_lzo_decompress(char *ibuf, grub_size_t isize, grub_off_t off, ++ char *obuf, grub_size_t osize) ++{ ++ grub_uint32_t total_size, cblock_size, ret = 0; ++ unsigned char buf[GRUB_BTRFS_LZO_BLOCK_SIZE]; ++ ++ total_size = grub_le_to_cpu32 (grub_get_unaligned32 (ibuf)); ++ ibuf += sizeof (total_size); ++ ++ if (isize < total_size) ++ return -1; ++ ++ /* Jump forward to first block with requested data. */ ++ while (off >= GRUB_BTRFS_LZO_BLOCK_SIZE) ++ { ++ cblock_size = grub_le_to_cpu32 (grub_get_unaligned32 (ibuf)); ++ ibuf += sizeof (cblock_size); ++ ++ if (cblock_size > GRUB_BTRFS_LZO_BLOCK_MAX_CSIZE) ++ return -1; ++ ++ off -= GRUB_BTRFS_LZO_BLOCK_SIZE; ++ ibuf += cblock_size; ++ } ++ ++ while (osize > 0) ++ { ++ lzo_uint usize = GRUB_BTRFS_LZO_BLOCK_SIZE; ++ ++ cblock_size = grub_le_to_cpu32 (grub_get_unaligned32 (ibuf)); ++ ibuf += sizeof (cblock_size); ++ ++ if (cblock_size > GRUB_BTRFS_LZO_BLOCK_MAX_CSIZE) ++ return -1; ++ ++ /* Block partially filled with requested data. */ ++ if (off > 0 || osize < GRUB_BTRFS_LZO_BLOCK_SIZE) ++ { ++ grub_size_t to_copy = grub_min(osize, GRUB_BTRFS_LZO_BLOCK_SIZE - off); ++ ++ if (lzo1x_decompress_safe ((lzo_bytep)ibuf, cblock_size, buf, &usize, ++ NULL) != LZO_E_OK) ++ return -1; ++ ++ to_copy = grub_min(to_copy, usize); ++ grub_memcpy(obuf, buf + off, to_copy); ++ ++ osize -= to_copy; ++ ret += to_copy; ++ obuf += to_copy; ++ ibuf += cblock_size; ++ off = 0; ++ continue; ++ } ++ ++ /* Decompress whole block directly to output buffer. */ ++ if (lzo1x_decompress_safe ((lzo_bytep)ibuf, cblock_size, (lzo_bytep)obuf, ++ &usize, NULL) != LZO_E_OK) ++ return -1; ++ ++ osize -= usize; ++ ret += usize; ++ obuf += usize; ++ ibuf += cblock_size; ++ } ++ ++ return ret; ++} ++ ++static grub_ssize_t + grub_btrfs_extent_read (struct grub_btrfs_data *data, + grub_uint64_t ino, grub_uint64_t tree, + grub_off_t pos0, char *buf, grub_size_t len) +@@ -915,19 +998,17 @@ + if (!data->extent) + return grub_errno; + +- err = grub_btrfs_read_logical (data, elemaddr, +- data->extent, elemsize); ++ err = grub_btrfs_read_logical (data, elemaddr, data->extent, ++ elemsize); + if (err) + return err; + +- data->extend = data->extstart +- + grub_le_to_cpu64 (data->extent->size); ++ data->extend = data->extstart + grub_le_to_cpu64 (data->extent->size); + if (data->extent->type == GRUB_BTRFS_EXTENT_REGULAR + && (char *) &data->extent + elemsize +- >= (char *) &data->extent->filled +- + sizeof (data->extent->filled)) +- data->extend = data->extstart +- + grub_le_to_cpu64 (data->extent->filled); ++ >= (char *) &data->extent->filled + sizeof (data->extent->filled)) ++ data->extend = ++ data->extstart + grub_le_to_cpu64 (data->extent->filled); + + grub_dprintf ("btrfs", "extent 0x%" PRIxGRUB_UINT64_T "+0x%" + PRIxGRUB_UINT64_T " (0x%" +@@ -954,7 +1035,8 @@ + } + + if (data->extent->compression != GRUB_BTRFS_COMPRESSION_NONE +- && data->extent->compression != GRUB_BTRFS_COMPRESSION_ZLIB) ++ && data->extent->compression != GRUB_BTRFS_COMPRESSION_ZLIB ++ && data->extent->compression != GRUB_BTRFS_COMPRESSION_LZO) + { + grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, + "compression type 0x%x not supported", +@@ -964,8 +1046,7 @@ + + if (data->extent->encoding) + { +- grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, +- "encoding not supported"); ++ grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, "encoding not supported"); + return -1; + } + +@@ -981,6 +1062,15 @@ + != (grub_ssize_t) csize) + return -1; + } ++ else if (data->extent->compression == GRUB_BTRFS_COMPRESSION_LZO) ++ { ++ if (grub_btrfs_lzo_decompress(data->extent->inl, data->extsize - ++ ((grub_uint8_t *) data->extent->inl ++ - (grub_uint8_t *) data->extent), ++ extoff, buf, csize) ++ != (grub_ssize_t) csize) ++ return -1; ++ } + else + grub_memcpy (buf, data->extent->inl + extoff, csize); + break; +@@ -990,10 +1080,13 @@ + grub_memset (buf, 0, csize); + break; + } +- if (data->extent->compression == GRUB_BTRFS_COMPRESSION_ZLIB) ++ ++ if (data->extent->compression != GRUB_BTRFS_COMPRESSION_NONE) + { + char *tmp; + grub_uint64_t zsize; ++ grub_ssize_t ret; ++ + zsize = grub_le_to_cpu64 (data->extent->compressed_size); + tmp = grub_malloc (zsize); + if (!tmp) +@@ -1006,27 +1099,35 @@ + grub_free (tmp); + return -1; + } +- if (grub_zlib_decompress (tmp, zsize, extoff +- + grub_le_to_cpu64 (data->extent->offset), +- buf, csize) != (grub_ssize_t) csize) +- { +- grub_free (tmp); +- return -1; +- } ++ ++ if (data->extent->compression == GRUB_BTRFS_COMPRESSION_ZLIB) ++ ret = grub_zlib_decompress (tmp, zsize, extoff ++ + grub_le_to_cpu64 (data->extent->offset), ++ buf, csize); ++ else if (data->extent->compression == GRUB_BTRFS_COMPRESSION_LZO) ++ ret = grub_btrfs_lzo_decompress (tmp, zsize, extoff ++ + grub_le_to_cpu64 (data->extent->offset), ++ buf, csize); ++ else ++ ret = -1; ++ + grub_free (tmp); ++ ++ if (ret != (grub_ssize_t) csize) ++ return -1; ++ + break; + } + err = grub_btrfs_read_logical (data, + grub_le_to_cpu64 (data->extent->laddr) + + grub_le_to_cpu64 (data->extent->offset) +- + extoff, +- buf, csize); ++ + extoff, buf, csize); + if (err) + return -1; + break; + default: + grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, +- "unsupported extent type 0x%x", data->extent->type); ++ "unsupported extent type 0x%x", data->extent->type); + return -1; + } + buf += csize; +@@ -1089,9 +1190,9 @@ + + key->type = GRUB_BTRFS_ITEM_TYPE_DIR_ITEM; + key->offset = grub_cpu_to_le64 (~grub_getcrc32c (1, ctoken, ctokenlen)); +- +- err = lower_bound (data, key, &key_out, *tree, +- &elemaddr, &elemsize, NULL); ++ ++ err = lower_bound (data, key, &key_out, *tree, &elemaddr, &elemsize, ++ NULL); + if (err) + { + grub_free (direl); +@@ -1128,7 +1229,7 @@ + + for (cdirel = direl; + (grub_uint8_t *) cdirel - (grub_uint8_t *) direl +- < (grub_ssize_t) elemsize; ++ < (grub_ssize_t) elemsize; + cdirel = (void *) ((grub_uint8_t *) (direl + 1) + + grub_le_to_cpu16 (cdirel->n) + + grub_le_to_cpu16 (cdirel->m))) +@@ -1159,7 +1260,7 @@ + return grub_error (GRUB_ERR_SYMLINK_LOOP, + "too deep nesting of symlinks"); + } +- ++ + err = grub_btrfs_read_inode (data, &inode, + cdirel->key.object_id, *tree); + if (err) +@@ -1187,7 +1288,7 @@ + grub_free (tmp); + return grub_errno; + } +- grub_memcpy (tmp + grub_le_to_cpu64 (inode.size), path, ++ grub_memcpy (tmp + grub_le_to_cpu64 (inode.size), path, + grub_strlen (path) + 1); + grub_free (path_alloc); + path = path_alloc = tmp; +@@ -1225,8 +1326,7 @@ + grub_free (path_alloc); + return grub_error (GRUB_ERR_FILE_NOT_FOUND, "file not found"); + } +- err = grub_btrfs_read_logical (data, elemaddr, +- &ri, sizeof (ri)); ++ err = grub_btrfs_read_logical (data, elemaddr, &ri, sizeof (ri)); + if (err) + { + grub_free (direl); +@@ -1253,7 +1353,7 @@ + default: + grub_free (path_alloc); + grub_free (direl); +- return grub_error (GRUB_ERR_BAD_FS, "unrecognised object type 0x%x", ++ return grub_error (GRUB_ERR_BAD_FS, "unrecognised object type 0x%x", + cdirel->key.type); + } + } +@@ -1264,8 +1364,8 @@ + + static grub_err_t + grub_btrfs_dir (grub_device_t device, const char *path, +- int (*hook) (const char *filename, +- const struct grub_dirhook_info *info)) ++ int (*hook) (const char *filename, ++ const struct grub_dirhook_info *info)) + { + struct grub_btrfs_data *data = grub_btrfs_mount (device); + struct grub_btrfs_key key_in, key_out; +@@ -1286,10 +1386,9 @@ + if (err) + return err; + if (type != GRUB_BTRFS_DIR_ITEM_TYPE_DIRECTORY) +- return grub_error (GRUB_ERR_BAD_FILE_TYPE, "not a directory"); ++ return grub_error (GRUB_ERR_BAD_FILE_TYPE, "not a directory"); + +- err = lower_bound (data, &key_in, &key_out, tree, +- &elemaddr, &elemsize, &desc); ++ err = lower_bound (data, &key_in, &key_out, tree, &elemaddr, &elemsize, &desc); + if (err) + return err; + if (key_out.type != GRUB_BTRFS_ITEM_TYPE_DIR_ITEM +@@ -1329,7 +1428,7 @@ + + for (cdirel = direl; + (grub_uint8_t *) cdirel - (grub_uint8_t *) direl +- < (grub_ssize_t) elemsize; ++ < (grub_ssize_t) elemsize; + cdirel = (void *) ((grub_uint8_t *) (direl + 1) + + grub_le_to_cpu16 (cdirel->n) + + grub_le_to_cpu16 (cdirel->m))) +@@ -1358,7 +1457,7 @@ + } + while (r > 0); + +- out: ++out: + grub_free (direl); + + free_iterator (&desc); +@@ -1430,7 +1529,7 @@ + *uuid = NULL; + + data = grub_btrfs_mount (device); +- if (! data) ++ if (!data) + return grub_errno; + + *uuid = grub_xasprintf ("%04x%04x-%04x-%04x-%04x-%04x%04x%04x", +@@ -1456,7 +1555,7 @@ + *label = NULL; + + data = grub_btrfs_mount (device); +- if (! data) ++ if (!data) + return grub_errno; + + *label = grub_strndup (data->sblock.label, sizeof (data->sblock.label)); +@@ -1466,26 +1565,25 @@ + return grub_errno; + } + +-static struct grub_fs grub_btrfs_fs = +- { +- .name = "btrfs", +- .dir = grub_btrfs_dir, +- .open = grub_btrfs_open, +- .read = grub_btrfs_read, +- .close = grub_btrfs_close, +- .uuid = grub_btrfs_uuid, +- .label = grub_btrfs_label, ++static struct grub_fs grub_btrfs_fs = { ++ .name = "btrfs", ++ .dir = grub_btrfs_dir, ++ .open = grub_btrfs_open, ++ .read = grub_btrfs_read, ++ .close = grub_btrfs_close, ++ .uuid = grub_btrfs_uuid, ++ .label = grub_btrfs_label, + #ifdef GRUB_UTIL +- .reserved_first_sector = 1, ++ .reserved_first_sector = 1, + #endif +- }; ++}; + +-GRUB_MOD_INIT(btrfs) ++GRUB_MOD_INIT (btrfs) + { + grub_fs_register (&grub_btrfs_fs); + } + +-GRUB_MOD_FINI(btrfs) ++GRUB_MOD_FINI (btrfs) + { + grub_fs_unregister (&grub_btrfs_fs); + } +Index: b/grub-core/io/lzopio.c +=================================================================== +--- /dev/null ++++ b/grub-core/io/lzopio.c +@@ -0,0 +1,564 @@ ++/* lzopio.c - decompression support for lzop */ ++/* ++ * GRUB -- GRand Unified Bootloader ++ * Copyright (C) 2011 Free Software Foundation, Inc. ++ * ++ * GRUB is free software: you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation, either version 3 of the License, or ++ * (at your option) any later version. ++ * ++ * GRUB is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with GRUB. If not, see <http://www.gnu.org/licenses/>. ++ */ ++ ++#include <grub/err.h> ++#include <grub/mm.h> ++#include <grub/file.h> ++#include <grub/fs.h> ++#include <grub/dl.h> ++#include <grub/crypto.h> ++#include <minilzo.h> ++ ++GRUB_MOD_LICENSE ("GPLv3+"); ++ ++#define LZOP_MAGIC "\x89\x4c\x5a\x4f\x00\x0d\x0a\x1a\x0a" ++#define LZOP_MAGIC_SIZE 9 ++#define LZOP_CHECK_SIZE 4 ++#define LZOP_NEW_LIB 0x0940 ++ ++/* Header flags - copied from conf.h of LZOP source code. */ ++#define F_ADLER32_D 0x00000001L ++#define F_ADLER32_C 0x00000002L ++#define F_STDIN 0x00000004L ++#define F_STDOUT 0x00000008L ++#define F_NAME_DEFAULT 0x00000010L ++#define F_DOSISH 0x00000020L ++#define F_H_EXTRA_FIELD 0x00000040L ++#define F_H_GMTDIFF 0x00000080L ++#define F_CRC32_D 0x00000100L ++#define F_CRC32_C 0x00000200L ++#define F_MULTIPART 0x00000400L ++#define F_H_FILTER 0x00000800L ++#define F_H_CRC32 0x00001000L ++#define F_H_PATH 0x00002000L ++#define F_MASK 0x00003FFFL ++ ++struct block_header ++{ ++ grub_uint32_t usize; ++ grub_uint32_t csize; ++ grub_uint32_t ucheck; ++ grub_uint32_t ccheck; ++ unsigned char *cdata; ++ unsigned char *udata; ++}; ++ ++struct grub_lzopio ++{ ++ grub_file_t file; ++ int has_ccheck; ++ int has_ucheck; ++ const gcry_md_spec_t *ucheck_fun; ++ const gcry_md_spec_t *ccheck_fun; ++ grub_off_t saved_off; /* Rounded down to block boundary. */ ++ grub_off_t start_block_off; ++ struct block_header block; ++}; ++ ++typedef struct grub_lzopio *grub_lzopio_t; ++static struct grub_fs grub_lzopio_fs; ++ ++/* Some helper functions. On errors memory allocated by those function is free ++ * either on close() so no risk of leaks. This makes functions simpler. */ ++ ++/* Read block header from file, after successful exit file points to ++ * beginning of block data. */ ++static int ++read_block_header (struct grub_lzopio *lzopio) ++{ ++ lzopio->saved_off += lzopio->block.usize; ++ ++ /* Free cached block data if any. */ ++ grub_free (lzopio->block.udata); ++ grub_free (lzopio->block.cdata); ++ lzopio->block.udata = NULL; ++ lzopio->block.cdata = NULL; ++ ++ if (grub_file_read (lzopio->file, &lzopio->block.usize, ++ sizeof (lzopio->block.usize)) != ++ sizeof (lzopio->block.usize)) ++ return -1; ++ ++ lzopio->block.usize = grub_be_to_cpu32 (lzopio->block.usize); ++ ++ /* Last block has uncompressed data size == 0 and no other fields. */ ++ if (lzopio->block.usize == 0) ++ { ++ if (grub_file_tell (lzopio->file) == grub_file_size (lzopio->file)) ++ return 0; ++ else ++ return -1; ++ } ++ ++ /* Read compressed data block size. */ ++ if (grub_file_read (lzopio->file, &lzopio->block.csize, ++ sizeof (lzopio->block.csize)) != ++ sizeof (lzopio->block.csize)) ++ return -1; ++ ++ lzopio->block.csize = grub_be_to_cpu32 (lzopio->block.csize); ++ ++ /* Corrupted. */ ++ if (lzopio->block.csize > lzopio->block.usize) ++ return -1; ++ ++ /* Read checksum of uncompressed data. */ ++ if (lzopio->has_ucheck) ++ { ++ if (grub_file_read (lzopio->file, &lzopio->block.ucheck, ++ sizeof (lzopio->block.ucheck)) != ++ sizeof (lzopio->block.ucheck)) ++ return -1; ++ ++ lzopio->block.ucheck = grub_be_to_cpu32 (lzopio->block.ucheck); ++ } ++ ++ /* Read checksum of compressed data. */ ++ if (lzopio->has_ccheck) ++ { ++ /* Incompressible data block. */ ++ if (lzopio->block.csize == lzopio->block.usize) ++ { ++ lzopio->block.ccheck = lzopio->block.ucheck; ++ } ++ else ++ { ++ if (grub_file_read (lzopio->file, &lzopio->block.ccheck, ++ sizeof (lzopio->block.ccheck)) != ++ sizeof (lzopio->block.ccheck)) ++ return -1; ++ ++ lzopio->block.ccheck = grub_be_to_cpu32 (lzopio->block.ccheck); ++ } ++ } ++ ++ return 0; ++} ++ ++/* Read block data into memory. File must be set to beginning of block data. ++ * Can't be called on last block. */ ++static int ++read_block_data (struct grub_lzopio *lzopio) ++{ ++ lzopio->block.cdata = grub_malloc (lzopio->block.csize); ++ if (!lzopio->block.cdata) ++ return -1; ++ ++ if (grub_file_read (lzopio->file, lzopio->block.cdata, lzopio->block.csize) ++ != (grub_ssize_t) lzopio->block.csize) ++ return -1; ++ ++ if (lzopio->ccheck_fun) ++ { ++ grub_uint64_t context[(lzopio->ccheck_fun->contextsize + 7) / 8]; ++ ++ lzopio->ccheck_fun->init (context); ++ lzopio->ccheck_fun->write (context, lzopio->block.cdata, ++ lzopio->block.csize); ++ lzopio->ccheck_fun->final (context); ++ ++ if (grub_memcmp ++ (lzopio->ccheck_fun->read (context), &lzopio->block.ccheck, ++ sizeof (lzopio->block.ccheck)) != 0) ++ return -1; ++ } ++ ++ return 0; ++} ++ ++/* Read block data, uncompressed and also store it in memory. */ ++/* XXX Investigate possibility of in-place decompression to reduce memory ++ * footprint. Or try to uncompress directly to buf if possible. */ ++static int ++uncompress_block (struct grub_lzopio *lzopio) ++{ ++ lzo_uint usize = lzopio->block.usize; ++ ++ if (read_block_data (lzopio) < 0) ++ return -1; ++ ++ /* Incompressible data. */ ++ if (lzopio->block.csize == lzopio->block.usize) ++ { ++ lzopio->block.udata = lzopio->block.cdata; ++ lzopio->block.cdata = NULL; ++ } ++ else ++ { ++ lzopio->block.udata = grub_malloc (lzopio->block.usize); ++ if (!lzopio->block.udata) ++ return -1; ++ ++ if (lzo1x_decompress_safe (lzopio->block.cdata, lzopio->block.csize, ++ lzopio->block.udata, &usize, NULL) ++ != LZO_E_OK) ++ return -1; ++ ++ if (lzopio->ucheck_fun) ++ { ++ grub_uint64_t context[(lzopio->ucheck_fun->contextsize + 7) / 8]; ++ ++ lzopio->ucheck_fun->init (context); ++ lzopio->ucheck_fun->write (context, lzopio->block.udata, ++ lzopio->block.usize); ++ lzopio->ucheck_fun->final (context); ++ ++ if (grub_memcmp ++ (lzopio->ucheck_fun->read (context), &lzopio->block.ucheck, ++ sizeof (lzopio->block.ucheck)) != 0) ++ return -1; ++ } ++ ++ /* Compressed data can be free now. */ ++ grub_free (lzopio->block.cdata); ++ lzopio->block.cdata = NULL; ++ } ++ ++ return 0; ++} ++ ++/* Jump to next block and read its header. */ ++static int ++jump_block (struct grub_lzopio *lzopio) ++{ ++ /* only jump if block was not decompressed (and read from disk) */ ++ if (!lzopio->block.udata) ++ { ++ grub_off_t off = grub_file_tell (lzopio->file) + lzopio->block.csize; ++ ++ if (grub_file_seek (lzopio->file, off) == ((grub_off_t) - 1)) ++ return -1; ++ } ++ ++ return read_block_header (lzopio); ++} ++ ++static int ++calculate_uncompressed_size (grub_file_t file) ++{ ++ grub_lzopio_t lzopio = file->data; ++ grub_off_t usize_total = 0; ++ ++ if (read_block_header (lzopio) < 0) ++ return -1; ++ ++ /* FIXME: Don't do this for not easily seekable files. */ ++ while (lzopio->block.usize != 0) ++ { ++ usize_total += lzopio->block.usize; ++ ++ if (jump_block (lzopio) < 0) ++ return -1; ++ } ++ ++ file->size = usize_total; ++ ++ return 0; ++} ++ ++struct lzop_header ++{ ++ grub_uint8_t magic[LZOP_MAGIC_SIZE]; ++ grub_uint16_t lzop_version; ++ grub_uint16_t lib_version; ++ grub_uint16_t lib_version_ext; ++ grub_uint8_t method; ++ grub_uint8_t level; ++ grub_uint32_t flags; ++ /* grub_uint32_t filter; */ /* No filters support. Rarely used anyway. */ ++ grub_uint32_t mode; ++ grub_uint32_t mtime_lo; ++ grub_uint32_t mtime_hi; ++ grub_uint8_t name_len; ++} __attribute__ ((packed)); ++ ++static int ++test_header (grub_file_t file) ++{ ++ grub_lzopio_t lzopio = file->data; ++ struct lzop_header header; ++ grub_uint32_t flags, checksum; ++ const gcry_md_spec_t *hcheck; ++ grub_uint8_t *context = NULL; ++ grub_uint8_t *name = NULL; ++ ++ if (grub_file_read (lzopio->file, &header, sizeof (header)) != sizeof (header)) ++ { ++ grub_error (GRUB_ERR_BAD_FILE_TYPE, "no lzop magic found"); ++ return 0; ++ } ++ ++ if (grub_memcmp (header.magic, LZOP_MAGIC, LZOP_MAGIC_SIZE) != 0) ++ { ++ grub_error (GRUB_ERR_BAD_FILE_TYPE, "no lzop magic found"); ++ return 0; ++ } ++ ++ if (grub_be_to_cpu16(header.lib_version) < LZOP_NEW_LIB) ++ { ++ grub_error (GRUB_ERR_BAD_COMPRESSED_DATA, ++ "unsupported (too old) LZOP version"); ++ return 0; ++ } ++ ++ /* Too new version, should upgrade minilzo? */ ++ if (grub_be_to_cpu16 (header.lib_version_ext) > MINILZO_VERSION) ++ { ++ grub_error (GRUB_ERR_BAD_COMPRESSED_DATA, ++ "unsupported (too new) LZO version"); ++ return 0; ++ } ++ ++ flags = grub_be_to_cpu32 (header.flags); ++ ++ if (flags & F_CRC32_D) ++ { ++ lzopio->has_ucheck = 1; ++ lzopio->ucheck_fun = grub_crypto_lookup_md_by_name ("crc32"); ++ } ++ else if (flags & F_ADLER32_D) ++ { ++ lzopio->has_ucheck = 1; ++ lzopio->ucheck_fun = grub_crypto_lookup_md_by_name ("adler32"); ++ } ++ ++ if (flags & F_CRC32_C) ++ { ++ lzopio->has_ccheck = 1; ++ lzopio->ccheck_fun = grub_crypto_lookup_md_by_name ("crc32"); ++ } ++ else if (flags & F_ADLER32_C) ++ { ++ lzopio->has_ccheck = 1; ++ lzopio->ccheck_fun = grub_crypto_lookup_md_by_name ("adler32"); ++ } ++ ++ if (flags & F_H_CRC32) ++ hcheck = grub_crypto_lookup_md_by_name ("crc32"); ++ else ++ hcheck = grub_crypto_lookup_md_by_name ("adler32"); ++ ++ if (hcheck) { ++ context = grub_malloc(hcheck->contextsize); ++ if (! context) ++ return 0; ++ ++ hcheck->init(context); ++ ++ /* MAGIC is not included in check calculation. */ ++ hcheck->write(context, &header.lzop_version, sizeof(header)- LZOP_MAGIC_SIZE); ++ } ++ ++ if (header.name_len != 0) ++ { ++ name = grub_malloc (header.name_len); ++ if (! name) ++ { ++ grub_free (context); ++ return 0; ++ } ++ ++ if (grub_file_read (lzopio->file, name, header.name_len) != ++ header.name_len) ++ { ++ grub_free(name); ++ goto CORRUPTED; ++ } ++ ++ if (hcheck) ++ hcheck->write(context, name, header.name_len); ++ ++ grub_free(name); ++ } ++ ++ if (hcheck) ++ hcheck->final(context); ++ ++ if (grub_file_read (lzopio->file, &checksum, sizeof (checksum)) != ++ sizeof (checksum)) ++ goto CORRUPTED; ++ ++ if (hcheck) ++ { ++ checksum = grub_cpu_to_be32(checksum); ++ if (grub_memcmp (&checksum, hcheck->read(context), sizeof(checksum)) != 0) ++ goto CORRUPTED; ++ } ++ ++ lzopio->start_block_off = grub_file_tell (lzopio->file); ++ ++ if (calculate_uncompressed_size (file) < 0) ++ goto CORRUPTED; ++ ++ /* Get back to start block. */ ++ grub_file_seek (lzopio->file, lzopio->start_block_off); ++ ++ /* Read first block - grub_lzopio_read() expects valid block. */ ++ if (read_block_header (lzopio) < 0) ++ goto CORRUPTED; ++ ++ lzopio->saved_off = 0; ++ return 1; ++ ++CORRUPTED: ++ grub_error (GRUB_ERR_BAD_COMPRESSED_DATA, "lzop file corrupted"); ++ ++ grub_free(name); ++ ++ return 0; ++} ++ ++static grub_file_t ++grub_lzopio_open (grub_file_t io) ++{ ++ grub_file_t file; ++ grub_lzopio_t lzopio; ++ ++ file = (grub_file_t) grub_zalloc (sizeof (*file)); ++ if (!file) ++ return 0; ++ ++ lzopio = grub_zalloc (sizeof (*lzopio)); ++ if (!lzopio) ++ { ++ grub_free (file); ++ return 0; ++ } ++ ++ lzopio->file = io; ++ ++ file->device = io->device; ++ file->offset = 0; ++ file->data = lzopio; ++ file->read_hook = 0; ++ file->fs = &grub_lzopio_fs; ++ file->size = GRUB_FILE_SIZE_UNKNOWN; ++ file->not_easily_seekable = 1; ++ ++ if (grub_file_tell (lzopio->file) != 0) ++ grub_file_seek (lzopio->file, 0); ++ ++ if (!test_header (file)) ++ { ++ grub_errno = GRUB_ERR_NONE; ++ grub_file_seek (io, 0); ++ grub_free (lzopio); ++ grub_free (file); ++ ++ return io; ++ } ++ ++ return file; ++} ++ ++static grub_ssize_t ++grub_lzopio_read (grub_file_t file, char *buf, grub_size_t len) ++{ ++ grub_lzopio_t lzopio = file->data; ++ grub_ssize_t ret = 0; ++ grub_off_t off; ++ ++ /* Backward seek before last read block. */ ++ if (lzopio->saved_off > grub_file_tell (file)) ++ { ++ grub_file_seek (lzopio->file, lzopio->start_block_off); ++ ++ if (read_block_header (lzopio) < 0) ++ goto CORRUPTED; ++ ++ lzopio->saved_off = 0; ++ } ++ ++ /* Forward to first block with requested data. */ ++ while (lzopio->saved_off + lzopio->block.usize <= grub_file_tell (file)) ++ { ++ /* EOF, could be possible files with unknown size. */ ++ if (lzopio->block.usize == 0) ++ return 0; ++ ++ if (jump_block (lzopio) < 0) ++ goto CORRUPTED; ++ } ++ ++ off = grub_file_tell (file) - lzopio->saved_off; ++ ++ while (len != 0 && lzopio->block.usize != 0) ++ { ++ long to_copy; ++ ++ /* Block not decompressed yet. */ ++ if (!lzopio->block.udata && uncompress_block (lzopio) < 0) ++ goto CORRUPTED; ++ ++ /* Copy requested data into buffer. */ ++ to_copy = grub_min (lzopio->block.usize - off, len); ++ grub_memcpy (buf, lzopio->block.udata + off, to_copy); ++ ++ len -= to_copy; ++ buf += to_copy; ++ ret += to_copy; ++ off = 0; ++ ++ /* Read next block if needed. */ ++ if (len > 0 && read_block_header (lzopio) < 0) ++ goto CORRUPTED; ++ } ++ ++ return ret; ++ ++CORRUPTED: ++ grub_error (GRUB_ERR_BAD_COMPRESSED_DATA, "lzop file corrupted"); ++ return -1; ++} ++ ++/* Release everything, including the underlying file object. */ ++static grub_err_t ++grub_lzopio_close (grub_file_t file) ++{ ++ grub_lzopio_t lzopio = file->data; ++ ++ grub_file_close (lzopio->file); ++ grub_free (lzopio->block.cdata); ++ grub_free (lzopio->block.udata); ++ grub_free (lzopio); ++ ++ /* Device must not be closed twice. */ ++ file->device = 0; ++ return grub_errno; ++} ++ ++static struct grub_fs grub_lzopio_fs = { ++ .name = "lzopio", ++ .dir = 0, ++ .open = 0, ++ .read = grub_lzopio_read, ++ .close = grub_lzopio_close, ++ .label = 0, ++ .next = 0 ++}; ++ ++GRUB_MOD_INIT (lzopio) ++{ ++ grub_file_filter_register (GRUB_FILE_FILTER_LZOPIO, grub_lzopio_open); ++} ++ ++GRUB_MOD_FINI (lzopio) ++{ ++ grub_file_filter_unregister (GRUB_FILE_FILTER_LZOPIO); ++} +Index: b/grub-core/lib/adler32.c +=================================================================== +--- /dev/null ++++ b/grub-core/lib/adler32.c +@@ -0,0 +1,151 @@ ++/* adler32.c - adler32 check. */ ++/* ++ * GRUB -- GRand Unified Bootloader ++ * Copyright (C) 2011 Free Software Foundation, Inc. ++ * ++ * GRUB is free software: you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation, either version 3 of the License, or ++ * (at your option) any later version. ++ * ++ * GRUB is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with GRUB. If not, see <http://www.gnu.org/licenses/>. ++ */ ++ ++#include <grub/types.h> ++#include <grub/dl.h> ++#include <grub/crypto.h> ++ ++/* Based on adler32() from adler32.c of zlib-1.2.5 library. */ ++ ++#define BASE 65521UL ++#define NMAX 5552 ++ ++#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} ++#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); ++#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); ++#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); ++#define DO16(buf) DO8(buf,0); DO8(buf,8); ++ ++static grub_uint32_t ++update_adler32 (grub_uint32_t adler, const grub_uint8_t *buf, grub_size_t len) ++{ ++ unsigned long sum2; ++ unsigned int n; ++ ++ sum2 = (adler >> 16) & 0xffff; ++ adler &= 0xffff; ++ ++ if (len == 1) ++ { ++ adler += buf[0]; ++ if (adler >= BASE) ++ adler -= BASE; ++ sum2 += adler; ++ if (sum2 >= BASE) ++ sum2 -= BASE; ++ return adler | (sum2 << 16); ++ } ++ ++ if (len < 16) ++ { ++ while (len--) ++ { ++ adler += *buf++; ++ sum2 += adler; ++ } ++ if (adler >= BASE) ++ adler -= BASE; ++ sum2 %= BASE; ++ return adler | (sum2 << 16); ++ } ++ ++ while (len >= NMAX) ++ { ++ len -= NMAX; ++ n = NMAX / 16; ++ do ++ { ++ DO16 (buf); ++ buf += 16; ++ } ++ while (--n); ++ adler %= BASE; ++ sum2 %= BASE; ++ } ++ ++ if (len) ++ { ++ while (len >= 16) ++ { ++ len -= 16; ++ DO16 (buf); ++ buf += 16; ++ } ++ while (len--) ++ { ++ adler += *buf++; ++ sum2 += adler; ++ } ++ adler %= BASE; ++ sum2 %= BASE; ++ } ++ ++ return adler | (sum2 << 16); ++} ++ ++typedef struct ++{ ++ grub_uint32_t adler; ++} ++adler32_context; ++ ++static void ++adler32_init (void *context) ++{ ++ adler32_context *ctx = (adler32_context *) context; ++ ctx->adler = 1; ++} ++ ++static void ++adler32_write (void *context, const void *inbuf, grub_size_t inlen) ++{ ++ adler32_context *ctx = (adler32_context *) context; ++ if (!inbuf) ++ return; ++ ctx->adler = update_adler32 (ctx->adler, inbuf, inlen); ++} ++ ++static grub_uint8_t * ++adler32_read (void *context) ++{ ++ adler32_context *ctx = (adler32_context *) context; ++ return (grub_uint8_t *) &ctx->adler; ++} ++ ++static void ++adler32_final (void *context __attribute__ ((unused))) ++{ ++} ++ ++gcry_md_spec_t _gcry_digest_spec_adler32 = { ++ "ADLER32",0 , 0, 0 , 4, ++ adler32_init, adler32_write, adler32_final, adler32_read, ++ sizeof (adler32_context), ++ .blocksize = 64 ++}; ++ ++GRUB_MOD_INIT(adler32) ++{ ++ grub_md_register (&_gcry_digest_spec_adler32); ++} ++ ++GRUB_MOD_FINI(adler32) ++{ ++ grub_md_unregister (&_gcry_digest_spec_adler32); ++} +Index: b/grub-core/lib/minilzo/lzoconf.h +=================================================================== +--- /dev/null ++++ b/grub-core/lib/minilzo/lzoconf.h +@@ -0,0 +1,446 @@ ++/* lzoconf.h -- configuration of the LZO data compression library ++ ++ This file is part of the LZO real-time data compression library. ++ ++ Copyright (C) 2011 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2010 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2009 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer ++ All Rights Reserved. ++ ++ The LZO library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU General Public License as ++ published by the Free Software Foundation; either version 2 of ++ the License, or (at your option) any later version. ++ ++ The LZO library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with the LZO library; see the file COPYING. ++ If not, write to the Free Software Foundation, Inc., ++ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ ++ Markus F.X.J. Oberhumer ++ <markus@oberhumer.com> ++ http://www.oberhumer.com/opensource/lzo/ ++ */ ++ ++ ++#ifndef __LZOCONF_H_INCLUDED ++#define __LZOCONF_H_INCLUDED 1 ++ ++#define LZO_VERSION 0x2050 ++#define LZO_VERSION_STRING "2.05" ++#define LZO_VERSION_DATE "Apr 23 2011" ++ ++/* internal Autoconf configuration file - only used when building LZO */ ++#if defined(LZO_HAVE_CONFIG_H) ++# include <config.h> ++#endif ++#include <limits.h> ++#include <stddef.h> ++ ++ ++/*********************************************************************** ++// LZO requires a conforming <limits.h> ++************************************************************************/ ++ ++#if !defined(CHAR_BIT) || (CHAR_BIT != 8) ++# error "invalid CHAR_BIT" ++#endif ++#if !defined(UCHAR_MAX) || !defined(UINT_MAX) || !defined(ULONG_MAX) ++# error "check your compiler installation" ++#endif ++#if (USHRT_MAX < 1) || (UINT_MAX < 1) || (ULONG_MAX < 1) ++# error "your limits.h macros are broken" ++#endif ++ ++/* get OS and architecture defines */ ++#ifndef __LZODEFS_H_INCLUDED ++#include "lzodefs.h" ++#endif ++ ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++ ++/*********************************************************************** ++// some core defines ++************************************************************************/ ++ ++#if !defined(LZO_UINT32_C) ++# if (UINT_MAX < LZO_0xffffffffL) ++# define LZO_UINT32_C(c) c ## UL ++# else ++# define LZO_UINT32_C(c) ((c) + 0U) ++# endif ++#endif ++ ++/* memory checkers */ ++#if !defined(__LZO_CHECKER) ++# if defined(__BOUNDS_CHECKING_ON) ++# define __LZO_CHECKER 1 ++# elif defined(__CHECKER__) ++# define __LZO_CHECKER 1 ++# elif defined(__INSURE__) ++# define __LZO_CHECKER 1 ++# elif defined(__PURIFY__) ++# define __LZO_CHECKER 1 ++# endif ++#endif ++ ++ ++/*********************************************************************** ++// integral and pointer types ++************************************************************************/ ++ ++/* lzo_uint should match size_t */ ++#if !defined(LZO_UINT_MAX) ++# if defined(LZO_ABI_LLP64) /* WIN64 */ ++# if defined(LZO_OS_WIN64) ++ typedef unsigned __int64 lzo_uint; ++ typedef __int64 lzo_int; ++# else ++ typedef unsigned long long lzo_uint; ++ typedef long long lzo_int; ++# endif ++# define LZO_UINT_MAX 0xffffffffffffffffull ++# define LZO_INT_MAX 9223372036854775807LL ++# define LZO_INT_MIN (-1LL - LZO_INT_MAX) ++# elif defined(LZO_ABI_IP32L64) /* MIPS R5900 */ ++ typedef unsigned int lzo_uint; ++ typedef int lzo_int; ++# define LZO_UINT_MAX UINT_MAX ++# define LZO_INT_MAX INT_MAX ++# define LZO_INT_MIN INT_MIN ++# elif (ULONG_MAX >= LZO_0xffffffffL) ++ typedef unsigned long lzo_uint; ++ typedef long lzo_int; ++# define LZO_UINT_MAX ULONG_MAX ++# define LZO_INT_MAX LONG_MAX ++# define LZO_INT_MIN LONG_MIN ++# else ++# error "lzo_uint" ++# endif ++#endif ++ ++/* Integral types with 32 bits or more. */ ++#if !defined(LZO_UINT32_MAX) ++# if (UINT_MAX >= LZO_0xffffffffL) ++ typedef unsigned int lzo_uint32; ++ typedef int lzo_int32; ++# define LZO_UINT32_MAX UINT_MAX ++# define LZO_INT32_MAX INT_MAX ++# define LZO_INT32_MIN INT_MIN ++# elif (ULONG_MAX >= LZO_0xffffffffL) ++ typedef unsigned long lzo_uint32; ++ typedef long lzo_int32; ++# define LZO_UINT32_MAX ULONG_MAX ++# define LZO_INT32_MAX LONG_MAX ++# define LZO_INT32_MIN LONG_MIN ++# else ++# error "lzo_uint32" ++# endif ++#endif ++ ++/* Integral types with exactly 64 bits. */ ++#if !defined(LZO_UINT64_MAX) ++# if (LZO_UINT_MAX >= LZO_0xffffffffL) ++# if ((((LZO_UINT_MAX) >> 31) >> 31) == 3) ++# define lzo_uint64 lzo_uint ++# define lzo_int64 lzo_int ++# define LZO_UINT64_MAX LZO_UINT_MAX ++# define LZO_INT64_MAX LZO_INT_MAX ++# define LZO_INT64_MIN LZO_INT_MIN ++# endif ++# elif (ULONG_MAX >= LZO_0xffffffffL) ++# if ((((ULONG_MAX) >> 31) >> 31) == 3) ++ typedef unsigned long lzo_uint64; ++ typedef long lzo_int64; ++# define LZO_UINT64_MAX ULONG_MAX ++# define LZO_INT64_MAX LONG_MAX ++# define LZO_INT64_MIN LONG_MIN ++# endif ++# endif ++#endif ++ ++/* The larger type of lzo_uint and lzo_uint32. */ ++#if (LZO_UINT_MAX >= LZO_UINT32_MAX) ++# define lzo_xint lzo_uint ++#else ++# define lzo_xint lzo_uint32 ++#endif ++ ++/* Memory model that allows to access memory at offsets of lzo_uint. */ ++#if !defined(__LZO_MMODEL) ++# if (LZO_UINT_MAX <= UINT_MAX) ++# define __LZO_MMODEL /*empty*/ ++# elif defined(LZO_HAVE_MM_HUGE_PTR) ++# define __LZO_MMODEL_HUGE 1 ++# define __LZO_MMODEL __huge ++# else ++# define __LZO_MMODEL /*empty*/ ++# endif ++#endif ++ ++/* no typedef here because of const-pointer issues */ ++#define lzo_bytep unsigned char __LZO_MMODEL * ++#define lzo_charp char __LZO_MMODEL * ++#define lzo_voidp void __LZO_MMODEL * ++#define lzo_shortp short __LZO_MMODEL * ++#define lzo_ushortp unsigned short __LZO_MMODEL * ++#define lzo_uint32p lzo_uint32 __LZO_MMODEL * ++#define lzo_int32p lzo_int32 __LZO_MMODEL * ++#if defined(LZO_UINT64_MAX) ++#define lzo_uint64p lzo_uint64 __LZO_MMODEL * ++#define lzo_int64p lzo_int64 __LZO_MMODEL * ++#endif ++#define lzo_uintp lzo_uint __LZO_MMODEL * ++#define lzo_intp lzo_int __LZO_MMODEL * ++#define lzo_xintp lzo_xint __LZO_MMODEL * ++#define lzo_voidpp lzo_voidp __LZO_MMODEL * ++#define lzo_bytepp lzo_bytep __LZO_MMODEL * ++/* deprecated - use 'lzo_bytep' instead of 'lzo_byte *' */ ++#define lzo_byte unsigned char __LZO_MMODEL ++ ++typedef int lzo_bool; ++ ++ ++/*********************************************************************** ++// function types ++************************************************************************/ ++ ++/* name mangling */ ++#if !defined(__LZO_EXTERN_C) ++# ifdef __cplusplus ++# define __LZO_EXTERN_C extern "C" ++# else ++# define __LZO_EXTERN_C extern ++# endif ++#endif ++ ++/* calling convention */ ++#if !defined(__LZO_CDECL) ++# define __LZO_CDECL __lzo_cdecl ++#endif ++ ++/* DLL export information */ ++#if !defined(__LZO_EXPORT1) ++# define __LZO_EXPORT1 /*empty*/ ++#endif ++#if !defined(__LZO_EXPORT2) ++# define __LZO_EXPORT2 /*empty*/ ++#endif ++ ++/* __cdecl calling convention for public C and assembly functions */ ++#if !defined(LZO_PUBLIC) ++# define LZO_PUBLIC(_rettype) __LZO_EXPORT1 _rettype __LZO_EXPORT2 __LZO_CDECL ++#endif ++#if !defined(LZO_EXTERN) ++# define LZO_EXTERN(_rettype) __LZO_EXTERN_C LZO_PUBLIC(_rettype) ++#endif ++#if !defined(LZO_PRIVATE) ++# define LZO_PRIVATE(_rettype) static _rettype __LZO_CDECL ++#endif ++ ++/* function types */ ++typedef int ++(__LZO_CDECL *lzo_compress_t) ( const lzo_bytep src, lzo_uint src_len, ++ lzo_bytep dst, lzo_uintp dst_len, ++ lzo_voidp wrkmem ); ++ ++typedef int ++(__LZO_CDECL *lzo_decompress_t) ( const lzo_bytep src, lzo_uint src_len, ++ lzo_bytep dst, lzo_uintp dst_len, ++ lzo_voidp wrkmem ); ++ ++typedef int ++(__LZO_CDECL *lzo_optimize_t) ( lzo_bytep src, lzo_uint src_len, ++ lzo_bytep dst, lzo_uintp dst_len, ++ lzo_voidp wrkmem ); ++ ++typedef int ++(__LZO_CDECL *lzo_compress_dict_t)(const lzo_bytep src, lzo_uint src_len, ++ lzo_bytep dst, lzo_uintp dst_len, ++ lzo_voidp wrkmem, ++ const lzo_bytep dict, lzo_uint dict_len ); ++ ++typedef int ++(__LZO_CDECL *lzo_decompress_dict_t)(const lzo_bytep src, lzo_uint src_len, ++ lzo_bytep dst, lzo_uintp dst_len, ++ lzo_voidp wrkmem, ++ const lzo_bytep dict, lzo_uint dict_len ); ++ ++ ++/* Callback interface. Currently only the progress indicator ("nprogress") ++ * is used, but this may change in a future release. */ ++ ++struct lzo_callback_t; ++typedef struct lzo_callback_t lzo_callback_t; ++#define lzo_callback_p lzo_callback_t __LZO_MMODEL * ++ ++/* malloc & free function types */ ++typedef lzo_voidp (__LZO_CDECL *lzo_alloc_func_t) ++ (lzo_callback_p self, lzo_uint items, lzo_uint size); ++typedef void (__LZO_CDECL *lzo_free_func_t) ++ (lzo_callback_p self, lzo_voidp ptr); ++ ++/* a progress indicator callback function */ ++typedef void (__LZO_CDECL *lzo_progress_func_t) ++ (lzo_callback_p, lzo_uint, lzo_uint, int); ++ ++struct lzo_callback_t ++{ ++ /* custom allocators (set to 0 to disable) */ ++ lzo_alloc_func_t nalloc; /* [not used right now] */ ++ lzo_free_func_t nfree; /* [not used right now] */ ++ ++ /* a progress indicator callback function (set to 0 to disable) */ ++ lzo_progress_func_t nprogress; ++ ++ /* NOTE: the first parameter "self" of the nalloc/nfree/nprogress ++ * callbacks points back to this struct, so you are free to store ++ * some extra info in the following variables. */ ++ lzo_voidp user1; ++ lzo_xint user2; ++ lzo_xint user3; ++}; ++ ++ ++/*********************************************************************** ++// error codes and prototypes ++************************************************************************/ ++ ++/* Error codes for the compression/decompression functions. Negative ++ * values are errors, positive values will be used for special but ++ * normal events. ++ */ ++#define LZO_E_OK 0 ++#define LZO_E_ERROR (-1) ++#define LZO_E_OUT_OF_MEMORY (-2) /* [lzo_alloc_func_t failure] */ ++#define LZO_E_NOT_COMPRESSIBLE (-3) /* [not used right now] */ ++#define LZO_E_INPUT_OVERRUN (-4) ++#define LZO_E_OUTPUT_OVERRUN (-5) ++#define LZO_E_LOOKBEHIND_OVERRUN (-6) ++#define LZO_E_EOF_NOT_FOUND (-7) ++#define LZO_E_INPUT_NOT_CONSUMED (-8) ++#define LZO_E_NOT_YET_IMPLEMENTED (-9) /* [not used right now] */ ++#define LZO_E_INVALID_ARGUMENT (-10) ++ ++ ++#ifndef lzo_sizeof_dict_t ++# define lzo_sizeof_dict_t ((unsigned)sizeof(lzo_bytep)) ++#endif ++ ++/* lzo_init() should be the first function you call. ++ * Check the return code ! ++ * ++ * lzo_init() is a macro to allow checking that the library and the ++ * compiler's view of various types are consistent. ++ */ ++#define lzo_init() __lzo_init_v2(LZO_VERSION,(int)sizeof(short),(int)sizeof(int),\ ++ (int)sizeof(long),(int)sizeof(lzo_uint32),(int)sizeof(lzo_uint),\ ++ (int)lzo_sizeof_dict_t,(int)sizeof(char *),(int)sizeof(lzo_voidp),\ ++ (int)sizeof(lzo_callback_t)) ++LZO_EXTERN(int) __lzo_init_v2(unsigned,int,int,int,int,int,int,int,int,int); ++ ++/* version functions (useful for shared libraries) */ ++LZO_EXTERN(unsigned) lzo_version(void); ++LZO_EXTERN(const char *) lzo_version_string(void); ++LZO_EXTERN(const char *) lzo_version_date(void); ++LZO_EXTERN(const lzo_charp) _lzo_version_string(void); ++LZO_EXTERN(const lzo_charp) _lzo_version_date(void); ++ ++/* string functions */ ++LZO_EXTERN(int) ++ lzo_memcmp(const lzo_voidp a, const lzo_voidp b, lzo_uint len); ++LZO_EXTERN(lzo_voidp) ++ lzo_memcpy(lzo_voidp dst, const lzo_voidp src, lzo_uint len); ++LZO_EXTERN(lzo_voidp) ++ lzo_memmove(lzo_voidp dst, const lzo_voidp src, lzo_uint len); ++LZO_EXTERN(lzo_voidp) ++ lzo_memset(lzo_voidp buf, int c, lzo_uint len); ++ ++/* checksum functions */ ++LZO_EXTERN(lzo_uint32) ++ lzo_adler32(lzo_uint32 c, const lzo_bytep buf, lzo_uint len); ++LZO_EXTERN(lzo_uint32) ++ lzo_crc32(lzo_uint32 c, const lzo_bytep buf, lzo_uint len); ++LZO_EXTERN(const lzo_uint32p) ++ lzo_get_crc32_table(void); ++ ++/* misc. */ ++LZO_EXTERN(int) _lzo_config_check(void); ++typedef union { lzo_bytep p; lzo_uint u; } __lzo_pu_u; ++typedef union { lzo_bytep p; lzo_uint32 u32; } __lzo_pu32_u; ++typedef union { void *vp; lzo_bytep bp; lzo_uint u; lzo_uint32 u32; unsigned long l; } lzo_align_t; ++ ++/* align a char pointer on a boundary that is a multiple of 'size' */ ++LZO_EXTERN(unsigned) __lzo_align_gap(const lzo_voidp p, lzo_uint size); ++#define LZO_PTR_ALIGN_UP(p,size) \ ++ ((p) + (lzo_uint) __lzo_align_gap((const lzo_voidp)(p),(lzo_uint)(size))) ++ ++ ++/*********************************************************************** ++// deprecated macros - only for backward compatibility with LZO v1.xx ++************************************************************************/ ++ ++#if defined(LZO_CFG_COMPAT) ++ ++#define __LZOCONF_H 1 ++ ++#if defined(LZO_ARCH_I086) ++# define __LZO_i386 1 ++#elif defined(LZO_ARCH_I386) ++# define __LZO_i386 1 ++#endif ++ ++#if defined(LZO_OS_DOS16) ++# define __LZO_DOS 1 ++# define __LZO_DOS16 1 ++#elif defined(LZO_OS_DOS32) ++# define __LZO_DOS 1 ++#elif defined(LZO_OS_WIN16) ++# define __LZO_WIN 1 ++# define __LZO_WIN16 1 ++#elif defined(LZO_OS_WIN32) ++# define __LZO_WIN 1 ++#endif ++ ++#define __LZO_CMODEL /*empty*/ ++#define __LZO_DMODEL /*empty*/ ++#define __LZO_ENTRY __LZO_CDECL ++#define LZO_EXTERN_CDECL LZO_EXTERN ++#define LZO_ALIGN LZO_PTR_ALIGN_UP ++ ++#define lzo_compress_asm_t lzo_compress_t ++#define lzo_decompress_asm_t lzo_decompress_t ++ ++#endif /* LZO_CFG_COMPAT */ ++ ++ ++#ifdef __cplusplus ++} /* extern "C" */ ++#endif ++ ++#endif /* already included */ ++ ++ ++/* vim:set ts=4 et: */ +Index: b/grub-core/lib/minilzo/lzodefs.h +=================================================================== +--- /dev/null ++++ b/grub-core/lib/minilzo/lzodefs.h +@@ -0,0 +1,1852 @@ ++/* lzodefs.h -- architecture, OS and compiler specific defines ++ ++ This file is part of the LZO real-time data compression library. ++ ++ Copyright (C) 2011 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2010 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2009 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer ++ All Rights Reserved. ++ ++ The LZO library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU General Public License as ++ published by the Free Software Foundation; either version 2 of ++ the License, or (at your option) any later version. ++ ++ The LZO library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with the LZO library; see the file COPYING. ++ If not, write to the Free Software Foundation, Inc., ++ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ ++ Markus F.X.J. Oberhumer ++ <markus@oberhumer.com> ++ http://www.oberhumer.com/opensource/lzo/ ++ */ ++ ++ ++#ifndef __LZODEFS_H_INCLUDED ++#define __LZODEFS_H_INCLUDED 1 ++ ++#if defined(__CYGWIN32__) && !defined(__CYGWIN__) ++# define __CYGWIN__ __CYGWIN32__ ++#endif ++#if defined(__IBMCPP__) && !defined(__IBMC__) ++# define __IBMC__ __IBMCPP__ ++#endif ++#if defined(__ICL) && defined(_WIN32) && !defined(__INTEL_COMPILER) ++# define __INTEL_COMPILER __ICL ++#endif ++#if 1 && defined(__INTERIX) && defined(__GNUC__) && !defined(_ALL_SOURCE) ++# define _ALL_SOURCE 1 ++#endif ++#if defined(__mips__) && defined(__R5900__) ++# if !defined(__LONG_MAX__) ++# define __LONG_MAX__ 9223372036854775807L ++# endif ++#endif ++#if defined(__INTEL_COMPILER) && defined(__linux__) ++# pragma warning(disable: 193) ++#endif ++#if defined(__KEIL__) && defined(__C166__) ++# pragma warning disable = 322 ++#elif 0 && defined(__C251__) ++# pragma warning disable = 322 ++#endif ++#if defined(_MSC_VER) && !defined(__INTEL_COMPILER) && !defined(__MWERKS__) ++# if (_MSC_VER >= 1300) ++# pragma warning(disable: 4668) ++# endif ++#endif ++#if 0 && defined(__WATCOMC__) ++# if (__WATCOMC__ >= 1050) && (__WATCOMC__ < 1060) ++# pragma warning 203 9 ++# endif ++#endif ++#if defined(__BORLANDC__) && defined(__MSDOS__) && !defined(__FLAT__) ++# pragma option -h ++#endif ++#if 0 ++#define LZO_0xffffL 0xfffful ++#define LZO_0xffffffffL 0xfffffffful ++#else ++#define LZO_0xffffL 65535ul ++#define LZO_0xffffffffL 4294967295ul ++#endif ++#if (LZO_0xffffL == LZO_0xffffffffL) ++# error "your preprocessor is broken 1" ++#endif ++#if (16ul * 16384ul != 262144ul) ++# error "your preprocessor is broken 2" ++#endif ++#if 0 ++#if (32767 >= 4294967295ul) ++# error "your preprocessor is broken 3" ++#endif ++#if (65535u >= 4294967295ul) ++# error "your preprocessor is broken 4" ++#endif ++#endif ++#if (UINT_MAX == LZO_0xffffL) ++#if defined(__ZTC__) && defined(__I86__) && !defined(__OS2__) ++# if !defined(MSDOS) ++# define MSDOS 1 ++# endif ++# if !defined(_MSDOS) ++# define _MSDOS 1 ++# endif ++#elif 0 && defined(__VERSION) && defined(MB_LEN_MAX) ++# if (__VERSION == 520) && (MB_LEN_MAX == 1) ++# if !defined(__AZTEC_C__) ++# define __AZTEC_C__ __VERSION ++# endif ++# if !defined(__DOS__) ++# define __DOS__ 1 ++# endif ++# endif ++#endif ++#endif ++#if defined(_MSC_VER) && defined(M_I86HM) && (UINT_MAX == LZO_0xffffL) ++# define ptrdiff_t long ++# define _PTRDIFF_T_DEFINED 1 ++#endif ++#if (UINT_MAX == LZO_0xffffL) ++# undef __LZO_RENAME_A ++# undef __LZO_RENAME_B ++# if defined(__AZTEC_C__) && defined(__DOS__) ++# define __LZO_RENAME_A 1 ++# elif defined(_MSC_VER) && defined(MSDOS) ++# if (_MSC_VER < 600) ++# define __LZO_RENAME_A 1 ++# elif (_MSC_VER < 700) ++# define __LZO_RENAME_B 1 ++# endif ++# elif defined(__TSC__) && defined(__OS2__) ++# define __LZO_RENAME_A 1 ++# elif defined(__MSDOS__) && defined(__TURBOC__) && (__TURBOC__ < 0x0410) ++# define __LZO_RENAME_A 1 ++# elif defined(__PACIFIC__) && defined(DOS) ++# if !defined(__far) ++# define __far far ++# endif ++# if !defined(__near) ++# define __near near ++# endif ++# endif ++# if defined(__LZO_RENAME_A) ++# if !defined(__cdecl) ++# define __cdecl cdecl ++# endif ++# if !defined(__far) ++# define __far far ++# endif ++# if !defined(__huge) ++# define __huge huge ++# endif ++# if !defined(__near) ++# define __near near ++# endif ++# if !defined(__pascal) ++# define __pascal pascal ++# endif ++# if !defined(__huge) ++# define __huge huge ++# endif ++# elif defined(__LZO_RENAME_B) ++# if !defined(__cdecl) ++# define __cdecl _cdecl ++# endif ++# if !defined(__far) ++# define __far _far ++# endif ++# if !defined(__huge) ++# define __huge _huge ++# endif ++# if !defined(__near) ++# define __near _near ++# endif ++# if !defined(__pascal) ++# define __pascal _pascal ++# endif ++# elif (defined(__PUREC__) || defined(__TURBOC__)) && defined(__TOS__) ++# if !defined(__cdecl) ++# define __cdecl cdecl ++# endif ++# if !defined(__pascal) ++# define __pascal pascal ++# endif ++# endif ++# undef __LZO_RENAME_A ++# undef __LZO_RENAME_B ++#endif ++#if (UINT_MAX == LZO_0xffffL) ++#if defined(__AZTEC_C__) && defined(__DOS__) ++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1 ++#elif defined(_MSC_VER) && defined(MSDOS) ++# if (_MSC_VER < 600) ++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1 ++# endif ++# if (_MSC_VER < 700) ++# define LZO_BROKEN_INTEGRAL_PROMOTION 1 ++# define LZO_BROKEN_SIZEOF 1 ++# endif ++#elif defined(__PACIFIC__) && defined(DOS) ++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1 ++#elif defined(__TURBOC__) && defined(__MSDOS__) ++# if (__TURBOC__ < 0x0150) ++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1 ++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1 ++# define LZO_BROKEN_INTEGRAL_PROMOTION 1 ++# endif ++# if (__TURBOC__ < 0x0200) ++# define LZO_BROKEN_SIZEOF 1 ++# endif ++# if (__TURBOC__ < 0x0400) && defined(__cplusplus) ++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1 ++# endif ++#elif (defined(__PUREC__) || defined(__TURBOC__)) && defined(__TOS__) ++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1 ++# define LZO_BROKEN_SIZEOF 1 ++#endif ++#endif ++#if defined(__WATCOMC__) && (__WATCOMC__ < 900) ++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1 ++#endif ++#if defined(_CRAY) && defined(_CRAY1) ++# define LZO_BROKEN_SIGNED_RIGHT_SHIFT 1 ++#endif ++#define LZO_PP_STRINGIZE(x) #x ++#define LZO_PP_MACRO_EXPAND(x) LZO_PP_STRINGIZE(x) ++#define LZO_PP_CONCAT2(a,b) a ## b ++#define LZO_PP_CONCAT3(a,b,c) a ## b ## c ++#define LZO_PP_CONCAT4(a,b,c,d) a ## b ## c ## d ++#define LZO_PP_CONCAT5(a,b,c,d,e) a ## b ## c ## d ## e ++#define LZO_PP_ECONCAT2(a,b) LZO_PP_CONCAT2(a,b) ++#define LZO_PP_ECONCAT3(a,b,c) LZO_PP_CONCAT3(a,b,c) ++#define LZO_PP_ECONCAT4(a,b,c,d) LZO_PP_CONCAT4(a,b,c,d) ++#define LZO_PP_ECONCAT5(a,b,c,d,e) LZO_PP_CONCAT5(a,b,c,d,e) ++#if 1 ++#define LZO_CPP_STRINGIZE(x) #x ++#define LZO_CPP_MACRO_EXPAND(x) LZO_CPP_STRINGIZE(x) ++#define LZO_CPP_CONCAT2(a,b) a ## b ++#define LZO_CPP_CONCAT3(a,b,c) a ## b ## c ++#define LZO_CPP_CONCAT4(a,b,c,d) a ## b ## c ## d ++#define LZO_CPP_CONCAT5(a,b,c,d,e) a ## b ## c ## d ## e ++#define LZO_CPP_ECONCAT2(a,b) LZO_CPP_CONCAT2(a,b) ++#define LZO_CPP_ECONCAT3(a,b,c) LZO_CPP_CONCAT3(a,b,c) ++#define LZO_CPP_ECONCAT4(a,b,c,d) LZO_CPP_CONCAT4(a,b,c,d) ++#define LZO_CPP_ECONCAT5(a,b,c,d,e) LZO_CPP_CONCAT5(a,b,c,d,e) ++#endif ++#define __LZO_MASK_GEN(o,b) (((((o) << ((b)-1)) - (o)) << 1) + (o)) ++#if 1 && defined(__cplusplus) ++# if !defined(__STDC_CONSTANT_MACROS) ++# define __STDC_CONSTANT_MACROS 1 ++# endif ++# if !defined(__STDC_LIMIT_MACROS) ++# define __STDC_LIMIT_MACROS 1 ++# endif ++#endif ++#if defined(__cplusplus) ++# define LZO_EXTERN_C extern "C" ++#else ++# define LZO_EXTERN_C extern ++#endif ++#if !defined(__LZO_OS_OVERRIDE) ++#if (LZO_OS_FREESTANDING) ++# define LZO_INFO_OS "freestanding" ++#elif (LZO_OS_EMBEDDED) ++# define LZO_INFO_OS "embedded" ++#elif 1 && defined(__IAR_SYSTEMS_ICC__) ++# define LZO_OS_EMBEDDED 1 ++# define LZO_INFO_OS "embedded" ++#elif defined(__CYGWIN__) && defined(__GNUC__) ++# define LZO_OS_CYGWIN 1 ++# define LZO_INFO_OS "cygwin" ++#elif defined(__EMX__) && defined(__GNUC__) ++# define LZO_OS_EMX 1 ++# define LZO_INFO_OS "emx" ++#elif defined(__BEOS__) ++# define LZO_OS_BEOS 1 ++# define LZO_INFO_OS "beos" ++#elif defined(__Lynx__) ++# define LZO_OS_LYNXOS 1 ++# define LZO_INFO_OS "lynxos" ++#elif defined(__OS400__) ++# define LZO_OS_OS400 1 ++# define LZO_INFO_OS "os400" ++#elif defined(__QNX__) ++# define LZO_OS_QNX 1 ++# define LZO_INFO_OS "qnx" ++#elif defined(__BORLANDC__) && defined(__DPMI32__) && (__BORLANDC__ >= 0x0460) ++# define LZO_OS_DOS32 1 ++# define LZO_INFO_OS "dos32" ++#elif defined(__BORLANDC__) && defined(__DPMI16__) ++# define LZO_OS_DOS16 1 ++# define LZO_INFO_OS "dos16" ++#elif defined(__ZTC__) && defined(DOS386) ++# define LZO_OS_DOS32 1 ++# define LZO_INFO_OS "dos32" ++#elif defined(__OS2__) || defined(__OS2V2__) ++# if (UINT_MAX == LZO_0xffffL) ++# define LZO_OS_OS216 1 ++# define LZO_INFO_OS "os216" ++# elif (UINT_MAX == LZO_0xffffffffL) ++# define LZO_OS_OS2 1 ++# define LZO_INFO_OS "os2" ++# else ++# error "check your limits.h header" ++# endif ++#elif defined(__WIN64__) || defined(_WIN64) || defined(WIN64) ++# define LZO_OS_WIN64 1 ++# define LZO_INFO_OS "win64" ++#elif defined(__WIN32__) || defined(_WIN32) || defined(WIN32) || defined(__WINDOWS_386__) ++# define LZO_OS_WIN32 1 ++# define LZO_INFO_OS "win32" ++#elif defined(__MWERKS__) && defined(__INTEL__) ++# define LZO_OS_WIN32 1 ++# define LZO_INFO_OS "win32" ++#elif defined(__WINDOWS__) || defined(_WINDOWS) || defined(_Windows) ++# if (UINT_MAX == LZO_0xffffL) ++# define LZO_OS_WIN16 1 ++# define LZO_INFO_OS "win16" ++# elif (UINT_MAX == LZO_0xffffffffL) ++# define LZO_OS_WIN32 1 ++# define LZO_INFO_OS "win32" ++# else ++# error "check your limits.h header" ++# endif ++#elif defined(__DOS__) || defined(__MSDOS__) || defined(_MSDOS) || defined(MSDOS) || (defined(__PACIFIC__) && defined(DOS)) ++# if (UINT_MAX == LZO_0xffffL) ++# define LZO_OS_DOS16 1 ++# define LZO_INFO_OS "dos16" ++# elif (UINT_MAX == LZO_0xffffffffL) ++# define LZO_OS_DOS32 1 ++# define LZO_INFO_OS "dos32" ++# else ++# error "check your limits.h header" ++# endif ++#elif defined(__WATCOMC__) ++# if defined(__NT__) && (UINT_MAX == LZO_0xffffL) ++# define LZO_OS_DOS16 1 ++# define LZO_INFO_OS "dos16" ++# elif defined(__NT__) && (__WATCOMC__ < 1100) ++# define LZO_OS_WIN32 1 ++# define LZO_INFO_OS "win32" ++# elif defined(__linux__) || defined(__LINUX__) ++# define LZO_OS_POSIX 1 ++# define LZO_INFO_OS "posix" ++# else ++# error "please specify a target using the -bt compiler option" ++# endif ++#elif defined(__palmos__) ++# define LZO_OS_PALMOS 1 ++# define LZO_INFO_OS "palmos" ++#elif defined(__TOS__) || defined(__atarist__) ++# define LZO_OS_TOS 1 ++# define LZO_INFO_OS "tos" ++#elif defined(macintosh) && !defined(__ppc__) ++# define LZO_OS_MACCLASSIC 1 ++# define LZO_INFO_OS "macclassic" ++#elif defined(__VMS) ++# define LZO_OS_VMS 1 ++# define LZO_INFO_OS "vms" ++#elif ((defined(__mips__) && defined(__R5900__)) || defined(__MIPS_PSX2__)) ++# define LZO_OS_CONSOLE 1 ++# define LZO_OS_CONSOLE_PS2 1 ++# define LZO_INFO_OS "console" ++# define LZO_INFO_OS_CONSOLE "ps2" ++#elif (defined(__mips__) && defined(__psp__)) ++# define LZO_OS_CONSOLE 1 ++# define LZO_OS_CONSOLE_PSP 1 ++# define LZO_INFO_OS "console" ++# define LZO_INFO_OS_CONSOLE "psp" ++#else ++# define LZO_OS_POSIX 1 ++# define LZO_INFO_OS "posix" ++#endif ++#if (LZO_OS_POSIX) ++# if defined(_AIX) || defined(__AIX__) || defined(__aix__) ++# define LZO_OS_POSIX_AIX 1 ++# define LZO_INFO_OS_POSIX "aix" ++# elif defined(__FreeBSD__) ++# define LZO_OS_POSIX_FREEBSD 1 ++# define LZO_INFO_OS_POSIX "freebsd" ++# elif defined(__hpux__) || defined(__hpux) ++# define LZO_OS_POSIX_HPUX 1 ++# define LZO_INFO_OS_POSIX "hpux" ++# elif defined(__INTERIX) ++# define LZO_OS_POSIX_INTERIX 1 ++# define LZO_INFO_OS_POSIX "interix" ++# elif defined(__IRIX__) || defined(__irix__) ++# define LZO_OS_POSIX_IRIX 1 ++# define LZO_INFO_OS_POSIX "irix" ++# elif defined(__linux__) || defined(__linux) || defined(__LINUX__) ++# define LZO_OS_POSIX_LINUX 1 ++# define LZO_INFO_OS_POSIX "linux" ++# elif defined(__APPLE__) || defined(__MACOS__) ++# define LZO_OS_POSIX_MACOSX 1 ++# define LZO_INFO_OS_POSIX "macosx" ++# elif defined(__minix__) || defined(__minix) ++# define LZO_OS_POSIX_MINIX 1 ++# define LZO_INFO_OS_POSIX "minix" ++# elif defined(__NetBSD__) ++# define LZO_OS_POSIX_NETBSD 1 ++# define LZO_INFO_OS_POSIX "netbsd" ++# elif defined(__OpenBSD__) ++# define LZO_OS_POSIX_OPENBSD 1 ++# define LZO_INFO_OS_POSIX "openbsd" ++# elif defined(__osf__) ++# define LZO_OS_POSIX_OSF 1 ++# define LZO_INFO_OS_POSIX "osf" ++# elif defined(__solaris__) || defined(__sun) ++# if defined(__SVR4) || defined(__svr4__) ++# define LZO_OS_POSIX_SOLARIS 1 ++# define LZO_INFO_OS_POSIX "solaris" ++# else ++# define LZO_OS_POSIX_SUNOS 1 ++# define LZO_INFO_OS_POSIX "sunos" ++# endif ++# elif defined(__ultrix__) || defined(__ultrix) ++# define LZO_OS_POSIX_ULTRIX 1 ++# define LZO_INFO_OS_POSIX "ultrix" ++# elif defined(_UNICOS) ++# define LZO_OS_POSIX_UNICOS 1 ++# define LZO_INFO_OS_POSIX "unicos" ++# else ++# define LZO_OS_POSIX_UNKNOWN 1 ++# define LZO_INFO_OS_POSIX "unknown" ++# endif ++#endif ++#endif ++#if (LZO_OS_DOS16 || LZO_OS_OS216 || LZO_OS_WIN16) ++# if (UINT_MAX != LZO_0xffffL) ++# error "this should not happen" ++# endif ++# if (ULONG_MAX != LZO_0xffffffffL) ++# error "this should not happen" ++# endif ++#endif ++#if (LZO_OS_DOS32 || LZO_OS_OS2 || LZO_OS_WIN32 || LZO_OS_WIN64) ++# if (UINT_MAX != LZO_0xffffffffL) ++# error "this should not happen" ++# endif ++# if (ULONG_MAX != LZO_0xffffffffL) ++# error "this should not happen" ++# endif ++#endif ++#if defined(CIL) && defined(_GNUCC) && defined(__GNUC__) ++# define LZO_CC_CILLY 1 ++# define LZO_INFO_CC "Cilly" ++# if defined(__CILLY__) ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__CILLY__) ++# else ++# define LZO_INFO_CCVER "unknown" ++# endif ++#elif 0 && defined(SDCC) && defined(__VERSION__) && !defined(__GNUC__) ++# define LZO_CC_SDCC 1 ++# define LZO_INFO_CC "sdcc" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(SDCC) ++#elif defined(__PATHSCALE__) && defined(__PATHCC_PATCHLEVEL__) ++# define LZO_CC_PATHSCALE (__PATHCC__ * 0x10000L + __PATHCC_MINOR__ * 0x100 + __PATHCC_PATCHLEVEL__) ++# define LZO_INFO_CC "Pathscale C" ++# define LZO_INFO_CCVER __PATHSCALE__ ++#elif defined(__INTEL_COMPILER) ++# define LZO_CC_INTELC 1 ++# define LZO_INFO_CC "Intel C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__INTEL_COMPILER) ++# if defined(_WIN32) || defined(_WIN64) ++# define LZO_CC_SYNTAX_MSC 1 ++# else ++# define LZO_CC_SYNTAX_GNUC 1 ++# endif ++#elif defined(__POCC__) && defined(_WIN32) ++# define LZO_CC_PELLESC 1 ++# define LZO_INFO_CC "Pelles C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__POCC__) ++#elif defined(__clang__) && defined(__llvm__) && defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__VERSION__) ++# if defined(__GNUC_PATCHLEVEL__) ++# define LZO_CC_CLANG_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__) ++# else ++# define LZO_CC_CLANG_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100) ++# endif ++# if defined(__clang_major__) && defined(__clang_minor__) && defined(__clang_patchlevel__) ++# define LZO_CC_CLANG_CLANG (__clang_major__ * 0x10000L + __clang_minor__ * 0x100 + __clang_patchlevel__) ++# else ++# define LZO_CC_CLANG_CLANG 0x010000L ++# endif ++# define LZO_CC_CLANG LZO_CC_CLANG_GNUC ++# define LZO_INFO_CC "clang" ++# define LZO_INFO_CCVER __VERSION__ ++#elif defined(__llvm__) && defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__VERSION__) ++# if defined(__GNUC_PATCHLEVEL__) ++# define LZO_CC_LLVM_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__) ++# else ++# define LZO_CC_LLVM_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100) ++# endif ++# define LZO_CC_LLVM LZO_CC_LLVM_GNUC ++# define LZO_INFO_CC "llvm-gcc" ++# define LZO_INFO_CCVER __VERSION__ ++#elif defined(__GNUC__) && defined(__VERSION__) ++# if defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) ++# define LZO_CC_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__) ++# elif defined(__GNUC_MINOR__) ++# define LZO_CC_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100) ++# else ++# define LZO_CC_GNUC (__GNUC__ * 0x10000L) ++# endif ++# define LZO_INFO_CC "gcc" ++# define LZO_INFO_CCVER __VERSION__ ++#elif defined(__ACK__) && defined(_ACK) ++# define LZO_CC_ACK 1 ++# define LZO_INFO_CC "Amsterdam Compiler Kit C" ++# define LZO_INFO_CCVER "unknown" ++#elif defined(__AZTEC_C__) ++# define LZO_CC_AZTECC 1 ++# define LZO_INFO_CC "Aztec C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__AZTEC_C__) ++#elif defined(__CODEGEARC__) ++# define LZO_CC_CODEGEARC 1 ++# define LZO_INFO_CC "CodeGear C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__CODEGEARC__) ++#elif defined(__BORLANDC__) ++# define LZO_CC_BORLANDC 1 ++# define LZO_INFO_CC "Borland C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__BORLANDC__) ++#elif defined(_CRAYC) && defined(_RELEASE) ++# define LZO_CC_CRAYC 1 ++# define LZO_INFO_CC "Cray C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(_RELEASE) ++#elif defined(__DMC__) && defined(__SC__) ++# define LZO_CC_DMC 1 ++# define LZO_INFO_CC "Digital Mars C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__DMC__) ++#elif defined(__DECC) ++# define LZO_CC_DECC 1 ++# define LZO_INFO_CC "DEC C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__DECC) ++#elif defined(__HIGHC__) ++# define LZO_CC_HIGHC 1 ++# define LZO_INFO_CC "MetaWare High C" ++# define LZO_INFO_CCVER "unknown" ++#elif defined(__IAR_SYSTEMS_ICC__) ++# define LZO_CC_IARC 1 ++# define LZO_INFO_CC "IAR C" ++# if defined(__VER__) ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__VER__) ++# else ++# define LZO_INFO_CCVER "unknown" ++# endif ++#elif defined(__IBMC__) ++# define LZO_CC_IBMC 1 ++# define LZO_INFO_CC "IBM C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__IBMC__) ++#elif defined(__KEIL__) && defined(__C166__) ++# define LZO_CC_KEILC 1 ++# define LZO_INFO_CC "Keil C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__C166__) ++#elif defined(__LCC__) && defined(_WIN32) && defined(__LCCOPTIMLEVEL) ++# define LZO_CC_LCCWIN32 1 ++# define LZO_INFO_CC "lcc-win32" ++# define LZO_INFO_CCVER "unknown" ++#elif defined(__LCC__) ++# define LZO_CC_LCC 1 ++# define LZO_INFO_CC "lcc" ++# if defined(__LCC_VERSION__) ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__LCC_VERSION__) ++# else ++# define LZO_INFO_CCVER "unknown" ++# endif ++#elif defined(_MSC_VER) ++# define LZO_CC_MSC 1 ++# define LZO_INFO_CC "Microsoft C" ++# if defined(_MSC_FULL_VER) ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(_MSC_VER) "." LZO_PP_MACRO_EXPAND(_MSC_FULL_VER) ++# else ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(_MSC_VER) ++# endif ++#elif defined(__MWERKS__) ++# define LZO_CC_MWERKS 1 ++# define LZO_INFO_CC "Metrowerks C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__MWERKS__) ++#elif (defined(__NDPC__) || defined(__NDPX__)) && defined(__i386) ++# define LZO_CC_NDPC 1 ++# define LZO_INFO_CC "Microway NDP C" ++# define LZO_INFO_CCVER "unknown" ++#elif defined(__PACIFIC__) ++# define LZO_CC_PACIFICC 1 ++# define LZO_INFO_CC "Pacific C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__PACIFIC__) ++#elif defined(__PGI) && (defined(__linux__) || defined(__WIN32__)) ++# define LZO_CC_PGI 1 ++# define LZO_INFO_CC "Portland Group PGI C" ++# define LZO_INFO_CCVER "unknown" ++#elif defined(__PUREC__) && defined(__TOS__) ++# define LZO_CC_PUREC 1 ++# define LZO_INFO_CC "Pure C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__PUREC__) ++#elif defined(__SC__) && defined(__ZTC__) ++# define LZO_CC_SYMANTECC 1 ++# define LZO_INFO_CC "Symantec C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__SC__) ++#elif defined(__SUNPRO_C) ++# define LZO_INFO_CC "SunPro C" ++# if ((__SUNPRO_C)+0 > 0) ++# define LZO_CC_SUNPROC __SUNPRO_C ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__SUNPRO_C) ++# else ++# define LZO_CC_SUNPROC 1 ++# define LZO_INFO_CCVER "unknown" ++# endif ++#elif defined(__SUNPRO_CC) ++# define LZO_INFO_CC "SunPro C" ++# if ((__SUNPRO_CC)+0 > 0) ++# define LZO_CC_SUNPROC __SUNPRO_CC ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__SUNPRO_CC) ++# else ++# define LZO_CC_SUNPROC 1 ++# define LZO_INFO_CCVER "unknown" ++# endif ++#elif defined(__TINYC__) ++# define LZO_CC_TINYC 1 ++# define LZO_INFO_CC "Tiny C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__TINYC__) ++#elif defined(__TSC__) ++# define LZO_CC_TOPSPEEDC 1 ++# define LZO_INFO_CC "TopSpeed C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__TSC__) ++#elif defined(__WATCOMC__) ++# define LZO_CC_WATCOMC 1 ++# define LZO_INFO_CC "Watcom C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__WATCOMC__) ++#elif defined(__TURBOC__) ++# define LZO_CC_TURBOC 1 ++# define LZO_INFO_CC "Turbo C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__TURBOC__) ++#elif defined(__ZTC__) ++# define LZO_CC_ZORTECHC 1 ++# define LZO_INFO_CC "Zortech C" ++# if (__ZTC__ == 0x310) ++# define LZO_INFO_CCVER "0x310" ++# else ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__ZTC__) ++# endif ++#else ++# define LZO_CC_UNKNOWN 1 ++# define LZO_INFO_CC "unknown" ++# define LZO_INFO_CCVER "unknown" ++#endif ++#if 0 && (LZO_CC_MSC && (_MSC_VER >= 1200)) && !defined(_MSC_FULL_VER) ++# error "LZO_CC_MSC: _MSC_FULL_VER is not defined" ++#endif ++#if !defined(__LZO_ARCH_OVERRIDE) && !(LZO_ARCH_GENERIC) && defined(_CRAY) ++# if (UINT_MAX > LZO_0xffffffffL) && defined(_CRAY) ++# if defined(_CRAYMPP) || defined(_CRAYT3D) || defined(_CRAYT3E) ++# define LZO_ARCH_CRAY_MPP 1 ++# elif defined(_CRAY1) ++# define LZO_ARCH_CRAY_PVP 1 ++# endif ++# endif ++#endif ++#if !defined(__LZO_ARCH_OVERRIDE) ++#if (LZO_ARCH_GENERIC) ++# define LZO_INFO_ARCH "generic" ++#elif (LZO_OS_DOS16 || LZO_OS_OS216 || LZO_OS_WIN16) ++# define LZO_ARCH_I086 1 ++# define LZO_ARCH_IA16 1 ++# define LZO_INFO_ARCH "i086" ++#elif defined(__alpha__) || defined(__alpha) || defined(_M_ALPHA) ++# define LZO_ARCH_ALPHA 1 ++# define LZO_INFO_ARCH "alpha" ++#elif (LZO_ARCH_CRAY_MPP) && (defined(_CRAYT3D) || defined(_CRAYT3E)) ++# define LZO_ARCH_ALPHA 1 ++# define LZO_INFO_ARCH "alpha" ++#elif defined(__amd64__) || defined(__x86_64__) || defined(_M_AMD64) ++# define LZO_ARCH_AMD64 1 ++# define LZO_INFO_ARCH "amd64" ++#elif defined(__thumb__) || (defined(_M_ARM) && defined(_M_THUMB)) ++# define LZO_ARCH_ARM 1 ++# define LZO_ARCH_ARM_THUMB 1 ++# define LZO_INFO_ARCH "arm_thumb" ++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICCARM__) ++# define LZO_ARCH_ARM 1 ++# if defined(__CPU_MODE__) && ((__CPU_MODE__)+0 == 1) ++# define LZO_ARCH_ARM_THUMB 1 ++# define LZO_INFO_ARCH "arm_thumb" ++# elif defined(__CPU_MODE__) && ((__CPU_MODE__)+0 == 2) ++# define LZO_INFO_ARCH "arm" ++# else ++# define LZO_INFO_ARCH "arm" ++# endif ++#elif defined(__arm__) || defined(_M_ARM) ++# define LZO_ARCH_ARM 1 ++# define LZO_INFO_ARCH "arm" ++#elif (UINT_MAX <= LZO_0xffffL) && defined(__AVR__) ++# define LZO_ARCH_AVR 1 ++# define LZO_INFO_ARCH "avr" ++#elif defined(__avr32__) || defined(__AVR32__) ++# define LZO_ARCH_AVR32 1 ++# define LZO_INFO_ARCH "avr32" ++#elif defined(__bfin__) ++# define LZO_ARCH_BLACKFIN 1 ++# define LZO_INFO_ARCH "blackfin" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__C166__) ++# define LZO_ARCH_C166 1 ++# define LZO_INFO_ARCH "c166" ++#elif defined(__cris__) ++# define LZO_ARCH_CRIS 1 ++# define LZO_INFO_ARCH "cris" ++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICCEZ80__) ++# define LZO_ARCH_EZ80 1 ++# define LZO_INFO_ARCH "ez80" ++#elif defined(__H8300__) || defined(__H8300H__) || defined(__H8300S__) || defined(__H8300SX__) ++# define LZO_ARCH_H8300 1 ++# define LZO_INFO_ARCH "h8300" ++#elif defined(__hppa__) || defined(__hppa) ++# define LZO_ARCH_HPPA 1 ++# define LZO_INFO_ARCH "hppa" ++#elif defined(__386__) || defined(__i386__) || defined(__i386) || defined(_M_IX86) || defined(_M_I386) ++# define LZO_ARCH_I386 1 ++# define LZO_ARCH_IA32 1 ++# define LZO_INFO_ARCH "i386" ++#elif (LZO_CC_ZORTECHC && defined(__I86__)) ++# define LZO_ARCH_I386 1 ++# define LZO_ARCH_IA32 1 ++# define LZO_INFO_ARCH "i386" ++#elif (LZO_OS_DOS32 && LZO_CC_HIGHC) && defined(_I386) ++# define LZO_ARCH_I386 1 ++# define LZO_ARCH_IA32 1 ++# define LZO_INFO_ARCH "i386" ++#elif defined(__ia64__) || defined(__ia64) || defined(_M_IA64) ++# define LZO_ARCH_IA64 1 ++# define LZO_INFO_ARCH "ia64" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__m32c__) ++# define LZO_ARCH_M16C 1 ++# define LZO_INFO_ARCH "m16c" ++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICCM16C__) ++# define LZO_ARCH_M16C 1 ++# define LZO_INFO_ARCH "m16c" ++#elif defined(__m32r__) ++# define LZO_ARCH_M32R 1 ++# define LZO_INFO_ARCH "m32r" ++#elif (LZO_OS_TOS) || defined(__m68k__) || defined(__m68000__) || defined(__mc68000__) || defined(__mc68020__) || defined(_M_M68K) ++# define LZO_ARCH_M68K 1 ++# define LZO_INFO_ARCH "m68k" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__C251__) ++# define LZO_ARCH_MCS251 1 ++# define LZO_INFO_ARCH "mcs251" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__C51__) ++# define LZO_ARCH_MCS51 1 ++# define LZO_INFO_ARCH "mcs51" ++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICC8051__) ++# define LZO_ARCH_MCS51 1 ++# define LZO_INFO_ARCH "mcs51" ++#elif defined(__mips__) || defined(__mips) || defined(_MIPS_ARCH) || defined(_M_MRX000) ++# define LZO_ARCH_MIPS 1 ++# define LZO_INFO_ARCH "mips" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__MSP430__) ++# define LZO_ARCH_MSP430 1 ++# define LZO_INFO_ARCH "msp430" ++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICC430__) ++# define LZO_ARCH_MSP430 1 ++# define LZO_INFO_ARCH "msp430" ++#elif defined(__powerpc__) || defined(__powerpc) || defined(__ppc__) || defined(__PPC__) || defined(_M_PPC) || defined(_ARCH_PPC) || defined(_ARCH_PWR) ++# define LZO_ARCH_POWERPC 1 ++# define LZO_INFO_ARCH "powerpc" ++#elif defined(__s390__) || defined(__s390) || defined(__s390x__) || defined(__s390x) ++# define LZO_ARCH_S390 1 ++# define LZO_INFO_ARCH "s390" ++#elif defined(__sh__) || defined(_M_SH) ++# define LZO_ARCH_SH 1 ++# define LZO_INFO_ARCH "sh" ++#elif defined(__sparc__) || defined(__sparc) || defined(__sparcv8) ++# define LZO_ARCH_SPARC 1 ++# define LZO_INFO_ARCH "sparc" ++#elif defined(__SPU__) ++# define LZO_ARCH_SPU 1 ++# define LZO_INFO_ARCH "spu" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__z80) ++# define LZO_ARCH_Z80 1 ++# define LZO_INFO_ARCH "z80" ++#elif (LZO_ARCH_CRAY_PVP) ++# if defined(_CRAYSV1) ++# define LZO_ARCH_CRAY_SV1 1 ++# define LZO_INFO_ARCH "cray_sv1" ++# elif (_ADDR64) ++# define LZO_ARCH_CRAY_T90 1 ++# define LZO_INFO_ARCH "cray_t90" ++# elif (_ADDR32) ++# define LZO_ARCH_CRAY_YMP 1 ++# define LZO_INFO_ARCH "cray_ymp" ++# else ++# define LZO_ARCH_CRAY_XMP 1 ++# define LZO_INFO_ARCH "cray_xmp" ++# endif ++#else ++# define LZO_ARCH_UNKNOWN 1 ++# define LZO_INFO_ARCH "unknown" ++#endif ++#endif ++#if 1 && (LZO_ARCH_UNKNOWN) && (LZO_OS_DOS32 || LZO_OS_OS2) ++# error "FIXME - missing define for CPU architecture" ++#endif ++#if 1 && (LZO_ARCH_UNKNOWN) && (LZO_OS_WIN32) ++# error "FIXME - missing WIN32 define for CPU architecture" ++#endif ++#if 1 && (LZO_ARCH_UNKNOWN) && (LZO_OS_WIN64) ++# error "FIXME - missing WIN64 define for CPU architecture" ++#endif ++#if (LZO_OS_OS216 || LZO_OS_WIN16) ++# define LZO_ARCH_I086PM 1 ++# define LZO_ARCH_IA16PM 1 ++#elif 1 && (LZO_OS_DOS16 && defined(BLX286)) ++# define LZO_ARCH_I086PM 1 ++# define LZO_ARCH_IA16PM 1 ++#elif 1 && (LZO_OS_DOS16 && defined(DOSX286)) ++# define LZO_ARCH_I086PM 1 ++# define LZO_ARCH_IA16PM 1 ++#elif 1 && (LZO_OS_DOS16 && LZO_CC_BORLANDC && defined(__DPMI16__)) ++# define LZO_ARCH_I086PM 1 ++# define LZO_ARCH_IA16PM 1 ++#endif ++#if (LZO_ARCH_ARM_THUMB) && !(LZO_ARCH_ARM) ++# error "this should not happen" ++#endif ++#if (LZO_ARCH_I086PM) && !(LZO_ARCH_I086) ++# error "this should not happen" ++#endif ++#if (LZO_ARCH_I086) ++# if (UINT_MAX != LZO_0xffffL) ++# error "this should not happen" ++# endif ++# if (ULONG_MAX != LZO_0xffffffffL) ++# error "this should not happen" ++# endif ++#endif ++#if (LZO_ARCH_I386) ++# if (UINT_MAX != LZO_0xffffL) && defined(__i386_int16__) ++# error "this should not happen" ++# endif ++# if (UINT_MAX != LZO_0xffffffffL) && !defined(__i386_int16__) ++# error "this should not happen" ++# endif ++# if (ULONG_MAX != LZO_0xffffffffL) ++# error "this should not happen" ++# endif ++#endif ++#if !defined(__LZO_MM_OVERRIDE) ++#if (LZO_ARCH_I086) ++#if (UINT_MAX != LZO_0xffffL) ++# error "this should not happen" ++#endif ++#if defined(__TINY__) || defined(M_I86TM) || defined(_M_I86TM) ++# define LZO_MM_TINY 1 ++#elif defined(__HUGE__) || defined(_HUGE_) || defined(M_I86HM) || defined(_M_I86HM) ++# define LZO_MM_HUGE 1 ++#elif defined(__SMALL__) || defined(M_I86SM) || defined(_M_I86SM) || defined(SMALL_MODEL) ++# define LZO_MM_SMALL 1 ++#elif defined(__MEDIUM__) || defined(M_I86MM) || defined(_M_I86MM) ++# define LZO_MM_MEDIUM 1 ++#elif defined(__COMPACT__) || defined(M_I86CM) || defined(_M_I86CM) ++# define LZO_MM_COMPACT 1 ++#elif defined(__LARGE__) || defined(M_I86LM) || defined(_M_I86LM) || defined(LARGE_MODEL) ++# define LZO_MM_LARGE 1 ++#elif (LZO_CC_AZTECC) ++# if defined(_LARGE_CODE) && defined(_LARGE_DATA) ++# define LZO_MM_LARGE 1 ++# elif defined(_LARGE_CODE) ++# define LZO_MM_MEDIUM 1 ++# elif defined(_LARGE_DATA) ++# define LZO_MM_COMPACT 1 ++# else ++# define LZO_MM_SMALL 1 ++# endif ++#elif (LZO_CC_ZORTECHC && defined(__VCM__)) ++# define LZO_MM_LARGE 1 ++#else ++# error "unknown memory model" ++#endif ++#if (LZO_OS_DOS16 || LZO_OS_OS216 || LZO_OS_WIN16) ++#define LZO_HAVE_MM_HUGE_PTR 1 ++#define LZO_HAVE_MM_HUGE_ARRAY 1 ++#if (LZO_MM_TINY) ++# undef LZO_HAVE_MM_HUGE_ARRAY ++#endif ++#if (LZO_CC_AZTECC || LZO_CC_PACIFICC || LZO_CC_ZORTECHC) ++# undef LZO_HAVE_MM_HUGE_PTR ++# undef LZO_HAVE_MM_HUGE_ARRAY ++#elif (LZO_CC_DMC || LZO_CC_SYMANTECC) ++# undef LZO_HAVE_MM_HUGE_ARRAY ++#elif (LZO_CC_MSC && defined(_QC)) ++# undef LZO_HAVE_MM_HUGE_ARRAY ++# if (_MSC_VER < 600) ++# undef LZO_HAVE_MM_HUGE_PTR ++# endif ++#elif (LZO_CC_TURBOC && (__TURBOC__ < 0x0295)) ++# undef LZO_HAVE_MM_HUGE_ARRAY ++#endif ++#if (LZO_ARCH_I086PM) && !(LZO_HAVE_MM_HUGE_PTR) ++# if (LZO_OS_DOS16) ++# error "this should not happen" ++# elif (LZO_CC_ZORTECHC) ++# else ++# error "this should not happen" ++# endif ++#endif ++#ifdef __cplusplus ++extern "C" { ++#endif ++#if (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0200)) ++ extern void __near __cdecl _AHSHIFT(void); ++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT) ++#elif (LZO_CC_DMC || LZO_CC_SYMANTECC || LZO_CC_ZORTECHC) ++ extern void __near __cdecl _AHSHIFT(void); ++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT) ++#elif (LZO_CC_MSC || LZO_CC_TOPSPEEDC) ++ extern void __near __cdecl _AHSHIFT(void); ++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT) ++#elif (LZO_CC_TURBOC && (__TURBOC__ >= 0x0295)) ++ extern void __near __cdecl _AHSHIFT(void); ++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT) ++#elif ((LZO_CC_AZTECC || LZO_CC_PACIFICC || LZO_CC_TURBOC) && LZO_OS_DOS16) ++# define LZO_MM_AHSHIFT 12 ++#elif (LZO_CC_WATCOMC) ++ extern unsigned char _HShift; ++# define LZO_MM_AHSHIFT ((unsigned) _HShift) ++#else ++# error "FIXME - implement LZO_MM_AHSHIFT" ++#endif ++#ifdef __cplusplus ++} ++#endif ++#endif ++#elif (LZO_ARCH_C166) ++#if !defined(__MODEL__) ++# error "FIXME - C166 __MODEL__" ++#elif ((__MODEL__) == 0) ++# define LZO_MM_SMALL 1 ++#elif ((__MODEL__) == 1) ++# define LZO_MM_SMALL 1 ++#elif ((__MODEL__) == 2) ++# define LZO_MM_LARGE 1 ++#elif ((__MODEL__) == 3) ++# define LZO_MM_TINY 1 ++#elif ((__MODEL__) == 4) ++# define LZO_MM_XTINY 1 ++#elif ((__MODEL__) == 5) ++# define LZO_MM_XSMALL 1 ++#else ++# error "FIXME - C166 __MODEL__" ++#endif ++#elif (LZO_ARCH_MCS251) ++#if !defined(__MODEL__) ++# error "FIXME - MCS251 __MODEL__" ++#elif ((__MODEL__) == 0) ++# define LZO_MM_SMALL 1 ++#elif ((__MODEL__) == 2) ++# define LZO_MM_LARGE 1 ++#elif ((__MODEL__) == 3) ++# define LZO_MM_TINY 1 ++#elif ((__MODEL__) == 4) ++# define LZO_MM_XTINY 1 ++#elif ((__MODEL__) == 5) ++# define LZO_MM_XSMALL 1 ++#else ++# error "FIXME - MCS251 __MODEL__" ++#endif ++#elif (LZO_ARCH_MCS51) ++#if !defined(__MODEL__) ++# error "FIXME - MCS51 __MODEL__" ++#elif ((__MODEL__) == 1) ++# define LZO_MM_SMALL 1 ++#elif ((__MODEL__) == 2) ++# define LZO_MM_LARGE 1 ++#elif ((__MODEL__) == 3) ++# define LZO_MM_TINY 1 ++#elif ((__MODEL__) == 4) ++# define LZO_MM_XTINY 1 ++#elif ((__MODEL__) == 5) ++# define LZO_MM_XSMALL 1 ++#else ++# error "FIXME - MCS51 __MODEL__" ++#endif ++#elif (LZO_ARCH_CRAY_PVP) ++# define LZO_MM_PVP 1 ++#else ++# define LZO_MM_FLAT 1 ++#endif ++#if (LZO_MM_COMPACT) ++# define LZO_INFO_MM "compact" ++#elif (LZO_MM_FLAT) ++# define LZO_INFO_MM "flat" ++#elif (LZO_MM_HUGE) ++# define LZO_INFO_MM "huge" ++#elif (LZO_MM_LARGE) ++# define LZO_INFO_MM "large" ++#elif (LZO_MM_MEDIUM) ++# define LZO_INFO_MM "medium" ++#elif (LZO_MM_PVP) ++# define LZO_INFO_MM "pvp" ++#elif (LZO_MM_SMALL) ++# define LZO_INFO_MM "small" ++#elif (LZO_MM_TINY) ++# define LZO_INFO_MM "tiny" ++#else ++# error "unknown memory model" ++#endif ++#endif ++#if defined(SIZEOF_SHORT) ++# define LZO_SIZEOF_SHORT (SIZEOF_SHORT) ++#endif ++#if defined(SIZEOF_INT) ++# define LZO_SIZEOF_INT (SIZEOF_INT) ++#endif ++#if defined(SIZEOF_LONG) ++# define LZO_SIZEOF_LONG (SIZEOF_LONG) ++#endif ++#if defined(SIZEOF_LONG_LONG) ++# define LZO_SIZEOF_LONG_LONG (SIZEOF_LONG_LONG) ++#endif ++#if defined(SIZEOF___INT16) ++# define LZO_SIZEOF___INT16 (SIZEOF___INT16) ++#endif ++#if defined(SIZEOF___INT32) ++# define LZO_SIZEOF___INT32 (SIZEOF___INT32) ++#endif ++#if defined(SIZEOF___INT64) ++# define LZO_SIZEOF___INT64 (SIZEOF___INT64) ++#endif ++#if defined(SIZEOF_VOID_P) ++# define LZO_SIZEOF_VOID_P (SIZEOF_VOID_P) ++#endif ++#if defined(SIZEOF_SIZE_T) ++# define LZO_SIZEOF_SIZE_T (SIZEOF_SIZE_T) ++#endif ++#if defined(SIZEOF_PTRDIFF_T) ++# define LZO_SIZEOF_PTRDIFF_T (SIZEOF_PTRDIFF_T) ++#endif ++#define __LZO_LSR(x,b) (((x)+0ul) >> (b)) ++#if !defined(LZO_SIZEOF_SHORT) ++# if (LZO_ARCH_CRAY_PVP) ++# define LZO_SIZEOF_SHORT 8 ++# elif (USHRT_MAX == LZO_0xffffL) ++# define LZO_SIZEOF_SHORT 2 ++# elif (__LZO_LSR(USHRT_MAX,7) == 1) ++# define LZO_SIZEOF_SHORT 1 ++# elif (__LZO_LSR(USHRT_MAX,15) == 1) ++# define LZO_SIZEOF_SHORT 2 ++# elif (__LZO_LSR(USHRT_MAX,31) == 1) ++# define LZO_SIZEOF_SHORT 4 ++# elif (__LZO_LSR(USHRT_MAX,63) == 1) ++# define LZO_SIZEOF_SHORT 8 ++# elif (__LZO_LSR(USHRT_MAX,127) == 1) ++# define LZO_SIZEOF_SHORT 16 ++# else ++# error "LZO_SIZEOF_SHORT" ++# endif ++#endif ++#if !defined(LZO_SIZEOF_INT) ++# if (LZO_ARCH_CRAY_PVP) ++# define LZO_SIZEOF_INT 8 ++# elif (UINT_MAX == LZO_0xffffL) ++# define LZO_SIZEOF_INT 2 ++# elif (UINT_MAX == LZO_0xffffffffL) ++# define LZO_SIZEOF_INT 4 ++# elif (__LZO_LSR(UINT_MAX,7) == 1) ++# define LZO_SIZEOF_INT 1 ++# elif (__LZO_LSR(UINT_MAX,15) == 1) ++# define LZO_SIZEOF_INT 2 ++# elif (__LZO_LSR(UINT_MAX,31) == 1) ++# define LZO_SIZEOF_INT 4 ++# elif (__LZO_LSR(UINT_MAX,63) == 1) ++# define LZO_SIZEOF_INT 8 ++# elif (__LZO_LSR(UINT_MAX,127) == 1) ++# define LZO_SIZEOF_INT 16 ++# else ++# error "LZO_SIZEOF_INT" ++# endif ++#endif ++#if !defined(LZO_SIZEOF_LONG) ++# if (ULONG_MAX == LZO_0xffffffffL) ++# define LZO_SIZEOF_LONG 4 ++# elif (__LZO_LSR(ULONG_MAX,7) == 1) ++# define LZO_SIZEOF_LONG 1 ++# elif (__LZO_LSR(ULONG_MAX,15) == 1) ++# define LZO_SIZEOF_LONG 2 ++# elif (__LZO_LSR(ULONG_MAX,31) == 1) ++# define LZO_SIZEOF_LONG 4 ++# elif (__LZO_LSR(ULONG_MAX,63) == 1) ++# define LZO_SIZEOF_LONG 8 ++# elif (__LZO_LSR(ULONG_MAX,127) == 1) ++# define LZO_SIZEOF_LONG 16 ++# else ++# error "LZO_SIZEOF_LONG" ++# endif ++#endif ++#if !defined(LZO_SIZEOF_LONG_LONG) && !defined(LZO_SIZEOF___INT64) ++#if (LZO_SIZEOF_LONG > 0 && LZO_SIZEOF_LONG < 8) ++# if defined(__LONG_MAX__) && defined(__LONG_LONG_MAX__) ++# if (LZO_CC_GNUC >= 0x030300ul) ++# if ((__LONG_MAX__)+0 == (__LONG_LONG_MAX__)+0) ++# define LZO_SIZEOF_LONG_LONG LZO_SIZEOF_LONG ++# elif (__LZO_LSR(__LONG_LONG_MAX__,30) == 1) ++# define LZO_SIZEOF_LONG_LONG 4 ++# endif ++# endif ++# endif ++#endif ++#endif ++#if !defined(LZO_SIZEOF_LONG_LONG) && !defined(LZO_SIZEOF___INT64) ++#if (LZO_SIZEOF_LONG > 0 && LZO_SIZEOF_LONG < 8) ++#if (LZO_ARCH_I086 && LZO_CC_DMC) ++#elif (LZO_CC_CILLY) && defined(__GNUC__) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif ((LZO_OS_WIN32 || LZO_OS_WIN64 || defined(_WIN32)) && LZO_CC_MSC && (_MSC_VER >= 1400)) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_OS_WIN64 || defined(_WIN64)) ++# define LZO_SIZEOF___INT64 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_DMC)) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_SYMANTECC && (__SC__ >= 0x700))) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_INTELC && defined(__linux__))) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_MWERKS || LZO_CC_PELLESC || LZO_CC_PGI || LZO_CC_SUNPROC)) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_INTELC || LZO_CC_MSC)) ++# define LZO_SIZEOF___INT64 8 ++#elif ((LZO_OS_WIN32 || defined(_WIN32)) && (LZO_CC_MSC)) ++# define LZO_SIZEOF___INT64 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0520))) ++# define LZO_SIZEOF___INT64 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_WATCOMC && (__WATCOMC__ >= 1100))) ++# define LZO_SIZEOF___INT64 8 ++#elif (LZO_CC_WATCOMC && defined(_INTEGRAL_MAX_BITS) && (_INTEGRAL_MAX_BITS == 64)) ++# define LZO_SIZEOF___INT64 8 ++#elif (LZO_OS_OS400 || defined(__OS400__)) && defined(__LLP64_IFC__) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (defined(__vms) || defined(__VMS)) && (__INITIAL_POINTER_SIZE+0 == 64) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_CC_SDCC) && (LZO_SIZEOF_INT == 2) ++#elif 1 && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) ++# define LZO_SIZEOF_LONG_LONG 8 ++#endif ++#endif ++#endif ++#if defined(__cplusplus) && (LZO_CC_GNUC) ++# if (LZO_CC_GNUC < 0x020800ul) ++# undef LZO_SIZEOF_LONG_LONG ++# endif ++#endif ++#if (LZO_CFG_NO_LONG_LONG) || defined(__NO_LONG_LONG) ++# undef LZO_SIZEOF_LONG_LONG ++#endif ++#if !defined(LZO_SIZEOF_VOID_P) ++#if (LZO_ARCH_I086) ++# define __LZO_WORDSIZE 2 ++# if (LZO_MM_TINY || LZO_MM_SMALL || LZO_MM_MEDIUM) ++# define LZO_SIZEOF_VOID_P 2 ++# elif (LZO_MM_COMPACT || LZO_MM_LARGE || LZO_MM_HUGE) ++# define LZO_SIZEOF_VOID_P 4 ++# else ++# error "LZO_MM" ++# endif ++#elif (LZO_ARCH_AVR || LZO_ARCH_Z80) ++# define __LZO_WORDSIZE 1 ++# define LZO_SIZEOF_VOID_P 2 ++#elif (LZO_ARCH_C166 || LZO_ARCH_MCS51 || LZO_ARCH_MCS251 || LZO_ARCH_MSP430) ++# define LZO_SIZEOF_VOID_P 2 ++#elif (LZO_ARCH_H8300) ++# if defined(__NORMAL_MODE__) ++# define __LZO_WORDSIZE 4 ++# define LZO_SIZEOF_VOID_P 2 ++# elif defined(__H8300H__) || defined(__H8300S__) || defined(__H8300SX__) ++# define __LZO_WORDSIZE 4 ++# define LZO_SIZEOF_VOID_P 4 ++# else ++# define __LZO_WORDSIZE 2 ++# define LZO_SIZEOF_VOID_P 2 ++# endif ++# if (LZO_CC_GNUC && (LZO_CC_GNUC < 0x040000ul)) && (LZO_SIZEOF_INT == 4) ++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_INT ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_INT ++# endif ++#elif (LZO_ARCH_M16C) ++# define __LZO_WORDSIZE 2 ++# if defined(__m32c_cpu__) || defined(__m32cm_cpu__) ++# define LZO_SIZEOF_VOID_P 4 ++# else ++# define LZO_SIZEOF_VOID_P 2 ++# endif ++#elif (LZO_SIZEOF_LONG == 8) && ((defined(__mips__) && defined(__R5900__)) || defined(__MIPS_PSX2__)) ++# define __LZO_WORDSIZE 8 ++# define LZO_SIZEOF_VOID_P 4 ++#elif defined(__LLP64__) || defined(__LLP64) || defined(_LLP64) || defined(_WIN64) ++# define __LZO_WORDSIZE 8 ++# define LZO_SIZEOF_VOID_P 8 ++#elif (LZO_OS_OS400 || defined(__OS400__)) && defined(__LLP64_IFC__) ++# define LZO_SIZEOF_VOID_P LZO_SIZEOF_LONG ++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_LONG ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_LONG ++#elif (LZO_OS_OS400 || defined(__OS400__)) ++# define __LZO_WORDSIZE LZO_SIZEOF_LONG ++# define LZO_SIZEOF_VOID_P 16 ++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_LONG ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_LONG ++#elif (defined(__vms) || defined(__VMS)) && (__INITIAL_POINTER_SIZE+0 == 64) ++# define LZO_SIZEOF_VOID_P 8 ++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_LONG ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_LONG ++#elif (LZO_ARCH_SPU) ++# if 0 ++# define __LZO_WORDSIZE 16 ++# endif ++# define LZO_SIZEOF_VOID_P 4 ++#else ++# define LZO_SIZEOF_VOID_P LZO_SIZEOF_LONG ++#endif ++#endif ++#if !defined(LZO_WORDSIZE) ++# if defined(__LZO_WORDSIZE) ++# define LZO_WORDSIZE __LZO_WORDSIZE ++# else ++# define LZO_WORDSIZE LZO_SIZEOF_VOID_P ++# endif ++#endif ++#if !defined(LZO_SIZEOF_SIZE_T) ++#if (LZO_ARCH_I086 || LZO_ARCH_M16C) ++# define LZO_SIZEOF_SIZE_T 2 ++#else ++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_VOID_P ++#endif ++#endif ++#if !defined(LZO_SIZEOF_PTRDIFF_T) ++#if (LZO_ARCH_I086) ++# if (LZO_MM_TINY || LZO_MM_SMALL || LZO_MM_MEDIUM || LZO_MM_HUGE) ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_VOID_P ++# elif (LZO_MM_COMPACT || LZO_MM_LARGE) ++# if (LZO_CC_BORLANDC || LZO_CC_TURBOC) ++# define LZO_SIZEOF_PTRDIFF_T 4 ++# else ++# define LZO_SIZEOF_PTRDIFF_T 2 ++# endif ++# else ++# error "LZO_MM" ++# endif ++#else ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_SIZE_T ++#endif ++#endif ++#if (LZO_ABI_NEUTRAL_ENDIAN) ++# undef LZO_ABI_BIG_ENDIAN ++# undef LZO_ABI_LITTLE_ENDIAN ++#elif !(LZO_ABI_BIG_ENDIAN) && !(LZO_ABI_LITTLE_ENDIAN) ++#if (LZO_ARCH_ALPHA) && (LZO_ARCH_CRAY_MPP) ++# define LZO_ABI_BIG_ENDIAN 1 ++#elif (LZO_ARCH_IA64) && (LZO_OS_POSIX_LINUX || LZO_OS_WIN64) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++#elif (LZO_ARCH_ALPHA || LZO_ARCH_AMD64 || LZO_ARCH_BLACKFIN || LZO_ARCH_CRIS || LZO_ARCH_I086 || LZO_ARCH_I386 || LZO_ARCH_MSP430) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++#elif (LZO_ARCH_AVR32 || LZO_ARCH_M68K || LZO_ARCH_S390) ++# define LZO_ABI_BIG_ENDIAN 1 ++#elif 1 && defined(__IAR_SYSTEMS_ICC__) && defined(__LITTLE_ENDIAN__) ++# if (__LITTLE_ENDIAN__ == 1) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++# else ++# define LZO_ABI_BIG_ENDIAN 1 ++# endif ++#elif 1 && defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__) ++# define LZO_ABI_BIG_ENDIAN 1 ++#elif 1 && defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++#elif 1 && (LZO_ARCH_ARM) && defined(__ARMEB__) && !defined(__ARMEL__) ++# define LZO_ABI_BIG_ENDIAN 1 ++#elif 1 && (LZO_ARCH_ARM) && defined(__ARMEL__) && !defined(__ARMEB__) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++#elif 1 && (LZO_ARCH_MIPS) && defined(__MIPSEB__) && !defined(__MIPSEL__) ++# define LZO_ABI_BIG_ENDIAN 1 ++#elif 1 && (LZO_ARCH_MIPS) && defined(__MIPSEL__) && !defined(__MIPSEB__) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++#endif ++#endif ++#if (LZO_ABI_BIG_ENDIAN) && (LZO_ABI_LITTLE_ENDIAN) ++# error "this should not happen" ++#endif ++#if (LZO_ABI_BIG_ENDIAN) ++# define LZO_INFO_ABI_ENDIAN "be" ++#elif (LZO_ABI_LITTLE_ENDIAN) ++# define LZO_INFO_ABI_ENDIAN "le" ++#elif (LZO_ABI_NEUTRAL_ENDIAN) ++# define LZO_INFO_ABI_ENDIAN "neutral" ++#endif ++#if (LZO_SIZEOF_INT == 1 && LZO_SIZEOF_LONG == 2 && LZO_SIZEOF_VOID_P == 2) ++# define LZO_ABI_I8LP16 1 ++# define LZO_INFO_ABI_PM "i8lp16" ++#elif (LZO_SIZEOF_INT == 2 && LZO_SIZEOF_LONG == 2 && LZO_SIZEOF_VOID_P == 2) ++# define LZO_ABI_ILP16 1 ++# define LZO_INFO_ABI_PM "ilp16" ++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 4 && LZO_SIZEOF_VOID_P == 4) ++# define LZO_ABI_ILP32 1 ++# define LZO_INFO_ABI_PM "ilp32" ++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 4 && LZO_SIZEOF_VOID_P == 8 && LZO_SIZEOF_SIZE_T == 8) ++# define LZO_ABI_LLP64 1 ++# define LZO_INFO_ABI_PM "llp64" ++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 8 && LZO_SIZEOF_VOID_P == 8) ++# define LZO_ABI_LP64 1 ++# define LZO_INFO_ABI_PM "lp64" ++#elif (LZO_SIZEOF_INT == 8 && LZO_SIZEOF_LONG == 8 && LZO_SIZEOF_VOID_P == 8) ++# define LZO_ABI_ILP64 1 ++# define LZO_INFO_ABI_PM "ilp64" ++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 8 && LZO_SIZEOF_VOID_P == 4) ++# define LZO_ABI_IP32L64 1 ++# define LZO_INFO_ABI_PM "ip32l64" ++#endif ++#if !defined(__LZO_LIBC_OVERRIDE) ++#if (LZO_LIBC_NAKED) ++# define LZO_INFO_LIBC "naked" ++#elif (LZO_LIBC_FREESTANDING) ++# define LZO_INFO_LIBC "freestanding" ++#elif (LZO_LIBC_MOSTLY_FREESTANDING) ++# define LZO_INFO_LIBC "mfreestanding" ++#elif (LZO_LIBC_ISOC90) ++# define LZO_INFO_LIBC "isoc90" ++#elif (LZO_LIBC_ISOC99) ++# define LZO_INFO_LIBC "isoc99" ++#elif defined(__dietlibc__) ++# define LZO_LIBC_DIETLIBC 1 ++# define LZO_INFO_LIBC "dietlibc" ++#elif defined(_NEWLIB_VERSION) ++# define LZO_LIBC_NEWLIB 1 ++# define LZO_INFO_LIBC "newlib" ++#elif defined(__UCLIBC__) && defined(__UCLIBC_MAJOR__) && defined(__UCLIBC_MINOR__) ++# if defined(__UCLIBC_SUBLEVEL__) ++# define LZO_LIBC_UCLIBC (__UCLIBC_MAJOR__ * 0x10000L + __UCLIBC_MINOR__ * 0x100 + __UCLIBC_SUBLEVEL__) ++# else ++# define LZO_LIBC_UCLIBC 0x00090bL ++# endif ++# define LZO_INFO_LIBC "uclibc" ++#elif defined(__GLIBC__) && defined(__GLIBC_MINOR__) ++# define LZO_LIBC_GLIBC (__GLIBC__ * 0x10000L + __GLIBC_MINOR__ * 0x100) ++# define LZO_INFO_LIBC "glibc" ++#elif (LZO_CC_MWERKS) && defined(__MSL__) ++# define LZO_LIBC_MSL __MSL__ ++# define LZO_INFO_LIBC "msl" ++#elif 1 && defined(__IAR_SYSTEMS_ICC__) ++# define LZO_LIBC_ISOC90 1 ++# define LZO_INFO_LIBC "isoc90" ++#else ++# define LZO_LIBC_DEFAULT 1 ++# define LZO_INFO_LIBC "default" ++#endif ++#endif ++#if !defined(__lzo_gnuc_extension__) ++#if (LZO_CC_GNUC >= 0x020800ul) ++# define __lzo_gnuc_extension__ __extension__ ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_gnuc_extension__ __extension__ ++#else ++# define __lzo_gnuc_extension__ /*empty*/ ++#endif ++#endif ++#if !defined(__lzo_ua_volatile) ++# define __lzo_ua_volatile volatile ++#endif ++#if !defined(__lzo_alignof) ++#if (LZO_CC_CILLY || LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE || LZO_CC_PGI) ++# define __lzo_alignof(e) __alignof__(e) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 700)) ++# define __lzo_alignof(e) __alignof__(e) ++#elif (LZO_CC_MSC && (_MSC_VER >= 1300)) ++# define __lzo_alignof(e) __alignof(e) ++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100)) ++# define __lzo_alignof(e) __alignof__(e) ++#endif ++#endif ++#if defined(__lzo_alignof) ++# define __lzo_HAVE_alignof 1 ++#endif ++#if !defined(__lzo_constructor) ++#if (LZO_CC_GNUC >= 0x030400ul) ++# define __lzo_constructor __attribute__((__constructor__,__used__)) ++#elif (LZO_CC_GNUC >= 0x020700ul) ++# define __lzo_constructor __attribute__((__constructor__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_constructor __attribute__((__constructor__)) ++#endif ++#endif ++#if defined(__lzo_constructor) ++# define __lzo_HAVE_constructor 1 ++#endif ++#if !defined(__lzo_destructor) ++#if (LZO_CC_GNUC >= 0x030400ul) ++# define __lzo_destructor __attribute__((__destructor__,__used__)) ++#elif (LZO_CC_GNUC >= 0x020700ul) ++# define __lzo_destructor __attribute__((__destructor__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_destructor __attribute__((__destructor__)) ++#endif ++#endif ++#if defined(__lzo_destructor) ++# define __lzo_HAVE_destructor 1 ++#endif ++#if (__lzo_HAVE_destructor) && !(__lzo_HAVE_constructor) ++# error "this should not happen" ++#endif ++#if !defined(__lzo_inline) ++#if (LZO_CC_TURBOC && (__TURBOC__ <= 0x0295)) ++#elif defined(__cplusplus) ++# define __lzo_inline inline ++#elif (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0550)) ++# define __lzo_inline __inline ++#elif (LZO_CC_CILLY || LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE || LZO_CC_PGI) ++# define __lzo_inline __inline__ ++#elif (LZO_CC_DMC) ++# define __lzo_inline __inline ++#elif (LZO_CC_INTELC) ++# define __lzo_inline __inline ++#elif (LZO_CC_MWERKS && (__MWERKS__ >= 0x2405)) ++# define __lzo_inline __inline ++#elif (LZO_CC_MSC && (_MSC_VER >= 900)) ++# define __lzo_inline __inline ++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100)) ++# define __lzo_inline __inline__ ++#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) ++# define __lzo_inline inline ++#endif ++#endif ++#if defined(__lzo_inline) ++# define __lzo_HAVE_inline 1 ++#else ++# define __lzo_inline /*empty*/ ++#endif ++#if !defined(__lzo_forceinline) ++#if (LZO_CC_GNUC >= 0x030200ul) ++# define __lzo_forceinline __inline__ __attribute__((__always_inline__)) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 450) && LZO_CC_SYNTAX_MSC) ++# define __lzo_forceinline __forceinline ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 800) && LZO_CC_SYNTAX_GNUC) ++# define __lzo_forceinline __inline__ __attribute__((__always_inline__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_forceinline __inline__ __attribute__((__always_inline__)) ++#elif (LZO_CC_MSC && (_MSC_VER >= 1200)) ++# define __lzo_forceinline __forceinline ++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100)) ++# define __lzo_forceinline __inline__ __attribute__((__always_inline__)) ++#endif ++#endif ++#if defined(__lzo_forceinline) ++# define __lzo_HAVE_forceinline 1 ++#else ++# define __lzo_forceinline /*empty*/ ++#endif ++#if !defined(__lzo_noinline) ++#if 1 && (LZO_ARCH_I386) && (LZO_CC_GNUC >= 0x040000ul) && (LZO_CC_GNUC < 0x040003ul) ++# define __lzo_noinline __attribute__((__noinline__,__used__)) ++#elif (LZO_CC_GNUC >= 0x030200ul) ++# define __lzo_noinline __attribute__((__noinline__)) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 600) && LZO_CC_SYNTAX_MSC) ++# define __lzo_noinline __declspec(noinline) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 800) && LZO_CC_SYNTAX_GNUC) ++# define __lzo_noinline __attribute__((__noinline__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_noinline __attribute__((__noinline__)) ++#elif (LZO_CC_MSC && (_MSC_VER >= 1300)) ++# define __lzo_noinline __declspec(noinline) ++#elif (LZO_CC_MWERKS && (__MWERKS__ >= 0x3200) && (LZO_OS_WIN32 || LZO_OS_WIN64)) ++# if defined(__cplusplus) ++# else ++# define __lzo_noinline __declspec(noinline) ++# endif ++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100)) ++# define __lzo_noinline __attribute__((__noinline__)) ++#endif ++#endif ++#if defined(__lzo_noinline) ++# define __lzo_HAVE_noinline 1 ++#else ++# define __lzo_noinline /*empty*/ ++#endif ++#if (__lzo_HAVE_forceinline || __lzo_HAVE_noinline) && !(__lzo_HAVE_inline) ++# error "this should not happen" ++#endif ++#if !defined(__lzo_noreturn) ++#if (LZO_CC_GNUC >= 0x020700ul) ++# define __lzo_noreturn __attribute__((__noreturn__)) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 450) && LZO_CC_SYNTAX_MSC) ++# define __lzo_noreturn __declspec(noreturn) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 600) && LZO_CC_SYNTAX_GNUC) ++# define __lzo_noreturn __attribute__((__noreturn__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_noreturn __attribute__((__noreturn__)) ++#elif (LZO_CC_MSC && (_MSC_VER >= 1200)) ++# define __lzo_noreturn __declspec(noreturn) ++#endif ++#endif ++#if defined(__lzo_noreturn) ++# define __lzo_HAVE_noreturn 1 ++#else ++# define __lzo_noreturn /*empty*/ ++#endif ++#if !defined(__lzo_nothrow) ++#if (LZO_CC_GNUC >= 0x030300ul) ++# define __lzo_nothrow __attribute__((__nothrow__)) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 450) && LZO_CC_SYNTAX_MSC) && defined(__cplusplus) ++# define __lzo_nothrow __declspec(nothrow) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 900) && LZO_CC_SYNTAX_GNUC) ++# define __lzo_nothrow __attribute__((__nothrow__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_nothrow __attribute__((__nothrow__)) ++#elif (LZO_CC_MSC && (_MSC_VER >= 1200)) && defined(__cplusplus) ++# define __lzo_nothrow __declspec(nothrow) ++#endif ++#endif ++#if defined(__lzo_nothrow) ++# define __lzo_HAVE_nothrow 1 ++#else ++# define __lzo_nothrow /*empty*/ ++#endif ++#if !defined(__lzo_restrict) ++#if (LZO_CC_GNUC >= 0x030400ul) ++# define __lzo_restrict __restrict__ ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 600) && LZO_CC_SYNTAX_GNUC) ++# define __lzo_restrict __restrict__ ++#elif (LZO_CC_CLANG || LZO_CC_LLVM) ++# define __lzo_restrict __restrict__ ++#elif (LZO_CC_MSC && (_MSC_VER >= 1400)) ++# define __lzo_restrict __restrict ++#endif ++#endif ++#if defined(__lzo_restrict) ++# define __lzo_HAVE_restrict 1 ++#else ++# define __lzo_restrict /*empty*/ ++#endif ++#if !defined(__lzo_likely) && !defined(__lzo_unlikely) ++#if (LZO_CC_GNUC >= 0x030200ul) ++# define __lzo_likely(e) (__builtin_expect(!!(e),1)) ++# define __lzo_unlikely(e) (__builtin_expect(!!(e),0)) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 800)) ++# define __lzo_likely(e) (__builtin_expect(!!(e),1)) ++# define __lzo_unlikely(e) (__builtin_expect(!!(e),0)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_likely(e) (__builtin_expect(!!(e),1)) ++# define __lzo_unlikely(e) (__builtin_expect(!!(e),0)) ++#endif ++#endif ++#if defined(__lzo_likely) ++# define __lzo_HAVE_likely 1 ++#else ++# define __lzo_likely(e) (e) ++#endif ++#if defined(__lzo_unlikely) ++# define __lzo_HAVE_unlikely 1 ++#else ++# define __lzo_unlikely(e) (e) ++#endif ++#if !defined(LZO_UNUSED) ++# if (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0600)) ++# define LZO_UNUSED(var) ((void) &var) ++# elif (LZO_CC_BORLANDC || LZO_CC_HIGHC || LZO_CC_NDPC || LZO_CC_PELLESC || LZO_CC_TURBOC) ++# define LZO_UNUSED(var) if (&var) ; else ++# elif (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define LZO_UNUSED(var) ((void) var) ++# elif (LZO_CC_MSC && (_MSC_VER < 900)) ++# define LZO_UNUSED(var) if (&var) ; else ++# elif (LZO_CC_KEILC) ++# define LZO_UNUSED(var) {extern int __lzo_unused[1-2*!(sizeof(var)>0)];} ++# elif (LZO_CC_PACIFICC) ++# define LZO_UNUSED(var) ((void) sizeof(var)) ++# elif (LZO_CC_WATCOMC) && defined(__cplusplus) ++# define LZO_UNUSED(var) ((void) var) ++# else ++# define LZO_UNUSED(var) ((void) &var) ++# endif ++#endif ++#if !defined(LZO_UNUSED_FUNC) ++# if (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0600)) ++# define LZO_UNUSED_FUNC(func) ((void) func) ++# elif (LZO_CC_BORLANDC || LZO_CC_NDPC || LZO_CC_TURBOC) ++# define LZO_UNUSED_FUNC(func) if (func) ; else ++# elif (LZO_CC_CLANG || LZO_CC_LLVM) ++# define LZO_UNUSED_FUNC(func) ((void) &func) ++# elif (LZO_CC_MSC && (_MSC_VER < 900)) ++# define LZO_UNUSED_FUNC(func) if (func) ; else ++# elif (LZO_CC_MSC) ++# define LZO_UNUSED_FUNC(func) ((void) &func) ++# elif (LZO_CC_KEILC || LZO_CC_PELLESC) ++# define LZO_UNUSED_FUNC(func) {extern int __lzo_unused[1-2*!(sizeof((int)func)>0)];} ++# else ++# define LZO_UNUSED_FUNC(func) ((void) func) ++# endif ++#endif ++#if !defined(LZO_UNUSED_LABEL) ++# if (LZO_CC_WATCOMC) && defined(__cplusplus) ++# define LZO_UNUSED_LABEL(l) switch(0) case 1:goto l ++# elif (LZO_CC_CLANG || LZO_CC_INTELC || LZO_CC_WATCOMC) ++# define LZO_UNUSED_LABEL(l) if (0) goto l ++# else ++# define LZO_UNUSED_LABEL(l) switch(0) case 1:goto l ++# endif ++#endif ++#if !defined(LZO_DEFINE_UNINITIALIZED_VAR) ++# if 0 ++# define LZO_DEFINE_UNINITIALIZED_VAR(type,var,init) type var ++# elif 0 && (LZO_CC_GNUC) ++# define LZO_DEFINE_UNINITIALIZED_VAR(type,var,init) type var = var ++# else ++# define LZO_DEFINE_UNINITIALIZED_VAR(type,var,init) type var = init ++# endif ++#endif ++#if !defined(LZO_UNCONST_CAST) ++# if 0 && defined(__cplusplus) ++# define LZO_UNCONST_CAST(t,e) (const_cast<t> (e)) ++# elif (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define LZO_UNCONST_CAST(t,e) ((t) ((void *) ((char *) ((lzo_uintptr_t) ((const void *) (e)))))) ++# else ++# define LZO_UNCONST_CAST(t,e) ((t) ((void *) ((char *) ((const void *) (e))))) ++# endif ++#endif ++#if !defined(LZO_COMPILE_TIME_ASSERT_HEADER) ++# if (LZO_CC_AZTECC || LZO_CC_ZORTECHC) ++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1-!(e)]; ++# elif (LZO_CC_DMC || LZO_CC_SYMANTECC) ++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1u-2*!(e)]; ++# elif (LZO_CC_TURBOC && (__TURBOC__ == 0x0295)) ++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1-!(e)]; ++# else ++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1-2*!(e)]; ++# endif ++#endif ++#if !defined(LZO_COMPILE_TIME_ASSERT) ++# if (LZO_CC_AZTECC) ++# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __lzo_cta_t[1-!(e)];} ++# elif (LZO_CC_DMC || LZO_CC_PACIFICC || LZO_CC_SYMANTECC || LZO_CC_ZORTECHC) ++# define LZO_COMPILE_TIME_ASSERT(e) switch(0) case 1:case !(e):break; ++# elif (LZO_CC_MSC && (_MSC_VER < 900)) ++# define LZO_COMPILE_TIME_ASSERT(e) switch(0) case 1:case !(e):break; ++# elif (LZO_CC_TURBOC && (__TURBOC__ == 0x0295)) ++# define LZO_COMPILE_TIME_ASSERT(e) switch(0) case 1:case !(e):break; ++# else ++# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __lzo_cta_t[1-2*!(e)];} ++# endif ++#endif ++#if (LZO_ARCH_I086 || LZO_ARCH_I386) && (LZO_OS_DOS16 || LZO_OS_DOS32 || LZO_OS_OS2 || LZO_OS_OS216 || LZO_OS_WIN16 || LZO_OS_WIN32 || LZO_OS_WIN64) ++# if (LZO_CC_GNUC || LZO_CC_HIGHC || LZO_CC_NDPC || LZO_CC_PACIFICC) ++# elif (LZO_CC_DMC || LZO_CC_SYMANTECC || LZO_CC_ZORTECHC) ++# define __lzo_cdecl __cdecl ++# define __lzo_cdecl_atexit /*empty*/ ++# define __lzo_cdecl_main __cdecl ++# if (LZO_OS_OS2 && (LZO_CC_DMC || LZO_CC_SYMANTECC)) ++# define __lzo_cdecl_qsort __pascal ++# elif (LZO_OS_OS2 && (LZO_CC_ZORTECHC)) ++# define __lzo_cdecl_qsort _stdcall ++# else ++# define __lzo_cdecl_qsort __cdecl ++# endif ++# elif (LZO_CC_WATCOMC) ++# define __lzo_cdecl __cdecl ++# else ++# define __lzo_cdecl __cdecl ++# define __lzo_cdecl_atexit __cdecl ++# define __lzo_cdecl_main __cdecl ++# define __lzo_cdecl_qsort __cdecl ++# endif ++# if (LZO_CC_GNUC || LZO_CC_HIGHC || LZO_CC_NDPC || LZO_CC_PACIFICC || LZO_CC_WATCOMC) ++# elif (LZO_OS_OS2 && (LZO_CC_DMC || LZO_CC_SYMANTECC)) ++# define __lzo_cdecl_sighandler __pascal ++# elif (LZO_OS_OS2 && (LZO_CC_ZORTECHC)) ++# define __lzo_cdecl_sighandler _stdcall ++# elif (LZO_CC_MSC && (_MSC_VER >= 1400)) && defined(_M_CEE_PURE) ++# define __lzo_cdecl_sighandler __clrcall ++# elif (LZO_CC_MSC && (_MSC_VER >= 600 && _MSC_VER < 700)) ++# if defined(_DLL) ++# define __lzo_cdecl_sighandler _far _cdecl _loadds ++# elif defined(_MT) ++# define __lzo_cdecl_sighandler _far _cdecl ++# else ++# define __lzo_cdecl_sighandler _cdecl ++# endif ++# else ++# define __lzo_cdecl_sighandler __cdecl ++# endif ++#elif (LZO_ARCH_I386) && (LZO_CC_WATCOMC) ++# define __lzo_cdecl __cdecl ++#elif (LZO_ARCH_M68K && LZO_OS_TOS && (LZO_CC_PUREC || LZO_CC_TURBOC)) ++# define __lzo_cdecl cdecl ++#endif ++#if !defined(__lzo_cdecl) ++# define __lzo_cdecl /*empty*/ ++#endif ++#if !defined(__lzo_cdecl_atexit) ++# define __lzo_cdecl_atexit /*empty*/ ++#endif ++#if !defined(__lzo_cdecl_main) ++# define __lzo_cdecl_main /*empty*/ ++#endif ++#if !defined(__lzo_cdecl_qsort) ++# define __lzo_cdecl_qsort /*empty*/ ++#endif ++#if !defined(__lzo_cdecl_sighandler) ++# define __lzo_cdecl_sighandler /*empty*/ ++#endif ++#if !defined(__lzo_cdecl_va) ++# define __lzo_cdecl_va __lzo_cdecl ++#endif ++#if !(LZO_CFG_NO_WINDOWS_H) ++#if (LZO_OS_CYGWIN || (LZO_OS_EMX && defined(__RSXNT__)) || LZO_OS_WIN32 || LZO_OS_WIN64) ++# if (LZO_CC_WATCOMC && (__WATCOMC__ < 1000)) ++# elif (LZO_OS_WIN32 && LZO_CC_GNUC) && defined(__PW32__) ++# elif ((LZO_OS_CYGWIN || defined(__MINGW32__)) && (LZO_CC_GNUC && (LZO_CC_GNUC < 0x025f00ul))) ++# else ++# define LZO_HAVE_WINDOWS_H 1 ++# endif ++#endif ++#endif ++#if (LZO_ARCH_ALPHA) ++# define LZO_OPT_AVOID_UINT_INDEX 1 ++# define LZO_OPT_AVOID_SHORT 1 ++# define LZO_OPT_AVOID_USHORT 1 ++#elif (LZO_ARCH_AMD64) ++# define LZO_OPT_AVOID_INT_INDEX 1 ++# define LZO_OPT_AVOID_UINT_INDEX 1 ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++# define LZO_OPT_UNALIGNED64 1 ++#elif (LZO_ARCH_ARM && LZO_ARCH_ARM_THUMB) ++#elif (LZO_ARCH_ARM) ++# define LZO_OPT_AVOID_SHORT 1 ++# define LZO_OPT_AVOID_USHORT 1 ++#elif (LZO_ARCH_CRIS) ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++#elif (LZO_ARCH_I386) ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++#elif (LZO_ARCH_IA64) ++# define LZO_OPT_AVOID_INT_INDEX 1 ++# define LZO_OPT_AVOID_UINT_INDEX 1 ++# define LZO_OPT_PREFER_POSTINC 1 ++#elif (LZO_ARCH_M68K) ++# define LZO_OPT_PREFER_POSTINC 1 ++# define LZO_OPT_PREFER_PREDEC 1 ++# if defined(__mc68020__) && !defined(__mcoldfire__) ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++# endif ++#elif (LZO_ARCH_MIPS) ++# define LZO_OPT_AVOID_UINT_INDEX 1 ++#elif (LZO_ARCH_POWERPC) ++# define LZO_OPT_PREFER_PREINC 1 ++# define LZO_OPT_PREFER_PREDEC 1 ++# if (LZO_ABI_BIG_ENDIAN) ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++# endif ++#elif (LZO_ARCH_S390) ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++# if (LZO_SIZEOF_SIZE_T == 8) ++# define LZO_OPT_UNALIGNED64 1 ++# endif ++#elif (LZO_ARCH_SH) ++# define LZO_OPT_PREFER_POSTINC 1 ++# define LZO_OPT_PREFER_PREDEC 1 ++#endif ++#ifndef LZO_CFG_NO_INLINE_ASM ++#if (LZO_CC_LLVM) ++# define LZO_CFG_NO_INLINE_ASM 1 ++#endif ++#endif ++#ifndef LZO_CFG_NO_UNALIGNED ++#if (LZO_ABI_NEUTRAL_ENDIAN) || (LZO_ARCH_GENERIC) ++# define LZO_CFG_NO_UNALIGNED 1 ++#endif ++#endif ++#if (LZO_CFG_NO_UNALIGNED) ++# undef LZO_OPT_UNALIGNED16 ++# undef LZO_OPT_UNALIGNED32 ++# undef LZO_OPT_UNALIGNED64 ++#endif ++#if (LZO_CFG_NO_INLINE_ASM) ++#elif (LZO_ARCH_I386 && (LZO_OS_DOS32 || LZO_OS_WIN32) && (LZO_CC_DMC || LZO_CC_INTELC || LZO_CC_MSC || LZO_CC_PELLESC)) ++# define LZO_ASM_SYNTAX_MSC 1 ++#elif (LZO_OS_WIN64 && (LZO_CC_DMC || LZO_CC_INTELC || LZO_CC_MSC || LZO_CC_PELLESC)) ++#elif (LZO_ARCH_I386 && LZO_CC_GNUC && (LZO_CC_GNUC == 0x011f00ul)) ++#elif (LZO_ARCH_I386 && (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_INTELC || LZO_CC_PATHSCALE)) ++# define LZO_ASM_SYNTAX_GNUC 1 ++#elif (LZO_ARCH_AMD64 && (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_INTELC || LZO_CC_PATHSCALE)) ++# define LZO_ASM_SYNTAX_GNUC 1 ++#endif ++#if (LZO_ASM_SYNTAX_GNUC) ++#if (LZO_ARCH_I386 && LZO_CC_GNUC && (LZO_CC_GNUC < 0x020000ul)) ++# define __LZO_ASM_CLOBBER "ax" ++#elif (LZO_CC_INTELC) ++# define __LZO_ASM_CLOBBER "memory" ++#else ++# define __LZO_ASM_CLOBBER "cc", "memory" ++#endif ++#endif ++#if defined(__LZO_INFOSTR_MM) ++#elif (LZO_MM_FLAT) && (defined(__LZO_INFOSTR_PM) || defined(LZO_INFO_ABI_PM)) ++# define __LZO_INFOSTR_MM "" ++#elif defined(LZO_INFO_MM) ++# define __LZO_INFOSTR_MM "." LZO_INFO_MM ++#else ++# define __LZO_INFOSTR_MM "" ++#endif ++#if defined(__LZO_INFOSTR_PM) ++#elif defined(LZO_INFO_ABI_PM) ++# define __LZO_INFOSTR_PM "." LZO_INFO_ABI_PM ++#else ++# define __LZO_INFOSTR_PM "" ++#endif ++#if defined(__LZO_INFOSTR_ENDIAN) ++#elif defined(LZO_INFO_ABI_ENDIAN) ++# define __LZO_INFOSTR_ENDIAN "." LZO_INFO_ABI_ENDIAN ++#else ++# define __LZO_INFOSTR_ENDIAN "" ++#endif ++#if defined(__LZO_INFOSTR_OSNAME) ++#elif defined(LZO_INFO_OS_CONSOLE) ++# define __LZO_INFOSTR_OSNAME LZO_INFO_OS "." LZO_INFO_OS_CONSOLE ++#elif defined(LZO_INFO_OS_POSIX) ++# define __LZO_INFOSTR_OSNAME LZO_INFO_OS "." LZO_INFO_OS_POSIX ++#else ++# define __LZO_INFOSTR_OSNAME LZO_INFO_OS ++#endif ++#if defined(__LZO_INFOSTR_LIBC) ++#elif defined(LZO_INFO_LIBC) ++# define __LZO_INFOSTR_LIBC "." LZO_INFO_LIBC ++#else ++# define __LZO_INFOSTR_LIBC "" ++#endif ++#if defined(__LZO_INFOSTR_CCVER) ++#elif defined(LZO_INFO_CCVER) ++# define __LZO_INFOSTR_CCVER " " LZO_INFO_CCVER ++#else ++# define __LZO_INFOSTR_CCVER "" ++#endif ++#define LZO_INFO_STRING \ ++ LZO_INFO_ARCH __LZO_INFOSTR_MM __LZO_INFOSTR_PM __LZO_INFOSTR_ENDIAN \ ++ " " __LZO_INFOSTR_OSNAME __LZO_INFOSTR_LIBC " " LZO_INFO_CC __LZO_INFOSTR_CCVER ++ ++#endif /* already included */ ++ ++/* vim:set ts=4 et: */ +Index: b/grub-core/lib/minilzo/minilzo.c +=================================================================== +--- /dev/null ++++ b/grub-core/lib/minilzo/minilzo.c +@@ -0,0 +1,4562 @@ ++/* minilzo.c -- mini subset of the LZO real-time data compression library ++ ++ This file is part of the LZO real-time data compression library. ++ ++ Copyright (C) 2011 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2010 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2009 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer ++ All Rights Reserved. ++ ++ The LZO library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU General Public License as ++ published by the Free Software Foundation; either version 2 of ++ the License, or (at your option) any later version. ++ ++ The LZO library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with the LZO library; see the file COPYING. ++ If not, write to the Free Software Foundation, Inc., ++ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ ++ Markus F.X.J. Oberhumer ++ <markus@oberhumer.com> ++ http://www.oberhumer.com/opensource/lzo/ ++ */ ++ ++/* ++ * NOTE: ++ * the full LZO package can be found at ++ * http://www.oberhumer.com/opensource/lzo/ ++ */ ++ ++#define __LZO_IN_MINILZO 1 ++ ++#if defined(LZO_CFG_FREESTANDING) ++# undef MINILZO_HAVE_CONFIG_H ++# define LZO_LIBC_FREESTANDING 1 ++# define LZO_OS_FREESTANDING 1 ++#endif ++ ++#ifdef MINILZO_HAVE_CONFIG_H ++# include <config.h> ++#endif ++#include <limits.h> ++#include <stddef.h> ++#if defined(MINILZO_CFG_USE_INTERNAL_LZODEFS) ++ ++#ifndef __LZODEFS_H_INCLUDED ++#define __LZODEFS_H_INCLUDED 1 ++ ++#if defined(__CYGWIN32__) && !defined(__CYGWIN__) ++# define __CYGWIN__ __CYGWIN32__ ++#endif ++#if defined(__IBMCPP__) && !defined(__IBMC__) ++# define __IBMC__ __IBMCPP__ ++#endif ++#if defined(__ICL) && defined(_WIN32) && !defined(__INTEL_COMPILER) ++# define __INTEL_COMPILER __ICL ++#endif ++#if 1 && defined(__INTERIX) && defined(__GNUC__) && !defined(_ALL_SOURCE) ++# define _ALL_SOURCE 1 ++#endif ++#if defined(__mips__) && defined(__R5900__) ++# if !defined(__LONG_MAX__) ++# define __LONG_MAX__ 9223372036854775807L ++# endif ++#endif ++#if defined(__INTEL_COMPILER) && defined(__linux__) ++# pragma warning(disable: 193) ++#endif ++#if defined(__KEIL__) && defined(__C166__) ++# pragma warning disable = 322 ++#elif 0 && defined(__C251__) ++# pragma warning disable = 322 ++#endif ++#if defined(_MSC_VER) && !defined(__INTEL_COMPILER) && !defined(__MWERKS__) ++# if (_MSC_VER >= 1300) ++# pragma warning(disable: 4668) ++# endif ++#endif ++#if 0 && defined(__WATCOMC__) ++# if (__WATCOMC__ >= 1050) && (__WATCOMC__ < 1060) ++# pragma warning 203 9 ++# endif ++#endif ++#if defined(__BORLANDC__) && defined(__MSDOS__) && !defined(__FLAT__) ++# pragma option -h ++#endif ++#if 0 ++#define LZO_0xffffL 0xfffful ++#define LZO_0xffffffffL 0xfffffffful ++#else ++#define LZO_0xffffL 65535ul ++#define LZO_0xffffffffL 4294967295ul ++#endif ++#if (LZO_0xffffL == LZO_0xffffffffL) ++# error "your preprocessor is broken 1" ++#endif ++#if (16ul * 16384ul != 262144ul) ++# error "your preprocessor is broken 2" ++#endif ++#if 0 ++#if (32767 >= 4294967295ul) ++# error "your preprocessor is broken 3" ++#endif ++#if (65535u >= 4294967295ul) ++# error "your preprocessor is broken 4" ++#endif ++#endif ++#if (UINT_MAX == LZO_0xffffL) ++#if defined(__ZTC__) && defined(__I86__) && !defined(__OS2__) ++# if !defined(MSDOS) ++# define MSDOS 1 ++# endif ++# if !defined(_MSDOS) ++# define _MSDOS 1 ++# endif ++#elif 0 && defined(__VERSION) && defined(MB_LEN_MAX) ++# if (__VERSION == 520) && (MB_LEN_MAX == 1) ++# if !defined(__AZTEC_C__) ++# define __AZTEC_C__ __VERSION ++# endif ++# if !defined(__DOS__) ++# define __DOS__ 1 ++# endif ++# endif ++#endif ++#endif ++#if defined(_MSC_VER) && defined(M_I86HM) && (UINT_MAX == LZO_0xffffL) ++# define ptrdiff_t long ++# define _PTRDIFF_T_DEFINED 1 ++#endif ++#if (UINT_MAX == LZO_0xffffL) ++# undef __LZO_RENAME_A ++# undef __LZO_RENAME_B ++# if defined(__AZTEC_C__) && defined(__DOS__) ++# define __LZO_RENAME_A 1 ++# elif defined(_MSC_VER) && defined(MSDOS) ++# if (_MSC_VER < 600) ++# define __LZO_RENAME_A 1 ++# elif (_MSC_VER < 700) ++# define __LZO_RENAME_B 1 ++# endif ++# elif defined(__TSC__) && defined(__OS2__) ++# define __LZO_RENAME_A 1 ++# elif defined(__MSDOS__) && defined(__TURBOC__) && (__TURBOC__ < 0x0410) ++# define __LZO_RENAME_A 1 ++# elif defined(__PACIFIC__) && defined(DOS) ++# if !defined(__far) ++# define __far far ++# endif ++# if !defined(__near) ++# define __near near ++# endif ++# endif ++# if defined(__LZO_RENAME_A) ++# if !defined(__cdecl) ++# define __cdecl cdecl ++# endif ++# if !defined(__far) ++# define __far far ++# endif ++# if !defined(__huge) ++# define __huge huge ++# endif ++# if !defined(__near) ++# define __near near ++# endif ++# if !defined(__pascal) ++# define __pascal pascal ++# endif ++# if !defined(__huge) ++# define __huge huge ++# endif ++# elif defined(__LZO_RENAME_B) ++# if !defined(__cdecl) ++# define __cdecl _cdecl ++# endif ++# if !defined(__far) ++# define __far _far ++# endif ++# if !defined(__huge) ++# define __huge _huge ++# endif ++# if !defined(__near) ++# define __near _near ++# endif ++# if !defined(__pascal) ++# define __pascal _pascal ++# endif ++# elif (defined(__PUREC__) || defined(__TURBOC__)) && defined(__TOS__) ++# if !defined(__cdecl) ++# define __cdecl cdecl ++# endif ++# if !defined(__pascal) ++# define __pascal pascal ++# endif ++# endif ++# undef __LZO_RENAME_A ++# undef __LZO_RENAME_B ++#endif ++#if (UINT_MAX == LZO_0xffffL) ++#if defined(__AZTEC_C__) && defined(__DOS__) ++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1 ++#elif defined(_MSC_VER) && defined(MSDOS) ++# if (_MSC_VER < 600) ++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1 ++# endif ++# if (_MSC_VER < 700) ++# define LZO_BROKEN_INTEGRAL_PROMOTION 1 ++# define LZO_BROKEN_SIZEOF 1 ++# endif ++#elif defined(__PACIFIC__) && defined(DOS) ++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1 ++#elif defined(__TURBOC__) && defined(__MSDOS__) ++# if (__TURBOC__ < 0x0150) ++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1 ++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1 ++# define LZO_BROKEN_INTEGRAL_PROMOTION 1 ++# endif ++# if (__TURBOC__ < 0x0200) ++# define LZO_BROKEN_SIZEOF 1 ++# endif ++# if (__TURBOC__ < 0x0400) && defined(__cplusplus) ++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1 ++# endif ++#elif (defined(__PUREC__) || defined(__TURBOC__)) && defined(__TOS__) ++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1 ++# define LZO_BROKEN_SIZEOF 1 ++#endif ++#endif ++#if defined(__WATCOMC__) && (__WATCOMC__ < 900) ++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1 ++#endif ++#if defined(_CRAY) && defined(_CRAY1) ++# define LZO_BROKEN_SIGNED_RIGHT_SHIFT 1 ++#endif ++#define LZO_PP_STRINGIZE(x) #x ++#define LZO_PP_MACRO_EXPAND(x) LZO_PP_STRINGIZE(x) ++#define LZO_PP_CONCAT2(a,b) a ## b ++#define LZO_PP_CONCAT3(a,b,c) a ## b ## c ++#define LZO_PP_CONCAT4(a,b,c,d) a ## b ## c ## d ++#define LZO_PP_CONCAT5(a,b,c,d,e) a ## b ## c ## d ## e ++#define LZO_PP_ECONCAT2(a,b) LZO_PP_CONCAT2(a,b) ++#define LZO_PP_ECONCAT3(a,b,c) LZO_PP_CONCAT3(a,b,c) ++#define LZO_PP_ECONCAT4(a,b,c,d) LZO_PP_CONCAT4(a,b,c,d) ++#define LZO_PP_ECONCAT5(a,b,c,d,e) LZO_PP_CONCAT5(a,b,c,d,e) ++#if 1 ++#define LZO_CPP_STRINGIZE(x) #x ++#define LZO_CPP_MACRO_EXPAND(x) LZO_CPP_STRINGIZE(x) ++#define LZO_CPP_CONCAT2(a,b) a ## b ++#define LZO_CPP_CONCAT3(a,b,c) a ## b ## c ++#define LZO_CPP_CONCAT4(a,b,c,d) a ## b ## c ## d ++#define LZO_CPP_CONCAT5(a,b,c,d,e) a ## b ## c ## d ## e ++#define LZO_CPP_ECONCAT2(a,b) LZO_CPP_CONCAT2(a,b) ++#define LZO_CPP_ECONCAT3(a,b,c) LZO_CPP_CONCAT3(a,b,c) ++#define LZO_CPP_ECONCAT4(a,b,c,d) LZO_CPP_CONCAT4(a,b,c,d) ++#define LZO_CPP_ECONCAT5(a,b,c,d,e) LZO_CPP_CONCAT5(a,b,c,d,e) ++#endif ++#define __LZO_MASK_GEN(o,b) (((((o) << ((b)-1)) - (o)) << 1) + (o)) ++#if 1 && defined(__cplusplus) ++# if !defined(__STDC_CONSTANT_MACROS) ++# define __STDC_CONSTANT_MACROS 1 ++# endif ++# if !defined(__STDC_LIMIT_MACROS) ++# define __STDC_LIMIT_MACROS 1 ++# endif ++#endif ++#if defined(__cplusplus) ++# define LZO_EXTERN_C extern "C" ++#else ++# define LZO_EXTERN_C extern ++#endif ++#if !defined(__LZO_OS_OVERRIDE) ++#if (LZO_OS_FREESTANDING) ++# define LZO_INFO_OS "freestanding" ++#elif (LZO_OS_EMBEDDED) ++# define LZO_INFO_OS "embedded" ++#elif 1 && defined(__IAR_SYSTEMS_ICC__) ++# define LZO_OS_EMBEDDED 1 ++# define LZO_INFO_OS "embedded" ++#elif defined(__CYGWIN__) && defined(__GNUC__) ++# define LZO_OS_CYGWIN 1 ++# define LZO_INFO_OS "cygwin" ++#elif defined(__EMX__) && defined(__GNUC__) ++# define LZO_OS_EMX 1 ++# define LZO_INFO_OS "emx" ++#elif defined(__BEOS__) ++# define LZO_OS_BEOS 1 ++# define LZO_INFO_OS "beos" ++#elif defined(__Lynx__) ++# define LZO_OS_LYNXOS 1 ++# define LZO_INFO_OS "lynxos" ++#elif defined(__OS400__) ++# define LZO_OS_OS400 1 ++# define LZO_INFO_OS "os400" ++#elif defined(__QNX__) ++# define LZO_OS_QNX 1 ++# define LZO_INFO_OS "qnx" ++#elif defined(__BORLANDC__) && defined(__DPMI32__) && (__BORLANDC__ >= 0x0460) ++# define LZO_OS_DOS32 1 ++# define LZO_INFO_OS "dos32" ++#elif defined(__BORLANDC__) && defined(__DPMI16__) ++# define LZO_OS_DOS16 1 ++# define LZO_INFO_OS "dos16" ++#elif defined(__ZTC__) && defined(DOS386) ++# define LZO_OS_DOS32 1 ++# define LZO_INFO_OS "dos32" ++#elif defined(__OS2__) || defined(__OS2V2__) ++# if (UINT_MAX == LZO_0xffffL) ++# define LZO_OS_OS216 1 ++# define LZO_INFO_OS "os216" ++# elif (UINT_MAX == LZO_0xffffffffL) ++# define LZO_OS_OS2 1 ++# define LZO_INFO_OS "os2" ++# else ++# error "check your limits.h header" ++# endif ++#elif defined(__WIN64__) || defined(_WIN64) || defined(WIN64) ++# define LZO_OS_WIN64 1 ++# define LZO_INFO_OS "win64" ++#elif defined(__WIN32__) || defined(_WIN32) || defined(WIN32) || defined(__WINDOWS_386__) ++# define LZO_OS_WIN32 1 ++# define LZO_INFO_OS "win32" ++#elif defined(__MWERKS__) && defined(__INTEL__) ++# define LZO_OS_WIN32 1 ++# define LZO_INFO_OS "win32" ++#elif defined(__WINDOWS__) || defined(_WINDOWS) || defined(_Windows) ++# if (UINT_MAX == LZO_0xffffL) ++# define LZO_OS_WIN16 1 ++# define LZO_INFO_OS "win16" ++# elif (UINT_MAX == LZO_0xffffffffL) ++# define LZO_OS_WIN32 1 ++# define LZO_INFO_OS "win32" ++# else ++# error "check your limits.h header" ++# endif ++#elif defined(__DOS__) || defined(__MSDOS__) || defined(_MSDOS) || defined(MSDOS) || (defined(__PACIFIC__) && defined(DOS)) ++# if (UINT_MAX == LZO_0xffffL) ++# define LZO_OS_DOS16 1 ++# define LZO_INFO_OS "dos16" ++# elif (UINT_MAX == LZO_0xffffffffL) ++# define LZO_OS_DOS32 1 ++# define LZO_INFO_OS "dos32" ++# else ++# error "check your limits.h header" ++# endif ++#elif defined(__WATCOMC__) ++# if defined(__NT__) && (UINT_MAX == LZO_0xffffL) ++# define LZO_OS_DOS16 1 ++# define LZO_INFO_OS "dos16" ++# elif defined(__NT__) && (__WATCOMC__ < 1100) ++# define LZO_OS_WIN32 1 ++# define LZO_INFO_OS "win32" ++# elif defined(__linux__) || defined(__LINUX__) ++# define LZO_OS_POSIX 1 ++# define LZO_INFO_OS "posix" ++# else ++# error "please specify a target using the -bt compiler option" ++# endif ++#elif defined(__palmos__) ++# define LZO_OS_PALMOS 1 ++# define LZO_INFO_OS "palmos" ++#elif defined(__TOS__) || defined(__atarist__) ++# define LZO_OS_TOS 1 ++# define LZO_INFO_OS "tos" ++#elif defined(macintosh) && !defined(__ppc__) ++# define LZO_OS_MACCLASSIC 1 ++# define LZO_INFO_OS "macclassic" ++#elif defined(__VMS) ++# define LZO_OS_VMS 1 ++# define LZO_INFO_OS "vms" ++#elif ((defined(__mips__) && defined(__R5900__)) || defined(__MIPS_PSX2__)) ++# define LZO_OS_CONSOLE 1 ++# define LZO_OS_CONSOLE_PS2 1 ++# define LZO_INFO_OS "console" ++# define LZO_INFO_OS_CONSOLE "ps2" ++#elif (defined(__mips__) && defined(__psp__)) ++# define LZO_OS_CONSOLE 1 ++# define LZO_OS_CONSOLE_PSP 1 ++# define LZO_INFO_OS "console" ++# define LZO_INFO_OS_CONSOLE "psp" ++#else ++# define LZO_OS_POSIX 1 ++# define LZO_INFO_OS "posix" ++#endif ++#if (LZO_OS_POSIX) ++# if defined(_AIX) || defined(__AIX__) || defined(__aix__) ++# define LZO_OS_POSIX_AIX 1 ++# define LZO_INFO_OS_POSIX "aix" ++# elif defined(__FreeBSD__) ++# define LZO_OS_POSIX_FREEBSD 1 ++# define LZO_INFO_OS_POSIX "freebsd" ++# elif defined(__hpux__) || defined(__hpux) ++# define LZO_OS_POSIX_HPUX 1 ++# define LZO_INFO_OS_POSIX "hpux" ++# elif defined(__INTERIX) ++# define LZO_OS_POSIX_INTERIX 1 ++# define LZO_INFO_OS_POSIX "interix" ++# elif defined(__IRIX__) || defined(__irix__) ++# define LZO_OS_POSIX_IRIX 1 ++# define LZO_INFO_OS_POSIX "irix" ++# elif defined(__linux__) || defined(__linux) || defined(__LINUX__) ++# define LZO_OS_POSIX_LINUX 1 ++# define LZO_INFO_OS_POSIX "linux" ++# elif defined(__APPLE__) || defined(__MACOS__) ++# define LZO_OS_POSIX_MACOSX 1 ++# define LZO_INFO_OS_POSIX "macosx" ++# elif defined(__minix__) || defined(__minix) ++# define LZO_OS_POSIX_MINIX 1 ++# define LZO_INFO_OS_POSIX "minix" ++# elif defined(__NetBSD__) ++# define LZO_OS_POSIX_NETBSD 1 ++# define LZO_INFO_OS_POSIX "netbsd" ++# elif defined(__OpenBSD__) ++# define LZO_OS_POSIX_OPENBSD 1 ++# define LZO_INFO_OS_POSIX "openbsd" ++# elif defined(__osf__) ++# define LZO_OS_POSIX_OSF 1 ++# define LZO_INFO_OS_POSIX "osf" ++# elif defined(__solaris__) || defined(__sun) ++# if defined(__SVR4) || defined(__svr4__) ++# define LZO_OS_POSIX_SOLARIS 1 ++# define LZO_INFO_OS_POSIX "solaris" ++# else ++# define LZO_OS_POSIX_SUNOS 1 ++# define LZO_INFO_OS_POSIX "sunos" ++# endif ++# elif defined(__ultrix__) || defined(__ultrix) ++# define LZO_OS_POSIX_ULTRIX 1 ++# define LZO_INFO_OS_POSIX "ultrix" ++# elif defined(_UNICOS) ++# define LZO_OS_POSIX_UNICOS 1 ++# define LZO_INFO_OS_POSIX "unicos" ++# else ++# define LZO_OS_POSIX_UNKNOWN 1 ++# define LZO_INFO_OS_POSIX "unknown" ++# endif ++#endif ++#endif ++#if (LZO_OS_DOS16 || LZO_OS_OS216 || LZO_OS_WIN16) ++# if (UINT_MAX != LZO_0xffffL) ++# error "this should not happen" ++# endif ++# if (ULONG_MAX != LZO_0xffffffffL) ++# error "this should not happen" ++# endif ++#endif ++#if (LZO_OS_DOS32 || LZO_OS_OS2 || LZO_OS_WIN32 || LZO_OS_WIN64) ++# if (UINT_MAX != LZO_0xffffffffL) ++# error "this should not happen" ++# endif ++# if (ULONG_MAX != LZO_0xffffffffL) ++# error "this should not happen" ++# endif ++#endif ++#if defined(CIL) && defined(_GNUCC) && defined(__GNUC__) ++# define LZO_CC_CILLY 1 ++# define LZO_INFO_CC "Cilly" ++# if defined(__CILLY__) ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__CILLY__) ++# else ++# define LZO_INFO_CCVER "unknown" ++# endif ++#elif 0 && defined(SDCC) && defined(__VERSION__) && !defined(__GNUC__) ++# define LZO_CC_SDCC 1 ++# define LZO_INFO_CC "sdcc" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(SDCC) ++#elif defined(__PATHSCALE__) && defined(__PATHCC_PATCHLEVEL__) ++# define LZO_CC_PATHSCALE (__PATHCC__ * 0x10000L + __PATHCC_MINOR__ * 0x100 + __PATHCC_PATCHLEVEL__) ++# define LZO_INFO_CC "Pathscale C" ++# define LZO_INFO_CCVER __PATHSCALE__ ++#elif defined(__INTEL_COMPILER) ++# define LZO_CC_INTELC 1 ++# define LZO_INFO_CC "Intel C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__INTEL_COMPILER) ++# if defined(_WIN32) || defined(_WIN64) ++# define LZO_CC_SYNTAX_MSC 1 ++# else ++# define LZO_CC_SYNTAX_GNUC 1 ++# endif ++#elif defined(__POCC__) && defined(_WIN32) ++# define LZO_CC_PELLESC 1 ++# define LZO_INFO_CC "Pelles C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__POCC__) ++#elif defined(__clang__) && defined(__llvm__) && defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__VERSION__) ++# if defined(__GNUC_PATCHLEVEL__) ++# define LZO_CC_CLANG_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__) ++# else ++# define LZO_CC_CLANG_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100) ++# endif ++# if defined(__clang_major__) && defined(__clang_minor__) && defined(__clang_patchlevel__) ++# define LZO_CC_CLANG_CLANG (__clang_major__ * 0x10000L + __clang_minor__ * 0x100 + __clang_patchlevel__) ++# else ++# define LZO_CC_CLANG_CLANG 0x010000L ++# endif ++# define LZO_CC_CLANG LZO_CC_CLANG_GNUC ++# define LZO_INFO_CC "clang" ++# define LZO_INFO_CCVER __VERSION__ ++#elif defined(__llvm__) && defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__VERSION__) ++# if defined(__GNUC_PATCHLEVEL__) ++# define LZO_CC_LLVM_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__) ++# else ++# define LZO_CC_LLVM_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100) ++# endif ++# define LZO_CC_LLVM LZO_CC_LLVM_GNUC ++# define LZO_INFO_CC "llvm-gcc" ++# define LZO_INFO_CCVER __VERSION__ ++#elif defined(__GNUC__) && defined(__VERSION__) ++# if defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) ++# define LZO_CC_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__) ++# elif defined(__GNUC_MINOR__) ++# define LZO_CC_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100) ++# else ++# define LZO_CC_GNUC (__GNUC__ * 0x10000L) ++# endif ++# define LZO_INFO_CC "gcc" ++# define LZO_INFO_CCVER __VERSION__ ++#elif defined(__ACK__) && defined(_ACK) ++# define LZO_CC_ACK 1 ++# define LZO_INFO_CC "Amsterdam Compiler Kit C" ++# define LZO_INFO_CCVER "unknown" ++#elif defined(__AZTEC_C__) ++# define LZO_CC_AZTECC 1 ++# define LZO_INFO_CC "Aztec C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__AZTEC_C__) ++#elif defined(__CODEGEARC__) ++# define LZO_CC_CODEGEARC 1 ++# define LZO_INFO_CC "CodeGear C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__CODEGEARC__) ++#elif defined(__BORLANDC__) ++# define LZO_CC_BORLANDC 1 ++# define LZO_INFO_CC "Borland C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__BORLANDC__) ++#elif defined(_CRAYC) && defined(_RELEASE) ++# define LZO_CC_CRAYC 1 ++# define LZO_INFO_CC "Cray C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(_RELEASE) ++#elif defined(__DMC__) && defined(__SC__) ++# define LZO_CC_DMC 1 ++# define LZO_INFO_CC "Digital Mars C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__DMC__) ++#elif defined(__DECC) ++# define LZO_CC_DECC 1 ++# define LZO_INFO_CC "DEC C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__DECC) ++#elif defined(__HIGHC__) ++# define LZO_CC_HIGHC 1 ++# define LZO_INFO_CC "MetaWare High C" ++# define LZO_INFO_CCVER "unknown" ++#elif defined(__IAR_SYSTEMS_ICC__) ++# define LZO_CC_IARC 1 ++# define LZO_INFO_CC "IAR C" ++# if defined(__VER__) ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__VER__) ++# else ++# define LZO_INFO_CCVER "unknown" ++# endif ++#elif defined(__IBMC__) ++# define LZO_CC_IBMC 1 ++# define LZO_INFO_CC "IBM C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__IBMC__) ++#elif defined(__KEIL__) && defined(__C166__) ++# define LZO_CC_KEILC 1 ++# define LZO_INFO_CC "Keil C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__C166__) ++#elif defined(__LCC__) && defined(_WIN32) && defined(__LCCOPTIMLEVEL) ++# define LZO_CC_LCCWIN32 1 ++# define LZO_INFO_CC "lcc-win32" ++# define LZO_INFO_CCVER "unknown" ++#elif defined(__LCC__) ++# define LZO_CC_LCC 1 ++# define LZO_INFO_CC "lcc" ++# if defined(__LCC_VERSION__) ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__LCC_VERSION__) ++# else ++# define LZO_INFO_CCVER "unknown" ++# endif ++#elif defined(_MSC_VER) ++# define LZO_CC_MSC 1 ++# define LZO_INFO_CC "Microsoft C" ++# if defined(_MSC_FULL_VER) ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(_MSC_VER) "." LZO_PP_MACRO_EXPAND(_MSC_FULL_VER) ++# else ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(_MSC_VER) ++# endif ++#elif defined(__MWERKS__) ++# define LZO_CC_MWERKS 1 ++# define LZO_INFO_CC "Metrowerks C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__MWERKS__) ++#elif (defined(__NDPC__) || defined(__NDPX__)) && defined(__i386) ++# define LZO_CC_NDPC 1 ++# define LZO_INFO_CC "Microway NDP C" ++# define LZO_INFO_CCVER "unknown" ++#elif defined(__PACIFIC__) ++# define LZO_CC_PACIFICC 1 ++# define LZO_INFO_CC "Pacific C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__PACIFIC__) ++#elif defined(__PGI) && (defined(__linux__) || defined(__WIN32__)) ++# define LZO_CC_PGI 1 ++# define LZO_INFO_CC "Portland Group PGI C" ++# define LZO_INFO_CCVER "unknown" ++#elif defined(__PUREC__) && defined(__TOS__) ++# define LZO_CC_PUREC 1 ++# define LZO_INFO_CC "Pure C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__PUREC__) ++#elif defined(__SC__) && defined(__ZTC__) ++# define LZO_CC_SYMANTECC 1 ++# define LZO_INFO_CC "Symantec C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__SC__) ++#elif defined(__SUNPRO_C) ++# define LZO_INFO_CC "SunPro C" ++# if ((__SUNPRO_C)+0 > 0) ++# define LZO_CC_SUNPROC __SUNPRO_C ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__SUNPRO_C) ++# else ++# define LZO_CC_SUNPROC 1 ++# define LZO_INFO_CCVER "unknown" ++# endif ++#elif defined(__SUNPRO_CC) ++# define LZO_INFO_CC "SunPro C" ++# if ((__SUNPRO_CC)+0 > 0) ++# define LZO_CC_SUNPROC __SUNPRO_CC ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__SUNPRO_CC) ++# else ++# define LZO_CC_SUNPROC 1 ++# define LZO_INFO_CCVER "unknown" ++# endif ++#elif defined(__TINYC__) ++# define LZO_CC_TINYC 1 ++# define LZO_INFO_CC "Tiny C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__TINYC__) ++#elif defined(__TSC__) ++# define LZO_CC_TOPSPEEDC 1 ++# define LZO_INFO_CC "TopSpeed C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__TSC__) ++#elif defined(__WATCOMC__) ++# define LZO_CC_WATCOMC 1 ++# define LZO_INFO_CC "Watcom C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__WATCOMC__) ++#elif defined(__TURBOC__) ++# define LZO_CC_TURBOC 1 ++# define LZO_INFO_CC "Turbo C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__TURBOC__) ++#elif defined(__ZTC__) ++# define LZO_CC_ZORTECHC 1 ++# define LZO_INFO_CC "Zortech C" ++# if (__ZTC__ == 0x310) ++# define LZO_INFO_CCVER "0x310" ++# else ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__ZTC__) ++# endif ++#else ++# define LZO_CC_UNKNOWN 1 ++# define LZO_INFO_CC "unknown" ++# define LZO_INFO_CCVER "unknown" ++#endif ++#if 0 && (LZO_CC_MSC && (_MSC_VER >= 1200)) && !defined(_MSC_FULL_VER) ++# error "LZO_CC_MSC: _MSC_FULL_VER is not defined" ++#endif ++#if !defined(__LZO_ARCH_OVERRIDE) && !(LZO_ARCH_GENERIC) && defined(_CRAY) ++# if (UINT_MAX > LZO_0xffffffffL) && defined(_CRAY) ++# if defined(_CRAYMPP) || defined(_CRAYT3D) || defined(_CRAYT3E) ++# define LZO_ARCH_CRAY_MPP 1 ++# elif defined(_CRAY1) ++# define LZO_ARCH_CRAY_PVP 1 ++# endif ++# endif ++#endif ++#if !defined(__LZO_ARCH_OVERRIDE) ++#if (LZO_ARCH_GENERIC) ++# define LZO_INFO_ARCH "generic" ++#elif (LZO_OS_DOS16 || LZO_OS_OS216 || LZO_OS_WIN16) ++# define LZO_ARCH_I086 1 ++# define LZO_ARCH_IA16 1 ++# define LZO_INFO_ARCH "i086" ++#elif defined(__alpha__) || defined(__alpha) || defined(_M_ALPHA) ++# define LZO_ARCH_ALPHA 1 ++# define LZO_INFO_ARCH "alpha" ++#elif (LZO_ARCH_CRAY_MPP) && (defined(_CRAYT3D) || defined(_CRAYT3E)) ++# define LZO_ARCH_ALPHA 1 ++# define LZO_INFO_ARCH "alpha" ++#elif defined(__amd64__) || defined(__x86_64__) || defined(_M_AMD64) ++# define LZO_ARCH_AMD64 1 ++# define LZO_INFO_ARCH "amd64" ++#elif defined(__thumb__) || (defined(_M_ARM) && defined(_M_THUMB)) ++# define LZO_ARCH_ARM 1 ++# define LZO_ARCH_ARM_THUMB 1 ++# define LZO_INFO_ARCH "arm_thumb" ++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICCARM__) ++# define LZO_ARCH_ARM 1 ++# if defined(__CPU_MODE__) && ((__CPU_MODE__)+0 == 1) ++# define LZO_ARCH_ARM_THUMB 1 ++# define LZO_INFO_ARCH "arm_thumb" ++# elif defined(__CPU_MODE__) && ((__CPU_MODE__)+0 == 2) ++# define LZO_INFO_ARCH "arm" ++# else ++# define LZO_INFO_ARCH "arm" ++# endif ++#elif defined(__arm__) || defined(_M_ARM) ++# define LZO_ARCH_ARM 1 ++# define LZO_INFO_ARCH "arm" ++#elif (UINT_MAX <= LZO_0xffffL) && defined(__AVR__) ++# define LZO_ARCH_AVR 1 ++# define LZO_INFO_ARCH "avr" ++#elif defined(__avr32__) || defined(__AVR32__) ++# define LZO_ARCH_AVR32 1 ++# define LZO_INFO_ARCH "avr32" ++#elif defined(__bfin__) ++# define LZO_ARCH_BLACKFIN 1 ++# define LZO_INFO_ARCH "blackfin" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__C166__) ++# define LZO_ARCH_C166 1 ++# define LZO_INFO_ARCH "c166" ++#elif defined(__cris__) ++# define LZO_ARCH_CRIS 1 ++# define LZO_INFO_ARCH "cris" ++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICCEZ80__) ++# define LZO_ARCH_EZ80 1 ++# define LZO_INFO_ARCH "ez80" ++#elif defined(__H8300__) || defined(__H8300H__) || defined(__H8300S__) || defined(__H8300SX__) ++# define LZO_ARCH_H8300 1 ++# define LZO_INFO_ARCH "h8300" ++#elif defined(__hppa__) || defined(__hppa) ++# define LZO_ARCH_HPPA 1 ++# define LZO_INFO_ARCH "hppa" ++#elif defined(__386__) || defined(__i386__) || defined(__i386) || defined(_M_IX86) || defined(_M_I386) ++# define LZO_ARCH_I386 1 ++# define LZO_ARCH_IA32 1 ++# define LZO_INFO_ARCH "i386" ++#elif (LZO_CC_ZORTECHC && defined(__I86__)) ++# define LZO_ARCH_I386 1 ++# define LZO_ARCH_IA32 1 ++# define LZO_INFO_ARCH "i386" ++#elif (LZO_OS_DOS32 && LZO_CC_HIGHC) && defined(_I386) ++# define LZO_ARCH_I386 1 ++# define LZO_ARCH_IA32 1 ++# define LZO_INFO_ARCH "i386" ++#elif defined(__ia64__) || defined(__ia64) || defined(_M_IA64) ++# define LZO_ARCH_IA64 1 ++# define LZO_INFO_ARCH "ia64" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__m32c__) ++# define LZO_ARCH_M16C 1 ++# define LZO_INFO_ARCH "m16c" ++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICCM16C__) ++# define LZO_ARCH_M16C 1 ++# define LZO_INFO_ARCH "m16c" ++#elif defined(__m32r__) ++# define LZO_ARCH_M32R 1 ++# define LZO_INFO_ARCH "m32r" ++#elif (LZO_OS_TOS) || defined(__m68k__) || defined(__m68000__) || defined(__mc68000__) || defined(__mc68020__) || defined(_M_M68K) ++# define LZO_ARCH_M68K 1 ++# define LZO_INFO_ARCH "m68k" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__C251__) ++# define LZO_ARCH_MCS251 1 ++# define LZO_INFO_ARCH "mcs251" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__C51__) ++# define LZO_ARCH_MCS51 1 ++# define LZO_INFO_ARCH "mcs51" ++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICC8051__) ++# define LZO_ARCH_MCS51 1 ++# define LZO_INFO_ARCH "mcs51" ++#elif defined(__mips__) || defined(__mips) || defined(_MIPS_ARCH) || defined(_M_MRX000) ++# define LZO_ARCH_MIPS 1 ++# define LZO_INFO_ARCH "mips" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__MSP430__) ++# define LZO_ARCH_MSP430 1 ++# define LZO_INFO_ARCH "msp430" ++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICC430__) ++# define LZO_ARCH_MSP430 1 ++# define LZO_INFO_ARCH "msp430" ++#elif defined(__powerpc__) || defined(__powerpc) || defined(__ppc__) || defined(__PPC__) || defined(_M_PPC) || defined(_ARCH_PPC) || defined(_ARCH_PWR) ++# define LZO_ARCH_POWERPC 1 ++# define LZO_INFO_ARCH "powerpc" ++#elif defined(__s390__) || defined(__s390) || defined(__s390x__) || defined(__s390x) ++# define LZO_ARCH_S390 1 ++# define LZO_INFO_ARCH "s390" ++#elif defined(__sh__) || defined(_M_SH) ++# define LZO_ARCH_SH 1 ++# define LZO_INFO_ARCH "sh" ++#elif defined(__sparc__) || defined(__sparc) || defined(__sparcv8) ++# define LZO_ARCH_SPARC 1 ++# define LZO_INFO_ARCH "sparc" ++#elif defined(__SPU__) ++# define LZO_ARCH_SPU 1 ++# define LZO_INFO_ARCH "spu" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__z80) ++# define LZO_ARCH_Z80 1 ++# define LZO_INFO_ARCH "z80" ++#elif (LZO_ARCH_CRAY_PVP) ++# if defined(_CRAYSV1) ++# define LZO_ARCH_CRAY_SV1 1 ++# define LZO_INFO_ARCH "cray_sv1" ++# elif (_ADDR64) ++# define LZO_ARCH_CRAY_T90 1 ++# define LZO_INFO_ARCH "cray_t90" ++# elif (_ADDR32) ++# define LZO_ARCH_CRAY_YMP 1 ++# define LZO_INFO_ARCH "cray_ymp" ++# else ++# define LZO_ARCH_CRAY_XMP 1 ++# define LZO_INFO_ARCH "cray_xmp" ++# endif ++#else ++# define LZO_ARCH_UNKNOWN 1 ++# define LZO_INFO_ARCH "unknown" ++#endif ++#endif ++#if 1 && (LZO_ARCH_UNKNOWN) && (LZO_OS_DOS32 || LZO_OS_OS2) ++# error "FIXME - missing define for CPU architecture" ++#endif ++#if 1 && (LZO_ARCH_UNKNOWN) && (LZO_OS_WIN32) ++# error "FIXME - missing WIN32 define for CPU architecture" ++#endif ++#if 1 && (LZO_ARCH_UNKNOWN) && (LZO_OS_WIN64) ++# error "FIXME - missing WIN64 define for CPU architecture" ++#endif ++#if (LZO_OS_OS216 || LZO_OS_WIN16) ++# define LZO_ARCH_I086PM 1 ++# define LZO_ARCH_IA16PM 1 ++#elif 1 && (LZO_OS_DOS16 && defined(BLX286)) ++# define LZO_ARCH_I086PM 1 ++# define LZO_ARCH_IA16PM 1 ++#elif 1 && (LZO_OS_DOS16 && defined(DOSX286)) ++# define LZO_ARCH_I086PM 1 ++# define LZO_ARCH_IA16PM 1 ++#elif 1 && (LZO_OS_DOS16 && LZO_CC_BORLANDC && defined(__DPMI16__)) ++# define LZO_ARCH_I086PM 1 ++# define LZO_ARCH_IA16PM 1 ++#endif ++#if (LZO_ARCH_ARM_THUMB) && !(LZO_ARCH_ARM) ++# error "this should not happen" ++#endif ++#if (LZO_ARCH_I086PM) && !(LZO_ARCH_I086) ++# error "this should not happen" ++#endif ++#if (LZO_ARCH_I086) ++# if (UINT_MAX != LZO_0xffffL) ++# error "this should not happen" ++# endif ++# if (ULONG_MAX != LZO_0xffffffffL) ++# error "this should not happen" ++# endif ++#endif ++#if (LZO_ARCH_I386) ++# if (UINT_MAX != LZO_0xffffL) && defined(__i386_int16__) ++# error "this should not happen" ++# endif ++# if (UINT_MAX != LZO_0xffffffffL) && !defined(__i386_int16__) ++# error "this should not happen" ++# endif ++# if (ULONG_MAX != LZO_0xffffffffL) ++# error "this should not happen" ++# endif ++#endif ++#if !defined(__LZO_MM_OVERRIDE) ++#if (LZO_ARCH_I086) ++#if (UINT_MAX != LZO_0xffffL) ++# error "this should not happen" ++#endif ++#if defined(__TINY__) || defined(M_I86TM) || defined(_M_I86TM) ++# define LZO_MM_TINY 1 ++#elif defined(__HUGE__) || defined(_HUGE_) || defined(M_I86HM) || defined(_M_I86HM) ++# define LZO_MM_HUGE 1 ++#elif defined(__SMALL__) || defined(M_I86SM) || defined(_M_I86SM) || defined(SMALL_MODEL) ++# define LZO_MM_SMALL 1 ++#elif defined(__MEDIUM__) || defined(M_I86MM) || defined(_M_I86MM) ++# define LZO_MM_MEDIUM 1 ++#elif defined(__COMPACT__) || defined(M_I86CM) || defined(_M_I86CM) ++# define LZO_MM_COMPACT 1 ++#elif defined(__LARGE__) || defined(M_I86LM) || defined(_M_I86LM) || defined(LARGE_MODEL) ++# define LZO_MM_LARGE 1 ++#elif (LZO_CC_AZTECC) ++# if defined(_LARGE_CODE) && defined(_LARGE_DATA) ++# define LZO_MM_LARGE 1 ++# elif defined(_LARGE_CODE) ++# define LZO_MM_MEDIUM 1 ++# elif defined(_LARGE_DATA) ++# define LZO_MM_COMPACT 1 ++# else ++# define LZO_MM_SMALL 1 ++# endif ++#elif (LZO_CC_ZORTECHC && defined(__VCM__)) ++# define LZO_MM_LARGE 1 ++#else ++# error "unknown memory model" ++#endif ++#if (LZO_OS_DOS16 || LZO_OS_OS216 || LZO_OS_WIN16) ++#define LZO_HAVE_MM_HUGE_PTR 1 ++#define LZO_HAVE_MM_HUGE_ARRAY 1 ++#if (LZO_MM_TINY) ++# undef LZO_HAVE_MM_HUGE_ARRAY ++#endif ++#if (LZO_CC_AZTECC || LZO_CC_PACIFICC || LZO_CC_ZORTECHC) ++# undef LZO_HAVE_MM_HUGE_PTR ++# undef LZO_HAVE_MM_HUGE_ARRAY ++#elif (LZO_CC_DMC || LZO_CC_SYMANTECC) ++# undef LZO_HAVE_MM_HUGE_ARRAY ++#elif (LZO_CC_MSC && defined(_QC)) ++# undef LZO_HAVE_MM_HUGE_ARRAY ++# if (_MSC_VER < 600) ++# undef LZO_HAVE_MM_HUGE_PTR ++# endif ++#elif (LZO_CC_TURBOC && (__TURBOC__ < 0x0295)) ++# undef LZO_HAVE_MM_HUGE_ARRAY ++#endif ++#if (LZO_ARCH_I086PM) && !(LZO_HAVE_MM_HUGE_PTR) ++# if (LZO_OS_DOS16) ++# error "this should not happen" ++# elif (LZO_CC_ZORTECHC) ++# else ++# error "this should not happen" ++# endif ++#endif ++#ifdef __cplusplus ++extern "C" { ++#endif ++#if (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0200)) ++ extern void __near __cdecl _AHSHIFT(void); ++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT) ++#elif (LZO_CC_DMC || LZO_CC_SYMANTECC || LZO_CC_ZORTECHC) ++ extern void __near __cdecl _AHSHIFT(void); ++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT) ++#elif (LZO_CC_MSC || LZO_CC_TOPSPEEDC) ++ extern void __near __cdecl _AHSHIFT(void); ++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT) ++#elif (LZO_CC_TURBOC && (__TURBOC__ >= 0x0295)) ++ extern void __near __cdecl _AHSHIFT(void); ++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT) ++#elif ((LZO_CC_AZTECC || LZO_CC_PACIFICC || LZO_CC_TURBOC) && LZO_OS_DOS16) ++# define LZO_MM_AHSHIFT 12 ++#elif (LZO_CC_WATCOMC) ++ extern unsigned char _HShift; ++# define LZO_MM_AHSHIFT ((unsigned) _HShift) ++#else ++# error "FIXME - implement LZO_MM_AHSHIFT" ++#endif ++#ifdef __cplusplus ++} ++#endif ++#endif ++#elif (LZO_ARCH_C166) ++#if !defined(__MODEL__) ++# error "FIXME - C166 __MODEL__" ++#elif ((__MODEL__) == 0) ++# define LZO_MM_SMALL 1 ++#elif ((__MODEL__) == 1) ++# define LZO_MM_SMALL 1 ++#elif ((__MODEL__) == 2) ++# define LZO_MM_LARGE 1 ++#elif ((__MODEL__) == 3) ++# define LZO_MM_TINY 1 ++#elif ((__MODEL__) == 4) ++# define LZO_MM_XTINY 1 ++#elif ((__MODEL__) == 5) ++# define LZO_MM_XSMALL 1 ++#else ++# error "FIXME - C166 __MODEL__" ++#endif ++#elif (LZO_ARCH_MCS251) ++#if !defined(__MODEL__) ++# error "FIXME - MCS251 __MODEL__" ++#elif ((__MODEL__) == 0) ++# define LZO_MM_SMALL 1 ++#elif ((__MODEL__) == 2) ++# define LZO_MM_LARGE 1 ++#elif ((__MODEL__) == 3) ++# define LZO_MM_TINY 1 ++#elif ((__MODEL__) == 4) ++# define LZO_MM_XTINY 1 ++#elif ((__MODEL__) == 5) ++# define LZO_MM_XSMALL 1 ++#else ++# error "FIXME - MCS251 __MODEL__" ++#endif ++#elif (LZO_ARCH_MCS51) ++#if !defined(__MODEL__) ++# error "FIXME - MCS51 __MODEL__" ++#elif ((__MODEL__) == 1) ++# define LZO_MM_SMALL 1 ++#elif ((__MODEL__) == 2) ++# define LZO_MM_LARGE 1 ++#elif ((__MODEL__) == 3) ++# define LZO_MM_TINY 1 ++#elif ((__MODEL__) == 4) ++# define LZO_MM_XTINY 1 ++#elif ((__MODEL__) == 5) ++# define LZO_MM_XSMALL 1 ++#else ++# error "FIXME - MCS51 __MODEL__" ++#endif ++#elif (LZO_ARCH_CRAY_PVP) ++# define LZO_MM_PVP 1 ++#else ++# define LZO_MM_FLAT 1 ++#endif ++#if (LZO_MM_COMPACT) ++# define LZO_INFO_MM "compact" ++#elif (LZO_MM_FLAT) ++# define LZO_INFO_MM "flat" ++#elif (LZO_MM_HUGE) ++# define LZO_INFO_MM "huge" ++#elif (LZO_MM_LARGE) ++# define LZO_INFO_MM "large" ++#elif (LZO_MM_MEDIUM) ++# define LZO_INFO_MM "medium" ++#elif (LZO_MM_PVP) ++# define LZO_INFO_MM "pvp" ++#elif (LZO_MM_SMALL) ++# define LZO_INFO_MM "small" ++#elif (LZO_MM_TINY) ++# define LZO_INFO_MM "tiny" ++#else ++# error "unknown memory model" ++#endif ++#endif ++#if defined(SIZEOF_SHORT) ++# define LZO_SIZEOF_SHORT (SIZEOF_SHORT) ++#endif ++#if defined(SIZEOF_INT) ++# define LZO_SIZEOF_INT (SIZEOF_INT) ++#endif ++#if defined(SIZEOF_LONG) ++# define LZO_SIZEOF_LONG (SIZEOF_LONG) ++#endif ++#if defined(SIZEOF_LONG_LONG) ++# define LZO_SIZEOF_LONG_LONG (SIZEOF_LONG_LONG) ++#endif ++#if defined(SIZEOF___INT16) ++# define LZO_SIZEOF___INT16 (SIZEOF___INT16) ++#endif ++#if defined(SIZEOF___INT32) ++# define LZO_SIZEOF___INT32 (SIZEOF___INT32) ++#endif ++#if defined(SIZEOF___INT64) ++# define LZO_SIZEOF___INT64 (SIZEOF___INT64) ++#endif ++#if defined(SIZEOF_VOID_P) ++# define LZO_SIZEOF_VOID_P (SIZEOF_VOID_P) ++#endif ++#if defined(SIZEOF_SIZE_T) ++# define LZO_SIZEOF_SIZE_T (SIZEOF_SIZE_T) ++#endif ++#if defined(SIZEOF_PTRDIFF_T) ++# define LZO_SIZEOF_PTRDIFF_T (SIZEOF_PTRDIFF_T) ++#endif ++#define __LZO_LSR(x,b) (((x)+0ul) >> (b)) ++#if !defined(LZO_SIZEOF_SHORT) ++# if (LZO_ARCH_CRAY_PVP) ++# define LZO_SIZEOF_SHORT 8 ++# elif (USHRT_MAX == LZO_0xffffL) ++# define LZO_SIZEOF_SHORT 2 ++# elif (__LZO_LSR(USHRT_MAX,7) == 1) ++# define LZO_SIZEOF_SHORT 1 ++# elif (__LZO_LSR(USHRT_MAX,15) == 1) ++# define LZO_SIZEOF_SHORT 2 ++# elif (__LZO_LSR(USHRT_MAX,31) == 1) ++# define LZO_SIZEOF_SHORT 4 ++# elif (__LZO_LSR(USHRT_MAX,63) == 1) ++# define LZO_SIZEOF_SHORT 8 ++# elif (__LZO_LSR(USHRT_MAX,127) == 1) ++# define LZO_SIZEOF_SHORT 16 ++# else ++# error "LZO_SIZEOF_SHORT" ++# endif ++#endif ++#if !defined(LZO_SIZEOF_INT) ++# if (LZO_ARCH_CRAY_PVP) ++# define LZO_SIZEOF_INT 8 ++# elif (UINT_MAX == LZO_0xffffL) ++# define LZO_SIZEOF_INT 2 ++# elif (UINT_MAX == LZO_0xffffffffL) ++# define LZO_SIZEOF_INT 4 ++# elif (__LZO_LSR(UINT_MAX,7) == 1) ++# define LZO_SIZEOF_INT 1 ++# elif (__LZO_LSR(UINT_MAX,15) == 1) ++# define LZO_SIZEOF_INT 2 ++# elif (__LZO_LSR(UINT_MAX,31) == 1) ++# define LZO_SIZEOF_INT 4 ++# elif (__LZO_LSR(UINT_MAX,63) == 1) ++# define LZO_SIZEOF_INT 8 ++# elif (__LZO_LSR(UINT_MAX,127) == 1) ++# define LZO_SIZEOF_INT 16 ++# else ++# error "LZO_SIZEOF_INT" ++# endif ++#endif ++#if !defined(LZO_SIZEOF_LONG) ++# if (ULONG_MAX == LZO_0xffffffffL) ++# define LZO_SIZEOF_LONG 4 ++# elif (__LZO_LSR(ULONG_MAX,7) == 1) ++# define LZO_SIZEOF_LONG 1 ++# elif (__LZO_LSR(ULONG_MAX,15) == 1) ++# define LZO_SIZEOF_LONG 2 ++# elif (__LZO_LSR(ULONG_MAX,31) == 1) ++# define LZO_SIZEOF_LONG 4 ++# elif (__LZO_LSR(ULONG_MAX,63) == 1) ++# define LZO_SIZEOF_LONG 8 ++# elif (__LZO_LSR(ULONG_MAX,127) == 1) ++# define LZO_SIZEOF_LONG 16 ++# else ++# error "LZO_SIZEOF_LONG" ++# endif ++#endif ++#if !defined(LZO_SIZEOF_LONG_LONG) && !defined(LZO_SIZEOF___INT64) ++#if (LZO_SIZEOF_LONG > 0 && LZO_SIZEOF_LONG < 8) ++# if defined(__LONG_MAX__) && defined(__LONG_LONG_MAX__) ++# if (LZO_CC_GNUC >= 0x030300ul) ++# if ((__LONG_MAX__)+0 == (__LONG_LONG_MAX__)+0) ++# define LZO_SIZEOF_LONG_LONG LZO_SIZEOF_LONG ++# elif (__LZO_LSR(__LONG_LONG_MAX__,30) == 1) ++# define LZO_SIZEOF_LONG_LONG 4 ++# endif ++# endif ++# endif ++#endif ++#endif ++#if !defined(LZO_SIZEOF_LONG_LONG) && !defined(LZO_SIZEOF___INT64) ++#if (LZO_SIZEOF_LONG > 0 && LZO_SIZEOF_LONG < 8) ++#if (LZO_ARCH_I086 && LZO_CC_DMC) ++#elif (LZO_CC_CILLY) && defined(__GNUC__) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif ((LZO_OS_WIN32 || LZO_OS_WIN64 || defined(_WIN32)) && LZO_CC_MSC && (_MSC_VER >= 1400)) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_OS_WIN64 || defined(_WIN64)) ++# define LZO_SIZEOF___INT64 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_DMC)) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_SYMANTECC && (__SC__ >= 0x700))) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_INTELC && defined(__linux__))) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_MWERKS || LZO_CC_PELLESC || LZO_CC_PGI || LZO_CC_SUNPROC)) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_INTELC || LZO_CC_MSC)) ++# define LZO_SIZEOF___INT64 8 ++#elif ((LZO_OS_WIN32 || defined(_WIN32)) && (LZO_CC_MSC)) ++# define LZO_SIZEOF___INT64 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0520))) ++# define LZO_SIZEOF___INT64 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_WATCOMC && (__WATCOMC__ >= 1100))) ++# define LZO_SIZEOF___INT64 8 ++#elif (LZO_CC_WATCOMC && defined(_INTEGRAL_MAX_BITS) && (_INTEGRAL_MAX_BITS == 64)) ++# define LZO_SIZEOF___INT64 8 ++#elif (LZO_OS_OS400 || defined(__OS400__)) && defined(__LLP64_IFC__) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (defined(__vms) || defined(__VMS)) && (__INITIAL_POINTER_SIZE+0 == 64) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_CC_SDCC) && (LZO_SIZEOF_INT == 2) ++#elif 1 && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) ++# define LZO_SIZEOF_LONG_LONG 8 ++#endif ++#endif ++#endif ++#if defined(__cplusplus) && (LZO_CC_GNUC) ++# if (LZO_CC_GNUC < 0x020800ul) ++# undef LZO_SIZEOF_LONG_LONG ++# endif ++#endif ++#if (LZO_CFG_NO_LONG_LONG) || defined(__NO_LONG_LONG) ++# undef LZO_SIZEOF_LONG_LONG ++#endif ++#if !defined(LZO_SIZEOF_VOID_P) ++#if (LZO_ARCH_I086) ++# define __LZO_WORDSIZE 2 ++# if (LZO_MM_TINY || LZO_MM_SMALL || LZO_MM_MEDIUM) ++# define LZO_SIZEOF_VOID_P 2 ++# elif (LZO_MM_COMPACT || LZO_MM_LARGE || LZO_MM_HUGE) ++# define LZO_SIZEOF_VOID_P 4 ++# else ++# error "LZO_MM" ++# endif ++#elif (LZO_ARCH_AVR || LZO_ARCH_Z80) ++# define __LZO_WORDSIZE 1 ++# define LZO_SIZEOF_VOID_P 2 ++#elif (LZO_ARCH_C166 || LZO_ARCH_MCS51 || LZO_ARCH_MCS251 || LZO_ARCH_MSP430) ++# define LZO_SIZEOF_VOID_P 2 ++#elif (LZO_ARCH_H8300) ++# if defined(__NORMAL_MODE__) ++# define __LZO_WORDSIZE 4 ++# define LZO_SIZEOF_VOID_P 2 ++# elif defined(__H8300H__) || defined(__H8300S__) || defined(__H8300SX__) ++# define __LZO_WORDSIZE 4 ++# define LZO_SIZEOF_VOID_P 4 ++# else ++# define __LZO_WORDSIZE 2 ++# define LZO_SIZEOF_VOID_P 2 ++# endif ++# if (LZO_CC_GNUC && (LZO_CC_GNUC < 0x040000ul)) && (LZO_SIZEOF_INT == 4) ++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_INT ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_INT ++# endif ++#elif (LZO_ARCH_M16C) ++# define __LZO_WORDSIZE 2 ++# if defined(__m32c_cpu__) || defined(__m32cm_cpu__) ++# define LZO_SIZEOF_VOID_P 4 ++# else ++# define LZO_SIZEOF_VOID_P 2 ++# endif ++#elif (LZO_SIZEOF_LONG == 8) && ((defined(__mips__) && defined(__R5900__)) || defined(__MIPS_PSX2__)) ++# define __LZO_WORDSIZE 8 ++# define LZO_SIZEOF_VOID_P 4 ++#elif defined(__LLP64__) || defined(__LLP64) || defined(_LLP64) || defined(_WIN64) ++# define __LZO_WORDSIZE 8 ++# define LZO_SIZEOF_VOID_P 8 ++#elif (LZO_OS_OS400 || defined(__OS400__)) && defined(__LLP64_IFC__) ++# define LZO_SIZEOF_VOID_P LZO_SIZEOF_LONG ++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_LONG ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_LONG ++#elif (LZO_OS_OS400 || defined(__OS400__)) ++# define __LZO_WORDSIZE LZO_SIZEOF_LONG ++# define LZO_SIZEOF_VOID_P 16 ++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_LONG ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_LONG ++#elif (defined(__vms) || defined(__VMS)) && (__INITIAL_POINTER_SIZE+0 == 64) ++# define LZO_SIZEOF_VOID_P 8 ++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_LONG ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_LONG ++#elif (LZO_ARCH_SPU) ++# if 0 ++# define __LZO_WORDSIZE 16 ++# endif ++# define LZO_SIZEOF_VOID_P 4 ++#else ++# define LZO_SIZEOF_VOID_P LZO_SIZEOF_LONG ++#endif ++#endif ++#if !defined(LZO_WORDSIZE) ++# if defined(__LZO_WORDSIZE) ++# define LZO_WORDSIZE __LZO_WORDSIZE ++# else ++# define LZO_WORDSIZE LZO_SIZEOF_VOID_P ++# endif ++#endif ++#if !defined(LZO_SIZEOF_SIZE_T) ++#if (LZO_ARCH_I086 || LZO_ARCH_M16C) ++# define LZO_SIZEOF_SIZE_T 2 ++#else ++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_VOID_P ++#endif ++#endif ++#if !defined(LZO_SIZEOF_PTRDIFF_T) ++#if (LZO_ARCH_I086) ++# if (LZO_MM_TINY || LZO_MM_SMALL || LZO_MM_MEDIUM || LZO_MM_HUGE) ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_VOID_P ++# elif (LZO_MM_COMPACT || LZO_MM_LARGE) ++# if (LZO_CC_BORLANDC || LZO_CC_TURBOC) ++# define LZO_SIZEOF_PTRDIFF_T 4 ++# else ++# define LZO_SIZEOF_PTRDIFF_T 2 ++# endif ++# else ++# error "LZO_MM" ++# endif ++#else ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_SIZE_T ++#endif ++#endif ++#if (LZO_ABI_NEUTRAL_ENDIAN) ++# undef LZO_ABI_BIG_ENDIAN ++# undef LZO_ABI_LITTLE_ENDIAN ++#elif !(LZO_ABI_BIG_ENDIAN) && !(LZO_ABI_LITTLE_ENDIAN) ++#if (LZO_ARCH_ALPHA) && (LZO_ARCH_CRAY_MPP) ++# define LZO_ABI_BIG_ENDIAN 1 ++#elif (LZO_ARCH_IA64) && (LZO_OS_POSIX_LINUX || LZO_OS_WIN64) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++#elif (LZO_ARCH_ALPHA || LZO_ARCH_AMD64 || LZO_ARCH_BLACKFIN || LZO_ARCH_CRIS || LZO_ARCH_I086 || LZO_ARCH_I386 || LZO_ARCH_MSP430) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++#elif (LZO_ARCH_AVR32 || LZO_ARCH_M68K || LZO_ARCH_S390) ++# define LZO_ABI_BIG_ENDIAN 1 ++#elif 1 && defined(__IAR_SYSTEMS_ICC__) && defined(__LITTLE_ENDIAN__) ++# if (__LITTLE_ENDIAN__ == 1) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++# else ++# define LZO_ABI_BIG_ENDIAN 1 ++# endif ++#elif 1 && defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__) ++# define LZO_ABI_BIG_ENDIAN 1 ++#elif 1 && defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++#elif 1 && (LZO_ARCH_ARM) && defined(__ARMEB__) && !defined(__ARMEL__) ++# define LZO_ABI_BIG_ENDIAN 1 ++#elif 1 && (LZO_ARCH_ARM) && defined(__ARMEL__) && !defined(__ARMEB__) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++#elif 1 && (LZO_ARCH_MIPS) && defined(__MIPSEB__) && !defined(__MIPSEL__) ++# define LZO_ABI_BIG_ENDIAN 1 ++#elif 1 && (LZO_ARCH_MIPS) && defined(__MIPSEL__) && !defined(__MIPSEB__) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++#endif ++#endif ++#if (LZO_ABI_BIG_ENDIAN) && (LZO_ABI_LITTLE_ENDIAN) ++# error "this should not happen" ++#endif ++#if (LZO_ABI_BIG_ENDIAN) ++# define LZO_INFO_ABI_ENDIAN "be" ++#elif (LZO_ABI_LITTLE_ENDIAN) ++# define LZO_INFO_ABI_ENDIAN "le" ++#elif (LZO_ABI_NEUTRAL_ENDIAN) ++# define LZO_INFO_ABI_ENDIAN "neutral" ++#endif ++#if (LZO_SIZEOF_INT == 1 && LZO_SIZEOF_LONG == 2 && LZO_SIZEOF_VOID_P == 2) ++# define LZO_ABI_I8LP16 1 ++# define LZO_INFO_ABI_PM "i8lp16" ++#elif (LZO_SIZEOF_INT == 2 && LZO_SIZEOF_LONG == 2 && LZO_SIZEOF_VOID_P == 2) ++# define LZO_ABI_ILP16 1 ++# define LZO_INFO_ABI_PM "ilp16" ++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 4 && LZO_SIZEOF_VOID_P == 4) ++# define LZO_ABI_ILP32 1 ++# define LZO_INFO_ABI_PM "ilp32" ++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 4 && LZO_SIZEOF_VOID_P == 8 && LZO_SIZEOF_SIZE_T == 8) ++# define LZO_ABI_LLP64 1 ++# define LZO_INFO_ABI_PM "llp64" ++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 8 && LZO_SIZEOF_VOID_P == 8) ++# define LZO_ABI_LP64 1 ++# define LZO_INFO_ABI_PM "lp64" ++#elif (LZO_SIZEOF_INT == 8 && LZO_SIZEOF_LONG == 8 && LZO_SIZEOF_VOID_P == 8) ++# define LZO_ABI_ILP64 1 ++# define LZO_INFO_ABI_PM "ilp64" ++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 8 && LZO_SIZEOF_VOID_P == 4) ++# define LZO_ABI_IP32L64 1 ++# define LZO_INFO_ABI_PM "ip32l64" ++#endif ++#if !defined(__LZO_LIBC_OVERRIDE) ++#if (LZO_LIBC_NAKED) ++# define LZO_INFO_LIBC "naked" ++#elif (LZO_LIBC_FREESTANDING) ++# define LZO_INFO_LIBC "freestanding" ++#elif (LZO_LIBC_MOSTLY_FREESTANDING) ++# define LZO_INFO_LIBC "mfreestanding" ++#elif (LZO_LIBC_ISOC90) ++# define LZO_INFO_LIBC "isoc90" ++#elif (LZO_LIBC_ISOC99) ++# define LZO_INFO_LIBC "isoc99" ++#elif defined(__dietlibc__) ++# define LZO_LIBC_DIETLIBC 1 ++# define LZO_INFO_LIBC "dietlibc" ++#elif defined(_NEWLIB_VERSION) ++# define LZO_LIBC_NEWLIB 1 ++# define LZO_INFO_LIBC "newlib" ++#elif defined(__UCLIBC__) && defined(__UCLIBC_MAJOR__) && defined(__UCLIBC_MINOR__) ++# if defined(__UCLIBC_SUBLEVEL__) ++# define LZO_LIBC_UCLIBC (__UCLIBC_MAJOR__ * 0x10000L + __UCLIBC_MINOR__ * 0x100 + __UCLIBC_SUBLEVEL__) ++# else ++# define LZO_LIBC_UCLIBC 0x00090bL ++# endif ++# define LZO_INFO_LIBC "uclibc" ++#elif defined(__GLIBC__) && defined(__GLIBC_MINOR__) ++# define LZO_LIBC_GLIBC (__GLIBC__ * 0x10000L + __GLIBC_MINOR__ * 0x100) ++# define LZO_INFO_LIBC "glibc" ++#elif (LZO_CC_MWERKS) && defined(__MSL__) ++# define LZO_LIBC_MSL __MSL__ ++# define LZO_INFO_LIBC "msl" ++#elif 1 && defined(__IAR_SYSTEMS_ICC__) ++# define LZO_LIBC_ISOC90 1 ++# define LZO_INFO_LIBC "isoc90" ++#else ++# define LZO_LIBC_DEFAULT 1 ++# define LZO_INFO_LIBC "default" ++#endif ++#endif ++#if !defined(__lzo_gnuc_extension__) ++#if (LZO_CC_GNUC >= 0x020800ul) ++# define __lzo_gnuc_extension__ __extension__ ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_gnuc_extension__ __extension__ ++#else ++# define __lzo_gnuc_extension__ /*empty*/ ++#endif ++#endif ++#if !defined(__lzo_ua_volatile) ++# define __lzo_ua_volatile volatile ++#endif ++#if !defined(__lzo_alignof) ++#if (LZO_CC_CILLY || LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE || LZO_CC_PGI) ++# define __lzo_alignof(e) __alignof__(e) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 700)) ++# define __lzo_alignof(e) __alignof__(e) ++#elif (LZO_CC_MSC && (_MSC_VER >= 1300)) ++# define __lzo_alignof(e) __alignof(e) ++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100)) ++# define __lzo_alignof(e) __alignof__(e) ++#endif ++#endif ++#if defined(__lzo_alignof) ++# define __lzo_HAVE_alignof 1 ++#endif ++#if !defined(__lzo_constructor) ++#if (LZO_CC_GNUC >= 0x030400ul) ++# define __lzo_constructor __attribute__((__constructor__,__used__)) ++#elif (LZO_CC_GNUC >= 0x020700ul) ++# define __lzo_constructor __attribute__((__constructor__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_constructor __attribute__((__constructor__)) ++#endif ++#endif ++#if defined(__lzo_constructor) ++# define __lzo_HAVE_constructor 1 ++#endif ++#if !defined(__lzo_destructor) ++#if (LZO_CC_GNUC >= 0x030400ul) ++# define __lzo_destructor __attribute__((__destructor__,__used__)) ++#elif (LZO_CC_GNUC >= 0x020700ul) ++# define __lzo_destructor __attribute__((__destructor__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_destructor __attribute__((__destructor__)) ++#endif ++#endif ++#if defined(__lzo_destructor) ++# define __lzo_HAVE_destructor 1 ++#endif ++#if (__lzo_HAVE_destructor) && !(__lzo_HAVE_constructor) ++# error "this should not happen" ++#endif ++#if !defined(__lzo_inline) ++#if (LZO_CC_TURBOC && (__TURBOC__ <= 0x0295)) ++#elif defined(__cplusplus) ++# define __lzo_inline inline ++#elif (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0550)) ++# define __lzo_inline __inline ++#elif (LZO_CC_CILLY || LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE || LZO_CC_PGI) ++# define __lzo_inline __inline__ ++#elif (LZO_CC_DMC) ++# define __lzo_inline __inline ++#elif (LZO_CC_INTELC) ++# define __lzo_inline __inline ++#elif (LZO_CC_MWERKS && (__MWERKS__ >= 0x2405)) ++# define __lzo_inline __inline ++#elif (LZO_CC_MSC && (_MSC_VER >= 900)) ++# define __lzo_inline __inline ++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100)) ++# define __lzo_inline __inline__ ++#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) ++# define __lzo_inline inline ++#endif ++#endif ++#if defined(__lzo_inline) ++# define __lzo_HAVE_inline 1 ++#else ++# define __lzo_inline /*empty*/ ++#endif ++#if !defined(__lzo_forceinline) ++#if (LZO_CC_GNUC >= 0x030200ul) ++# define __lzo_forceinline __inline__ __attribute__((__always_inline__)) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 450) && LZO_CC_SYNTAX_MSC) ++# define __lzo_forceinline __forceinline ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 800) && LZO_CC_SYNTAX_GNUC) ++# define __lzo_forceinline __inline__ __attribute__((__always_inline__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_forceinline __inline__ __attribute__((__always_inline__)) ++#elif (LZO_CC_MSC && (_MSC_VER >= 1200)) ++# define __lzo_forceinline __forceinline ++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100)) ++# define __lzo_forceinline __inline__ __attribute__((__always_inline__)) ++#endif ++#endif ++#if defined(__lzo_forceinline) ++# define __lzo_HAVE_forceinline 1 ++#else ++# define __lzo_forceinline /*empty*/ ++#endif ++#if !defined(__lzo_noinline) ++#if 1 && (LZO_ARCH_I386) && (LZO_CC_GNUC >= 0x040000ul) && (LZO_CC_GNUC < 0x040003ul) ++# define __lzo_noinline __attribute__((__noinline__,__used__)) ++#elif (LZO_CC_GNUC >= 0x030200ul) ++# define __lzo_noinline __attribute__((__noinline__)) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 600) && LZO_CC_SYNTAX_MSC) ++# define __lzo_noinline __declspec(noinline) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 800) && LZO_CC_SYNTAX_GNUC) ++# define __lzo_noinline __attribute__((__noinline__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_noinline __attribute__((__noinline__)) ++#elif (LZO_CC_MSC && (_MSC_VER >= 1300)) ++# define __lzo_noinline __declspec(noinline) ++#elif (LZO_CC_MWERKS && (__MWERKS__ >= 0x3200) && (LZO_OS_WIN32 || LZO_OS_WIN64)) ++# if defined(__cplusplus) ++# else ++# define __lzo_noinline __declspec(noinline) ++# endif ++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100)) ++# define __lzo_noinline __attribute__((__noinline__)) ++#endif ++#endif ++#if defined(__lzo_noinline) ++# define __lzo_HAVE_noinline 1 ++#else ++# define __lzo_noinline /*empty*/ ++#endif ++#if (__lzo_HAVE_forceinline || __lzo_HAVE_noinline) && !(__lzo_HAVE_inline) ++# error "this should not happen" ++#endif ++#if !defined(__lzo_noreturn) ++#if (LZO_CC_GNUC >= 0x020700ul) ++# define __lzo_noreturn __attribute__((__noreturn__)) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 450) && LZO_CC_SYNTAX_MSC) ++# define __lzo_noreturn __declspec(noreturn) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 600) && LZO_CC_SYNTAX_GNUC) ++# define __lzo_noreturn __attribute__((__noreturn__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_noreturn __attribute__((__noreturn__)) ++#elif (LZO_CC_MSC && (_MSC_VER >= 1200)) ++# define __lzo_noreturn __declspec(noreturn) ++#endif ++#endif ++#if defined(__lzo_noreturn) ++# define __lzo_HAVE_noreturn 1 ++#else ++# define __lzo_noreturn /*empty*/ ++#endif ++#if !defined(__lzo_nothrow) ++#if (LZO_CC_GNUC >= 0x030300ul) ++# define __lzo_nothrow __attribute__((__nothrow__)) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 450) && LZO_CC_SYNTAX_MSC) && defined(__cplusplus) ++# define __lzo_nothrow __declspec(nothrow) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 900) && LZO_CC_SYNTAX_GNUC) ++# define __lzo_nothrow __attribute__((__nothrow__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_nothrow __attribute__((__nothrow__)) ++#elif (LZO_CC_MSC && (_MSC_VER >= 1200)) && defined(__cplusplus) ++# define __lzo_nothrow __declspec(nothrow) ++#endif ++#endif ++#if defined(__lzo_nothrow) ++# define __lzo_HAVE_nothrow 1 ++#else ++# define __lzo_nothrow /*empty*/ ++#endif ++#if !defined(__lzo_restrict) ++#if (LZO_CC_GNUC >= 0x030400ul) ++# define __lzo_restrict __restrict__ ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 600) && LZO_CC_SYNTAX_GNUC) ++# define __lzo_restrict __restrict__ ++#elif (LZO_CC_CLANG || LZO_CC_LLVM) ++# define __lzo_restrict __restrict__ ++#elif (LZO_CC_MSC && (_MSC_VER >= 1400)) ++# define __lzo_restrict __restrict ++#endif ++#endif ++#if defined(__lzo_restrict) ++# define __lzo_HAVE_restrict 1 ++#else ++# define __lzo_restrict /*empty*/ ++#endif ++#if !defined(__lzo_likely) && !defined(__lzo_unlikely) ++#if (LZO_CC_GNUC >= 0x030200ul) ++# define __lzo_likely(e) (__builtin_expect(!!(e),1)) ++# define __lzo_unlikely(e) (__builtin_expect(!!(e),0)) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 800)) ++# define __lzo_likely(e) (__builtin_expect(!!(e),1)) ++# define __lzo_unlikely(e) (__builtin_expect(!!(e),0)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_likely(e) (__builtin_expect(!!(e),1)) ++# define __lzo_unlikely(e) (__builtin_expect(!!(e),0)) ++#endif ++#endif ++#if defined(__lzo_likely) ++# define __lzo_HAVE_likely 1 ++#else ++# define __lzo_likely(e) (e) ++#endif ++#if defined(__lzo_unlikely) ++# define __lzo_HAVE_unlikely 1 ++#else ++# define __lzo_unlikely(e) (e) ++#endif ++#if !defined(LZO_UNUSED) ++# if (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0600)) ++# define LZO_UNUSED(var) ((void) &var) ++# elif (LZO_CC_BORLANDC || LZO_CC_HIGHC || LZO_CC_NDPC || LZO_CC_PELLESC || LZO_CC_TURBOC) ++# define LZO_UNUSED(var) if (&var) ; else ++# elif (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define LZO_UNUSED(var) ((void) var) ++# elif (LZO_CC_MSC && (_MSC_VER < 900)) ++# define LZO_UNUSED(var) if (&var) ; else ++# elif (LZO_CC_KEILC) ++# define LZO_UNUSED(var) {extern int __lzo_unused[1-2*!(sizeof(var)>0)];} ++# elif (LZO_CC_PACIFICC) ++# define LZO_UNUSED(var) ((void) sizeof(var)) ++# elif (LZO_CC_WATCOMC) && defined(__cplusplus) ++# define LZO_UNUSED(var) ((void) var) ++# else ++# define LZO_UNUSED(var) ((void) &var) ++# endif ++#endif ++#if !defined(LZO_UNUSED_FUNC) ++# if (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0600)) ++# define LZO_UNUSED_FUNC(func) ((void) func) ++# elif (LZO_CC_BORLANDC || LZO_CC_NDPC || LZO_CC_TURBOC) ++# define LZO_UNUSED_FUNC(func) if (func) ; else ++# elif (LZO_CC_CLANG || LZO_CC_LLVM) ++# define LZO_UNUSED_FUNC(func) ((void) &func) ++# elif (LZO_CC_MSC && (_MSC_VER < 900)) ++# define LZO_UNUSED_FUNC(func) if (func) ; else ++# elif (LZO_CC_MSC) ++# define LZO_UNUSED_FUNC(func) ((void) &func) ++# elif (LZO_CC_KEILC || LZO_CC_PELLESC) ++# define LZO_UNUSED_FUNC(func) {extern int __lzo_unused[1-2*!(sizeof((int)func)>0)];} ++# else ++# define LZO_UNUSED_FUNC(func) ((void) func) ++# endif ++#endif ++#if !defined(LZO_UNUSED_LABEL) ++# if (LZO_CC_WATCOMC) && defined(__cplusplus) ++# define LZO_UNUSED_LABEL(l) switch(0) case 1:goto l ++# elif (LZO_CC_CLANG || LZO_CC_INTELC || LZO_CC_WATCOMC) ++# define LZO_UNUSED_LABEL(l) if (0) goto l ++# else ++# define LZO_UNUSED_LABEL(l) switch(0) case 1:goto l ++# endif ++#endif ++#if !defined(LZO_DEFINE_UNINITIALIZED_VAR) ++# if 0 ++# define LZO_DEFINE_UNINITIALIZED_VAR(type,var,init) type var ++# elif 0 && (LZO_CC_GNUC) ++# define LZO_DEFINE_UNINITIALIZED_VAR(type,var,init) type var = var ++# else ++# define LZO_DEFINE_UNINITIALIZED_VAR(type,var,init) type var = init ++# endif ++#endif ++#if !defined(LZO_UNCONST_CAST) ++# if 0 && defined(__cplusplus) ++# define LZO_UNCONST_CAST(t,e) (const_cast<t> (e)) ++# elif (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define LZO_UNCONST_CAST(t,e) ((t) ((void *) ((char *) ((lzo_uintptr_t) ((const void *) (e)))))) ++# else ++# define LZO_UNCONST_CAST(t,e) ((t) ((void *) ((char *) ((const void *) (e))))) ++# endif ++#endif ++#if !defined(LZO_COMPILE_TIME_ASSERT_HEADER) ++# if (LZO_CC_AZTECC || LZO_CC_ZORTECHC) ++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1-!(e)]; ++# elif (LZO_CC_DMC || LZO_CC_SYMANTECC) ++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1u-2*!(e)]; ++# elif (LZO_CC_TURBOC && (__TURBOC__ == 0x0295)) ++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1-!(e)]; ++# else ++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1-2*!(e)]; ++# endif ++#endif ++#if !defined(LZO_COMPILE_TIME_ASSERT) ++# if (LZO_CC_AZTECC) ++# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __lzo_cta_t[1-!(e)];} ++# elif (LZO_CC_DMC || LZO_CC_PACIFICC || LZO_CC_SYMANTECC || LZO_CC_ZORTECHC) ++# define LZO_COMPILE_TIME_ASSERT(e) switch(0) case 1:case !(e):break; ++# elif (LZO_CC_MSC && (_MSC_VER < 900)) ++# define LZO_COMPILE_TIME_ASSERT(e) switch(0) case 1:case !(e):break; ++# elif (LZO_CC_TURBOC && (__TURBOC__ == 0x0295)) ++# define LZO_COMPILE_TIME_ASSERT(e) switch(0) case 1:case !(e):break; ++# else ++# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __lzo_cta_t[1-2*!(e)];} ++# endif ++#endif ++#if (LZO_ARCH_I086 || LZO_ARCH_I386) && (LZO_OS_DOS16 || LZO_OS_DOS32 || LZO_OS_OS2 || LZO_OS_OS216 || LZO_OS_WIN16 || LZO_OS_WIN32 || LZO_OS_WIN64) ++# if (LZO_CC_GNUC || LZO_CC_HIGHC || LZO_CC_NDPC || LZO_CC_PACIFICC) ++# elif (LZO_CC_DMC || LZO_CC_SYMANTECC || LZO_CC_ZORTECHC) ++# define __lzo_cdecl __cdecl ++# define __lzo_cdecl_atexit /*empty*/ ++# define __lzo_cdecl_main __cdecl ++# if (LZO_OS_OS2 && (LZO_CC_DMC || LZO_CC_SYMANTECC)) ++# define __lzo_cdecl_qsort __pascal ++# elif (LZO_OS_OS2 && (LZO_CC_ZORTECHC)) ++# define __lzo_cdecl_qsort _stdcall ++# else ++# define __lzo_cdecl_qsort __cdecl ++# endif ++# elif (LZO_CC_WATCOMC) ++# define __lzo_cdecl __cdecl ++# else ++# define __lzo_cdecl __cdecl ++# define __lzo_cdecl_atexit __cdecl ++# define __lzo_cdecl_main __cdecl ++# define __lzo_cdecl_qsort __cdecl ++# endif ++# if (LZO_CC_GNUC || LZO_CC_HIGHC || LZO_CC_NDPC || LZO_CC_PACIFICC || LZO_CC_WATCOMC) ++# elif (LZO_OS_OS2 && (LZO_CC_DMC || LZO_CC_SYMANTECC)) ++# define __lzo_cdecl_sighandler __pascal ++# elif (LZO_OS_OS2 && (LZO_CC_ZORTECHC)) ++# define __lzo_cdecl_sighandler _stdcall ++# elif (LZO_CC_MSC && (_MSC_VER >= 1400)) && defined(_M_CEE_PURE) ++# define __lzo_cdecl_sighandler __clrcall ++# elif (LZO_CC_MSC && (_MSC_VER >= 600 && _MSC_VER < 700)) ++# if defined(_DLL) ++# define __lzo_cdecl_sighandler _far _cdecl _loadds ++# elif defined(_MT) ++# define __lzo_cdecl_sighandler _far _cdecl ++# else ++# define __lzo_cdecl_sighandler _cdecl ++# endif ++# else ++# define __lzo_cdecl_sighandler __cdecl ++# endif ++#elif (LZO_ARCH_I386) && (LZO_CC_WATCOMC) ++# define __lzo_cdecl __cdecl ++#elif (LZO_ARCH_M68K && LZO_OS_TOS && (LZO_CC_PUREC || LZO_CC_TURBOC)) ++# define __lzo_cdecl cdecl ++#endif ++#if !defined(__lzo_cdecl) ++# define __lzo_cdecl /*empty*/ ++#endif ++#if !defined(__lzo_cdecl_atexit) ++# define __lzo_cdecl_atexit /*empty*/ ++#endif ++#if !defined(__lzo_cdecl_main) ++# define __lzo_cdecl_main /*empty*/ ++#endif ++#if !defined(__lzo_cdecl_qsort) ++# define __lzo_cdecl_qsort /*empty*/ ++#endif ++#if !defined(__lzo_cdecl_sighandler) ++# define __lzo_cdecl_sighandler /*empty*/ ++#endif ++#if !defined(__lzo_cdecl_va) ++# define __lzo_cdecl_va __lzo_cdecl ++#endif ++#if !(LZO_CFG_NO_WINDOWS_H) ++#if (LZO_OS_CYGWIN || (LZO_OS_EMX && defined(__RSXNT__)) || LZO_OS_WIN32 || LZO_OS_WIN64) ++# if (LZO_CC_WATCOMC && (__WATCOMC__ < 1000)) ++# elif (LZO_OS_WIN32 && LZO_CC_GNUC) && defined(__PW32__) ++# elif ((LZO_OS_CYGWIN || defined(__MINGW32__)) && (LZO_CC_GNUC && (LZO_CC_GNUC < 0x025f00ul))) ++# else ++# define LZO_HAVE_WINDOWS_H 1 ++# endif ++#endif ++#endif ++#if (LZO_ARCH_ALPHA) ++# define LZO_OPT_AVOID_UINT_INDEX 1 ++# define LZO_OPT_AVOID_SHORT 1 ++# define LZO_OPT_AVOID_USHORT 1 ++#elif (LZO_ARCH_AMD64) ++# define LZO_OPT_AVOID_INT_INDEX 1 ++# define LZO_OPT_AVOID_UINT_INDEX 1 ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++# define LZO_OPT_UNALIGNED64 1 ++#elif (LZO_ARCH_ARM && LZO_ARCH_ARM_THUMB) ++#elif (LZO_ARCH_ARM) ++# define LZO_OPT_AVOID_SHORT 1 ++# define LZO_OPT_AVOID_USHORT 1 ++#elif (LZO_ARCH_CRIS) ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++#elif (LZO_ARCH_I386) ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++#elif (LZO_ARCH_IA64) ++# define LZO_OPT_AVOID_INT_INDEX 1 ++# define LZO_OPT_AVOID_UINT_INDEX 1 ++# define LZO_OPT_PREFER_POSTINC 1 ++#elif (LZO_ARCH_M68K) ++# define LZO_OPT_PREFER_POSTINC 1 ++# define LZO_OPT_PREFER_PREDEC 1 ++# if defined(__mc68020__) && !defined(__mcoldfire__) ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++# endif ++#elif (LZO_ARCH_MIPS) ++# define LZO_OPT_AVOID_UINT_INDEX 1 ++#elif (LZO_ARCH_POWERPC) ++# define LZO_OPT_PREFER_PREINC 1 ++# define LZO_OPT_PREFER_PREDEC 1 ++# if (LZO_ABI_BIG_ENDIAN) ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++# endif ++#elif (LZO_ARCH_S390) ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++# if (LZO_SIZEOF_SIZE_T == 8) ++# define LZO_OPT_UNALIGNED64 1 ++# endif ++#elif (LZO_ARCH_SH) ++# define LZO_OPT_PREFER_POSTINC 1 ++# define LZO_OPT_PREFER_PREDEC 1 ++#endif ++#ifndef LZO_CFG_NO_INLINE_ASM ++#if (LZO_CC_LLVM) ++# define LZO_CFG_NO_INLINE_ASM 1 ++#endif ++#endif ++#ifndef LZO_CFG_NO_UNALIGNED ++#if (LZO_ABI_NEUTRAL_ENDIAN) || (LZO_ARCH_GENERIC) ++# define LZO_CFG_NO_UNALIGNED 1 ++#endif ++#endif ++#if (LZO_CFG_NO_UNALIGNED) ++# undef LZO_OPT_UNALIGNED16 ++# undef LZO_OPT_UNALIGNED32 ++# undef LZO_OPT_UNALIGNED64 ++#endif ++#if (LZO_CFG_NO_INLINE_ASM) ++#elif (LZO_ARCH_I386 && (LZO_OS_DOS32 || LZO_OS_WIN32) && (LZO_CC_DMC || LZO_CC_INTELC || LZO_CC_MSC || LZO_CC_PELLESC)) ++# define LZO_ASM_SYNTAX_MSC 1 ++#elif (LZO_OS_WIN64 && (LZO_CC_DMC || LZO_CC_INTELC || LZO_CC_MSC || LZO_CC_PELLESC)) ++#elif (LZO_ARCH_I386 && LZO_CC_GNUC && (LZO_CC_GNUC == 0x011f00ul)) ++#elif (LZO_ARCH_I386 && (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_INTELC || LZO_CC_PATHSCALE)) ++# define LZO_ASM_SYNTAX_GNUC 1 ++#elif (LZO_ARCH_AMD64 && (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_INTELC || LZO_CC_PATHSCALE)) ++# define LZO_ASM_SYNTAX_GNUC 1 ++#endif ++#if (LZO_ASM_SYNTAX_GNUC) ++#if (LZO_ARCH_I386 && LZO_CC_GNUC && (LZO_CC_GNUC < 0x020000ul)) ++# define __LZO_ASM_CLOBBER "ax" ++#elif (LZO_CC_INTELC) ++# define __LZO_ASM_CLOBBER "memory" ++#else ++# define __LZO_ASM_CLOBBER "cc", "memory" ++#endif ++#endif ++#if defined(__LZO_INFOSTR_MM) ++#elif (LZO_MM_FLAT) && (defined(__LZO_INFOSTR_PM) || defined(LZO_INFO_ABI_PM)) ++# define __LZO_INFOSTR_MM "" ++#elif defined(LZO_INFO_MM) ++# define __LZO_INFOSTR_MM "." LZO_INFO_MM ++#else ++# define __LZO_INFOSTR_MM "" ++#endif ++#if defined(__LZO_INFOSTR_PM) ++#elif defined(LZO_INFO_ABI_PM) ++# define __LZO_INFOSTR_PM "." LZO_INFO_ABI_PM ++#else ++# define __LZO_INFOSTR_PM "" ++#endif ++#if defined(__LZO_INFOSTR_ENDIAN) ++#elif defined(LZO_INFO_ABI_ENDIAN) ++# define __LZO_INFOSTR_ENDIAN "." LZO_INFO_ABI_ENDIAN ++#else ++# define __LZO_INFOSTR_ENDIAN "" ++#endif ++#if defined(__LZO_INFOSTR_OSNAME) ++#elif defined(LZO_INFO_OS_CONSOLE) ++# define __LZO_INFOSTR_OSNAME LZO_INFO_OS "." LZO_INFO_OS_CONSOLE ++#elif defined(LZO_INFO_OS_POSIX) ++# define __LZO_INFOSTR_OSNAME LZO_INFO_OS "." LZO_INFO_OS_POSIX ++#else ++# define __LZO_INFOSTR_OSNAME LZO_INFO_OS ++#endif ++#if defined(__LZO_INFOSTR_LIBC) ++#elif defined(LZO_INFO_LIBC) ++# define __LZO_INFOSTR_LIBC "." LZO_INFO_LIBC ++#else ++# define __LZO_INFOSTR_LIBC "" ++#endif ++#if defined(__LZO_INFOSTR_CCVER) ++#elif defined(LZO_INFO_CCVER) ++# define __LZO_INFOSTR_CCVER " " LZO_INFO_CCVER ++#else ++# define __LZO_INFOSTR_CCVER "" ++#endif ++#define LZO_INFO_STRING \ ++ LZO_INFO_ARCH __LZO_INFOSTR_MM __LZO_INFOSTR_PM __LZO_INFOSTR_ENDIAN \ ++ " " __LZO_INFOSTR_OSNAME __LZO_INFOSTR_LIBC " " LZO_INFO_CC __LZO_INFOSTR_CCVER ++ ++#endif ++ ++#endif ++ ++#undef LZO_HAVE_CONFIG_H ++#include "minilzo.h" ++ ++#if !defined(MINILZO_VERSION) || (MINILZO_VERSION != 0x2050) ++# error "version mismatch in miniLZO source files" ++#endif ++ ++#ifdef MINILZO_HAVE_CONFIG_H ++# define LZO_HAVE_CONFIG_H 1 ++#endif ++ ++#ifndef __LZO_CONF_H ++#define __LZO_CONF_H 1 ++ ++#if !defined(__LZO_IN_MINILZO) ++#if (LZO_CFG_FREESTANDING) ++# define LZO_LIBC_FREESTANDING 1 ++# define LZO_OS_FREESTANDING 1 ++# define ACC_LIBC_FREESTANDING 1 ++# define ACC_OS_FREESTANDING 1 ++#endif ++#if (LZO_CFG_NO_UNALIGNED) ++# define ACC_CFG_NO_UNALIGNED 1 ++#endif ++#if (LZO_ARCH_GENERIC) ++# define ACC_ARCH_GENERIC 1 ++#endif ++#if (LZO_ABI_NEUTRAL_ENDIAN) ++# define ACC_ABI_NEUTRAL_ENDIAN 1 ++#endif ++#if (LZO_HAVE_CONFIG_H) ++# define ACC_CONFIG_NO_HEADER 1 ++#endif ++#if defined(LZO_CFG_EXTRA_CONFIG_HEADER) ++# include LZO_CFG_EXTRA_CONFIG_HEADER ++#endif ++#if defined(__LZOCONF_H) || defined(__LZOCONF_H_INCLUDED) ++# error "include this file first" ++#endif ++#include "lzo/lzoconf.h" ++#endif ++ ++#if (LZO_VERSION < 0x02000) || !defined(__LZOCONF_H_INCLUDED) ++# error "version mismatch" ++#endif ++ ++#if (LZO_CC_BORLANDC && LZO_ARCH_I086) ++# pragma option -h ++#endif ++ ++#if (LZO_CC_MSC && (_MSC_VER >= 1000)) ++# pragma warning(disable: 4127 4701) ++#endif ++#if (LZO_CC_MSC && (_MSC_VER >= 1300)) ++# pragma warning(disable: 4820) ++# pragma warning(disable: 4514 4710 4711) ++#endif ++ ++#if (LZO_CC_SUNPROC) ++#if !defined(__cplusplus) ++# pragma error_messages(off,E_END_OF_LOOP_CODE_NOT_REACHED) ++# pragma error_messages(off,E_LOOP_NOT_ENTERED_AT_TOP) ++# pragma error_messages(off,E_STATEMENT_NOT_REACHED) ++#endif ++#endif ++ ++#if (__LZO_MMODEL_HUGE) && !(LZO_HAVE_MM_HUGE_PTR) ++# error "this should not happen - check defines for __huge" ++#endif ++ ++#if defined(__LZO_IN_MINILZO) || defined(LZO_CFG_FREESTANDING) ++#elif (LZO_OS_DOS16 || LZO_OS_OS216 || LZO_OS_WIN16) ++# define ACC_WANT_ACC_INCD_H 1 ++# define ACC_WANT_ACC_INCE_H 1 ++# define ACC_WANT_ACC_INCI_H 1 ++#elif 1 ++# include <string.h> ++#else ++# define ACC_WANT_ACC_INCD_H 1 ++#endif ++ ++#if (LZO_ARCH_I086) ++# define ACC_MM_AHSHIFT LZO_MM_AHSHIFT ++# define ACC_PTR_FP_OFF(x) (((const unsigned __far*)&(x))[0]) ++# define ACC_PTR_FP_SEG(x) (((const unsigned __far*)&(x))[1]) ++# define ACC_PTR_MK_FP(s,o) ((void __far*)(((unsigned long)(s)<<16)+(unsigned)(o))) ++#endif ++ ++#if !defined(lzo_uintptr_t) ++# if defined(__LZO_MMODEL_HUGE) ++# define lzo_uintptr_t unsigned long ++# elif 1 && defined(LZO_OS_OS400) && (LZO_SIZEOF_VOID_P == 16) ++# define __LZO_UINTPTR_T_IS_POINTER 1 ++ typedef char* lzo_uintptr_t; ++# define lzo_uintptr_t lzo_uintptr_t ++# elif (LZO_SIZEOF_SIZE_T == LZO_SIZEOF_VOID_P) ++# define lzo_uintptr_t size_t ++# elif (LZO_SIZEOF_LONG == LZO_SIZEOF_VOID_P) ++# define lzo_uintptr_t unsigned long ++# elif (LZO_SIZEOF_INT == LZO_SIZEOF_VOID_P) ++# define lzo_uintptr_t unsigned int ++# elif (LZO_SIZEOF_LONG_LONG == LZO_SIZEOF_VOID_P) ++# define lzo_uintptr_t unsigned long long ++# else ++# define lzo_uintptr_t size_t ++# endif ++#endif ++LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uintptr_t) >= sizeof(lzo_voidp)) ++ ++#if 1 && !defined(LZO_CFG_FREESTANDING) ++#if 1 && !defined(HAVE_STRING_H) ++#define HAVE_STRING_H 1 ++#endif ++#if 1 && !defined(HAVE_MEMCMP) ++#define HAVE_MEMCMP 1 ++#endif ++#if 1 && !defined(HAVE_MEMCPY) ++#define HAVE_MEMCPY 1 ++#endif ++#if 1 && !defined(HAVE_MEMMOVE) ++#define HAVE_MEMMOVE 1 ++#endif ++#if 1 && !defined(HAVE_MEMSET) ++#define HAVE_MEMSET 1 ++#endif ++#endif ++ ++#if 1 && defined(HAVE_STRING_H) ++#include <string.h> ++#endif ++ ++#if (LZO_CFG_FREESTANDING) ++# undef HAVE_MEMCMP ++# undef HAVE_MEMCPY ++# undef HAVE_MEMMOVE ++# undef HAVE_MEMSET ++#endif ++ ++#if !(HAVE_MEMCMP) ++# undef memcmp ++# define memcmp(a,b,c) lzo_memcmp(a,b,c) ++#elif !(__LZO_MMODEL_HUGE) ++# undef lzo_memcmp ++# define lzo_memcmp(a,b,c) memcmp(a,b,c) ++#endif ++#if !(HAVE_MEMCPY) ++# undef memcpy ++# define memcpy(a,b,c) lzo_memcpy(a,b,c) ++#elif !(__LZO_MMODEL_HUGE) ++# undef lzo_memcpy ++# define lzo_memcpy(a,b,c) memcpy(a,b,c) ++#endif ++#if !(HAVE_MEMMOVE) ++# undef memmove ++# define memmove(a,b,c) lzo_memmove(a,b,c) ++#elif !(__LZO_MMODEL_HUGE) ++# undef lzo_memmove ++# define lzo_memmove(a,b,c) memmove(a,b,c) ++#endif ++#if !(HAVE_MEMSET) ++# undef memset ++# define memset(a,b,c) lzo_memset(a,b,c) ++#elif !(__LZO_MMODEL_HUGE) ++# undef lzo_memset ++# define lzo_memset(a,b,c) memset(a,b,c) ++#endif ++ ++#undef NDEBUG ++#if (LZO_CFG_FREESTANDING) ++# undef LZO_DEBUG ++# define NDEBUG 1 ++# undef assert ++# define assert(e) ((void)0) ++#else ++# if !defined(LZO_DEBUG) ++# define NDEBUG 1 ++# endif ++# include <assert.h> ++#endif ++ ++#if 0 && defined(__BOUNDS_CHECKING_ON) ++# include <unchecked.h> ++#else ++# define BOUNDS_CHECKING_OFF_DURING(stmt) stmt ++# define BOUNDS_CHECKING_OFF_IN_EXPR(expr) (expr) ++#endif ++ ++#if !defined(__lzo_inline) ++# define __lzo_inline /*empty*/ ++#endif ++#if !defined(__lzo_forceinline) ++# define __lzo_forceinline /*empty*/ ++#endif ++#if !defined(__lzo_noinline) ++# define __lzo_noinline /*empty*/ ++#endif ++ ++#if (LZO_CFG_PGO) ++# undef __acc_likely ++# undef __acc_unlikely ++# undef __lzo_likely ++# undef __lzo_unlikely ++# define __acc_likely(e) (e) ++# define __acc_unlikely(e) (e) ++# define __lzo_likely(e) (e) ++# define __lzo_unlikely(e) (e) ++#endif ++ ++#if 1 ++# define LZO_BYTE(x) ((unsigned char) (x)) ++#else ++# define LZO_BYTE(x) ((unsigned char) ((x) & 0xff)) ++#endif ++ ++#define LZO_MAX(a,b) ((a) >= (b) ? (a) : (b)) ++#define LZO_MIN(a,b) ((a) <= (b) ? (a) : (b)) ++#define LZO_MAX3(a,b,c) ((a) >= (b) ? LZO_MAX(a,c) : LZO_MAX(b,c)) ++#define LZO_MIN3(a,b,c) ((a) <= (b) ? LZO_MIN(a,c) : LZO_MIN(b,c)) ++ ++#define lzo_sizeof(type) ((lzo_uint) (sizeof(type))) ++ ++#define LZO_HIGH(array) ((lzo_uint) (sizeof(array)/sizeof(*(array)))) ++ ++#define LZO_SIZE(bits) (1u << (bits)) ++#define LZO_MASK(bits) (LZO_SIZE(bits) - 1) ++ ++#define LZO_LSIZE(bits) (1ul << (bits)) ++#define LZO_LMASK(bits) (LZO_LSIZE(bits) - 1) ++ ++#define LZO_USIZE(bits) ((lzo_uint) 1 << (bits)) ++#define LZO_UMASK(bits) (LZO_USIZE(bits) - 1) ++ ++#if !defined(DMUL) ++#if 0 ++ ++# define DMUL(a,b) ((lzo_xint) ((lzo_uint32)(a) * (lzo_uint32)(b))) ++#else ++# define DMUL(a,b) ((lzo_xint) ((a) * (b))) ++#endif ++#endif ++ ++#if 1 && (LZO_ARCH_AMD64 || LZO_ARCH_I386 || LZO_ARCH_POWERPC) ++# if (LZO_SIZEOF_SHORT == 2) ++# define LZO_UNALIGNED_OK_2 1 ++# endif ++# if (LZO_SIZEOF_INT == 4) ++# define LZO_UNALIGNED_OK_4 1 ++# endif ++#endif ++#if 1 && (LZO_ARCH_AMD64) ++# if defined(LZO_UINT64_MAX) ++# define LZO_UNALIGNED_OK_8 1 ++# endif ++#endif ++#if (LZO_CFG_NO_UNALIGNED) ++# undef LZO_UNALIGNED_OK_2 ++# undef LZO_UNALIGNED_OK_4 ++# undef LZO_UNALIGNED_OK_8 ++#endif ++ ++#undef UA_GET16 ++#undef UA_SET16 ++#undef UA_COPY16 ++#undef UA_GET32 ++#undef UA_SET32 ++#undef UA_COPY32 ++#undef UA_GET64 ++#undef UA_SET64 ++#undef UA_COPY64 ++#if defined(LZO_UNALIGNED_OK_2) ++ LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(unsigned short) == 2) ++# if 1 && defined(ACC_UA_COPY16) ++# define UA_GET16 ACC_UA_GET16 ++# define UA_SET16 ACC_UA_SET16 ++# define UA_COPY16 ACC_UA_COPY16 ++# else ++# define UA_GET16(p) (* (__lzo_ua_volatile const lzo_ushortp) (__lzo_ua_volatile const lzo_voidp) (p)) ++# define UA_SET16(p,v) ((* (__lzo_ua_volatile lzo_ushortp) (__lzo_ua_volatile lzo_voidp) (p)) = (unsigned short) (v)) ++# define UA_COPY16(d,s) UA_SET16(d, UA_GET16(s)) ++# endif ++#endif ++#if defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4) ++ LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint32) == 4) ++# if 1 && defined(ACC_UA_COPY32) ++# define UA_GET32 ACC_UA_GET32 ++# define UA_SET32 ACC_UA_SET32 ++# define UA_COPY32 ACC_UA_COPY32 ++# else ++# define UA_GET32(p) (* (__lzo_ua_volatile const lzo_uint32p) (__lzo_ua_volatile const lzo_voidp) (p)) ++# define UA_SET32(p,v) ((* (__lzo_ua_volatile lzo_uint32p) (__lzo_ua_volatile lzo_voidp) (p)) = (lzo_uint32) (v)) ++# define UA_COPY32(d,s) UA_SET32(d, UA_GET32(s)) ++# endif ++#endif ++#if defined(LZO_UNALIGNED_OK_8) ++ LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint64) == 8) ++# if 1 && defined(ACC_UA_COPY64) ++# define UA_GET64 ACC_UA_GET64 ++# define UA_SET64 ACC_UA_SET64 ++# define UA_COPY64 ACC_UA_COPY64 ++# else ++# define UA_GET64(p) (* (__lzo_ua_volatile const lzo_uint64p) (__lzo_ua_volatile const lzo_voidp) (p)) ++# define UA_SET64(p,v) ((* (__lzo_ua_volatile lzo_uint64p) (__lzo_ua_volatile lzo_voidp) (p)) = (lzo_uint64) (v)) ++# define UA_COPY64(d,s) UA_SET64(d, UA_GET64(s)) ++# endif ++#endif ++ ++#define MEMCPY8_DS(dest,src,len) \ ++ lzo_memcpy(dest,src,len); dest += len; src += len ++ ++#define BZERO8_PTR(s,l,n) \ ++ lzo_memset((lzo_voidp)(s),0,(lzo_uint)(l)*(n)) ++ ++#define MEMCPY_DS(dest,src,len) \ ++ do *dest++ = *src++; while (--len > 0) ++ ++LZO_EXTERN(const lzo_bytep) lzo_copyright(void); ++ ++#ifndef __LZO_PTR_H ++#define __LZO_PTR_H 1 ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#if !defined(lzo_uintptr_t) ++# if (__LZO_MMODEL_HUGE) ++# define lzo_uintptr_t unsigned long ++# else ++# define lzo_uintptr_t acc_uintptr_t ++# ifdef __ACC_INTPTR_T_IS_POINTER ++# define __LZO_UINTPTR_T_IS_POINTER 1 ++# endif ++# endif ++#endif ++ ++#if (LZO_ARCH_I086) ++#define PTR(a) ((lzo_bytep) (a)) ++#define PTR_ALIGNED_4(a) ((ACC_PTR_FP_OFF(a) & 3) == 0) ++#define PTR_ALIGNED2_4(a,b) (((ACC_PTR_FP_OFF(a) | ACC_PTR_FP_OFF(b)) & 3) == 0) ++#elif (LZO_MM_PVP) ++#define PTR(a) ((lzo_bytep) (a)) ++#define PTR_ALIGNED_8(a) ((((lzo_uintptr_t)(a)) >> 61) == 0) ++#define PTR_ALIGNED2_8(a,b) ((((lzo_uintptr_t)(a)|(lzo_uintptr_t)(b)) >> 61) == 0) ++#else ++#define PTR(a) ((lzo_uintptr_t) (a)) ++#define PTR_LINEAR(a) PTR(a) ++#define PTR_ALIGNED_4(a) ((PTR_LINEAR(a) & 3) == 0) ++#define PTR_ALIGNED_8(a) ((PTR_LINEAR(a) & 7) == 0) ++#define PTR_ALIGNED2_4(a,b) (((PTR_LINEAR(a) | PTR_LINEAR(b)) & 3) == 0) ++#define PTR_ALIGNED2_8(a,b) (((PTR_LINEAR(a) | PTR_LINEAR(b)) & 7) == 0) ++#endif ++ ++#define PTR_LT(a,b) (PTR(a) < PTR(b)) ++#define PTR_GE(a,b) (PTR(a) >= PTR(b)) ++#define PTR_DIFF(a,b) (PTR(a) - PTR(b)) ++#define pd(a,b) ((lzo_uint) ((a)-(b))) ++ ++LZO_EXTERN(lzo_uintptr_t) ++__lzo_ptr_linear(const lzo_voidp ptr); ++ ++typedef union ++{ ++ char a_char; ++ unsigned char a_uchar; ++ short a_short; ++ unsigned short a_ushort; ++ int a_int; ++ unsigned int a_uint; ++ long a_long; ++ unsigned long a_ulong; ++ lzo_int a_lzo_int; ++ lzo_uint a_lzo_uint; ++ lzo_int32 a_lzo_int32; ++ lzo_uint32 a_lzo_uint32; ++#if defined(LZO_UINT64_MAX) ++ lzo_int64 a_lzo_int64; ++ lzo_uint64 a_lzo_uint64; ++#endif ++ ptrdiff_t a_ptrdiff_t; ++ lzo_uintptr_t a_lzo_uintptr_t; ++ lzo_voidp a_lzo_voidp; ++ void * a_void_p; ++ lzo_bytep a_lzo_bytep; ++ lzo_bytepp a_lzo_bytepp; ++ lzo_uintp a_lzo_uintp; ++ lzo_uint * a_lzo_uint_p; ++ lzo_uint32p a_lzo_uint32p; ++ lzo_uint32 * a_lzo_uint32_p; ++ unsigned char * a_uchar_p; ++ char * a_char_p; ++} ++lzo_full_align_t; ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif ++ ++#ifndef LZO_DETERMINISTIC ++#define LZO_DETERMINISTIC 1 ++#endif ++ ++#ifndef LZO_DICT_USE_PTR ++#define LZO_DICT_USE_PTR 1 ++#if 0 && (LZO_ARCH_I086) ++# undef LZO_DICT_USE_PTR ++# define LZO_DICT_USE_PTR 0 ++#endif ++#endif ++ ++#if (LZO_DICT_USE_PTR) ++# define lzo_dict_t const lzo_bytep ++# define lzo_dict_p lzo_dict_t __LZO_MMODEL * ++#else ++# define lzo_dict_t lzo_uint ++# define lzo_dict_p lzo_dict_t __LZO_MMODEL * ++#endif ++ ++#endif ++ ++#if !defined(MINILZO_CFG_SKIP_LZO_PTR) ++ ++LZO_PUBLIC(lzo_uintptr_t) ++__lzo_ptr_linear(const lzo_voidp ptr) ++{ ++ lzo_uintptr_t p; ++ ++#if (LZO_ARCH_I086) ++ p = (((lzo_uintptr_t)(ACC_PTR_FP_SEG(ptr))) << (16 - ACC_MM_AHSHIFT)) + (ACC_PTR_FP_OFF(ptr)); ++#elif (LZO_MM_PVP) ++ p = (lzo_uintptr_t) (ptr); ++ p = (p << 3) | (p >> 61); ++#else ++ p = (lzo_uintptr_t) PTR_LINEAR(ptr); ++#endif ++ ++ return p; ++} ++ ++LZO_PUBLIC(unsigned) ++__lzo_align_gap(const lzo_voidp ptr, lzo_uint size) ++{ ++#if defined(__LZO_UINTPTR_T_IS_POINTER) ++ size_t n = (size_t) ptr; ++ n = (((n + size - 1) / size) * size) - n; ++#else ++ lzo_uintptr_t p, n; ++ p = __lzo_ptr_linear(ptr); ++ n = (((p + size - 1) / size) * size) - p; ++#endif ++ ++ assert(size > 0); ++ assert((long)n >= 0); ++ assert(n <= size); ++ return (unsigned)n; ++} ++ ++#endif ++#if !defined(MINILZO_CFG_SKIP_LZO_UTIL) ++ ++/* If you use the LZO library in a product, I would appreciate that you ++ * keep this copyright string in the executable of your product. ++ */ ++ ++static const char __lzo_copyright[] = ++#if !defined(__LZO_IN_MINLZO) ++ LZO_VERSION_STRING; ++#else ++ "\r\n\n" ++ "LZO data compression library.\n" ++ "$Copyright: LZO Copyright (C) 1996-2011 Markus Franz Xaver Johannes Oberhumer\n" ++ "<markus@oberhumer.com>\n" ++ "http://www.oberhumer.com $\n\n" ++ "$Id: LZO version: v" LZO_VERSION_STRING ", " LZO_VERSION_DATE " $\n" ++ "$Info: " LZO_INFO_STRING " $\n"; ++#endif ++ ++LZO_PUBLIC(const lzo_bytep) ++lzo_copyright(void) ++{ ++#if (LZO_OS_DOS16 && LZO_CC_TURBOC) ++ return (lzo_voidp) __lzo_copyright; ++#else ++ return (const lzo_bytep) __lzo_copyright; ++#endif ++} ++ ++LZO_PUBLIC(unsigned) ++lzo_version(void) ++{ ++ return LZO_VERSION; ++} ++ ++LZO_PUBLIC(const char *) ++lzo_version_string(void) ++{ ++ return LZO_VERSION_STRING; ++} ++ ++LZO_PUBLIC(const char *) ++lzo_version_date(void) ++{ ++ return LZO_VERSION_DATE; ++} ++ ++LZO_PUBLIC(const lzo_charp) ++_lzo_version_string(void) ++{ ++ return LZO_VERSION_STRING; ++} ++ ++LZO_PUBLIC(const lzo_charp) ++_lzo_version_date(void) ++{ ++ return LZO_VERSION_DATE; ++} ++ ++#define LZO_BASE 65521u ++#define LZO_NMAX 5552 ++ ++#define LZO_DO1(buf,i) s1 += buf[i]; s2 += s1 ++#define LZO_DO2(buf,i) LZO_DO1(buf,i); LZO_DO1(buf,i+1); ++#define LZO_DO4(buf,i) LZO_DO2(buf,i); LZO_DO2(buf,i+2); ++#define LZO_DO8(buf,i) LZO_DO4(buf,i); LZO_DO4(buf,i+4); ++#define LZO_DO16(buf,i) LZO_DO8(buf,i); LZO_DO8(buf,i+8); ++ ++LZO_PUBLIC(lzo_uint32) ++lzo_adler32(lzo_uint32 adler, const lzo_bytep buf, lzo_uint len) ++{ ++ lzo_uint32 s1 = adler & 0xffff; ++ lzo_uint32 s2 = (adler >> 16) & 0xffff; ++ unsigned k; ++ ++ if (buf == NULL) ++ return 1; ++ ++ while (len > 0) ++ { ++ k = len < LZO_NMAX ? (unsigned) len : LZO_NMAX; ++ len -= k; ++ if (k >= 16) do ++ { ++ LZO_DO16(buf,0); ++ buf += 16; ++ k -= 16; ++ } while (k >= 16); ++ if (k != 0) do ++ { ++ s1 += *buf++; ++ s2 += s1; ++ } while (--k > 0); ++ s1 %= LZO_BASE; ++ s2 %= LZO_BASE; ++ } ++ return (s2 << 16) | s1; ++} ++ ++#undef LZO_DO1 ++#undef LZO_DO2 ++#undef LZO_DO4 ++#undef LZO_DO8 ++#undef LZO_DO16 ++ ++#endif ++#if !defined(MINILZO_CFG_SKIP_LZO_STRING) ++#undef lzo_memcmp ++#undef lzo_memcpy ++#undef lzo_memmove ++#undef lzo_memset ++#if !defined(__LZO_MMODEL_HUGE) ++# undef LZO_HAVE_MM_HUGE_PTR ++#endif ++#define lzo_hsize_t lzo_uint ++#define lzo_hvoid_p lzo_voidp ++#define lzo_hbyte_p lzo_bytep ++#define LZOLIB_PUBLIC(r,f) LZO_PUBLIC(r) f ++#define lzo_hmemcmp lzo_memcmp ++#define lzo_hmemcpy lzo_memcpy ++#define lzo_hmemmove lzo_memmove ++#define lzo_hmemset lzo_memset ++#define __LZOLIB_HMEMCPY_CH_INCLUDED 1 ++#if !defined(LZOLIB_PUBLIC) ++# define LZOLIB_PUBLIC(r,f) r __LZOLIB_FUNCNAME(f) ++#endif ++LZOLIB_PUBLIC(int, lzo_hmemcmp) (const lzo_hvoid_p s1, const lzo_hvoid_p s2, lzo_hsize_t len) ++{ ++#if (LZO_HAVE_MM_HUGE_PTR) || !(HAVE_MEMCMP) ++ const lzo_hbyte_p p1 = (const lzo_hbyte_p) s1; ++ const lzo_hbyte_p p2 = (const lzo_hbyte_p) s2; ++ if __lzo_likely(len > 0) do ++ { ++ int d = *p1 - *p2; ++ if (d != 0) ++ return d; ++ p1++; p2++; ++ } while __lzo_likely(--len > 0); ++ return 0; ++#else ++ return memcmp(s1, s2, len); ++#endif ++} ++LZOLIB_PUBLIC(lzo_hvoid_p, lzo_hmemcpy) (lzo_hvoid_p dest, const lzo_hvoid_p src, lzo_hsize_t len) ++{ ++#if (LZO_HAVE_MM_HUGE_PTR) || !(HAVE_MEMCPY) ++ lzo_hbyte_p p1 = (lzo_hbyte_p) dest; ++ const lzo_hbyte_p p2 = (const lzo_hbyte_p) src; ++ if (!(len > 0) || p1 == p2) ++ return dest; ++ do ++ *p1++ = *p2++; ++ while __lzo_likely(--len > 0); ++ return dest; ++#else ++ return memcpy(dest, src, len); ++#endif ++} ++LZOLIB_PUBLIC(lzo_hvoid_p, lzo_hmemmove) (lzo_hvoid_p dest, const lzo_hvoid_p src, lzo_hsize_t len) ++{ ++#if (LZO_HAVE_MM_HUGE_PTR) || !(HAVE_MEMMOVE) ++ lzo_hbyte_p p1 = (lzo_hbyte_p) dest; ++ const lzo_hbyte_p p2 = (const lzo_hbyte_p) src; ++ if (!(len > 0) || p1 == p2) ++ return dest; ++ if (p1 < p2) ++ { ++ do ++ *p1++ = *p2++; ++ while __lzo_likely(--len > 0); ++ } ++ else ++ { ++ p1 += len; ++ p2 += len; ++ do ++ *--p1 = *--p2; ++ while __lzo_likely(--len > 0); ++ } ++ return dest; ++#else ++ return memmove(dest, src, len); ++#endif ++} ++LZOLIB_PUBLIC(lzo_hvoid_p, lzo_hmemset) (lzo_hvoid_p s, int c, lzo_hsize_t len) ++{ ++#if (LZO_HAVE_MM_HUGE_PTR) || !(HAVE_MEMSET) ++ lzo_hbyte_p p = (lzo_hbyte_p) s; ++ if __lzo_likely(len > 0) do ++ *p++ = (unsigned char) c; ++ while __lzo_likely(--len > 0); ++ return s; ++#else ++ return memset(s, c, len); ++#endif ++} ++#undef LZOLIB_PUBLIC ++#endif ++#if !defined(MINILZO_CFG_SKIP_LZO_INIT) ++ ++#if !defined(__LZO_IN_MINILZO) ++ ++#define ACC_WANT_ACC_CHK_CH 1 ++#undef ACCCHK_ASSERT ++ ++ ACCCHK_ASSERT_IS_SIGNED_T(lzo_int) ++ ACCCHK_ASSERT_IS_UNSIGNED_T(lzo_uint) ++ ++ ACCCHK_ASSERT_IS_SIGNED_T(lzo_int32) ++ ACCCHK_ASSERT_IS_UNSIGNED_T(lzo_uint32) ++ ACCCHK_ASSERT((LZO_UINT32_C(1) << (int)(8*sizeof(LZO_UINT32_C(1))-1)) > 0) ++ ACCCHK_ASSERT(sizeof(lzo_uint32) >= 4) ++#if defined(LZO_UINT64_MAX) ++ ACCCHK_ASSERT(sizeof(lzo_uint64) == 8) ++ ACCCHK_ASSERT_IS_SIGNED_T(lzo_int64) ++ ACCCHK_ASSERT_IS_UNSIGNED_T(lzo_uint64) ++#endif ++ ++#if !defined(__LZO_UINTPTR_T_IS_POINTER) ++ ACCCHK_ASSERT_IS_UNSIGNED_T(lzo_uintptr_t) ++#endif ++ ACCCHK_ASSERT(sizeof(lzo_uintptr_t) >= sizeof(lzo_voidp)) ++ ++ ACCCHK_ASSERT_IS_UNSIGNED_T(lzo_xint) ++ ACCCHK_ASSERT(sizeof(lzo_xint) >= sizeof(lzo_uint32)) ++ ACCCHK_ASSERT(sizeof(lzo_xint) >= sizeof(lzo_uint)) ++ ACCCHK_ASSERT(sizeof(lzo_xint) == sizeof(lzo_uint32) || sizeof(lzo_xint) == sizeof(lzo_uint)) ++ ++#endif ++#undef ACCCHK_ASSERT ++ ++#if 0 ++#define WANT_lzo_bitops_clz32 1 ++#define WANT_lzo_bitops_clz64 1 ++#endif ++#define WANT_lzo_bitops_ctz32 1 ++#define WANT_lzo_bitops_ctz64 1 ++ ++#if (defined(_WIN32) || defined(_WIN64)) && ((LZO_CC_INTELC && (__INTEL_COMPILER >= 1000)) || (LZO_CC_MSC && (_MSC_VER >= 1400))) ++#include <intrin.h> ++#if !defined(lzo_bitops_clz32) && defined(WANT_lzo_bitops_clz32) && 0 ++#pragma intrinsic(_BitScanReverse) ++static __lzo_inline unsigned lzo_bitops_clz32(lzo_uint32 v) ++{ ++ unsigned long r; ++ (void) _BitScanReverse(&r, v); ++ return (unsigned) r; ++} ++#define lzo_bitops_clz32 lzo_bitops_clz32 ++#endif ++#if !defined(lzo_bitops_clz64) && defined(WANT_lzo_bitops_clz64) && defined(LZO_UINT64_MAX) && 0 ++#pragma intrinsic(_BitScanReverse64) ++static __lzo_inline unsigned lzo_bitops_clz64(lzo_uint64 v) ++{ ++ unsigned long r; ++ (void) _BitScanReverse64(&r, v); ++ return (unsigned) r; ++} ++#define lzo_bitops_clz64 lzo_bitops_clz64 ++#endif ++#if !defined(lzo_bitops_ctz32) && defined(WANT_lzo_bitops_ctz32) ++#pragma intrinsic(_BitScanForward) ++static __lzo_inline unsigned lzo_bitops_ctz32(lzo_uint32 v) ++{ ++ unsigned long r; ++ (void) _BitScanForward(&r, v); ++ return (unsigned) r; ++} ++#define lzo_bitops_ctz32 lzo_bitops_ctz32 ++#endif ++#if !defined(lzo_bitops_ctz64) && defined(WANT_lzo_bitops_ctz64) && defined(LZO_UINT64_MAX) ++#pragma intrinsic(_BitScanForward64) ++static __lzo_inline unsigned lzo_bitops_ctz64(lzo_uint64 v) ++{ ++ unsigned long r; ++ (void) _BitScanForward64(&r, v); ++ return (unsigned) r; ++} ++#define lzo_bitops_ctz64 lzo_bitops_ctz64 ++#endif ++ ++#elif (LZO_CC_CLANG || (LZO_CC_GNUC >= 0x030400ul) || (LZO_CC_INTELC && (__INTEL_COMPILER >= 1000)) || LZO_CC_LLVM) ++#if !defined(lzo_bitops_clz32) && defined(WANT_lzo_bitops_clz32) ++#define lzo_bitops_clz32(v) ((unsigned) __builtin_clz(v)) ++#endif ++#if !defined(lzo_bitops_clz64) && defined(WANT_lzo_bitops_clz64) && defined(LZO_UINT64_MAX) ++#define lzo_bitops_clz64(v) ((unsigned) __builtin_clzll(v)) ++#endif ++#if !defined(lzo_bitops_ctz32) && defined(WANT_lzo_bitops_ctz32) ++#define lzo_bitops_ctz32(v) ((unsigned) __builtin_ctz(v)) ++#endif ++#if !defined(lzo_bitops_ctz64) && defined(WANT_lzo_bitops_ctz64) && defined(LZO_UINT64_MAX) ++#define lzo_bitops_ctz64(v) ((unsigned) __builtin_ctzll(v)) ++#endif ++#if !defined(lzo_bitops_popcount32) && defined(WANT_lzo_bitops_popcount32) ++#define lzo_bitops_popcount32(v) ((unsigned) __builtin_popcount(v)) ++#endif ++#if !defined(lzo_bitops_popcount32) && defined(WANT_lzo_bitops_popcount64) && defined(LZO_UINT64_MAX) ++#define lzo_bitops_popcount64(v) ((unsigned) __builtin_popcountll(v)) ++#endif ++#endif ++ ++#if 0 ++#define u2p(ptr,off) ((lzo_voidp) (((lzo_bytep)(lzo_voidp)(ptr)) + (off))) ++#else ++static __lzo_noinline lzo_voidp u2p(lzo_voidp ptr, lzo_uint off) ++{ ++ return (lzo_voidp) ((lzo_bytep) ptr + off); ++} ++#endif ++ ++LZO_PUBLIC(int) ++_lzo_config_check(void) ++{ ++ lzo_bool r = 1; ++ union { ++ lzo_xint a[2]; unsigned char b[2*LZO_MAX(8,sizeof(lzo_xint))]; ++#if defined(LZO_UNALIGNED_OK_8) ++ lzo_uint64 c[2]; ++#endif ++ unsigned short x[2]; lzo_uint32 y[2]; lzo_uint z[2]; ++ } u; ++ lzo_voidp p; ++ ++ u.a[0] = u.a[1] = 0; ++ p = u2p(&u, 0); ++ r &= ((* (lzo_bytep) p) == 0); ++#if !defined(LZO_CFG_NO_CONFIG_CHECK) ++#if defined(LZO_ABI_BIG_ENDIAN) ++ u.a[0] = u.a[1] = 0; u.b[sizeof(lzo_uint) - 1] = 128; ++ p = u2p(&u, 0); ++ r &= ((* (lzo_uintp) p) == 128); ++#endif ++#if defined(LZO_ABI_LITTLE_ENDIAN) ++ u.a[0] = u.a[1] = 0; u.b[0] = 128; ++ p = u2p(&u, 0); ++ r &= ((* (lzo_uintp) p) == 128); ++#endif ++#if defined(LZO_UNALIGNED_OK_2) ++ u.a[0] = u.a[1] = 0; ++ u.b[0] = 1; u.b[sizeof(unsigned short) + 1] = 2; ++ p = u2p(&u, 1); ++ r &= ((* (lzo_ushortp) p) == 0); ++#endif ++#if defined(LZO_UNALIGNED_OK_4) ++ u.a[0] = u.a[1] = 0; ++ u.b[0] = 3; u.b[sizeof(lzo_uint32) + 1] = 4; ++ p = u2p(&u, 1); ++ r &= ((* (lzo_uint32p) p) == 0); ++#endif ++#if defined(LZO_UNALIGNED_OK_8) ++ u.c[0] = u.c[1] = 0; ++ u.b[0] = 5; u.b[sizeof(lzo_uint64) + 1] = 6; ++ p = u2p(&u, 1); ++ r &= ((* (lzo_uint64p) p) == 0); ++#endif ++#if defined(lzo_bitops_clz32) ++ { unsigned i; lzo_uint32 v = 1; ++ for (i = 0; i < 31; i++, v <<= 1) ++ r &= lzo_bitops_clz32(v) == 31 - i; ++ } ++#endif ++#if defined(lzo_bitops_clz64) ++ { unsigned i; lzo_uint64 v = 1; ++ for (i = 0; i < 63; i++, v <<= 1) ++ r &= lzo_bitops_clz64(v) == 63 - i; ++ } ++#endif ++#if defined(lzo_bitops_ctz32) ++ { unsigned i; lzo_uint32 v = 1; ++ for (i = 0; i < 31; i++, v <<= 1) ++ r &= lzo_bitops_ctz32(v) == i; ++ } ++#endif ++#if defined(lzo_bitops_ctz64) ++ { unsigned i; lzo_uint64 v = 1; ++ for (i = 0; i < 63; i++, v <<= 1) ++ r &= lzo_bitops_ctz64(v) == i; ++ } ++#endif ++#endif ++ ++ return r == 1 ? LZO_E_OK : LZO_E_ERROR; ++} ++ ++LZO_PUBLIC(int) ++__lzo_init_v2(unsigned v, int s1, int s2, int s3, int s4, int s5, ++ int s6, int s7, int s8, int s9) ++{ ++ int r; ++ ++#if defined(__LZO_IN_MINILZO) ++#elif (LZO_CC_MSC && ((_MSC_VER) < 700)) ++#else ++#define ACC_WANT_ACC_CHK_CH 1 ++#undef ACCCHK_ASSERT ++#define ACCCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) ++#endif ++#undef ACCCHK_ASSERT ++ ++ if (v == 0) ++ return LZO_E_ERROR; ++ ++ r = (s1 == -1 || s1 == (int) sizeof(short)) && ++ (s2 == -1 || s2 == (int) sizeof(int)) && ++ (s3 == -1 || s3 == (int) sizeof(long)) && ++ (s4 == -1 || s4 == (int) sizeof(lzo_uint32)) && ++ (s5 == -1 || s5 == (int) sizeof(lzo_uint)) && ++ (s6 == -1 || s6 == (int) lzo_sizeof_dict_t) && ++ (s7 == -1 || s7 == (int) sizeof(char *)) && ++ (s8 == -1 || s8 == (int) sizeof(lzo_voidp)) && ++ (s9 == -1 || s9 == (int) sizeof(lzo_callback_t)); ++ if (!r) ++ return LZO_E_ERROR; ++ ++ r = _lzo_config_check(); ++ if (r != LZO_E_OK) ++ return r; ++ ++ return r; ++} ++ ++#if !defined(__LZO_IN_MINILZO) ++ ++#if (LZO_OS_WIN16 && LZO_CC_WATCOMC) && defined(__SW_BD) ++ ++#if 0 ++BOOL FAR PASCAL LibMain ( HANDLE hInstance, WORD wDataSegment, ++ WORD wHeapSize, LPSTR lpszCmdLine ) ++#else ++int __far __pascal LibMain ( int a, short b, short c, long d ) ++#endif ++{ ++ LZO_UNUSED(a); LZO_UNUSED(b); LZO_UNUSED(c); LZO_UNUSED(d); ++ return 1; ++} ++ ++#endif ++ ++#endif ++ ++#endif ++ ++#define LZO1X 1 ++#define LZO_EOF_CODE 1 ++#define M2_MAX_OFFSET 0x0800 ++ ++#if !defined(MINILZO_CFG_SKIP_LZO1X_1_COMPRESS) ++ ++#if 1 && defined(UA_GET32) ++#undef LZO_DICT_USE_PTR ++#define LZO_DICT_USE_PTR 0 ++#undef lzo_dict_t ++#define lzo_dict_t unsigned short ++#endif ++ ++#define LZO_NEED_DICT_H 1 ++#ifndef D_BITS ++#define D_BITS 14 ++#endif ++#define D_INDEX1(d,p) d = DM(DMUL(0x21,DX3(p,5,5,6)) >> 5) ++#define D_INDEX2(d,p) d = (d & (D_MASK & 0x7ff)) ^ (D_HIGH | 0x1f) ++#if 1 ++#define DINDEX(dv,p) DM(((DMUL(0x1824429d,dv)) >> (32-D_BITS))) ++#else ++#define DINDEX(dv,p) DM((dv) + ((dv) >> (32-D_BITS))) ++#endif ++ ++#ifndef __LZO_CONFIG1X_H ++#define __LZO_CONFIG1X_H 1 ++ ++#if !defined(LZO1X) && !defined(LZO1Y) && !defined(LZO1Z) ++# define LZO1X 1 ++#endif ++ ++#if !defined(__LZO_IN_MINILZO) ++#include "lzo/lzo1x.h" ++#endif ++ ++#ifndef LZO_EOF_CODE ++#define LZO_EOF_CODE 1 ++#endif ++#undef LZO_DETERMINISTIC ++ ++#define M1_MAX_OFFSET 0x0400 ++#ifndef M2_MAX_OFFSET ++#define M2_MAX_OFFSET 0x0800 ++#endif ++#define M3_MAX_OFFSET 0x4000 ++#define M4_MAX_OFFSET 0xbfff ++ ++#define MX_MAX_OFFSET (M1_MAX_OFFSET + M2_MAX_OFFSET) ++ ++#define M1_MIN_LEN 2 ++#define M1_MAX_LEN 2 ++#define M2_MIN_LEN 3 ++#ifndef M2_MAX_LEN ++#define M2_MAX_LEN 8 ++#endif ++#define M3_MIN_LEN 3 ++#define M3_MAX_LEN 33 ++#define M4_MIN_LEN 3 ++#define M4_MAX_LEN 9 ++ ++#define M1_MARKER 0 ++#define M2_MARKER 64 ++#define M3_MARKER 32 ++#define M4_MARKER 16 ++ ++#ifndef MIN_LOOKAHEAD ++#define MIN_LOOKAHEAD (M2_MAX_LEN + 1) ++#endif ++ ++#if defined(LZO_NEED_DICT_H) ++ ++#ifndef LZO_HASH ++#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_B ++#endif ++#define DL_MIN_LEN M2_MIN_LEN ++ ++#ifndef __LZO_DICT_H ++#define __LZO_DICT_H 1 ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#if !defined(D_BITS) && defined(DBITS) ++# define D_BITS DBITS ++#endif ++#if !defined(D_BITS) ++# error "D_BITS is not defined" ++#endif ++#if (D_BITS < 16) ++# define D_SIZE LZO_SIZE(D_BITS) ++# define D_MASK LZO_MASK(D_BITS) ++#else ++# define D_SIZE LZO_USIZE(D_BITS) ++# define D_MASK LZO_UMASK(D_BITS) ++#endif ++#define D_HIGH ((D_MASK >> 1) + 1) ++ ++#if !defined(DD_BITS) ++# define DD_BITS 0 ++#endif ++#define DD_SIZE LZO_SIZE(DD_BITS) ++#define DD_MASK LZO_MASK(DD_BITS) ++ ++#if !defined(DL_BITS) ++# define DL_BITS (D_BITS - DD_BITS) ++#endif ++#if (DL_BITS < 16) ++# define DL_SIZE LZO_SIZE(DL_BITS) ++# define DL_MASK LZO_MASK(DL_BITS) ++#else ++# define DL_SIZE LZO_USIZE(DL_BITS) ++# define DL_MASK LZO_UMASK(DL_BITS) ++#endif ++ ++#if (D_BITS != DL_BITS + DD_BITS) ++# error "D_BITS does not match" ++#endif ++#if (D_BITS < 6 || D_BITS > 18) ++# error "invalid D_BITS" ++#endif ++#if (DL_BITS < 6 || DL_BITS > 20) ++# error "invalid DL_BITS" ++#endif ++#if (DD_BITS < 0 || DD_BITS > 6) ++# error "invalid DD_BITS" ++#endif ++ ++#if !defined(DL_MIN_LEN) ++# define DL_MIN_LEN 3 ++#endif ++#if !defined(DL_SHIFT) ++# define DL_SHIFT ((DL_BITS + (DL_MIN_LEN - 1)) / DL_MIN_LEN) ++#endif ++ ++#define LZO_HASH_GZIP 1 ++#define LZO_HASH_GZIP_INCREMENTAL 2 ++#define LZO_HASH_LZO_INCREMENTAL_A 3 ++#define LZO_HASH_LZO_INCREMENTAL_B 4 ++ ++#if !defined(LZO_HASH) ++# error "choose a hashing strategy" ++#endif ++ ++#undef DM ++#undef DX ++ ++#if (DL_MIN_LEN == 3) ++# define _DV2_A(p,shift1,shift2) \ ++ (((( (lzo_xint)((p)[0]) << shift1) ^ (p)[1]) << shift2) ^ (p)[2]) ++# define _DV2_B(p,shift1,shift2) \ ++ (((( (lzo_xint)((p)[2]) << shift1) ^ (p)[1]) << shift2) ^ (p)[0]) ++# define _DV3_B(p,shift1,shift2,shift3) \ ++ ((_DV2_B((p)+1,shift1,shift2) << (shift3)) ^ (p)[0]) ++#elif (DL_MIN_LEN == 2) ++# define _DV2_A(p,shift1,shift2) \ ++ (( (lzo_xint)(p[0]) << shift1) ^ p[1]) ++# define _DV2_B(p,shift1,shift2) \ ++ (( (lzo_xint)(p[1]) << shift1) ^ p[2]) ++#else ++# error "invalid DL_MIN_LEN" ++#endif ++#define _DV_A(p,shift) _DV2_A(p,shift,shift) ++#define _DV_B(p,shift) _DV2_B(p,shift,shift) ++#define DA2(p,s1,s2) \ ++ (((((lzo_xint)((p)[2]) << (s2)) + (p)[1]) << (s1)) + (p)[0]) ++#define DS2(p,s1,s2) \ ++ (((((lzo_xint)((p)[2]) << (s2)) - (p)[1]) << (s1)) - (p)[0]) ++#define DX2(p,s1,s2) \ ++ (((((lzo_xint)((p)[2]) << (s2)) ^ (p)[1]) << (s1)) ^ (p)[0]) ++#define DA3(p,s1,s2,s3) ((DA2((p)+1,s2,s3) << (s1)) + (p)[0]) ++#define DS3(p,s1,s2,s3) ((DS2((p)+1,s2,s3) << (s1)) - (p)[0]) ++#define DX3(p,s1,s2,s3) ((DX2((p)+1,s2,s3) << (s1)) ^ (p)[0]) ++#define DMS(v,s) ((lzo_uint) (((v) & (D_MASK >> (s))) << (s))) ++#define DM(v) DMS(v,0) ++ ++#if (LZO_HASH == LZO_HASH_GZIP) ++# define _DINDEX(dv,p) (_DV_A((p),DL_SHIFT)) ++ ++#elif (LZO_HASH == LZO_HASH_GZIP_INCREMENTAL) ++# define __LZO_HASH_INCREMENTAL 1 ++# define DVAL_FIRST(dv,p) dv = _DV_A((p),DL_SHIFT) ++# define DVAL_NEXT(dv,p) dv = (((dv) << DL_SHIFT) ^ p[2]) ++# define _DINDEX(dv,p) (dv) ++# define DVAL_LOOKAHEAD DL_MIN_LEN ++ ++#elif (LZO_HASH == LZO_HASH_LZO_INCREMENTAL_A) ++# define __LZO_HASH_INCREMENTAL 1 ++# define DVAL_FIRST(dv,p) dv = _DV_A((p),5) ++# define DVAL_NEXT(dv,p) \ ++ dv ^= (lzo_xint)(p[-1]) << (2*5); dv = (((dv) << 5) ^ p[2]) ++# define _DINDEX(dv,p) ((DMUL(0x9f5f,dv)) >> 5) ++# define DVAL_LOOKAHEAD DL_MIN_LEN ++ ++#elif (LZO_HASH == LZO_HASH_LZO_INCREMENTAL_B) ++# define __LZO_HASH_INCREMENTAL 1 ++# define DVAL_FIRST(dv,p) dv = _DV_B((p),5) ++# define DVAL_NEXT(dv,p) \ ++ dv ^= p[-1]; dv = (((dv) >> 5) ^ ((lzo_xint)(p[2]) << (2*5))) ++# define _DINDEX(dv,p) ((DMUL(0x9f5f,dv)) >> 5) ++# define DVAL_LOOKAHEAD DL_MIN_LEN ++ ++#else ++# error "choose a hashing strategy" ++#endif ++ ++#ifndef DINDEX ++#define DINDEX(dv,p) ((lzo_uint)((_DINDEX(dv,p)) & DL_MASK) << DD_BITS) ++#endif ++#if !defined(DINDEX1) && defined(D_INDEX1) ++#define DINDEX1 D_INDEX1 ++#endif ++#if !defined(DINDEX2) && defined(D_INDEX2) ++#define DINDEX2 D_INDEX2 ++#endif ++ ++#if !defined(__LZO_HASH_INCREMENTAL) ++# define DVAL_FIRST(dv,p) ((void) 0) ++# define DVAL_NEXT(dv,p) ((void) 0) ++# define DVAL_LOOKAHEAD 0 ++#endif ++ ++#if !defined(DVAL_ASSERT) ++#if defined(__LZO_HASH_INCREMENTAL) && !defined(NDEBUG) ++#if (LZO_CC_CLANG || (LZO_CC_GNUC >= 0x020700ul) || LZO_CC_LLVM) ++static void __attribute__((__unused__)) ++#else ++static void ++#endif ++DVAL_ASSERT(lzo_xint dv, const lzo_bytep p) ++{ ++ lzo_xint df; ++ DVAL_FIRST(df,(p)); ++ assert(DINDEX(dv,p) == DINDEX(df,p)); ++} ++#else ++# define DVAL_ASSERT(dv,p) ((void) 0) ++#endif ++#endif ++ ++#if (LZO_DICT_USE_PTR) ++# define DENTRY(p,in) (p) ++# define GINDEX(m_pos,m_off,dict,dindex,in) m_pos = dict[dindex] ++#else ++# define DENTRY(p,in) ((lzo_dict_t) pd(p, in)) ++# define GINDEX(m_pos,m_off,dict,dindex,in) m_off = dict[dindex] ++#endif ++ ++#if (DD_BITS == 0) ++ ++# define UPDATE_D(dict,drun,dv,p,in) dict[ DINDEX(dv,p) ] = DENTRY(p,in) ++# define UPDATE_I(dict,drun,index,p,in) dict[index] = DENTRY(p,in) ++# define UPDATE_P(ptr,drun,p,in) (ptr)[0] = DENTRY(p,in) ++ ++#else ++ ++# define UPDATE_D(dict,drun,dv,p,in) \ ++ dict[ DINDEX(dv,p) + drun++ ] = DENTRY(p,in); drun &= DD_MASK ++# define UPDATE_I(dict,drun,index,p,in) \ ++ dict[ (index) + drun++ ] = DENTRY(p,in); drun &= DD_MASK ++# define UPDATE_P(ptr,drun,p,in) \ ++ (ptr) [ drun++ ] = DENTRY(p,in); drun &= DD_MASK ++ ++#endif ++ ++#if (LZO_DICT_USE_PTR) ++ ++#define LZO_CHECK_MPOS_DET(m_pos,m_off,in,ip,max_offset) \ ++ (m_pos == NULL || (m_off = pd(ip, m_pos)) > max_offset) ++ ++#define LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,max_offset) \ ++ (BOUNDS_CHECKING_OFF_IN_EXPR(( \ ++ m_pos = ip - (lzo_uint) PTR_DIFF(ip,m_pos), \ ++ PTR_LT(m_pos,in) || \ ++ (m_off = (lzo_uint) PTR_DIFF(ip,m_pos)) == 0 || \ ++ m_off > max_offset ))) ++ ++#else ++ ++#define LZO_CHECK_MPOS_DET(m_pos,m_off,in,ip,max_offset) \ ++ (m_off == 0 || \ ++ ((m_off = pd(ip, in) - m_off) > max_offset) || \ ++ (m_pos = (ip) - (m_off), 0) ) ++ ++#define LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,max_offset) \ ++ (pd(ip, in) <= m_off || \ ++ ((m_off = pd(ip, in) - m_off) > max_offset) || \ ++ (m_pos = (ip) - (m_off), 0) ) ++ ++#endif ++ ++#if (LZO_DETERMINISTIC) ++# define LZO_CHECK_MPOS LZO_CHECK_MPOS_DET ++#else ++# define LZO_CHECK_MPOS LZO_CHECK_MPOS_NON_DET ++#endif ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif ++ ++#endif ++ ++#endif ++ ++#define LZO_DETERMINISTIC !(LZO_DICT_USE_PTR) ++ ++#ifndef DO_COMPRESS ++#define DO_COMPRESS lzo1x_1_compress ++#endif ++ ++#if 1 && defined(DO_COMPRESS) && !defined(do_compress) ++# define do_compress LZO_CPP_ECONCAT2(DO_COMPRESS,_core) ++#endif ++ ++#if defined(UA_GET64) ++# define WANT_lzo_bitops_ctz64 1 ++#elif defined(UA_GET32) ++# define WANT_lzo_bitops_ctz32 1 ++#endif ++ ++#if (defined(_WIN32) || defined(_WIN64)) && ((LZO_CC_INTELC && (__INTEL_COMPILER >= 1000)) || (LZO_CC_MSC && (_MSC_VER >= 1400))) ++#include <intrin.h> ++#if !defined(lzo_bitops_clz32) && defined(WANT_lzo_bitops_clz32) && 0 ++#pragma intrinsic(_BitScanReverse) ++static __lzo_inline unsigned lzo_bitops_clz32(lzo_uint32 v) ++{ ++ unsigned long r; ++ (void) _BitScanReverse(&r, v); ++ return (unsigned) r; ++} ++#define lzo_bitops_clz32 lzo_bitops_clz32 ++#endif ++#if !defined(lzo_bitops_clz64) && defined(WANT_lzo_bitops_clz64) && defined(LZO_UINT64_MAX) && 0 ++#pragma intrinsic(_BitScanReverse64) ++static __lzo_inline unsigned lzo_bitops_clz64(lzo_uint64 v) ++{ ++ unsigned long r; ++ (void) _BitScanReverse64(&r, v); ++ return (unsigned) r; ++} ++#define lzo_bitops_clz64 lzo_bitops_clz64 ++#endif ++#if !defined(lzo_bitops_ctz32) && defined(WANT_lzo_bitops_ctz32) ++#pragma intrinsic(_BitScanForward) ++static __lzo_inline unsigned lzo_bitops_ctz32(lzo_uint32 v) ++{ ++ unsigned long r; ++ (void) _BitScanForward(&r, v); ++ return (unsigned) r; ++} ++#define lzo_bitops_ctz32 lzo_bitops_ctz32 ++#endif ++#if !defined(lzo_bitops_ctz64) && defined(WANT_lzo_bitops_ctz64) && defined(LZO_UINT64_MAX) ++#pragma intrinsic(_BitScanForward64) ++static __lzo_inline unsigned lzo_bitops_ctz64(lzo_uint64 v) ++{ ++ unsigned long r; ++ (void) _BitScanForward64(&r, v); ++ return (unsigned) r; ++} ++#define lzo_bitops_ctz64 lzo_bitops_ctz64 ++#endif ++ ++#elif (LZO_CC_CLANG || (LZO_CC_GNUC >= 0x030400ul) || (LZO_CC_INTELC && (__INTEL_COMPILER >= 1000)) || LZO_CC_LLVM) ++#if !defined(lzo_bitops_clz32) && defined(WANT_lzo_bitops_clz32) ++#define lzo_bitops_clz32(v) ((unsigned) __builtin_clz(v)) ++#endif ++#if !defined(lzo_bitops_clz64) && defined(WANT_lzo_bitops_clz64) && defined(LZO_UINT64_MAX) ++#define lzo_bitops_clz64(v) ((unsigned) __builtin_clzll(v)) ++#endif ++#if !defined(lzo_bitops_ctz32) && defined(WANT_lzo_bitops_ctz32) ++#define lzo_bitops_ctz32(v) ((unsigned) __builtin_ctz(v)) ++#endif ++#if !defined(lzo_bitops_ctz64) && defined(WANT_lzo_bitops_ctz64) && defined(LZO_UINT64_MAX) ++#define lzo_bitops_ctz64(v) ((unsigned) __builtin_ctzll(v)) ++#endif ++#if !defined(lzo_bitops_popcount32) && defined(WANT_lzo_bitops_popcount32) ++#define lzo_bitops_popcount32(v) ((unsigned) __builtin_popcount(v)) ++#endif ++#if !defined(lzo_bitops_popcount32) && defined(WANT_lzo_bitops_popcount64) && defined(LZO_UINT64_MAX) ++#define lzo_bitops_popcount64(v) ((unsigned) __builtin_popcountll(v)) ++#endif ++#endif ++ ++static __lzo_noinline lzo_uint ++do_compress ( const lzo_bytep in , lzo_uint in_len, ++ lzo_bytep out, lzo_uintp out_len, ++ lzo_uint ti, lzo_voidp wrkmem) ++{ ++ register const lzo_bytep ip; ++ lzo_bytep op; ++ const lzo_bytep const in_end = in + in_len; ++ const lzo_bytep const ip_end = in + in_len - 20; ++ const lzo_bytep ii; ++ lzo_dict_p const dict = (lzo_dict_p) wrkmem; ++ ++ op = out; ++ ip = in; ++ ii = ip - ti; ++ ++ ip += ti < 4 ? 4 - ti : 0; ++ for (;;) ++ { ++ const lzo_bytep m_pos; ++#if !(LZO_DETERMINISTIC) ++ LZO_DEFINE_UNINITIALIZED_VAR(lzo_uint, m_off, 0); ++ lzo_uint m_len; ++ lzo_uint dindex; ++next: ++ if __lzo_unlikely(ip >= ip_end) ++ break; ++ DINDEX1(dindex,ip); ++ GINDEX(m_pos,m_off,dict,dindex,in); ++ if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M4_MAX_OFFSET)) ++ goto literal; ++#if 1 ++ if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3]) ++ goto try_match; ++ DINDEX2(dindex,ip); ++#endif ++ GINDEX(m_pos,m_off,dict,dindex,in); ++ if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M4_MAX_OFFSET)) ++ goto literal; ++ if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3]) ++ goto try_match; ++ goto literal; ++ ++try_match: ++#if defined(UA_GET32) ++ if (UA_GET32(m_pos) != UA_GET32(ip)) ++#else ++ if (m_pos[0] != ip[0] || m_pos[1] != ip[1] || m_pos[2] != ip[2] || m_pos[3] != ip[3]) ++#endif ++ { ++literal: ++ UPDATE_I(dict,0,dindex,ip,in); ++ ip += 1 + ((ip - ii) >> 5); ++ continue; ++ } ++ UPDATE_I(dict,0,dindex,ip,in); ++#else ++ lzo_uint m_off; ++ lzo_uint m_len; ++ { ++ lzo_uint32 dv; ++ lzo_uint dindex; ++literal: ++ ip += 1 + ((ip - ii) >> 5); ++next: ++ if __lzo_unlikely(ip >= ip_end) ++ break; ++ dv = UA_GET32(ip); ++ dindex = DINDEX(dv,ip); ++ GINDEX(m_off,m_pos,in+dict,dindex,in); ++ UPDATE_I(dict,0,dindex,ip,in); ++ if __lzo_unlikely(dv != UA_GET32(m_pos)) ++ goto literal; ++ } ++#endif ++ ++ { ++ register lzo_uint t = pd(ip,ii); ++ if (t != 0) ++ { ++ if (t <= 3) ++ { ++ op[-2] |= LZO_BYTE(t); ++#if defined(UA_COPY32) ++ UA_COPY32(op, ii); ++ op += t; ++#else ++ { do *op++ = *ii++; while (--t > 0); } ++#endif ++ } ++#if defined(UA_COPY32) || defined(UA_COPY64) ++ else if (t <= 16) ++ { ++ *op++ = LZO_BYTE(t - 3); ++#if defined(UA_COPY64) ++ UA_COPY64(op, ii); ++ UA_COPY64(op+8, ii+8); ++#else ++ UA_COPY32(op, ii); ++ UA_COPY32(op+4, ii+4); ++ UA_COPY32(op+8, ii+8); ++ UA_COPY32(op+12, ii+12); ++#endif ++ op += t; ++ } ++#endif ++ else ++ { ++ if (t <= 18) ++ *op++ = LZO_BYTE(t - 3); ++ else ++ { ++ register lzo_uint tt = t - 18; ++ *op++ = 0; ++ while __lzo_unlikely(tt > 255) ++ { ++ tt -= 255; ++#if 1 && (LZO_CC_MSC && (_MSC_VER >= 1400)) ++ * (volatile unsigned char *) op++ = 0; ++#else ++ *op++ = 0; ++#endif ++ } ++ assert(tt > 0); ++ *op++ = LZO_BYTE(tt); ++ } ++#if defined(UA_COPY32) || defined(UA_COPY64) ++ do { ++#if defined(UA_COPY64) ++ UA_COPY64(op, ii); ++ UA_COPY64(op+8, ii+8); ++#else ++ UA_COPY32(op, ii); ++ UA_COPY32(op+4, ii+4); ++ UA_COPY32(op+8, ii+8); ++ UA_COPY32(op+12, ii+12); ++#endif ++ op += 16; ii += 16; t -= 16; ++ } while (t >= 16); if (t > 0) ++#endif ++ { do *op++ = *ii++; while (--t > 0); } ++ } ++ } ++ } ++ m_len = 4; ++ { ++#if defined(UA_GET64) ++ lzo_uint64 v; ++ v = UA_GET64(ip + m_len) ^ UA_GET64(m_pos + m_len); ++ if __lzo_unlikely(v == 0) { ++ do { ++ m_len += 8; ++ v = UA_GET64(ip + m_len) ^ UA_GET64(m_pos + m_len); ++ if __lzo_unlikely(ip + m_len >= ip_end) ++ goto m_len_done; ++ } while (v == 0); ++ } ++#if (LZO_ABI_LITTLE_ENDIAN) && defined(lzo_bitops_ctz64) ++ m_len += lzo_bitops_ctz64(v) / CHAR_BIT; ++#elif (LZO_ABI_LITTLE_ENDIAN) ++ if ((v & UCHAR_MAX) == 0) do { ++ v >>= CHAR_BIT; ++ m_len += 1; ++ } while ((v & UCHAR_MAX) == 0); ++#else ++ if (ip[m_len] == m_pos[m_len]) do { ++ m_len += 1; ++ } while (ip[m_len] == m_pos[m_len]); ++#endif ++#elif defined(UA_GET32) ++ lzo_uint32 v; ++ v = UA_GET32(ip + m_len) ^ UA_GET32(m_pos + m_len); ++ if __lzo_unlikely(v == 0) { ++ do { ++ m_len += 4; ++ v = UA_GET32(ip + m_len) ^ UA_GET32(m_pos + m_len); ++ if __lzo_unlikely(ip + m_len >= ip_end) ++ goto m_len_done; ++ } while (v == 0); ++ } ++#if (LZO_ABI_LITTLE_ENDIAN) && defined(lzo_bitops_ctz32) ++ m_len += lzo_bitops_ctz32(v) / CHAR_BIT; ++#elif (LZO_ABI_LITTLE_ENDIAN) ++ if ((v & UCHAR_MAX) == 0) do { ++ v >>= CHAR_BIT; ++ m_len += 1; ++ } while ((v & UCHAR_MAX) == 0); ++#else ++ if (ip[m_len] == m_pos[m_len]) do { ++ m_len += 1; ++ } while (ip[m_len] == m_pos[m_len]); ++#endif ++#else ++ if __lzo_unlikely(ip[m_len] == m_pos[m_len]) { ++ do { ++ m_len += 1; ++ if __lzo_unlikely(ip + m_len >= ip_end) ++ goto m_len_done; ++ } while (ip[m_len] == m_pos[m_len]); ++ } ++#endif ++ } ++m_len_done: ++ m_off = pd(ip,m_pos); ++ ip += m_len; ++ ii = ip; ++ if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) ++ { ++ m_off -= 1; ++#if defined(LZO1X) ++ *op++ = LZO_BYTE(((m_len - 1) << 5) | ((m_off & 7) << 2)); ++ *op++ = LZO_BYTE(m_off >> 3); ++#elif defined(LZO1Y) ++ *op++ = LZO_BYTE(((m_len + 1) << 4) | ((m_off & 3) << 2)); ++ *op++ = LZO_BYTE(m_off >> 2); ++#endif ++ } ++ else if (m_off <= M3_MAX_OFFSET) ++ { ++ m_off -= 1; ++ if (m_len <= M3_MAX_LEN) ++ *op++ = LZO_BYTE(M3_MARKER | (m_len - 2)); ++ else ++ { ++ m_len -= M3_MAX_LEN; ++ *op++ = M3_MARKER | 0; ++ while __lzo_unlikely(m_len > 255) ++ { ++ m_len -= 255; ++#if 1 && (LZO_CC_MSC && (_MSC_VER >= 1400)) ++ * (volatile unsigned char *) op++ = 0; ++#else ++ *op++ = 0; ++#endif ++ } ++ *op++ = LZO_BYTE(m_len); ++ } ++ *op++ = LZO_BYTE(m_off << 2); ++ *op++ = LZO_BYTE(m_off >> 6); ++ } ++ else ++ { ++ m_off -= 0x4000; ++ if (m_len <= M4_MAX_LEN) ++ *op++ = LZO_BYTE(M4_MARKER | ((m_off >> 11) & 8) | (m_len - 2)); ++ else ++ { ++ m_len -= M4_MAX_LEN; ++ *op++ = LZO_BYTE(M4_MARKER | ((m_off >> 11) & 8)); ++ while __lzo_unlikely(m_len > 255) ++ { ++ m_len -= 255; ++#if 1 && (LZO_CC_MSC && (_MSC_VER >= 1400)) ++ * (volatile unsigned char *) op++ = 0; ++#else ++ *op++ = 0; ++#endif ++ } ++ *op++ = LZO_BYTE(m_len); ++ } ++ *op++ = LZO_BYTE(m_off << 2); ++ *op++ = LZO_BYTE(m_off >> 6); ++ } ++ goto next; ++ } ++ ++ *out_len = pd(op, out); ++ return pd(in_end,ii); ++} ++ ++LZO_PUBLIC(int) ++DO_COMPRESS ( const lzo_bytep in , lzo_uint in_len, ++ lzo_bytep out, lzo_uintp out_len, ++ lzo_voidp wrkmem ) ++{ ++ const lzo_bytep ip = in; ++ lzo_bytep op = out; ++ lzo_uint l = in_len; ++ lzo_uint t = 0; ++ ++ while (l > 20) ++ { ++ lzo_uint ll = l; ++ lzo_uintptr_t ll_end; ++#if 0 || (LZO_DETERMINISTIC) ++ ll = LZO_MIN(ll, 49152); ++#endif ++ ll_end = (lzo_uintptr_t)ip + ll; ++ if ((ll_end + ((t + ll) >> 5)) <= ll_end || (const lzo_bytep)(ll_end + ((t + ll) >> 5)) <= ip + ll) ++ break; ++#if (LZO_DETERMINISTIC) ++ lzo_memset(wrkmem, 0, ((lzo_uint)1 << D_BITS) * sizeof(lzo_dict_t)); ++#endif ++ t = do_compress(ip,ll,op,out_len,t,wrkmem); ++ ip += ll; ++ op += *out_len; ++ l -= ll; ++ } ++ t += l; ++ ++ if (t > 0) ++ { ++ const lzo_bytep ii = in + in_len - t; ++ ++ if (op == out && t <= 238) ++ *op++ = LZO_BYTE(17 + t); ++ else if (t <= 3) ++ op[-2] |= LZO_BYTE(t); ++ else if (t <= 18) ++ *op++ = LZO_BYTE(t - 3); ++ else ++ { ++ lzo_uint tt = t - 18; ++ ++ *op++ = 0; ++ while (tt > 255) ++ { ++ tt -= 255; ++#if 1 && (LZO_CC_MSC && (_MSC_VER >= 1400)) ++ ++ * (volatile unsigned char *) op++ = 0; ++#else ++ *op++ = 0; ++#endif ++ } ++ assert(tt > 0); ++ *op++ = LZO_BYTE(tt); ++ } ++ do *op++ = *ii++; while (--t > 0); ++ } ++ ++ *op++ = M4_MARKER | 1; ++ *op++ = 0; ++ *op++ = 0; ++ ++ *out_len = pd(op, out); ++ return LZO_E_OK; ++} ++ ++#endif ++ ++#undef do_compress ++#undef DO_COMPRESS ++#undef LZO_HASH ++ ++#undef LZO_TEST_OVERRUN ++#undef DO_DECOMPRESS ++#define DO_DECOMPRESS lzo1x_decompress ++ ++#if !defined(MINILZO_CFG_SKIP_LZO1X_DECOMPRESS) ++ ++#if defined(LZO_TEST_OVERRUN) ++# if !defined(LZO_TEST_OVERRUN_INPUT) ++# define LZO_TEST_OVERRUN_INPUT 2 ++# endif ++# if !defined(LZO_TEST_OVERRUN_OUTPUT) ++# define LZO_TEST_OVERRUN_OUTPUT 2 ++# endif ++# if !defined(LZO_TEST_OVERRUN_LOOKBEHIND) ++# define LZO_TEST_OVERRUN_LOOKBEHIND 1 ++# endif ++#endif ++ ++#undef TEST_IP ++#undef TEST_OP ++#undef TEST_LB ++#undef TEST_LBO ++#undef NEED_IP ++#undef NEED_OP ++#undef HAVE_TEST_IP ++#undef HAVE_TEST_OP ++#undef HAVE_NEED_IP ++#undef HAVE_NEED_OP ++#undef HAVE_ANY_IP ++#undef HAVE_ANY_OP ++ ++#if defined(LZO_TEST_OVERRUN_INPUT) ++# if (LZO_TEST_OVERRUN_INPUT >= 1) ++# define TEST_IP (ip < ip_end) ++# endif ++# if (LZO_TEST_OVERRUN_INPUT >= 2) ++# define NEED_IP(x) \ ++ if ((lzo_uint)(ip_end - ip) < (lzo_uint)(x)) goto input_overrun ++# endif ++#endif ++ ++#if defined(LZO_TEST_OVERRUN_OUTPUT) ++# if (LZO_TEST_OVERRUN_OUTPUT >= 1) ++# define TEST_OP (op <= op_end) ++# endif ++# if (LZO_TEST_OVERRUN_OUTPUT >= 2) ++# undef TEST_OP ++# define NEED_OP(x) \ ++ if ((lzo_uint)(op_end - op) < (lzo_uint)(x)) goto output_overrun ++# endif ++#endif ++ ++#if defined(LZO_TEST_OVERRUN_LOOKBEHIND) ++# define TEST_LB(m_pos) if (m_pos < out || m_pos >= op) goto lookbehind_overrun ++# define TEST_LBO(m_pos,o) if (m_pos < out || m_pos >= op - (o)) goto lookbehind_overrun ++#else ++# define TEST_LB(m_pos) ((void) 0) ++# define TEST_LBO(m_pos,o) ((void) 0) ++#endif ++ ++#if !defined(LZO_EOF_CODE) && !defined(TEST_IP) ++# define TEST_IP (ip < ip_end) ++#endif ++ ++#if defined(TEST_IP) ++# define HAVE_TEST_IP 1 ++#else ++# define TEST_IP 1 ++#endif ++#if defined(TEST_OP) ++# define HAVE_TEST_OP 1 ++#else ++# define TEST_OP 1 ++#endif ++ ++#if defined(NEED_IP) ++# define HAVE_NEED_IP 1 ++#else ++# define NEED_IP(x) ((void) 0) ++#endif ++#if defined(NEED_OP) ++# define HAVE_NEED_OP 1 ++#else ++# define NEED_OP(x) ((void) 0) ++#endif ++ ++#if defined(HAVE_TEST_IP) || defined(HAVE_NEED_IP) ++# define HAVE_ANY_IP 1 ++#endif ++#if defined(HAVE_TEST_OP) || defined(HAVE_NEED_OP) ++# define HAVE_ANY_OP 1 ++#endif ++ ++#if defined(DO_DECOMPRESS) ++LZO_PUBLIC(int) ++DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, ++ lzo_bytep out, lzo_uintp out_len, ++ lzo_voidp wrkmem ) ++#endif ++{ ++ register lzo_bytep op; ++ register const lzo_bytep ip; ++ register lzo_uint t; ++#if defined(COPY_DICT) ++ lzo_uint m_off; ++ const lzo_bytep dict_end; ++#else ++ register const lzo_bytep m_pos; ++#endif ++ ++ const lzo_bytep const ip_end = in + in_len; ++#if defined(HAVE_ANY_OP) ++ lzo_bytep const op_end = out + *out_len; ++#endif ++#if defined(LZO1Z) ++ lzo_uint last_m_off = 0; ++#endif ++ ++ LZO_UNUSED(wrkmem); ++ ++#if defined(COPY_DICT) ++ if (dict) ++ { ++ if (dict_len > M4_MAX_OFFSET) ++ { ++ dict += dict_len - M4_MAX_OFFSET; ++ dict_len = M4_MAX_OFFSET; ++ } ++ dict_end = dict + dict_len; ++ } ++ else ++ { ++ dict_len = 0; ++ dict_end = NULL; ++ } ++#endif ++ ++ *out_len = 0; ++ ++ op = out; ++ ip = in; ++ ++ if (*ip > 17) ++ { ++ t = *ip++ - 17; ++ if (t < 4) ++ goto match_next; ++ assert(t > 0); NEED_OP(t); NEED_IP(t+1); ++ do *op++ = *ip++; while (--t > 0); ++ goto first_literal_run; ++ } ++ ++ while (TEST_IP && TEST_OP) ++ { ++ t = *ip++; ++ if (t >= 16) ++ goto match; ++ if (t == 0) ++ { ++ NEED_IP(1); ++ while (*ip == 0) ++ { ++ t += 255; ++ ip++; ++ NEED_IP(1); ++ } ++ t += 15 + *ip++; ++ } ++ assert(t > 0); NEED_OP(t+3); NEED_IP(t+4); ++#if defined(LZO_UNALIGNED_OK_8) && defined(LZO_UNALIGNED_OK_4) ++ t += 3; ++ if (t >= 8) do ++ { ++ UA_COPY64(op,ip); ++ op += 8; ip += 8; t -= 8; ++ } while (t >= 8); ++ if (t >= 4) ++ { ++ UA_COPY32(op,ip); ++ op += 4; ip += 4; t -= 4; ++ } ++ if (t > 0) ++ { ++ *op++ = *ip++; ++ if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } } ++ } ++#elif defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4) ++#if !defined(LZO_UNALIGNED_OK_4) ++ if (PTR_ALIGNED2_4(op,ip)) ++ { ++#endif ++ UA_COPY32(op,ip); ++ op += 4; ip += 4; ++ if (--t > 0) ++ { ++ if (t >= 4) ++ { ++ do { ++ UA_COPY32(op,ip); ++ op += 4; ip += 4; t -= 4; ++ } while (t >= 4); ++ if (t > 0) do *op++ = *ip++; while (--t > 0); ++ } ++ else ++ do *op++ = *ip++; while (--t > 0); ++ } ++#if !defined(LZO_UNALIGNED_OK_4) ++ } ++ else ++#endif ++#endif ++#if !defined(LZO_UNALIGNED_OK_4) && !defined(LZO_UNALIGNED_OK_8) ++ { ++ *op++ = *ip++; *op++ = *ip++; *op++ = *ip++; ++ do *op++ = *ip++; while (--t > 0); ++ } ++#endif ++ ++first_literal_run: ++ ++ t = *ip++; ++ if (t >= 16) ++ goto match; ++#if defined(COPY_DICT) ++#if defined(LZO1Z) ++ m_off = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2); ++ last_m_off = m_off; ++#else ++ m_off = (1 + M2_MAX_OFFSET) + (t >> 2) + (*ip++ << 2); ++#endif ++ NEED_OP(3); ++ t = 3; COPY_DICT(t,m_off) ++#else ++#if defined(LZO1Z) ++ t = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2); ++ m_pos = op - t; ++ last_m_off = t; ++#else ++ m_pos = op - (1 + M2_MAX_OFFSET); ++ m_pos -= t >> 2; ++ m_pos -= *ip++ << 2; ++#endif ++ TEST_LB(m_pos); NEED_OP(3); ++ *op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos; ++#endif ++ goto match_done; ++ ++ do { ++match: ++ if (t >= 64) ++ { ++#if defined(COPY_DICT) ++#if defined(LZO1X) ++ m_off = 1 + ((t >> 2) & 7) + (*ip++ << 3); ++ t = (t >> 5) - 1; ++#elif defined(LZO1Y) ++ m_off = 1 + ((t >> 2) & 3) + (*ip++ << 2); ++ t = (t >> 4) - 3; ++#elif defined(LZO1Z) ++ m_off = t & 0x1f; ++ if (m_off >= 0x1c) ++ m_off = last_m_off; ++ else ++ { ++ m_off = 1 + (m_off << 6) + (*ip++ >> 2); ++ last_m_off = m_off; ++ } ++ t = (t >> 5) - 1; ++#endif ++#else ++#if defined(LZO1X) ++ m_pos = op - 1; ++ m_pos -= (t >> 2) & 7; ++ m_pos -= *ip++ << 3; ++ t = (t >> 5) - 1; ++#elif defined(LZO1Y) ++ m_pos = op - 1; ++ m_pos -= (t >> 2) & 3; ++ m_pos -= *ip++ << 2; ++ t = (t >> 4) - 3; ++#elif defined(LZO1Z) ++ { ++ lzo_uint off = t & 0x1f; ++ m_pos = op; ++ if (off >= 0x1c) ++ { ++ assert(last_m_off > 0); ++ m_pos -= last_m_off; ++ } ++ else ++ { ++ off = 1 + (off << 6) + (*ip++ >> 2); ++ m_pos -= off; ++ last_m_off = off; ++ } ++ } ++ t = (t >> 5) - 1; ++#endif ++ TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1); ++ goto copy_match; ++#endif ++ } ++ else if (t >= 32) ++ { ++ t &= 31; ++ if (t == 0) ++ { ++ NEED_IP(1); ++ while (*ip == 0) ++ { ++ t += 255; ++ ip++; ++ NEED_IP(1); ++ } ++ t += 31 + *ip++; ++ } ++#if defined(COPY_DICT) ++#if defined(LZO1Z) ++ m_off = 1 + (ip[0] << 6) + (ip[1] >> 2); ++ last_m_off = m_off; ++#else ++ m_off = 1 + (ip[0] >> 2) + (ip[1] << 6); ++#endif ++#else ++#if defined(LZO1Z) ++ { ++ lzo_uint off = 1 + (ip[0] << 6) + (ip[1] >> 2); ++ m_pos = op - off; ++ last_m_off = off; ++ } ++#elif defined(LZO_UNALIGNED_OK_2) && defined(LZO_ABI_LITTLE_ENDIAN) ++ m_pos = op - 1; ++ m_pos -= UA_GET16(ip) >> 2; ++#else ++ m_pos = op - 1; ++ m_pos -= (ip[0] >> 2) + (ip[1] << 6); ++#endif ++#endif ++ ip += 2; ++ } ++ else if (t >= 16) ++ { ++#if defined(COPY_DICT) ++ m_off = (t & 8) << 11; ++#else ++ m_pos = op; ++ m_pos -= (t & 8) << 11; ++#endif ++ t &= 7; ++ if (t == 0) ++ { ++ NEED_IP(1); ++ while (*ip == 0) ++ { ++ t += 255; ++ ip++; ++ NEED_IP(1); ++ } ++ t += 7 + *ip++; ++ } ++#if defined(COPY_DICT) ++#if defined(LZO1Z) ++ m_off += (ip[0] << 6) + (ip[1] >> 2); ++#else ++ m_off += (ip[0] >> 2) + (ip[1] << 6); ++#endif ++ ip += 2; ++ if (m_off == 0) ++ goto eof_found; ++ m_off += 0x4000; ++#if defined(LZO1Z) ++ last_m_off = m_off; ++#endif ++#else ++#if defined(LZO1Z) ++ m_pos -= (ip[0] << 6) + (ip[1] >> 2); ++#elif defined(LZO_UNALIGNED_OK_2) && defined(LZO_ABI_LITTLE_ENDIAN) ++ m_pos -= UA_GET16(ip) >> 2; ++#else ++ m_pos -= (ip[0] >> 2) + (ip[1] << 6); ++#endif ++ ip += 2; ++ if (m_pos == op) ++ goto eof_found; ++ m_pos -= 0x4000; ++#if defined(LZO1Z) ++ last_m_off = pd((const lzo_bytep)op, m_pos); ++#endif ++#endif ++ } ++ else ++ { ++#if defined(COPY_DICT) ++#if defined(LZO1Z) ++ m_off = 1 + (t << 6) + (*ip++ >> 2); ++ last_m_off = m_off; ++#else ++ m_off = 1 + (t >> 2) + (*ip++ << 2); ++#endif ++ NEED_OP(2); ++ t = 2; COPY_DICT(t,m_off) ++#else ++#if defined(LZO1Z) ++ t = 1 + (t << 6) + (*ip++ >> 2); ++ m_pos = op - t; ++ last_m_off = t; ++#else ++ m_pos = op - 1; ++ m_pos -= t >> 2; ++ m_pos -= *ip++ << 2; ++#endif ++ TEST_LB(m_pos); NEED_OP(2); ++ *op++ = *m_pos++; *op++ = *m_pos; ++#endif ++ goto match_done; ++ } ++ ++#if defined(COPY_DICT) ++ ++ NEED_OP(t+3-1); ++ t += 3-1; COPY_DICT(t,m_off) ++ ++#else ++ ++ TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1); ++#if defined(LZO_UNALIGNED_OK_8) && defined(LZO_UNALIGNED_OK_4) ++ if (op - m_pos >= 8) ++ { ++ t += (3 - 1); ++ if (t >= 8) do ++ { ++ UA_COPY64(op,m_pos); ++ op += 8; m_pos += 8; t -= 8; ++ } while (t >= 8); ++ if (t >= 4) ++ { ++ UA_COPY32(op,m_pos); ++ op += 4; m_pos += 4; t -= 4; ++ } ++ if (t > 0) ++ { ++ *op++ = m_pos[0]; ++ if (t > 1) { *op++ = m_pos[1]; if (t > 2) { *op++ = m_pos[2]; } } ++ } ++ } ++ else ++#elif defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4) ++#if !defined(LZO_UNALIGNED_OK_4) ++ if (t >= 2 * 4 - (3 - 1) && PTR_ALIGNED2_4(op,m_pos)) ++ { ++ assert((op - m_pos) >= 4); ++#else ++ if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4) ++ { ++#endif ++ UA_COPY32(op,m_pos); ++ op += 4; m_pos += 4; t -= 4 - (3 - 1); ++ do { ++ UA_COPY32(op,m_pos); ++ op += 4; m_pos += 4; t -= 4; ++ } while (t >= 4); ++ if (t > 0) do *op++ = *m_pos++; while (--t > 0); ++ } ++ else ++#endif ++ { ++copy_match: ++ *op++ = *m_pos++; *op++ = *m_pos++; ++ do *op++ = *m_pos++; while (--t > 0); ++ } ++ ++#endif ++ ++match_done: ++#if defined(LZO1Z) ++ t = ip[-1] & 3; ++#else ++ t = ip[-2] & 3; ++#endif ++ if (t == 0) ++ break; ++ ++match_next: ++ assert(t > 0); assert(t < 4); NEED_OP(t); NEED_IP(t+1); ++#if 0 ++ do *op++ = *ip++; while (--t > 0); ++#else ++ *op++ = *ip++; ++ if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } } ++#endif ++ t = *ip++; ++ } while (TEST_IP && TEST_OP); ++ } ++ ++#if defined(HAVE_TEST_IP) || defined(HAVE_TEST_OP) ++ *out_len = pd(op, out); ++ return LZO_E_EOF_NOT_FOUND; ++#endif ++ ++eof_found: ++ assert(t == 1); ++ *out_len = pd(op, out); ++ return (ip == ip_end ? LZO_E_OK : ++ (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); ++ ++#if defined(HAVE_NEED_IP) ++input_overrun: ++ *out_len = pd(op, out); ++ return LZO_E_INPUT_OVERRUN; ++#endif ++ ++#if defined(HAVE_NEED_OP) ++output_overrun: ++ *out_len = pd(op, out); ++ return LZO_E_OUTPUT_OVERRUN; ++#endif ++ ++#if defined(LZO_TEST_OVERRUN_LOOKBEHIND) ++lookbehind_overrun: ++ *out_len = pd(op, out); ++ return LZO_E_LOOKBEHIND_OVERRUN; ++#endif ++} ++ ++#endif ++ ++#define LZO_TEST_OVERRUN 1 ++#undef DO_DECOMPRESS ++#define DO_DECOMPRESS lzo1x_decompress_safe ++ ++#if !defined(MINILZO_CFG_SKIP_LZO1X_DECOMPRESS_SAFE) ++ ++#if defined(LZO_TEST_OVERRUN) ++# if !defined(LZO_TEST_OVERRUN_INPUT) ++# define LZO_TEST_OVERRUN_INPUT 2 ++# endif ++# if !defined(LZO_TEST_OVERRUN_OUTPUT) ++# define LZO_TEST_OVERRUN_OUTPUT 2 ++# endif ++# if !defined(LZO_TEST_OVERRUN_LOOKBEHIND) ++# define LZO_TEST_OVERRUN_LOOKBEHIND 1 ++# endif ++#endif ++ ++#undef TEST_IP ++#undef TEST_OP ++#undef TEST_LB ++#undef TEST_LBO ++#undef NEED_IP ++#undef NEED_OP ++#undef HAVE_TEST_IP ++#undef HAVE_TEST_OP ++#undef HAVE_NEED_IP ++#undef HAVE_NEED_OP ++#undef HAVE_ANY_IP ++#undef HAVE_ANY_OP ++ ++#if defined(LZO_TEST_OVERRUN_INPUT) ++# if (LZO_TEST_OVERRUN_INPUT >= 1) ++# define TEST_IP (ip < ip_end) ++# endif ++# if (LZO_TEST_OVERRUN_INPUT >= 2) ++# define NEED_IP(x) \ ++ if ((lzo_uint)(ip_end - ip) < (lzo_uint)(x)) goto input_overrun ++# endif ++#endif ++ ++#if defined(LZO_TEST_OVERRUN_OUTPUT) ++# if (LZO_TEST_OVERRUN_OUTPUT >= 1) ++# define TEST_OP (op <= op_end) ++# endif ++# if (LZO_TEST_OVERRUN_OUTPUT >= 2) ++# undef TEST_OP ++# define NEED_OP(x) \ ++ if ((lzo_uint)(op_end - op) < (lzo_uint)(x)) goto output_overrun ++# endif ++#endif ++ ++#if defined(LZO_TEST_OVERRUN_LOOKBEHIND) ++# define TEST_LB(m_pos) if (m_pos < out || m_pos >= op) goto lookbehind_overrun ++# define TEST_LBO(m_pos,o) if (m_pos < out || m_pos >= op - (o)) goto lookbehind_overrun ++#else ++# define TEST_LB(m_pos) ((void) 0) ++# define TEST_LBO(m_pos,o) ((void) 0) ++#endif ++ ++#if !defined(LZO_EOF_CODE) && !defined(TEST_IP) ++# define TEST_IP (ip < ip_end) ++#endif ++ ++#if defined(TEST_IP) ++# define HAVE_TEST_IP 1 ++#else ++# define TEST_IP 1 ++#endif ++#if defined(TEST_OP) ++# define HAVE_TEST_OP 1 ++#else ++# define TEST_OP 1 ++#endif ++ ++#if defined(NEED_IP) ++# define HAVE_NEED_IP 1 ++#else ++# define NEED_IP(x) ((void) 0) ++#endif ++#if defined(NEED_OP) ++# define HAVE_NEED_OP 1 ++#else ++# define NEED_OP(x) ((void) 0) ++#endif ++ ++#if defined(HAVE_TEST_IP) || defined(HAVE_NEED_IP) ++# define HAVE_ANY_IP 1 ++#endif ++#if defined(HAVE_TEST_OP) || defined(HAVE_NEED_OP) ++# define HAVE_ANY_OP 1 ++#endif ++ ++#if defined(DO_DECOMPRESS) ++LZO_PUBLIC(int) ++DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, ++ lzo_bytep out, lzo_uintp out_len, ++ lzo_voidp wrkmem ) ++#endif ++{ ++ register lzo_bytep op; ++ register const lzo_bytep ip; ++ register lzo_uint t; ++#if defined(COPY_DICT) ++ lzo_uint m_off; ++ const lzo_bytep dict_end; ++#else ++ register const lzo_bytep m_pos; ++#endif ++ ++ const lzo_bytep const ip_end = in + in_len; ++#if defined(HAVE_ANY_OP) ++ lzo_bytep const op_end = out + *out_len; ++#endif ++#if defined(LZO1Z) ++ lzo_uint last_m_off = 0; ++#endif ++ ++ LZO_UNUSED(wrkmem); ++ ++#if defined(COPY_DICT) ++ if (dict) ++ { ++ if (dict_len > M4_MAX_OFFSET) ++ { ++ dict += dict_len - M4_MAX_OFFSET; ++ dict_len = M4_MAX_OFFSET; ++ } ++ dict_end = dict + dict_len; ++ } ++ else ++ { ++ dict_len = 0; ++ dict_end = NULL; ++ } ++#endif ++ ++ *out_len = 0; ++ ++ op = out; ++ ip = in; ++ ++ if (*ip > 17) ++ { ++ t = *ip++ - 17; ++ if (t < 4) ++ goto match_next; ++ assert(t > 0); NEED_OP(t); NEED_IP(t+1); ++ do *op++ = *ip++; while (--t > 0); ++ goto first_literal_run; ++ } ++ ++ while (TEST_IP && TEST_OP) ++ { ++ t = *ip++; ++ if (t >= 16) ++ goto match; ++ if (t == 0) ++ { ++ NEED_IP(1); ++ while (*ip == 0) ++ { ++ t += 255; ++ ip++; ++ NEED_IP(1); ++ } ++ t += 15 + *ip++; ++ } ++ assert(t > 0); NEED_OP(t+3); NEED_IP(t+4); ++#if defined(LZO_UNALIGNED_OK_8) && defined(LZO_UNALIGNED_OK_4) ++ t += 3; ++ if (t >= 8) do ++ { ++ UA_COPY64(op,ip); ++ op += 8; ip += 8; t -= 8; ++ } while (t >= 8); ++ if (t >= 4) ++ { ++ UA_COPY32(op,ip); ++ op += 4; ip += 4; t -= 4; ++ } ++ if (t > 0) ++ { ++ *op++ = *ip++; ++ if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } } ++ } ++#elif defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4) ++#if !defined(LZO_UNALIGNED_OK_4) ++ if (PTR_ALIGNED2_4(op,ip)) ++ { ++#endif ++ UA_COPY32(op,ip); ++ op += 4; ip += 4; ++ if (--t > 0) ++ { ++ if (t >= 4) ++ { ++ do { ++ UA_COPY32(op,ip); ++ op += 4; ip += 4; t -= 4; ++ } while (t >= 4); ++ if (t > 0) do *op++ = *ip++; while (--t > 0); ++ } ++ else ++ do *op++ = *ip++; while (--t > 0); ++ } ++#if !defined(LZO_UNALIGNED_OK_4) ++ } ++ else ++#endif ++#endif ++#if !defined(LZO_UNALIGNED_OK_4) && !defined(LZO_UNALIGNED_OK_8) ++ { ++ *op++ = *ip++; *op++ = *ip++; *op++ = *ip++; ++ do *op++ = *ip++; while (--t > 0); ++ } ++#endif ++ ++first_literal_run: ++ ++ t = *ip++; ++ if (t >= 16) ++ goto match; ++#if defined(COPY_DICT) ++#if defined(LZO1Z) ++ m_off = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2); ++ last_m_off = m_off; ++#else ++ m_off = (1 + M2_MAX_OFFSET) + (t >> 2) + (*ip++ << 2); ++#endif ++ NEED_OP(3); ++ t = 3; COPY_DICT(t,m_off) ++#else ++#if defined(LZO1Z) ++ t = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2); ++ m_pos = op - t; ++ last_m_off = t; ++#else ++ m_pos = op - (1 + M2_MAX_OFFSET); ++ m_pos -= t >> 2; ++ m_pos -= *ip++ << 2; ++#endif ++ TEST_LB(m_pos); NEED_OP(3); ++ *op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos; ++#endif ++ goto match_done; ++ ++ do { ++match: ++ if (t >= 64) ++ { ++#if defined(COPY_DICT) ++#if defined(LZO1X) ++ m_off = 1 + ((t >> 2) & 7) + (*ip++ << 3); ++ t = (t >> 5) - 1; ++#elif defined(LZO1Y) ++ m_off = 1 + ((t >> 2) & 3) + (*ip++ << 2); ++ t = (t >> 4) - 3; ++#elif defined(LZO1Z) ++ m_off = t & 0x1f; ++ if (m_off >= 0x1c) ++ m_off = last_m_off; ++ else ++ { ++ m_off = 1 + (m_off << 6) + (*ip++ >> 2); ++ last_m_off = m_off; ++ } ++ t = (t >> 5) - 1; ++#endif ++#else ++#if defined(LZO1X) ++ m_pos = op - 1; ++ m_pos -= (t >> 2) & 7; ++ m_pos -= *ip++ << 3; ++ t = (t >> 5) - 1; ++#elif defined(LZO1Y) ++ m_pos = op - 1; ++ m_pos -= (t >> 2) & 3; ++ m_pos -= *ip++ << 2; ++ t = (t >> 4) - 3; ++#elif defined(LZO1Z) ++ { ++ lzo_uint off = t & 0x1f; ++ m_pos = op; ++ if (off >= 0x1c) ++ { ++ assert(last_m_off > 0); ++ m_pos -= last_m_off; ++ } ++ else ++ { ++ off = 1 + (off << 6) + (*ip++ >> 2); ++ m_pos -= off; ++ last_m_off = off; ++ } ++ } ++ t = (t >> 5) - 1; ++#endif ++ TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1); ++ goto copy_match; ++#endif ++ } ++ else if (t >= 32) ++ { ++ t &= 31; ++ if (t == 0) ++ { ++ NEED_IP(1); ++ while (*ip == 0) ++ { ++ t += 255; ++ ip++; ++ NEED_IP(1); ++ } ++ t += 31 + *ip++; ++ } ++#if defined(COPY_DICT) ++#if defined(LZO1Z) ++ m_off = 1 + (ip[0] << 6) + (ip[1] >> 2); ++ last_m_off = m_off; ++#else ++ m_off = 1 + (ip[0] >> 2) + (ip[1] << 6); ++#endif ++#else ++#if defined(LZO1Z) ++ { ++ lzo_uint off = 1 + (ip[0] << 6) + (ip[1] >> 2); ++ m_pos = op - off; ++ last_m_off = off; ++ } ++#elif defined(LZO_UNALIGNED_OK_2) && defined(LZO_ABI_LITTLE_ENDIAN) ++ m_pos = op - 1; ++ m_pos -= UA_GET16(ip) >> 2; ++#else ++ m_pos = op - 1; ++ m_pos -= (ip[0] >> 2) + (ip[1] << 6); ++#endif ++#endif ++ ip += 2; ++ } ++ else if (t >= 16) ++ { ++#if defined(COPY_DICT) ++ m_off = (t & 8) << 11; ++#else ++ m_pos = op; ++ m_pos -= (t & 8) << 11; ++#endif ++ t &= 7; ++ if (t == 0) ++ { ++ NEED_IP(1); ++ while (*ip == 0) ++ { ++ t += 255; ++ ip++; ++ NEED_IP(1); ++ } ++ t += 7 + *ip++; ++ } ++#if defined(COPY_DICT) ++#if defined(LZO1Z) ++ m_off += (ip[0] << 6) + (ip[1] >> 2); ++#else ++ m_off += (ip[0] >> 2) + (ip[1] << 6); ++#endif ++ ip += 2; ++ if (m_off == 0) ++ goto eof_found; ++ m_off += 0x4000; ++#if defined(LZO1Z) ++ last_m_off = m_off; ++#endif ++#else ++#if defined(LZO1Z) ++ m_pos -= (ip[0] << 6) + (ip[1] >> 2); ++#elif defined(LZO_UNALIGNED_OK_2) && defined(LZO_ABI_LITTLE_ENDIAN) ++ m_pos -= UA_GET16(ip) >> 2; ++#else ++ m_pos -= (ip[0] >> 2) + (ip[1] << 6); ++#endif ++ ip += 2; ++ if (m_pos == op) ++ goto eof_found; ++ m_pos -= 0x4000; ++#if defined(LZO1Z) ++ last_m_off = pd((const lzo_bytep)op, m_pos); ++#endif ++#endif ++ } ++ else ++ { ++#if defined(COPY_DICT) ++#if defined(LZO1Z) ++ m_off = 1 + (t << 6) + (*ip++ >> 2); ++ last_m_off = m_off; ++#else ++ m_off = 1 + (t >> 2) + (*ip++ << 2); ++#endif ++ NEED_OP(2); ++ t = 2; COPY_DICT(t,m_off) ++#else ++#if defined(LZO1Z) ++ t = 1 + (t << 6) + (*ip++ >> 2); ++ m_pos = op - t; ++ last_m_off = t; ++#else ++ m_pos = op - 1; ++ m_pos -= t >> 2; ++ m_pos -= *ip++ << 2; ++#endif ++ TEST_LB(m_pos); NEED_OP(2); ++ *op++ = *m_pos++; *op++ = *m_pos; ++#endif ++ goto match_done; ++ } ++ ++#if defined(COPY_DICT) ++ ++ NEED_OP(t+3-1); ++ t += 3-1; COPY_DICT(t,m_off) ++ ++#else ++ ++ TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1); ++#if defined(LZO_UNALIGNED_OK_8) && defined(LZO_UNALIGNED_OK_4) ++ if (op - m_pos >= 8) ++ { ++ t += (3 - 1); ++ if (t >= 8) do ++ { ++ UA_COPY64(op,m_pos); ++ op += 8; m_pos += 8; t -= 8; ++ } while (t >= 8); ++ if (t >= 4) ++ { ++ UA_COPY32(op,m_pos); ++ op += 4; m_pos += 4; t -= 4; ++ } ++ if (t > 0) ++ { ++ *op++ = m_pos[0]; ++ if (t > 1) { *op++ = m_pos[1]; if (t > 2) { *op++ = m_pos[2]; } } ++ } ++ } ++ else ++#elif defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4) ++#if !defined(LZO_UNALIGNED_OK_4) ++ if (t >= 2 * 4 - (3 - 1) && PTR_ALIGNED2_4(op,m_pos)) ++ { ++ assert((op - m_pos) >= 4); ++#else ++ if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4) ++ { ++#endif ++ UA_COPY32(op,m_pos); ++ op += 4; m_pos += 4; t -= 4 - (3 - 1); ++ do { ++ UA_COPY32(op,m_pos); ++ op += 4; m_pos += 4; t -= 4; ++ } while (t >= 4); ++ if (t > 0) do *op++ = *m_pos++; while (--t > 0); ++ } ++ else ++#endif ++ { ++copy_match: ++ *op++ = *m_pos++; *op++ = *m_pos++; ++ do *op++ = *m_pos++; while (--t > 0); ++ } ++ ++#endif ++ ++match_done: ++#if defined(LZO1Z) ++ t = ip[-1] & 3; ++#else ++ t = ip[-2] & 3; ++#endif ++ if (t == 0) ++ break; ++ ++match_next: ++ assert(t > 0); assert(t < 4); NEED_OP(t); NEED_IP(t+1); ++#if 0 ++ do *op++ = *ip++; while (--t > 0); ++#else ++ *op++ = *ip++; ++ if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } } ++#endif ++ t = *ip++; ++ } while (TEST_IP && TEST_OP); ++ } ++ ++#if defined(HAVE_TEST_IP) || defined(HAVE_TEST_OP) ++ *out_len = pd(op, out); ++ return LZO_E_EOF_NOT_FOUND; ++#endif ++ ++eof_found: ++ assert(t == 1); ++ *out_len = pd(op, out); ++ return (ip == ip_end ? LZO_E_OK : ++ (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); ++ ++#if defined(HAVE_NEED_IP) ++input_overrun: ++ *out_len = pd(op, out); ++ return LZO_E_INPUT_OVERRUN; ++#endif ++ ++#if defined(HAVE_NEED_OP) ++output_overrun: ++ *out_len = pd(op, out); ++ return LZO_E_OUTPUT_OVERRUN; ++#endif ++ ++#if defined(LZO_TEST_OVERRUN_LOOKBEHIND) ++lookbehind_overrun: ++ *out_len = pd(op, out); ++ return LZO_E_LOOKBEHIND_OVERRUN; ++#endif ++} ++ ++#endif ++ ++/***** End of minilzo.c *****/ ++ +Index: b/grub-core/lib/minilzo/minilzo.h +=================================================================== +--- /dev/null ++++ b/grub-core/lib/minilzo/minilzo.h +@@ -0,0 +1,109 @@ ++/* minilzo.h -- mini subset of the LZO real-time data compression library ++ ++ This file is part of the LZO real-time data compression library. ++ ++ Copyright (C) 2011 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2010 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2009 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer ++ All Rights Reserved. ++ ++ The LZO library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU General Public License as ++ published by the Free Software Foundation; either version 2 of ++ the License, or (at your option) any later version. ++ ++ The LZO library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with the LZO library; see the file COPYING. ++ If not, write to the Free Software Foundation, Inc., ++ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ ++ Markus F.X.J. Oberhumer ++ <markus@oberhumer.com> ++ http://www.oberhumer.com/opensource/lzo/ ++ */ ++ ++/* ++ * NOTE: ++ * the full LZO package can be found at ++ * http://www.oberhumer.com/opensource/lzo/ ++ */ ++ ++ ++#ifndef __MINILZO_H ++#define __MINILZO_H 1 ++ ++#define MINILZO_VERSION 0x2050 ++ ++#ifdef __LZOCONF_H ++# error "you cannot use both LZO and miniLZO" ++#endif ++ ++#undef LZO_HAVE_CONFIG_H ++#include "lzoconf.h" ++ ++#if !defined(LZO_VERSION) || (LZO_VERSION != MINILZO_VERSION) ++# error "version mismatch in header files" ++#endif ++ ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++ ++/*********************************************************************** ++// ++************************************************************************/ ++ ++/* Memory required for the wrkmem parameter. ++ * When the required size is 0, you can also pass a NULL pointer. ++ */ ++ ++#define LZO1X_MEM_COMPRESS LZO1X_1_MEM_COMPRESS ++#define LZO1X_1_MEM_COMPRESS ((lzo_uint32) (16384L * lzo_sizeof_dict_t)) ++#define LZO1X_MEM_DECOMPRESS (0) ++ ++ ++/* compression */ ++LZO_EXTERN(int) ++lzo1x_1_compress ( const lzo_bytep src, lzo_uint src_len, ++ lzo_bytep dst, lzo_uintp dst_len, ++ lzo_voidp wrkmem ); ++ ++/* decompression */ ++LZO_EXTERN(int) ++lzo1x_decompress ( const lzo_bytep src, lzo_uint src_len, ++ lzo_bytep dst, lzo_uintp dst_len, ++ lzo_voidp wrkmem /* NOT USED */ ); ++ ++/* safe decompression with overrun testing */ ++LZO_EXTERN(int) ++lzo1x_decompress_safe ( const lzo_bytep src, lzo_uint src_len, ++ lzo_bytep dst, lzo_uintp dst_len, ++ lzo_voidp wrkmem /* NOT USED */ ); ++ ++ ++#ifdef __cplusplus ++} /* extern "C" */ ++#endif ++ ++#endif /* already included */ ++ +Index: b/grub-core/lib/posix_wrap/limits.h +=================================================================== +--- /dev/null ++++ b/grub-core/lib/posix_wrap/limits.h +@@ -0,0 +1,31 @@ ++/* ++ * GRUB -- GRand Unified Bootloader ++ * Copyright (C) 2010 Free Software Foundation, Inc. ++ * ++ * GRUB is free software: you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation, either version 3 of the License, or ++ * (at your option) any later version. ++ * ++ * GRUB is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with GRUB. If not, see <http://www.gnu.org/licenses/>. ++ */ ++ ++#ifndef GRUB_POSIX_LIMITS_H ++#define GRUB_POSIX_LIMITS_H ++ ++#include <grub/types.h> ++ ++#define UCHAR_MAX GRUB_UCHAR_MAX ++#define USHRT_MAX GRUB_USHRT_MAX ++#define UINT_MAX GRUB_UINT_MAX ++#define ULONG_MAX GRUB_ULONG_MAX ++ ++#define CHAR_BIT 8 ++ ++#endif +Index: b/grub-core/lib/posix_wrap/sys/types.h +=================================================================== +--- a/grub-core/lib/posix_wrap/sys/types.h ++++ b/grub-core/lib/posix_wrap/sys/types.h +@@ -24,9 +24,6 @@ + typedef grub_size_t size_t; + typedef enum { false = 0, true = 1 } bool; + +-#define ULONG_MAX GRUB_ULONG_MAX +-#define UCHAR_MAX 0xff +- + typedef grub_uint8_t uint8_t; + typedef grub_uint16_t uint16_t; + typedef grub_uint32_t uint32_t; +Index: b/include/grub/file.h +=================================================================== +--- a/include/grub/file.h ++++ b/include/grub/file.h +@@ -56,9 +56,10 @@ + { + GRUB_FILE_FILTER_GZIO, + GRUB_FILE_FILTER_XZIO, ++ GRUB_FILE_FILTER_LZOPIO, + GRUB_FILE_FILTER_MAX, + GRUB_FILE_FILTER_COMPRESSION_FIRST = GRUB_FILE_FILTER_GZIO, +- GRUB_FILE_FILTER_COMPRESSION_LAST = GRUB_FILE_FILTER_XZIO, ++ GRUB_FILE_FILTER_COMPRESSION_LAST = GRUB_FILE_FILTER_LZOPIO, + } grub_file_filter_id_t; + + typedef grub_file_t (*grub_file_filter_t) (grub_file_t in); +Index: b/include/grub/libgcc.h +=================================================================== +--- a/include/grub/libgcc.h ++++ b/include/grub/libgcc.h +@@ -39,6 +39,12 @@ + # ifdef HAVE___BSWAPDI2 + void EXPORT_FUNC (__bswapdi2) (void); + # endif ++# ifdef HAVE___CTZDI2 ++void EXPORT_FUNC (__ctzdi2) (void); ++# endif ++# ifdef HAVE___CTZSI2 ++void EXPORT_FUNC (__ctzsi2) (void); ++# endif + #endif + + #ifdef HAVE___TRAMPOLINE_SETUP +Index: b/include/grub/types.h +=================================================================== +--- a/include/grub/types.h ++++ b/include/grub/types.h +@@ -113,6 +113,10 @@ + # define PRIuGRUB_SIZE "u" + #endif + ++#define GRUB_UCHAR_MAX 0xFF ++#define GRUB_USHRT_MAX 65535 ++#define GRUB_UINT_MAX 4294967295U ++ + #if GRUB_CPU_SIZEOF_LONG == 8 + # define GRUB_ULONG_MAX 18446744073709551615UL + # define GRUB_LONG_MAX 9223372036854775807L +@@ -215,4 +219,31 @@ + # define grub_cpu_to_le32_compile_time(x) ((grub_uint32_t) (x)) + #endif /* ! WORDS_BIGENDIAN */ + ++static inline grub_uint16_t grub_get_unaligned16(void *ptr) ++{ ++ struct ++ { ++ grub_uint16_t d; ++ } __attribute__((packed)) *dd = ptr; ++ return dd->d; ++} ++ ++static inline grub_uint32_t grub_get_unaligned32(void *ptr) ++{ ++ struct ++ { ++ grub_uint32_t d; ++ } __attribute__((packed)) *dd = ptr; ++ return dd->d; ++} ++ ++static inline grub_uint64_t grub_get_unaligned64(void *ptr) ++{ ++ struct ++ { ++ grub_uint64_t d; ++ } __attribute__((packed)) *dd = ptr; ++ return dd->d; ++} ++ + #endif /* ! GRUB_TYPES_HEADER */ +Index: b/util/import_gcry.py +=================================================================== +--- a/util/import_gcry.py ++++ b/util/import_gcry.py +@@ -73,6 +73,8 @@ + cryptolist.write ("AES-192: gcry_rijndael\n"); + cryptolist.write ("AES-256: gcry_rijndael\n"); + ++cryptolist.write ("ADLER32: adler32\n"); ++ + for cipher_file in cipher_files: + infile = os.path.join (cipher_dir_in, cipher_file) + outfile = os.path.join (cipher_dir_out, cipher_file) |