summaryrefslogtreecommitdiffstats
path: root/master/debian
diff options
context:
space:
mode:
Diffstat (limited to 'master/debian')
-rw-r--r--master/debian/4k_sectors.patch1029
-rw-r--r--master/debian/bash-completion_identifiers.patch45
-rw-r--r--master/debian/branch_devmapper.patch286
-rw-r--r--master/debian/branch_embed-sectors.patch247
-rw-r--r--master/debian/branch_fuse.patch605
-rw-r--r--master/debian/branch_longlinuxcmd.patch179
-rw-r--r--master/debian/branch_parse-color.patch1310
-rw-r--r--master/debian/branch_squash.patch694
-rw-r--r--master/debian/btrfs_stat.patch36
-rw-r--r--master/debian/core_in_fs.patch31
-rw-r--r--master/debian/dirlen.patch19
-rw-r--r--master/debian/disable_floppies.patch28
-rw-r--r--master/debian/dpkg_version_comparison.patch30
-rw-r--r--master/debian/efi_disk_cache.patch26
-rw-r--r--master/debian/efiemu_fix.patch134
-rw-r--r--master/debian/fat_uuid.patch25
-rw-r--r--master/debian/gcc_4_6_space.patch33
-rw-r--r--master/debian/gfxpayload_keep_default.patch38
-rw-r--r--master/debian/gfxterm_background.patch69
-rw-r--r--master/debian/grub.cfg_400.patch15
-rw-r--r--master/debian/grub_legacy_0_based_partitions.patch43
-rw-r--r--master/debian/handle_new_autotools.patch535
-rw-r--r--master/debian/hurd.patch37
-rw-r--r--master/debian/install_stage2_confusion.patch24
-rw-r--r--master/debian/kfreebsd-9_ada_devices.patch71
-rw-r--r--master/debian/kfreebsd_lvm.patch187
-rw-r--r--master/debian/kfreebsd_mfi_devices.patch35
-rw-r--r--master/debian/lazy_stat.patch73
-rw-r--r--master/debian/lzo.patch8643
-rw-r--r--master/debian/mkconfig_gnumach.patch53
-rw-r--r--master/debian/mkconfig_loopback.patch84
-rw-r--r--master/debian/mkconfig_skip_dmcrypt.patch30
-rw-r--r--master/debian/mkconfig_skip_readme.patch20
-rw-r--r--master/debian/mkrescue_diet.patch54
-rw-r--r--master/debian/mkrescue_efi_modules.patch22
-rw-r--r--master/debian/no_libzfs.patch227
-rw-r--r--master/debian/olpc_prefix_hack.patch50
-rw-r--r--master/debian/partition_performance.patch36
-rw-r--r--master/debian/probe_canonicalise.patch26
-rw-r--r--master/debian/qemu_img_exists.patch18
-rw-r--r--master/debian/series45
-rw-r--r--master/debian/userland-part.patch149
-rw-r--r--master/debian/xen_replace.patch64
-rw-r--r--master/debian/xfs_invalid_bmap.patch188
-rw-r--r--master/debian/zfs_packed_la_array.patch17
-rw-r--r--master/debian/zfs_update.patch2415
46 files changed, 18025 insertions, 0 deletions
diff --git a/master/debian/4k_sectors.patch b/master/debian/4k_sectors.patch
new file mode 100644
index 0000000..7281b3f
--- /dev/null
+++ b/master/debian/4k_sectors.patch
@@ -0,0 +1,1029 @@
+Description: Support non-512B sectors and agglomerate reads
+Author: Vladimir Serbinenko <phcoder@gmail.com>
+Origin: backport, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3325
+Origin: upstream, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3476
+Origin: upstream, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3709
+Forwarded: not-needed
+Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3325
+Last-Update: 2012-04-02
+
+Index: b/Makefile.util.def
+===================================================================
+--- a/Makefile.util.def
++++ b/Makefile.util.def
+@@ -34,6 +34,7 @@
+ common_nodist = grub_script.tab.h;
+
+ common = grub-core/commands/blocklist.c;
++ common = grub-core/commands/testload.c;
+ common = grub-core/commands/extcmd.c;
+ common = grub-core/commands/ls.c;
+ common = grub-core/disk/dmraid_nvidia.c;
+Index: b/grub-core/disk/efi/efidisk.c
+===================================================================
+--- a/grub-core/disk/efi/efidisk.c
++++ b/grub-core/disk/efi/efidisk.c
+@@ -33,12 +33,10 @@
+ grub_efi_device_path_t *device_path;
+ grub_efi_device_path_t *last_device_path;
+ grub_efi_block_io_t *block_io;
+- grub_efi_disk_io_t *disk_io;
+ struct grub_efidisk_data *next;
+ };
+
+-/* GUIDs. */
+-static grub_efi_guid_t disk_io_guid = GRUB_EFI_DISK_IO_GUID;
++/* GUID. */
+ static grub_efi_guid_t block_io_guid = GRUB_EFI_BLOCK_IO_GUID;
+
+ static struct grub_efidisk_data *fd_devices;
+@@ -143,7 +141,7 @@
+ struct grub_efidisk_data *devices = 0;
+
+ /* Find handles which support the disk io interface. */
+- handles = grub_efi_locate_handle (GRUB_EFI_BY_PROTOCOL, &disk_io_guid,
++ handles = grub_efi_locate_handle (GRUB_EFI_BY_PROTOCOL, &block_io_guid,
+ 0, &num_handles);
+ if (! handles)
+ return 0;
+@@ -155,7 +153,6 @@
+ grub_efi_device_path_t *ldp;
+ struct grub_efidisk_data *d;
+ grub_efi_block_io_t *bio;
+- grub_efi_disk_io_t *dio;
+
+ dp = grub_efi_get_device_path (*handle);
+ if (! dp)
+@@ -168,9 +165,7 @@
+
+ bio = grub_efi_open_protocol (*handle, &block_io_guid,
+ GRUB_EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+- dio = grub_efi_open_protocol (*handle, &disk_io_guid,
+- GRUB_EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+- if (! bio || ! dio)
++ if (! bio)
+ /* This should not happen... Why? */
+ continue;
+
+@@ -186,7 +181,6 @@
+ d->device_path = dp;
+ d->last_device_path = ldp;
+ d->block_io = bio;
+- d->disk_io = dio;
+ d->next = devices;
+ devices = d;
+ }
+@@ -536,8 +530,13 @@
+ and total sectors should be replaced with total blocks. */
+ grub_dprintf ("efidisk", "m = %p, last block = %llx, block size = %x\n",
+ m, (unsigned long long) m->last_block, m->block_size);
+- disk->total_sectors = (m->last_block
+- * (m->block_size >> GRUB_DISK_SECTOR_BITS));
++ disk->total_sectors = m->last_block;
++ if (m->block_size & (m->block_size - 1) || !m->block_size)
++ return grub_error (GRUB_ERR_IO, "invalid sector size %d",
++ m->block_size);
++ for (disk->log_sector_size = 0;
++ (1U << disk->log_sector_size) < m->block_size;
++ disk->log_sector_size++);
+ disk->data = d;
+
+ grub_dprintf ("efidisk", "opening %s succeeded\n", name);
+@@ -558,22 +557,20 @@
+ {
+ /* For now, use the disk io interface rather than the block io's. */
+ struct grub_efidisk_data *d;
+- grub_efi_disk_io_t *dio;
+ grub_efi_block_io_t *bio;
+ grub_efi_status_t status;
+
+ d = disk->data;
+- dio = d->disk_io;
+ bio = d->block_io;
+
+ grub_dprintf ("efidisk",
+ "reading 0x%lx sectors at the sector 0x%llx from %s\n",
+ (unsigned long) size, (unsigned long long) sector, disk->name);
+
+- status = efi_call_5 (dio->read, dio, bio->media->media_id,
+- (grub_efi_uint64_t) sector << GRUB_DISK_SECTOR_BITS,
+- (grub_efi_uintn_t) size << GRUB_DISK_SECTOR_BITS,
+- buf);
++ status = efi_call_5 (bio->read_blocks, bio, bio->media->media_id,
++ (grub_efi_uint64_t) sector,
++ (grub_efi_uintn_t) size << disk->log_sector_size,
++ buf);
+ if (status != GRUB_EFI_SUCCESS)
+ return grub_error (GRUB_ERR_READ_ERROR, "efidisk read error");
+
+@@ -586,21 +583,19 @@
+ {
+ /* For now, use the disk io interface rather than the block io's. */
+ struct grub_efidisk_data *d;
+- grub_efi_disk_io_t *dio;
+ grub_efi_block_io_t *bio;
+ grub_efi_status_t status;
+
+ d = disk->data;
+- dio = d->disk_io;
+ bio = d->block_io;
+
+ grub_dprintf ("efidisk",
+ "writing 0x%lx sectors at the sector 0x%llx to %s\n",
+ (unsigned long) size, (unsigned long long) sector, disk->name);
+
+- status = efi_call_5 (dio->write, dio, bio->media->media_id,
+- (grub_efi_uint64_t) sector << GRUB_DISK_SECTOR_BITS,
+- (grub_efi_uintn_t) size << GRUB_DISK_SECTOR_BITS,
++ status = efi_call_5 (bio->write_blocks, bio, bio->media->media_id,
++ (grub_efi_uint64_t) sector,
++ (grub_efi_uintn_t) size << disk->log_sector_size,
+ (void *) buf);
+ if (status != GRUB_EFI_SUCCESS)
+ return grub_error (GRUB_ERR_WRITE_ERROR, "efidisk write error");
+Index: b/grub-core/disk/i386/pc/biosdisk.c
+===================================================================
+--- a/grub-core/disk/i386/pc/biosdisk.c
++++ b/grub-core/disk/i386/pc/biosdisk.c
+@@ -340,7 +340,8 @@
+ if ((cd_drive) && (drive == cd_drive))
+ {
+ data->flags = GRUB_BIOSDISK_FLAG_LBA | GRUB_BIOSDISK_FLAG_CDROM;
+- data->sectors = 32;
++ data->sectors = 8;
++ disk->log_sector_size = 11;
+ /* TODO: get the correct size. */
+ total_sectors = GRUB_DISK_SIZE_UNKNOWN;
+ }
+@@ -349,6 +350,8 @@
+ /* HDD */
+ int version;
+
++ disk->log_sector_size = 9;
++
+ version = grub_biosdisk_check_int13_extensions (drive);
+ if (version)
+ {
+@@ -369,6 +372,15 @@
+ correctly but returns zero. So if it is zero, compute
+ it by C/H/S returned by the LBA BIOS call. */
+ total_sectors = drp->cylinders * drp->heads * drp->sectors;
++ if (drp->bytes_per_sector
++ && !(drp->bytes_per_sector & (drp->bytes_per_sector - 1))
++ && drp->bytes_per_sector >= 512
++ && drp->bytes_per_sector <= 16384)
++ {
++ for (disk->log_sector_size = 0;
++ (1 << disk->log_sector_size) < drp->bytes_per_sector;
++ disk->log_sector_size++);
++ }
+ }
+ }
+ }
+@@ -431,7 +443,7 @@
+
+ dap = (struct grub_biosdisk_dap *) (GRUB_MEMORY_MACHINE_SCRATCH_ADDR
+ + (data->sectors
+- << GRUB_DISK_SECTOR_BITS));
++ << disk->log_sector_size));
+ dap->length = sizeof (*dap);
+ dap->reserved = 0;
+ dap->blocks = size;
+@@ -445,9 +457,6 @@
+ if (cmd)
+ return grub_error (GRUB_ERR_WRITE_ERROR, "can\'t write to cdrom");
+
+- dap->blocks = ALIGN_UP (dap->blocks, 4) >> 2;
+- dap->block >>= 2;
+-
+ for (i = 0; i < GRUB_BIOSDISK_CDROM_RETRY_COUNT; i++)
+ if (! grub_biosdisk_rw_int13_extensions (0x42, data->drive, dap))
+ break;
+@@ -503,19 +512,21 @@
+
+ /* Return the number of sectors which can be read safely at a time. */
+ static grub_size_t
+-get_safe_sectors (grub_disk_addr_t sector, grub_uint32_t sectors)
++get_safe_sectors (grub_disk_t disk, grub_disk_addr_t sector)
+ {
+ grub_size_t size;
+- grub_uint32_t offset;
++ grub_uint64_t offset;
++ struct grub_biosdisk_data *data = disk->data;
++ grub_uint32_t sectors = data->sectors;
+
+ /* OFFSET = SECTOR % SECTORS */
+- grub_divmod64 (sector, sectors, &offset);
++ grub_divmod64_full (sector, sectors, &offset);
+
+ size = sectors - offset;
+
+ /* Limit the max to 0x7f because of Phoenix EDD. */
+- if (size > 0x7f)
+- size = 0x7f;
++ if (size > ((0x7fU << GRUB_DISK_SECTOR_BITS) >> disk->log_sector_size))
++ size = ((0x7fU << GRUB_DISK_SECTOR_BITS) >> disk->log_sector_size);
+
+ return size;
+ }
+@@ -524,21 +535,11 @@
+ grub_biosdisk_read (grub_disk_t disk, grub_disk_addr_t sector,
+ grub_size_t size, char *buf)
+ {
+- struct grub_biosdisk_data *data = disk->data;
+-
+ while (size)
+ {
+ grub_size_t len;
+- grub_size_t cdoff = 0;
+
+- len = get_safe_sectors (sector, data->sectors);
+-
+- if (data->flags & GRUB_BIOSDISK_FLAG_CDROM)
+- {
+- cdoff = (sector & 3) << GRUB_DISK_SECTOR_BITS;
+- len = ALIGN_UP (sector + len, 4) - (sector & ~3);
+- sector &= ~3;
+- }
++ len = get_safe_sectors (disk, sector);
+
+ if (len > size)
+ len = size;
+@@ -547,9 +548,10 @@
+ GRUB_MEMORY_MACHINE_SCRATCH_SEG))
+ return grub_errno;
+
+- grub_memcpy (buf, (void *) (GRUB_MEMORY_MACHINE_SCRATCH_ADDR + cdoff),
+- len << GRUB_DISK_SECTOR_BITS);
+- buf += len << GRUB_DISK_SECTOR_BITS;
++ grub_memcpy (buf, (void *) GRUB_MEMORY_MACHINE_SCRATCH_ADDR,
++ len << disk->log_sector_size);
++
++ buf += len << disk->log_sector_size;
+ sector += len;
+ size -= len;
+ }
+@@ -570,18 +572,18 @@
+ {
+ grub_size_t len;
+
+- len = get_safe_sectors (sector, data->sectors);
++ len = get_safe_sectors (disk, sector);
+ if (len > size)
+ len = size;
+
+ grub_memcpy ((void *) GRUB_MEMORY_MACHINE_SCRATCH_ADDR, buf,
+- len << GRUB_DISK_SECTOR_BITS);
++ len << disk->log_sector_size);
+
+ if (grub_biosdisk_rw (GRUB_BIOSDISK_WRITE, disk, sector, len,
+ GRUB_MEMORY_MACHINE_SCRATCH_SEG))
+ return grub_errno;
+
+- buf += len << GRUB_DISK_SECTOR_BITS;
++ buf += len << disk->log_sector_size;
+ sector += len;
+ size -= len;
+ }
+Index: b/grub-core/disk/scsi.c
+===================================================================
+--- a/grub-core/disk/scsi.c
++++ b/grub-core/disk/scsi.c
+@@ -465,15 +465,20 @@
+ return err;
+ }
+
+- /* SCSI blocks can be something else than 512, although GRUB
+- wants 512 byte blocks. */
+- disk->total_sectors = ((grub_uint64_t)scsi->size
+- * (grub_uint64_t)scsi->blocksize)
+- >> GRUB_DISK_SECTOR_BITS;
++ disk->total_sectors = scsi->size;
++ if (scsi->blocksize & (scsi->blocksize - 1) || !scsi->blocksize)
++ {
++ grub_free (scsi);
++ return grub_error (GRUB_ERR_IO, "invalid sector size %d",
++ scsi->blocksize);
++ }
++ for (disk->log_sector_size = 0;
++ (1 << disk->log_sector_size) < scsi->blocksize;
++ disk->log_sector_size++);
+
+ grub_dprintf ("scsi", "blocks=%u, blocksize=%u\n",
+ scsi->size, scsi->blocksize);
+- grub_dprintf ("scsi", "Disk total 512 sectors = %llu\n",
++ grub_dprintf ("scsi", "Disk total sectors = %llu\n",
+ (unsigned long long) disk->total_sectors);
+
+ return GRUB_ERR_NONE;
+@@ -503,25 +508,6 @@
+
+ scsi = disk->data;
+
+- /* SCSI sectors are variable in size. GRUB uses 512 byte
+- sectors. */
+- if (scsi->blocksize != GRUB_DISK_SECTOR_SIZE)
+- {
+- unsigned spb = scsi->blocksize >> GRUB_DISK_SECTOR_BITS;
+- if (spb == 0 || (scsi->blocksize & (GRUB_DISK_SECTOR_SIZE - 1)) != 0)
+- return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
+- "unsupported SCSI block size");
+-
+- grub_uint32_t sector_mod = 0;
+- sector = grub_divmod64 (sector, spb, &sector_mod);
+-
+- if (! (sector_mod == 0 && size % spb == 0))
+- return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
+- "unaligned SCSI read not supported");
+-
+- size /= spb;
+- }
+-
+ /* Depending on the type, select a read function. */
+ switch (scsi->devtype)
+ {
+Index: b/grub-core/kern/disk.c
+===================================================================
+--- a/grub-core/kern/disk.c
++++ b/grub-core/kern/disk.c
+@@ -247,6 +247,7 @@
+ disk = (grub_disk_t) grub_zalloc (sizeof (*disk));
+ if (! disk)
+ return 0;
++ disk->log_sector_size = GRUB_DISK_SECTOR_BITS;
+
+ p = find_part_sep (name);
+ if (p)
+@@ -266,7 +267,6 @@
+ if (! disk->name)
+ goto fail;
+
+-
+ for (dev = grub_disk_dev_list; dev; dev = dev->next)
+ {
+ if ((dev->open) (raw, disk) == GRUB_ERR_NONE)
+@@ -282,6 +282,14 @@
+ grub_error (GRUB_ERR_UNKNOWN_DEVICE, "no such disk");
+ goto fail;
+ }
++ if (disk->log_sector_size > GRUB_DISK_CACHE_BITS + GRUB_DISK_SECTOR_BITS
++ || disk->log_sector_size < GRUB_DISK_SECTOR_BITS)
++ {
++ grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
++ "sector sizes of %d bytes aren't supported yet",
++ (1 << disk->log_sector_size));
++ goto fail;
++ }
+
+ disk->dev = dev;
+
+@@ -373,21 +381,113 @@
+ *sector += start;
+ }
+
+- if (disk->total_sectors <= *sector
+- || ((*offset + size + GRUB_DISK_SECTOR_SIZE - 1)
+- >> GRUB_DISK_SECTOR_BITS) > disk->total_sectors - *sector)
++ if (disk->total_sectors != GRUB_DISK_SIZE_UNKNOWN
++ && ((disk->total_sectors << (disk->log_sector_size - GRUB_DISK_SECTOR_BITS)) <= *sector
++ || ((*offset + size + GRUB_DISK_SECTOR_SIZE - 1)
++ >> GRUB_DISK_SECTOR_BITS) > (disk->total_sectors
++ << (disk->log_sector_size
++ - GRUB_DISK_SECTOR_BITS)) - *sector))
+ return grub_error (GRUB_ERR_OUT_OF_RANGE, "out of disk");
+
+ return GRUB_ERR_NONE;
+ }
+
++static inline grub_disk_addr_t
++transform_sector (grub_disk_t disk, grub_disk_addr_t sector)
++{
++ return sector >> (disk->log_sector_size - GRUB_DISK_SECTOR_BITS);
++}
++
++/* Small read (less than cache size and not pass across cache unit boundaries).
++ sector is already adjusted and is divisible by cache unit size.
++ */
++static grub_err_t
++grub_disk_read_small (grub_disk_t disk, grub_disk_addr_t sector,
++ grub_off_t offset, grub_size_t size, void *buf)
++{
++ char *data;
++ char *tmp_buf;
++
++ /* Fetch the cache. */
++ data = grub_disk_cache_fetch (disk->dev->id, disk->id, sector);
++ if (data)
++ {
++ /* Just copy it! */
++ grub_memcpy (buf, data + offset, size);
++ grub_disk_cache_unlock (disk->dev->id, disk->id, sector);
++ return GRUB_ERR_NONE;
++ }
++
++ /* Allocate a temporary buffer. */
++ tmp_buf = grub_malloc (GRUB_DISK_SECTOR_SIZE << GRUB_DISK_CACHE_BITS);
++ if (! tmp_buf)
++ return grub_errno;
++
++ /* Otherwise read data from the disk actually. */
++ if (disk->total_sectors == GRUB_DISK_SIZE_UNKNOWN
++ || sector + GRUB_DISK_CACHE_SIZE
++ < (disk->total_sectors << (disk->log_sector_size - GRUB_DISK_SECTOR_BITS)))
++ {
++ grub_err_t err;
++ err = (disk->dev->read) (disk, transform_sector (disk, sector),
++ 1 << (GRUB_DISK_CACHE_BITS
++ + GRUB_DISK_SECTOR_BITS
++ - disk->log_sector_size), tmp_buf);
++ if (!err)
++ {
++ /* Copy it and store it in the disk cache. */
++ grub_memcpy (buf, tmp_buf + offset, size);
++ grub_disk_cache_store (disk->dev->id, disk->id,
++ sector, tmp_buf);
++ grub_free (tmp_buf);
++ return GRUB_ERR_NONE;
++ }
++ }
++
++ grub_free (tmp_buf);
++ grub_errno = GRUB_ERR_NONE;
++
++ {
++ /* Uggh... Failed. Instead, just read necessary data. */
++ unsigned num;
++ grub_disk_addr_t aligned_sector;
++
++ sector += (offset >> GRUB_DISK_SECTOR_BITS);
++ offset &= ((1 << GRUB_DISK_SECTOR_BITS) - 1);
++ aligned_sector = (sector & ~((1 << (disk->log_sector_size
++ - GRUB_DISK_SECTOR_BITS))
++ - 1));
++ offset += ((sector - aligned_sector) << GRUB_DISK_SECTOR_BITS);
++ num = ((size + offset + (1 << (disk->log_sector_size))
++ - 1) >> (disk->log_sector_size));
++
++ tmp_buf = grub_malloc (num << disk->log_sector_size);
++ if (!tmp_buf)
++ return grub_errno;
++
++ if ((disk->dev->read) (disk, transform_sector (disk, aligned_sector),
++ num, tmp_buf))
++ {
++ grub_error_push ();
++ grub_dprintf ("disk", "%s read failed\n", disk->name);
++ grub_error_pop ();
++ grub_free (tmp_buf);
++ return grub_errno;
++ }
++ grub_memcpy (buf, tmp_buf + offset, size);
++ grub_free (tmp_buf);
++ return GRUB_ERR_NONE;
++ }
++}
++
+ /* Read data from the disk. */
+ grub_err_t
+ grub_disk_read (grub_disk_t disk, grub_disk_addr_t sector,
+ grub_off_t offset, grub_size_t size, void *buf)
+ {
+- char *tmp_buf;
+- unsigned real_offset;
++ grub_off_t real_offset;
++ grub_disk_addr_t real_sector;
++ grub_size_t real_size;
+
+ /* First of all, check if the region is within the disk. */
+ if (grub_disk_adjust_range (disk, &sector, &offset, size) != GRUB_ERR_NONE)
+@@ -399,126 +499,126 @@
+ return grub_errno;
+ }
+
++ real_sector = sector;
+ real_offset = offset;
++ real_size = size;
+
+- /* Allocate a temporary buffer. */
+- tmp_buf = grub_malloc (GRUB_DISK_SECTOR_SIZE << GRUB_DISK_CACHE_BITS);
+- if (! tmp_buf)
+- return grub_errno;
+-
+- /* Until SIZE is zero... */
+- while (size)
++ /* First read until first cache boundary. */
++ if (offset || (sector & (GRUB_DISK_CACHE_SIZE - 1)))
+ {
+- char *data;
+ grub_disk_addr_t start_sector;
+- grub_size_t len;
+ grub_size_t pos;
++ grub_err_t err;
++ grub_size_t len;
+
+- /* For reading bulk data. */
+ start_sector = sector & ~(GRUB_DISK_CACHE_SIZE - 1);
+ pos = (sector - start_sector) << GRUB_DISK_SECTOR_BITS;
+ len = ((GRUB_DISK_SECTOR_SIZE << GRUB_DISK_CACHE_BITS)
+- - pos - real_offset);
++ - pos - offset);
+ if (len > size)
+ len = size;
++ err = grub_disk_read_small (disk, start_sector,
++ offset + pos, len, buf);
++ if (err)
++ return err;
++ buf = (char *) buf + len;
++ size -= len;
++ offset += len;
++ sector += (offset >> GRUB_DISK_SECTOR_BITS);
++ offset &= ((1 << GRUB_DISK_SECTOR_BITS) - 1);
++ }
+
+- /* Fetch the cache. */
+- data = grub_disk_cache_fetch (disk->dev->id, disk->id, start_sector);
+- if (data)
++ /* Until SIZE is zero... */
++ while (size >= (GRUB_DISK_CACHE_SIZE << GRUB_DISK_SECTOR_BITS))
++ {
++ char *data = NULL;
++ grub_disk_addr_t agglomerate;
++ grub_err_t err;
++
++ /* agglomerate read until we find a first cached entry. */
++ for (agglomerate = 0; agglomerate
++ < (size >> (GRUB_DISK_SECTOR_BITS + GRUB_DISK_CACHE_BITS));
++ agglomerate++)
+ {
+- /* Just copy it! */
+- grub_memcpy (buf, data + pos + real_offset, len);
+- grub_disk_cache_unlock (disk->dev->id, disk->id, start_sector);
++ data = grub_disk_cache_fetch (disk->dev->id, disk->id,
++ sector + (agglomerate
++ << GRUB_DISK_CACHE_BITS));
++ if (data)
++ break;
+ }
+- else
++
++ if (data)
+ {
+- /* Otherwise read data from the disk actually. */
+- if (start_sector + GRUB_DISK_CACHE_SIZE > disk->total_sectors
+- || (disk->dev->read) (disk, start_sector,
+- GRUB_DISK_CACHE_SIZE, tmp_buf)
+- != GRUB_ERR_NONE)
+- {
+- /* Uggh... Failed. Instead, just read necessary data. */
+- unsigned num;
+- char *p;
+-
+- grub_errno = GRUB_ERR_NONE;
+-
+- num = ((size + real_offset + GRUB_DISK_SECTOR_SIZE - 1)
+- >> GRUB_DISK_SECTOR_BITS);
+-
+- p = grub_realloc (tmp_buf, num << GRUB_DISK_SECTOR_BITS);
+- if (!p)
+- goto finish;
+-
+- tmp_buf = p;
+-
+- if ((disk->dev->read) (disk, sector, num, tmp_buf))
+- {
+- grub_error_push ();
+- grub_dprintf ("disk", "%s read failed\n", disk->name);
+- grub_error_pop ();
+- goto finish;
+- }
+-
+- grub_memcpy (buf, tmp_buf + real_offset, size);
+-
+- /* Call the read hook, if any. */
+- if (disk->read_hook)
+- while (size)
+- {
+- grub_size_t to_read = (size > GRUB_DISK_SECTOR_SIZE) ? GRUB_DISK_SECTOR_SIZE : size;
+- (disk->read_hook) (sector, real_offset,
+- to_read);
+- if (grub_errno != GRUB_ERR_NONE)
+- goto finish;
+-
+- sector++;
+- size -= to_read - real_offset;
+- real_offset = 0;
+- }
++ grub_memcpy ((char *) buf
++ + (agglomerate << (GRUB_DISK_CACHE_BITS
++ + GRUB_DISK_SECTOR_BITS)),
++ data, GRUB_DISK_CACHE_SIZE << GRUB_DISK_SECTOR_BITS);
++ grub_disk_cache_unlock (disk->dev->id, disk->id,
++ sector + (agglomerate
++ << GRUB_DISK_CACHE_BITS));
++ }
+
+- /* This must be the end. */
+- goto finish;
+- }
++ if (agglomerate)
++ {
++ grub_disk_addr_t i;
+
+- /* Copy it and store it in the disk cache. */
+- grub_memcpy (buf, tmp_buf + pos + real_offset, len);
+- grub_disk_cache_store (disk->dev->id, disk->id,
+- start_sector, tmp_buf);
++ err = (disk->dev->read) (disk, transform_sector (disk, sector),
++ agglomerate << (GRUB_DISK_CACHE_BITS
++ + GRUB_DISK_SECTOR_BITS
++ - disk->log_sector_size),
++ buf);
++ if (err)
++ return err;
++
++ for (i = 0; i < agglomerate; i ++)
++ grub_disk_cache_store (disk->dev->id, disk->id,
++ sector + (i << GRUB_DISK_CACHE_BITS),
++ (char *) buf
++ + (i << (GRUB_DISK_CACHE_BITS
++ + GRUB_DISK_SECTOR_BITS)));
++
++ sector += agglomerate << GRUB_DISK_CACHE_BITS;
++ size -= agglomerate << (GRUB_DISK_CACHE_BITS + GRUB_DISK_SECTOR_BITS);
++ buf = (char *) buf
++ + (agglomerate << (GRUB_DISK_CACHE_BITS + GRUB_DISK_SECTOR_BITS));
+ }
+
+- /* Call the read hook, if any. */
+- if (disk->read_hook)
++ if (data)
+ {
+- grub_disk_addr_t s = sector;
+- grub_size_t l = len;
+-
+- while (l)
+- {
+- (disk->read_hook) (s, real_offset,
+- ((l > GRUB_DISK_SECTOR_SIZE)
+- ? GRUB_DISK_SECTOR_SIZE
+- : l));
+-
+- if (l < GRUB_DISK_SECTOR_SIZE - real_offset)
+- break;
+-
+- s++;
+- l -= GRUB_DISK_SECTOR_SIZE - real_offset;
+- real_offset = 0;
+- }
++ sector += GRUB_DISK_CACHE_SIZE;
++ buf = (char *) buf + (GRUB_DISK_CACHE_SIZE << GRUB_DISK_SECTOR_BITS);
++ size -= (GRUB_DISK_CACHE_SIZE << GRUB_DISK_SECTOR_BITS);
+ }
++ }
+
+- sector = start_sector + GRUB_DISK_CACHE_SIZE;
+- buf = (char *) buf + len;
+- size -= len;
+- real_offset = 0;
++ /* And now read the last part. */
++ if (size)
++ {
++ grub_err_t err;
++ err = grub_disk_read_small (disk, sector, 0, size, buf);
++ if (err)
++ return err;
+ }
+
+- finish:
++ /* Call the read hook, if any. */
++ if (disk->read_hook)
++ {
++ grub_disk_addr_t s = real_sector;
++ grub_size_t l = real_size;
++ grub_off_t o = real_offset;
+
+- grub_free (tmp_buf);
++ while (l)
++ {
++ grub_size_t cl;
++ cl = GRUB_DISK_SECTOR_SIZE - o;
++ if (cl > l)
++ cl = l;
++ (disk->read_hook) (s, o, cl);
++ s++;
++ l -= cl;
++ o = 0;
++ }
++ }
+
+ return grub_errno;
+ }
+@@ -528,25 +628,31 @@
+ grub_off_t offset, grub_size_t size, const void *buf)
+ {
+ unsigned real_offset;
++ grub_disk_addr_t aligned_sector;
+
+ grub_dprintf ("disk", "Writing `%s'...\n", disk->name);
+
+ if (grub_disk_adjust_range (disk, &sector, &offset, size) != GRUB_ERR_NONE)
+ return -1;
+
+- real_offset = offset;
++ aligned_sector = (sector & ~((1 << (disk->log_sector_size
++ - GRUB_DISK_SECTOR_BITS)) - 1));
++ real_offset = offset + ((sector - aligned_sector) << GRUB_DISK_SECTOR_BITS);
++ sector = aligned_sector;
+
+ while (size)
+ {
+- if (real_offset != 0 || (size < GRUB_DISK_SECTOR_SIZE && size != 0))
++ if (real_offset != 0 || (size < (1U << disk->log_sector_size)
++ && size != 0))
+ {
+- char tmp_buf[GRUB_DISK_SECTOR_SIZE];
++ char tmp_buf[1 << disk->log_sector_size];
+ grub_size_t len;
+ grub_partition_t part;
+
+ part = disk->partition;
+ disk->partition = 0;
+- if (grub_disk_read (disk, sector, 0, GRUB_DISK_SECTOR_SIZE, tmp_buf)
++ if (grub_disk_read (disk, sector,
++ 0, (1 << disk->log_sector_size), tmp_buf)
+ != GRUB_ERR_NONE)
+ {
+ disk->partition = part;
+@@ -554,7 +660,7 @@
+ }
+ disk->partition = part;
+
+- len = GRUB_DISK_SECTOR_SIZE - real_offset;
++ len = (1 << disk->log_sector_size) - real_offset;
+ if (len > size)
+ len = size;
+
+@@ -565,7 +671,7 @@
+ if ((disk->dev->write) (disk, sector, 1, tmp_buf) != GRUB_ERR_NONE)
+ goto finish;
+
+- sector++;
++ sector += (1 << (disk->log_sector_size - GRUB_DISK_SECTOR_BITS));
+ buf = (char *) buf + len;
+ size -= len;
+ real_offset = 0;
+@@ -575,8 +681,8 @@
+ grub_size_t len;
+ grub_size_t n;
+
+- len = size & ~(GRUB_DISK_SECTOR_SIZE - 1);
+- n = size >> GRUB_DISK_SECTOR_BITS;
++ len = size & ~((1 << disk->log_sector_size) - 1);
++ n = size >> disk->log_sector_size;
+
+ if ((disk->dev->write) (disk, sector, n, buf) != GRUB_ERR_NONE)
+ goto finish;
+@@ -599,6 +705,8 @@
+ {
+ if (disk->partition)
+ return grub_partition_get_len (disk->partition);
++ else if (disk->total_sectors != GRUB_DISK_SIZE_UNKNOWN)
++ return disk->total_sectors << (disk->log_sector_size - GRUB_DISK_SECTOR_BITS);
+ else
+- return disk->total_sectors;
++ return GRUB_DISK_SIZE_UNKNOWN;
+ }
+Index: b/grub-core/kern/emu/hostdisk.c
+===================================================================
+--- a/grub-core/kern/emu/hostdisk.c
++++ b/grub-core/kern/emu/hostdisk.c
+@@ -43,6 +43,7 @@
+
+ #ifdef __linux__
+ # include <sys/ioctl.h> /* ioctl */
++# include <sys/mount.h>
+ # if !defined(__GLIBC__) || \
+ ((__GLIBC__ < 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ < 1)))
+ /* Maybe libc doesn't have large file support. */
+@@ -267,6 +268,7 @@
+ # else
+ unsigned long long nr;
+ # endif
++ int sector_size;
+ int fd;
+
+ fd = open (map[drive].device, O_RDONLY);
+@@ -299,16 +301,32 @@
+ goto fail;
+ }
+
++# if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
++ if (ioctl (fd, DIOCGSECTORSIZE, &sector_size))
++# else
++ if (ioctl (fd, BLKSSZGET, &sector_size))
++# endif
++ {
++ close (fd);
++ goto fail;
++ }
++
+ close (fd);
+
++ if (sector_size & (sector_size - 1) || !sector_size)
++ goto fail;
++ for (disk->log_sector_size = 0;
++ (1 << disk->log_sector_size) < sector_size;
++ disk->log_sector_size++);
++
+ # if defined (__APPLE__)
+ disk->total_sectors = nr;
+ # elif defined(__NetBSD__)
+ disk->total_sectors = label.d_secperunit;
+ # else
+- disk->total_sectors = nr / 512;
++ disk->total_sectors = nr >> disk->log_sector_size;
+
+- if (nr % 512)
++ if (nr & ((1 << disk->log_sector_size) - 1))
+ grub_util_error ("unaligned device size");
+ # endif
+
+@@ -325,7 +343,7 @@
+ if (stat (map[drive].device, &st) < 0)
+ return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "cannot stat `%s'", map[drive].device);
+
+- disk->total_sectors = st.st_size >> GRUB_DISK_SECTOR_BITS;
++ disk->total_sectors = st.st_size >> disk->log_sector_size;
+
+ grub_util_info ("the size of %s is %lu", name, disk->total_sectors);
+
+@@ -798,7 +816,7 @@
+ _syscall5 (int, _llseek, uint, filedes, ulong, hi, ulong, lo,
+ loff_t *, res, uint, wh);
+
+- offset = (loff_t) sector << GRUB_DISK_SECTOR_BITS;
++ offset = (loff_t) sector << disk->log_sector_size;
+ if (_llseek (fd, offset >> 32, offset & 0xffffffff, &result, SEEK_SET))
+ {
+ grub_error (GRUB_ERR_BAD_DEVICE, "cannot seek `%s'", map[disk->id].device);
+@@ -808,7 +826,7 @@
+ }
+ #else
+ {
+- off_t offset = (off_t) sector << GRUB_DISK_SECTOR_BITS;
++ off_t offset = (off_t) sector << disk->log_sector_size;
+
+ if (lseek (fd, offset, SEEK_SET) != offset)
+ {
+@@ -908,19 +926,20 @@
+ sectors that are read together with the MBR in one read. It
+ should only remap the MBR, so we split the read in two
+ parts. -jochen */
+- if (nread (fd, buf, GRUB_DISK_SECTOR_SIZE) != GRUB_DISK_SECTOR_SIZE)
++ if (nread (fd, buf, (1 << disk->log_sector_size))
++ != (1 << disk->log_sector_size))
+ {
+ grub_error (GRUB_ERR_READ_ERROR, "cannot read `%s'", map[disk->id].device);
+ return grub_errno;
+ }
+
+- buf += GRUB_DISK_SECTOR_SIZE;
++ buf += (1 << disk->log_sector_size);
+ size--;
+ }
+ #endif /* __linux__ */
+
+- if (nread (fd, buf, size << GRUB_DISK_SECTOR_BITS)
+- != (ssize_t) (size << GRUB_DISK_SECTOR_BITS))
++ if (nread (fd, buf, size << disk->log_sector_size)
++ != (ssize_t) (size << disk->log_sector_size))
+ grub_error (GRUB_ERR_READ_ERROR, "cannot read from `%s'", map[disk->id].device);
+
+ return grub_errno;
+@@ -953,8 +972,8 @@
+ if (fd < 0)
+ return grub_errno;
+
+- if (nwrite (fd, buf, size << GRUB_DISK_SECTOR_BITS)
+- != (ssize_t) (size << GRUB_DISK_SECTOR_BITS))
++ if (nwrite (fd, buf, size << disk->log_sector_size)
++ != (ssize_t) (size << disk->log_sector_size))
+ grub_error (GRUB_ERR_WRITE_ERROR, "cannot write to `%s'", map[disk->id].device);
+
+ return grub_errno;
+Index: b/grub-core/partmap/msdos.c
+===================================================================
+--- a/grub-core/partmap/msdos.c
++++ b/grub-core/partmap/msdos.c
+@@ -152,8 +152,11 @@
+ {
+ e = mbr.entries + p.index;
+
+- p.start = p.offset + grub_le_to_cpu32 (e->start) - delta;
+- p.len = grub_le_to_cpu32 (e->length);
++ p.start = p.offset
++ + (grub_le_to_cpu32 (e->start)
++ << (disk->log_sector_size - GRUB_DISK_SECTOR_BITS)) - delta;
++ p.len = grub_le_to_cpu32 (e->length)
++ << (disk->log_sector_size - GRUB_DISK_SECTOR_BITS);
+ p.msdostype = e->type;
+
+ grub_dprintf ("partition",
+@@ -188,7 +191,9 @@
+
+ if (grub_msdos_partition_is_extended (e->type))
+ {
+- p.offset = ext_offset + grub_le_to_cpu32 (e->start);
++ p.offset = ext_offset
++ + (grub_le_to_cpu32 (e->start)
++ << (disk->log_sector_size - GRUB_DISK_SECTOR_BITS));
+ if (! ext_offset)
+ ext_offset = p.offset;
+
+@@ -267,8 +272,11 @@
+ e = mbr.entries + i;
+
+ if (!grub_msdos_partition_is_empty (e->type)
+- && end > offset + grub_le_to_cpu32 (e->start))
+- end = offset + grub_le_to_cpu32 (e->start);
++ && end > offset
++ + (grub_le_to_cpu32 (e->start)
++ << (disk->log_sector_size - GRUB_DISK_SECTOR_BITS)))
++ end = offset + (grub_le_to_cpu32 (e->start)
++ << (disk->log_sector_size - GRUB_DISK_SECTOR_BITS));
+
+ /* If this is a GPT partition, this MBR is just a dummy. */
+ if (e->type == GRUB_PC_PARTITION_TYPE_GPT_DISK && i == 0)
+@@ -282,7 +290,9 @@
+
+ if (grub_msdos_partition_is_extended (e->type))
+ {
+- offset = ext_offset + grub_le_to_cpu32 (e->start);
++ offset = ext_offset
++ + (grub_le_to_cpu32 (e->start)
++ << (disk->log_sector_size - GRUB_DISK_SECTOR_BITS));
+ if (! ext_offset)
+ ext_offset = offset;
+
+Index: b/include/grub/disk.h
+===================================================================
+--- a/include/grub/disk.h
++++ b/include/grub/disk.h
+@@ -100,6 +100,9 @@
+ /* The total number of sectors. */
+ grub_uint64_t total_sectors;
+
++ /* Logarithm of sector size. */
++ unsigned int log_sector_size;
++
+ /* The id used by the disk cache manager. */
+ unsigned long id;
+
+@@ -132,9 +135,10 @@
+ /* The maximum number of disk caches. */
+ #define GRUB_DISK_CACHE_NUM 1021
+
+-/* The size of a disk cache in sector units. */
+-#define GRUB_DISK_CACHE_SIZE 8
+-#define GRUB_DISK_CACHE_BITS 3
++/* The size of a disk cache in 512B units. Must be at least as big as the
++ largest supported sector size, currently 16K. */
++#define GRUB_DISK_CACHE_BITS 6
++#define GRUB_DISK_CACHE_SIZE (1 << GRUB_DISK_CACHE_BITS)
+
+ /* Return value of grub_disk_get_size() in case disk size is unknown. */
+ #define GRUB_DISK_SIZE_UNKNOWN 0xffffffffffffffffULL
+Index: b/util/grub-fstest.c
+===================================================================
+--- a/util/grub-fstest.c
++++ b/util/grub-fstest.c
+@@ -60,6 +60,7 @@
+ #define CMD_HEX 4
+ #define CMD_CRC 6
+ #define CMD_BLOCKLIST 7
++#define CMD_TESTLOAD 8
+
+ #define BUF_SIZE 32256
+
+@@ -333,6 +334,9 @@
+ case CMD_BLOCKLIST:
+ execute_command ("blocklist", n, args);
+ grub_printf ("\n");
++ case CMD_TESTLOAD:
++ execute_command ("testload", n, args);
++ grub_printf ("\n");
+ }
+
+ for (i = 0; i < num_disks; i++)
+@@ -488,6 +492,11 @@
+ cmd = CMD_BLOCKLIST;
+ nparm = 1;
+ }
++ else if (!grub_strcmp (arg, "testload"))
++ {
++ cmd = CMD_TESTLOAD;
++ nparm = 1;
++ }
+ else
+ {
+ fprintf (stderr, _("Invalid command %s.\n"), arg);
diff --git a/master/debian/bash-completion_identifiers.patch b/master/debian/bash-completion_identifiers.patch
new file mode 100644
index 0000000..814c101
--- /dev/null
+++ b/master/debian/bash-completion_identifiers.patch
@@ -0,0 +1,45 @@
+Description: Fix incorrect identifiers in bash-completion
+Author: Andreas Born <futur.andy@googlemail.com>
+Origin: upstream, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3426
+Last-Update: 2012-03-05
+
+Index: b/util/bash-completion.d/grub-completion.bash.in
+===================================================================
+--- a/util/bash-completion.d/grub-completion.bash.in
++++ b/util/bash-completion.d/grub-completion.bash.in
+@@ -402,7 +402,7 @@
+ #
+ # grub-mkpasswd-pbkdf2
+ #
+-_grub_mkpasswd-pbkdf2 () {
++_grub_mkpasswd_pbkdf2 () {
+ local cur
+
+ COMPREPLY=()
+@@ -417,7 +417,7 @@
+ }
+ __grub_mkpasswd_pbkdf2_program=$( echo grub-mkpasswd-pbkdf2 | sed "@program_transform_name@" )
+ have ${__grub_mkpasswd_pbkdf2_program} && \
+- complete -F _grub_mkpasswd-pbkdf2 -o filenames ${__grub_mkpasswd_pbkdf2_program}
++ complete -F _grub_mkpasswd_pbkdf2 -o filenames ${__grub_mkpasswd_pbkdf2_program}
+ unset __grub_mkpasswd_pbkdf2_program
+
+
+@@ -462,7 +462,7 @@
+ #
+ # grub-script-check
+ #
+-_grub_script-check () {
++_grub_script_check () {
+ local cur
+
+ COMPREPLY=()
+@@ -477,7 +477,7 @@
+ }
+ __grub_script_check_program=$( echo grub-script-check | sed "@program_transform_name@" )
+ have ${__grub_script_check_program} && \
+- complete -F _grub_script-check -o filenames ${__grub_script_check_program}
++ complete -F _grub_script_check -o filenames ${__grub_script_check_program}
+
+
+ # Local variables:
diff --git a/master/debian/branch_devmapper.patch b/master/debian/branch_devmapper.patch
new file mode 100644
index 0000000..1911a0b
--- /dev/null
+++ b/master/debian/branch_devmapper.patch
@@ -0,0 +1,286 @@
+Description: Support for partitioned loop devices; improved devmapper support
+Author: Vladimir Serbinenko <phcoder@gmail.com>
+Origin: upstream, http://bzr.sv.gnu.org/r/grub/branches/devmapper/
+Forwarded: not-needed
+Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3302
+Last-Update: 2011-05-19
+
+Index: b/grub-core/kern/emu/getroot.c
+===================================================================
+--- a/grub-core/kern/emu/getroot.c
++++ b/grub-core/kern/emu/getroot.c
+@@ -34,6 +34,10 @@
+ #include <stdint.h>
+ #include <grub/util/misc.h>
+
++#ifdef HAVE_DEVICE_MAPPER
++# include <libdevmapper.h>
++#endif
++
+ #ifdef __GNU__
+ #include <hurd.h>
+ #include <hurd/lookup.h>
+@@ -634,32 +638,65 @@
+ }
+
+ static int
+-grub_util_is_dmraid (const char *os_dev)
++grub_util_is_lvm (const char *os_dev)
+ {
+- if (! strncmp (os_dev, "/dev/mapper/nvidia_", 19))
+- return 1;
+- else if (! strncmp (os_dev, "/dev/mapper/isw_", 16))
+- return 1;
+- else if (! strncmp (os_dev, "/dev/mapper/hpt37x_", 19))
+- return 1;
+- else if (! strncmp (os_dev, "/dev/mapper/hpt45x_", 19))
+- return 1;
+- else if (! strncmp (os_dev, "/dev/mapper/via_", 16))
+- return 1;
+- else if (! strncmp (os_dev, "/dev/mapper/lsi_", 16))
+- return 1;
+- else if (! strncmp (os_dev, "/dev/mapper/pdc_", 16))
+- return 1;
+- else if (! strncmp (os_dev, "/dev/mapper/jmicron_", 20))
+- return 1;
+- else if (! strncmp (os_dev, "/dev/mapper/asr_", 16))
+- return 1;
+- else if (! strncmp (os_dev, "/dev/mapper/sil_", 16))
+- return 1;
+- else if (! strncmp (os_dev, "/dev/mapper/ddf1_", 17))
+- return 1;
++ if ((strncmp ("/dev/mapper/", os_dev, 12) != 0))
++ return 0;
++
++#ifdef HAVE_DEVICE_MAPPER
++ {
++ struct dm_tree *tree;
++ uint32_t maj, min;
++ struct dm_tree_node *node = NULL;
++ const char *node_uuid;
++ struct stat st;
+
+- return 0;
++ if (stat (os_dev, &st) < 0)
++ return 0;
++
++ tree = dm_tree_create ();
++ if (! tree)
++ {
++ grub_printf ("Failed to create tree\n");
++ grub_dprintf ("hostdisk", "dm_tree_create failed\n");
++ return 0;
++ }
++
++ maj = major (st.st_rdev);
++ min = minor (st.st_rdev);
++
++ if (! dm_tree_add_dev (tree, maj, min))
++ {
++ grub_dprintf ("hostdisk", "dm_tree_add_dev failed\n");
++ dm_tree_free (tree);
++ return 0;
++ }
++
++ node = dm_tree_find_node (tree, maj, min);
++ if (! node)
++ {
++ grub_dprintf ("hostdisk", "dm_tree_find_node failed\n");
++ dm_tree_free (tree);
++ return 0;
++ }
++ node_uuid = dm_tree_node_get_uuid (node);
++ if (! node_uuid)
++ {
++ grub_dprintf ("hostdisk", "%s has no DM uuid\n", os_dev);
++ dm_tree_free (tree);
++ return 0;
++ }
++ if (strncmp (node_uuid, "LVM-", 4) != 0)
++ {
++ dm_tree_free (tree);
++ return 0;
++ }
++ dm_tree_free (tree);
++ return 1;
++ }
++#else
++ return 1;
++#endif /* HAVE_DEVICE_MAPPER */
+ }
+
+ int
+@@ -671,13 +708,11 @@
+ return GRUB_DEV_ABSTRACTION_NONE;
+
+ /* Check for LVM. */
+- if (!strncmp (os_dev, "/dev/mapper/", 12)
+- && ! grub_util_is_dmraid (os_dev)
+- && strncmp (os_dev, "/dev/mapper/mpath", 17) != 0)
++ if (grub_util_is_lvm (os_dev))
+ return GRUB_DEV_ABSTRACTION_LVM;
+
+ /* Check for RAID. */
+- if (!strncmp (os_dev, "/dev/md", 7))
++ if (!strncmp (os_dev, "/dev/md", 7) && ! grub_util_device_is_mapped (os_dev))
+ return GRUB_DEV_ABSTRACTION_RAID;
+ #endif
+
+Index: b/grub-core/kern/emu/hostdisk.c
+===================================================================
+--- a/grub-core/kern/emu/hostdisk.c
++++ b/grub-core/kern/emu/hostdisk.c
+@@ -24,6 +24,7 @@
+ #include <grub/err.h>
+ #include <grub/emu/misc.h>
+ #include <grub/emu/hostdisk.h>
++#include <grub/emu/getroot.h>
+ #include <grub/misc.h>
+ #include <grub/i18n.h>
+ #include <grub/list.h>
+@@ -331,18 +332,23 @@
+ return GRUB_ERR_NONE;
+ }
+
+-#ifdef HAVE_DEVICE_MAPPER
+-static int
+-device_is_mapped (const char *dev)
++int
++grub_util_device_is_mapped (const char *dev)
+ {
++#ifdef HAVE_DEVICE_MAPPER
+ struct stat st;
+
++ if (!grub_device_mapper_supported ())
++ return 0;
++
+ if (stat (dev, &st) < 0)
+ return 0;
+
+ return dm_is_dm_major (major (st.st_rdev));
+-}
++#else
++ return 0;
+ #endif /* HAVE_DEVICE_MAPPER */
++}
+
+ #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
+ /* FIXME: geom actually gives us the whole container hierarchy.
+@@ -418,7 +424,7 @@
+ # endif /* !defined(HAVE_DIOCGDINFO) */
+
+ # ifdef HAVE_DEVICE_MAPPER
+- if (grub_device_mapper_supported () && device_is_mapped (dev)) {
++ if (grub_util_device_is_mapped (dev)) {
+ struct dm_task *task = NULL;
+ grub_uint64_t start, length;
+ char *target_type, *params, *space;
+@@ -1161,6 +1167,54 @@
+ return ret;
+ }
+
++#ifdef HAVE_DEVICE_MAPPER
++static int
++grub_util_get_dm_node_linear_info (const char *dev,
++ int *maj, int *min)
++{
++ struct dm_task *dmt;
++ void *next = NULL;
++ uint64_t length, start;
++ char *target, *params;
++ char *ptr;
++ int major, minor;
++
++ dmt = dm_task_create(DM_DEVICE_TABLE);
++ if (!dmt)
++ return 0;
++
++ if (!dm_task_set_name(dmt, dev))
++ return 0;
++ dm_task_no_open_count(dmt);
++ if (!dm_task_run(dmt))
++ return 0;
++ next = dm_get_next_target(dmt, next, &start, &length,
++ &target, &params);
++ if (grub_strcmp (target, "linear") != 0)
++ return 0;
++ major = grub_strtoul (params, &ptr, 10);
++ if (grub_errno)
++ {
++ grub_errno = GRUB_ERR_NONE;
++ return 0;
++ }
++ if (*ptr != ':')
++ return 0;
++ ptr++;
++ minor = grub_strtoul (ptr, 0, 10);
++ if (grub_errno)
++ {
++ grub_errno = GRUB_ERR_NONE;
++ return 0;
++ }
++ if (maj)
++ *maj = major;
++ if (min)
++ *min = minor;
++ return 1;
++}
++#endif
++
+ static char *
+ convert_system_partition_to_system_disk (const char *os_dev, struct stat *st)
+ {
+@@ -1337,9 +1391,39 @@
+ node = NULL;
+ goto devmapper_out;
+ }
+- else if (strncmp (node_uuid, "DMRAID-", 7) != 0)
++ if (strncmp (node_uuid, "LVM-", 4) == 0)
+ {
++ grub_dprintf ("hostdisk", "%s is an LVM\n", path);
++ node = NULL;
++ goto devmapper_out;
++ }
++ if (strncmp (node_uuid, "mpath-", 6) == 0)
++ {
++ /* Multipath partitions have partN-mpath-* UUIDs, and are
++ linear mappings so are handled by
++ grub_util_get_dm_node_linear_info. Multipath disks are not
++ linear mappings and must be handled specially. */
++ grub_dprintf ("hostdisk", "%s is a multipath disk\n", path);
++ mapper_name = dm_tree_node_get_name (node);
++ goto devmapper_out;
++ }
++ if (strncmp (node_uuid, "DMRAID-", 7) != 0)
++ {
++ int major, minor;
++ const char *node_name;
+ grub_dprintf ("hostdisk", "%s is not DM-RAID\n", path);
++
++ if ((node_name = dm_tree_node_get_name (node))
++ && grub_util_get_dm_node_linear_info (node_name,
++ &major, &minor))
++ {
++ if (tree)
++ dm_tree_free (tree);
++ free (path);
++ char *ret = grub_find_device (NULL, (major << 8) | minor);
++ return ret;
++ }
++
+ node = NULL;
+ goto devmapper_out;
+ }
+Index: b/include/grub/emu/misc.h
+===================================================================
+--- a/include/grub/emu/misc.h
++++ b/include/grub/emu/misc.h
+@@ -54,6 +54,8 @@
+
+ char *grub_make_system_path_relative_to_its_root (const char *path)
+ __attribute__ ((warn_unused_result));
++int
++grub_util_device_is_mapped (const char *dev);
+
+ void * EXPORT_FUNC(xmalloc) (grub_size_t size) __attribute__ ((warn_unused_result));
+ void * EXPORT_FUNC(xrealloc) (void *ptr, grub_size_t size) __attribute__ ((warn_unused_result));
diff --git a/master/debian/branch_embed-sectors.patch b/master/debian/branch_embed-sectors.patch
new file mode 100644
index 0000000..9b16423
--- /dev/null
+++ b/master/debian/branch_embed-sectors.patch
@@ -0,0 +1,247 @@
+Description: Detect other software using embedding area
+ When embedding the core image in a post-MBR gap, check for and avoid
+ sectors matching any of the signatures in embed_signatures.
+Author: Colin Watson <cjwatson@ubuntu.com>
+Origin: upstream, http://bzr.sv.gnu.org/r/grub/branches/embed-sectors/
+Forwarded: http://lists.gnu.org/archive/html/grub-devel/2010-08/msg00137.html
+Last-Update: 2011-04-21
+
+Index: b/ChangeLog.embed-sectors
+===================================================================
+--- /dev/null
++++ b/ChangeLog.embed-sectors
+@@ -0,0 +1,12 @@
++2011-03-14 Colin Watson <cjwatson@ubuntu.com>
++
++ * include/grub/partition.h (grub_partition_map): Change prototype of
++ embed to take a maximum value for nsectors.
++ * grub-core/partmap/msdos.c (embed_signatures): New array.
++ (pc_partition_map_embed): Check for and avoid sectors matching any
++ of the signatures in embed_signatures, up to max_nsectors.
++ * grub-core/partmap/gpt.c (gpt_partition_map_embed): Restrict
++ returned sector map to max_nsectors.
++ * util/grub-setup.c (setup): Allow for the embedding area being
++ split into multiple blocklists. Tell dest_partmap->embed the
++ maximum number of sectors we care about.
+Index: b/grub-core/partmap/gpt.c
+===================================================================
+--- a/grub-core/partmap/gpt.c
++++ b/grub-core/partmap/gpt.c
+@@ -127,6 +127,7 @@
+ #ifdef GRUB_UTIL
+ static grub_err_t
+ gpt_partition_map_embed (struct grub_disk *disk, unsigned int *nsectors,
++ unsigned int max_nsectors,
+ grub_embed_type_t embed_type,
+ grub_disk_addr_t **sectors)
+ {
+@@ -176,6 +177,8 @@
+ " embedding won't be possible!");
+
+ *nsectors = len;
++ if (*nsectors > max_nsectors)
++ *nsectors = max_nsectors;
+ *sectors = grub_malloc (*nsectors * sizeof (**sectors));
+ if (!*sectors)
+ return grub_errno;
+Index: b/grub-core/partmap/msdos.c
+===================================================================
+--- a/grub-core/partmap/msdos.c
++++ b/grub-core/partmap/msdos.c
+@@ -29,6 +29,66 @@
+ static struct grub_partition_map grub_msdos_partition_map;
+
+
++#ifdef GRUB_UTIL
++#include <grub/emu/misc.h>
++
++struct embed_signature
++{
++ const char *name;
++ const char *signature;
++ int signature_len;
++ enum { TYPE_SOFTWARE, TYPE_RAID } type;
++};
++
++const char message_warn[][200] = {
++ [TYPE_RAID] = "Sector %llu is already in use by %s; avoiding it. "
++ "Please ask the manufacturer not to store data in MBR gap",
++ [TYPE_SOFTWARE] = "Sector %llu is already in use by %s; avoiding it. "
++ "This software may cause boot or other problems in "
++ "future. Please ask its authors not to store data "
++ "in the boot track"
++};
++
++
++/* Signatures of other software that may be using sectors in the embedding
++ area. */
++struct embed_signature embed_signatures[] =
++ {
++ {
++ .name = "ZISD",
++ .signature = "ZISD",
++ .signature_len = 4,
++ .type = TYPE_SOFTWARE
++ },
++ {
++ .name = "FlexNet",
++ .signature = "\xd4\x41\xa0\xf5\x03\x00\x03\x00",
++ .signature_len = 8,
++ .type = TYPE_SOFTWARE
++ },
++ {
++ .name = "FlexNet",
++ .signature = "\xd8\x41\xa0\xf5\x02\x00\x02\x00",
++ .signature_len = 8,
++ .type = TYPE_SOFTWARE
++ },
++ {
++ /* from Ryan Perkins */
++ .name = "HP Backup and Recovery Manager (?)",
++ .signature = "\x70\x8a\x5d\x46\x35\xc5\x1b\x93"
++ "\xae\x3d\x86\xfd\xb1\x55\x3e\xe0",
++ .signature_len = 16,
++ .type = TYPE_SOFTWARE
++ },
++ {
++ .name = "HighPoint RAID controller",
++ .signature = "ycgl",
++ .signature_len = 4,
++ .type = TYPE_RAID
++ }
++ };
++#endif
++
+ grub_err_t
+ grub_partition_msdos_iterate (grub_disk_t disk,
+ int (*hook) (grub_disk_t disk,
+@@ -148,6 +208,7 @@
+ #ifdef GRUB_UTIL
+ static grub_err_t
+ pc_partition_map_embed (struct grub_disk *disk, unsigned int *nsectors,
++ unsigned int max_nsectors,
+ grub_embed_type_t embed_type,
+ grub_disk_addr_t **sectors)
+ {
+@@ -236,13 +297,65 @@
+
+ if (end >= *nsectors + 2)
+ {
+- unsigned i;
++ unsigned i, j;
++ char *embed_signature_check;
++ unsigned int orig_nsectors, avail_nsectors;
++
++ orig_nsectors = *nsectors;
+ *nsectors = end - 2;
++ avail_nsectors = *nsectors;
++ if (*nsectors > max_nsectors)
++ *nsectors = max_nsectors;
+ *sectors = grub_malloc (*nsectors * sizeof (**sectors));
+ if (!*sectors)
+ return grub_errno;
+ for (i = 0; i < *nsectors; i++)
+ (*sectors)[i] = 1 + i;
++
++ /* Check for software that is already using parts of the embedding
++ * area.
++ */
++ embed_signature_check = grub_malloc (GRUB_DISK_SECTOR_SIZE);
++ for (i = 0; i < *nsectors; i++)
++ {
++ if (grub_disk_read (disk, (*sectors)[i], 0, GRUB_DISK_SECTOR_SIZE,
++ embed_signature_check))
++ continue;
++
++ for (j = 0; j < ARRAY_SIZE (embed_signatures); j++)
++ if (! grub_memcmp (embed_signatures[j].signature,
++ embed_signature_check,
++ embed_signatures[j].signature_len))
++ break;
++ if (j == ARRAY_SIZE (embed_signatures))
++ continue;
++ grub_util_warn (message_warn[embed_signatures[j].type],
++ (*sectors)[i], embed_signatures[j].name);
++ avail_nsectors--;
++ if (avail_nsectors < *nsectors)
++ *nsectors = avail_nsectors;
++
++ /* Avoid this sector. */
++ for (j = i; j < *nsectors; j++)
++ (*sectors)[j]++;
++
++ /* Have we run out of space? */
++ if (avail_nsectors < orig_nsectors)
++ break;
++
++ /* Make sure to check the next sector. */
++ i--;
++ }
++ grub_free (embed_signature_check);
++
++ if (*nsectors < orig_nsectors)
++ return grub_error (GRUB_ERR_OUT_OF_RANGE,
++ "Other software is using the embedding area, and "
++ "there is not enough room for core.img. Such "
++ "software is often trying to store data in a way "
++ "that avoids detection. We recommend you "
++ "investigate.");
++
+ return GRUB_ERR_NONE;
+ }
+
+Index: b/include/grub/partition.h
+===================================================================
+--- a/include/grub/partition.h
++++ b/include/grub/partition.h
+@@ -49,6 +49,7 @@
+ #ifdef GRUB_UTIL
+ /* Determine sectors available for embedding. */
+ grub_err_t (*embed) (struct grub_disk *disk, unsigned int *nsectors,
++ unsigned int max_nsectors,
+ grub_embed_type_t embed_type,
+ grub_disk_addr_t **sectors);
+ #endif
+Index: b/util/grub-setup.c
+===================================================================
+--- a/util/grub-setup.c
++++ b/util/grub-setup.c
+@@ -428,10 +428,8 @@
+ }
+
+ nsec = core_sectors;
+- err = dest_partmap->embed (dest_dev->disk, &nsec,
++ err = dest_partmap->embed (dest_dev->disk, &nsec, 2 * core_sectors,
+ GRUB_EMBED_PCBIOS, &sectors);
+- if (nsec > 2 * core_sectors)
+- nsec = 2 * core_sectors;
+
+ if (err)
+ {
+@@ -460,6 +458,13 @@
+ save_blocklists (sectors[i] + grub_partition_get_start (container),
+ 0, GRUB_DISK_SECTOR_SIZE);
+
++ /* Make sure that the last blocklist is a terminator. */
++ if (block == first_block)
++ block--;
++ block->start = 0;
++ block->len = 0;
++ block->segment = 0;
++
+ write_rootdev (core_img, root_dev, boot_img, first_sector);
+
+ core_img = realloc (core_img, nsec * GRUB_DISK_SECTOR_SIZE);
+@@ -476,12 +481,6 @@
+ nsec * GRUB_DISK_SECTOR_SIZE
+ - core_size);
+
+- /* Make sure that the second blocklist is a terminator. */
+- block = first_block - 1;
+- block->start = 0;
+- block->len = 0;
+- block->segment = 0;
+-
+ /* Write the core image onto the disk. */
+ for (i = 0; i < nsec; i++)
+ grub_disk_write (dest_dev->disk, sectors[i], 0,
diff --git a/master/debian/branch_fuse.patch b/master/debian/branch_fuse.patch
new file mode 100644
index 0000000..1f5a22d
--- /dev/null
+++ b/master/debian/branch_fuse.patch
@@ -0,0 +1,605 @@
+Description: Add grub-mount utility
+Author: Vladimir Serbinenko <phcoder@gmail.com>
+Origin: upstream, http://bzr.sv.gnu.org/r/grub/branches/fuse/
+Forwarded: http://lists.gnu.org/archive/html/grub-devel/2011-01/msg00056.html
+Last-Update: 2011-07-10
+
+--- a/Makefile.util.def
++++ b/Makefile.util.def
+@@ -216,6 +216,21 @@
+ };
+
+ program = {
++ name = grub-mount;
++ mansection = 1;
++ common_nodist = grub_fstest_init.c;
++ common = util/grub-mount.c;
++ common = grub-core/kern/emu/hostfs.c;
++ common = grub-core/disk/host.c;
++
++ ldadd = libgrubmods.a;
++ ldadd = libgrubkern.a;
++ ldadd = grub-core/gnulib/libgnu.a;
++ ldadd = '$(LIBINTL) $(LIBDEVMAPPER) $(LIBZFS) $(LIBNVPAIR) -lfuse';
++ condition = COND_GRUB_MOUNT;
++};
++
++program = {
+ name = grub-mkfont;
+ mansection = 1;
+ common = util/grub-mkfont.c;
+--- a/configure.ac
++++ b/configure.ac
+@@ -856,6 +856,37 @@
+ AC_SUBST([freetype_cflags])
+ AC_SUBST([freetype_libs])
+
++AC_ARG_ENABLE([grub-mount],
++ [AS_HELP_STRING([--enable-grub-mount],
++ [build and install the `grub-mount' utility (default=guessed)])])
++if test x"$enable_grub_mount" = xno ; then
++ grub_mount_excuse="explicitly disabled"
++fi
++
++if test x"$grub_mount_excuse" = x ; then
++ AC_CHECK_LIB([fuse], [fuse_main_real], [],
++ [grub_mount_excuse="need FUSE library"])
++fi
++
++if test x"$grub_mount_excuse" = x ; then
++ # Check for fuse headers.
++ SAVED_CPPFLAGS="$CPPFLAGS"
++ CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=64 -DFUSE_USE_VERSION=26"
++ AC_CHECK_HEADERS([fuse/fuse.h], [],
++ [grub_mount_excuse=["need FUSE headers"]])
++ CPPFLAGS="$SAVED_CPPFLAGS"
++fi
++
++if test x"$enable_grub_mount" = xyes && test x"$grub_mount_excuse" != x ; then
++ AC_MSG_ERROR([grub-mount was explicitly requested but can't be compiled])
++fi
++if test x"$grub_mount_excuse" = x ; then
++enable_grub_mount=yes
++else
++enable_grub_mount=no
++fi
++AC_SUBST([enable_grub_mount])
++
+ AC_ARG_ENABLE([device-mapper],
+ [AS_HELP_STRING([--enable-device-mapper],
+ [enable Linux device-mapper support (default=guessed)])])
+@@ -967,6 +998,7 @@
+ AM_CONDITIONAL([COND_GRUB_EMU_SDL], [test x$enable_grub_emu_sdl = xyes])
+ AM_CONDITIONAL([COND_GRUB_EMU_PCI], [test x$enable_grub_emu_pci = xyes])
+ AM_CONDITIONAL([COND_GRUB_MKFONT], [test x$enable_grub_mkfont = xyes])
++AM_CONDITIONAL([COND_GRUB_MOUNT], [test x$enable_grub_mount = xyes])
+ AM_CONDITIONAL([COND_HAVE_FONT_SOURCE], [test x$FONT_SOURCE != x])
+ AM_CONDITIONAL([COND_GRUB_PE2ELF], [test x$TARGET_OBJ2ELF != x])
+ AM_CONDITIONAL([COND_APPLE_CC], [test x$TARGET_APPLE_CC = x1])
+@@ -1043,5 +1075,10 @@
+ else
+ echo grub-mkfont: No "($grub_mkfont_excuse)"
+ fi
++if [ x"$grub_mount_excuse" = x ]; then
++echo grub-mount: Yes
++else
++echo grub-mount: No "($grub_mount_excuse)"
++fi
+ echo "*******************************************************"
+ ]
+--- /dev/null
++++ b/docs/man/grub-mount.h2m
+@@ -0,0 +1,2 @@
++[NAME]
++grub-mount \- export GRUB filesystem with FUSE
+--- /dev/null
++++ b/util/grub-mount.c
+@@ -0,0 +1,508 @@
++/* grub-mount.c - FUSE driver for filesystems that GRUB understands */
++/*
++ * GRUB -- GRand Unified Bootloader
++ * Copyright (C) 2008,2009,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/>.
++ */
++#define FUSE_USE_VERSION 26
++#include <config.h>
++#include <grub/types.h>
++#include <grub/emu/misc.h>
++#include <grub/util/misc.h>
++#include <grub/misc.h>
++#include <grub/device.h>
++#include <grub/disk.h>
++#include <grub/file.h>
++#include <grub/fs.h>
++#include <grub/env.h>
++#include <grub/term.h>
++#include <grub/mm.h>
++#include <grub/lib/hexdump.h>
++#include <grub/crypto.h>
++#include <grub/command.h>
++#include <grub/i18n.h>
++#include <fuse/fuse.h>
++
++#include <stdio.h>
++#include <unistd.h>
++#include <string.h>
++#include <stdlib.h>
++
++#include "progname.h"
++#include "argp.h"
++
++static char *root = NULL;
++grub_device_t dev = NULL;
++grub_fs_t fs = NULL;
++static char **images = NULL;
++static char *debug_str = NULL;
++static char **fuse_args = NULL;
++static int fuse_argc = 0;
++static int num_disks = 0;
++
++static grub_err_t
++execute_command (char *name, int n, char **args)
++{
++ grub_command_t cmd;
++
++ cmd = grub_command_find (name);
++ if (! cmd)
++ grub_util_error (_("can\'t find command %s"), name);
++
++ return (cmd->func) (cmd, n, args);
++}
++
++/* Translate GRUB error numbers into OS error numbers. Print any unexpected
++ errors. */
++static int
++translate_error (void)
++{
++ int ret;
++
++ switch (grub_errno)
++ {
++ case GRUB_ERR_NONE:
++ ret = 0;
++ break;
++
++ case GRUB_ERR_OUT_OF_MEMORY:
++ grub_print_error ();
++ ret = -ENOMEM;
++ break;
++
++ case GRUB_ERR_BAD_FILE_TYPE:
++ /* This could also be EISDIR. Take a guess. */
++ ret = -ENOTDIR;
++ break;
++
++ case GRUB_ERR_FILE_NOT_FOUND:
++ ret = -ENOENT;
++ break;
++
++ case GRUB_ERR_FILE_READ_ERROR:
++ case GRUB_ERR_READ_ERROR:
++ case GRUB_ERR_IO:
++ grub_print_error ();
++ ret = -EIO;
++ break;
++
++ case GRUB_ERR_SYMLINK_LOOP:
++ ret = -ELOOP;
++ break;
++
++ default:
++ grub_print_error ();
++ ret = -EINVAL;
++ break;
++ }
++
++ /* Any previous errors were handled. */
++ grub_errno = GRUB_ERR_NONE;
++
++ return ret;
++}
++
++static int
++fuse_getattr (const char *path, struct stat *st)
++{
++ char *filename, *pathname, *path2;
++ const char *pathname_t;
++ struct grub_dirhook_info file_info;
++ int file_exists = 0;
++
++ /* A hook for iterating directories. */
++ auto int find_file (const char *cur_filename,
++ const struct grub_dirhook_info *info);
++ int find_file (const char *cur_filename,
++ const struct grub_dirhook_info *info)
++ {
++ if ((info->case_insensitive ? grub_strcasecmp (cur_filename, filename)
++ : grub_strcmp (cur_filename, filename)) == 0)
++ {
++ file_info = *info;
++ file_exists = 1;
++ return 1;
++ }
++ return 0;
++ }
++
++ if (path[0] == '/' && path[1] == 0)
++ {
++ st->st_dev = 0;
++ st->st_ino = 0;
++ st->st_mode = 0555 | S_IFDIR;
++ st->st_uid = 0;
++ st->st_gid = 0;
++ st->st_rdev = 0;
++ st->st_size = 0;
++ st->st_blksize = 512;
++ st->st_blocks = (st->st_blksize + 511) >> 9;
++ st->st_atime = st->st_mtime = st->st_ctime = 0;
++ return 0;
++ }
++
++ file_exists = 0;
++
++ pathname_t = grub_strchr (path, ')');
++ if (! pathname_t)
++ pathname_t = path;
++ else
++ pathname_t++;
++ pathname = xstrdup (pathname_t);
++
++ /* Remove trailing '/'. */
++ while (*pathname && pathname[grub_strlen (pathname) - 1] == '/')
++ pathname[grub_strlen (pathname) - 1] = 0;
++
++ /* Split into path and filename. */
++ filename = grub_strrchr (pathname, '/');
++ if (! filename)
++ {
++ path2 = grub_strdup ("/");
++ filename = pathname;
++ }
++ else
++ {
++ filename++;
++ path2 = grub_strdup (pathname);
++ path2[filename - pathname] = 0;
++ }
++
++ /* It's the whole device. */
++ (fs->dir) (dev, path2, find_file);
++
++ grub_free (path2);
++ if (!file_exists)
++ {
++ grub_errno = GRUB_ERR_NONE;
++ return -ENOENT;
++ }
++ st->st_dev = 0;
++ st->st_ino = 0;
++ st->st_mode = file_info.dir ? (0555 | S_IFDIR) : (0444 | S_IFREG);
++ st->st_uid = 0;
++ st->st_gid = 0;
++ st->st_rdev = 0;
++ if (!file_info.dir)
++ {
++ grub_file_t file;
++ file = grub_file_open (path);
++ if (! file)
++ return translate_error ();
++ st->st_size = file->size;
++ grub_file_close (file);
++ }
++ else
++ st->st_size = 0;
++ st->st_blksize = 512;
++ st->st_blocks = (st->st_size + 511) >> 9;
++ st->st_atime = st->st_mtime = st->st_ctime = file_info.mtimeset
++ ? file_info.mtime : 0;
++ grub_errno = GRUB_ERR_NONE;
++ return 0;
++}
++
++static int
++fuse_opendir (const char *path, struct fuse_file_info *fi)
++{
++ return 0;
++}
++
++/* FIXME */
++static grub_file_t files[65536];
++static int first_fd = 1;
++
++static int
++fuse_open (const char *path, struct fuse_file_info *fi __attribute__ ((unused)))
++{
++ grub_file_t file;
++ file = grub_file_open (path);
++ if (! file)
++ return translate_error ();
++ files[first_fd++] = file;
++ fi->fh = first_fd;
++ files[first_fd++] = file;
++ grub_errno = GRUB_ERR_NONE;
++ return 0;
++}
++
++static int
++fuse_read (const char *path, char *buf, size_t sz, off_t off,
++ struct fuse_file_info *fi)
++{
++ grub_file_t file = files[fi->fh];
++ grub_ssize_t size;
++
++ if (off > file->size)
++ return -EINVAL;
++
++ file->offset = off;
++
++ size = grub_file_read (file, buf, sz);
++ if (size < 0)
++ return translate_error ();
++ else
++ {
++ grub_errno = GRUB_ERR_NONE;
++ return size;
++ }
++}
++
++static int
++fuse_release (const char *path, struct fuse_file_info *fi)
++{
++ grub_file_close (files[fi->fh]);
++ files[fi->fh] = NULL;
++ grub_errno = GRUB_ERR_NONE;
++ return 0;
++}
++
++static int
++fuse_readdir (const char *path, void *buf,
++ fuse_fill_dir_t fill, off_t off, struct fuse_file_info *fi)
++{
++ char *pathname;
++
++ auto int call_fill (const char *filename,
++ const struct grub_dirhook_info *info);
++ int call_fill (const char *filename, const struct grub_dirhook_info *info)
++ {
++ fill (buf, filename, NULL, 0);
++ return 0;
++ }
++
++ pathname = xstrdup (path);
++
++ /* Remove trailing '/'. */
++ while (pathname [0] && pathname[1]
++ && pathname[grub_strlen (pathname) - 1] == '/')
++ pathname[grub_strlen (pathname) - 1] = 0;
++
++ (fs->dir) (dev, pathname, call_fill);
++ free (pathname);
++ grub_errno = GRUB_ERR_NONE;
++ return 0;
++}
++
++struct fuse_operations grub_opers = {
++ .getattr = fuse_getattr,
++ .open = fuse_open,
++ .release = fuse_release,
++ .opendir = fuse_opendir,
++ .readdir = fuse_readdir,
++ .read = fuse_read
++};
++
++static grub_err_t
++fuse_init (void)
++{
++ int i;
++
++ for (i = 0; i < num_disks; i++)
++ {
++ char *argv[2];
++ char *host_file;
++ char *loop_name;
++ loop_name = grub_xasprintf ("loop%d", i);
++ if (!loop_name)
++ grub_util_error (grub_errmsg);
++
++ host_file = grub_xasprintf ("(host)%s", images[i]);
++ if (!host_file)
++ grub_util_error (grub_errmsg);
++
++ argv[0] = loop_name;
++ argv[1] = host_file;
++
++ if (execute_command ("loopback", 2, argv))
++ grub_util_error (_("loopback command fails"));
++
++ grub_free (loop_name);
++ grub_free (host_file);
++ }
++
++ grub_lvm_fini ();
++ grub_mdraid09_fini ();
++ grub_mdraid1x_fini ();
++ grub_raid_fini ();
++ grub_raid_init ();
++ grub_mdraid09_init ();
++ grub_mdraid1x_init ();
++ grub_lvm_init ();
++
++ dev = grub_device_open (0);
++ if (! dev)
++ return grub_errno;
++
++ fs = grub_fs_probe (dev);
++ if (! fs)
++ {
++ grub_device_close (dev);
++ return grub_errno;
++ }
++
++ fuse_main (fuse_argc, fuse_args, &grub_opers, NULL);
++
++ for (i = 0; i < num_disks; i++)
++ {
++ char *argv[2];
++ char *loop_name;
++
++ loop_name = grub_xasprintf ("loop%d", i);
++ if (!loop_name)
++ grub_util_error (grub_errmsg);
++
++ argv[0] = "-d";
++ argv[1] = loop_name;
++
++ execute_command ("loopback", 2, argv);
++
++ grub_free (loop_name);
++ }
++
++ return GRUB_ERR_NONE;
++}
++
++static struct argp_option options[] = {
++ {"root", 'r', N_("DEVICE_NAME"), 0, N_("Set root device."), 2},
++ {"debug", 'd', "S", 0, N_("Set debug environment variable."), 2},
++ {"verbose", 'v', NULL, OPTION_ARG_OPTIONAL, N_("Print verbose messages."), 2},
++ {0, 0, 0, 0, 0, 0}
++};
++
++/* Print the version information. */
++static void
++print_version (FILE *stream, struct argp_state *state)
++{
++ fprintf (stream, "%s (%s) %s\n", program_name, PACKAGE_NAME, PACKAGE_VERSION);
++}
++void (*argp_program_version_hook) (FILE *, struct argp_state *) = print_version;
++
++error_t
++argp_parser (int key, char *arg, struct argp_state *state)
++{
++ char *p;
++
++ switch (key)
++ {
++ case 'r':
++ root = arg;
++ return 0;
++
++ case 'd':
++ debug_str = arg;
++ return 0;
++
++ case 'v':
++ verbosity++;
++ return 0;
++
++ case ARGP_KEY_ARG:
++ if (arg[0] != '-')
++ break;
++
++ default:
++ if (!arg)
++ return 0;
++
++ fuse_args = xrealloc (fuse_args, (fuse_argc + 1) * sizeof (fuse_args[0]));
++ fuse_args[fuse_argc] = xstrdup (arg);
++ fuse_argc++;
++ return 0;
++ }
++
++ if (arg[0] != '/')
++ {
++ fprintf (stderr, "%s", _("Must use absolute path.\n"));
++ argp_usage (state);
++ }
++ images = xrealloc (images, (num_disks + 1) * sizeof (images[0]));
++ images[num_disks] = xstrdup (arg);
++ num_disks++;
++
++ return 0;
++}
++
++struct argp argp = {
++ options, argp_parser, N_("IMAGE1 [IMAGE2 ...] MOUNTPOINT"),
++ N_("Debug tool for filesystem driver."),
++ NULL, NULL, NULL
++};
++
++int
++main (int argc, char *argv[])
++{
++ char *default_root, *alloc_root;
++
++ set_program_name (argv[0]);
++
++ grub_util_init_nls ();
++
++ fuse_args = xrealloc (fuse_args, (fuse_argc + 2) * sizeof (fuse_args[0]));
++ fuse_args[fuse_argc] = xstrdup (argv[0]);
++ fuse_argc++;
++ /* Run single-threaded. */
++ fuse_args[fuse_argc] = xstrdup ("-s");
++ fuse_argc++;
++
++ argp_parse (&argp, argc, argv, 0, 0, 0);
++
++ if (num_disks < 2)
++ grub_util_error ("need an image and mountpoint");
++ fuse_args = xrealloc (fuse_args, (fuse_argc + 2) * sizeof (fuse_args[0]));
++ fuse_args[fuse_argc] = images[num_disks - 1];
++ fuse_argc++;
++ num_disks--;
++ fuse_args[fuse_argc] = NULL;
++
++ /* Initialize all modules. */
++ grub_init_all ();
++
++ if (debug_str)
++ grub_env_set ("debug", debug_str);
++
++ default_root = (num_disks == 1) ? "loop0" : "md0";
++ alloc_root = 0;
++ if (root)
++ {
++ if ((*root >= '0') && (*root <= '9'))
++ {
++ alloc_root = xmalloc (strlen (default_root) + strlen (root) + 2);
++
++ sprintf (alloc_root, "%s,%s", default_root, root);
++ root = alloc_root;
++ }
++ }
++ else
++ root = default_root;
++
++ grub_env_set ("root", root);
++
++ if (alloc_root)
++ free (alloc_root);
++
++ /* Do it. */
++ fuse_init ();
++ if (grub_errno)
++ {
++ grub_print_error ();
++ return 1;
++ }
++
++ /* Free resources. */
++ grub_fini_all ();
++
++ return 0;
++}
diff --git a/master/debian/branch_longlinuxcmd.patch b/master/debian/branch_longlinuxcmd.patch
new file mode 100644
index 0000000..f7a048f
--- /dev/null
+++ b/master/debian/branch_longlinuxcmd.patch
@@ -0,0 +1,179 @@
+Description: Support long Linux command lines
+Author: Vladimir Serbinenko <phcoder@gmail.com>
+Origin: upstream, http://bzr.sv.gnu.org/r/grub/branches/longlinuxcmd/
+Forwarded: not-needed
+Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3303
+Last-Update: 2011-05-19
+
+Index: b/grub-core/loader/i386/linux.c
+===================================================================
+--- a/grub-core/loader/i386/linux.c
++++ b/grub-core/loader/i386/linux.c
+@@ -57,7 +57,6 @@
+ #endif
+
+ #define GRUB_LINUX_CL_OFFSET 0x1000
+-#define GRUB_LINUX_CL_END_OFFSET 0x2000
+
+ static grub_dl_t my_mod;
+
+@@ -74,6 +73,7 @@
+ static grub_uint32_t initrd_pages;
+ static struct grub_relocator *relocator = NULL;
+ static void *efi_mmap_buf;
++static grub_size_t maximal_cmdline_size;
+ #ifdef GRUB_MACHINE_EFI
+ static grub_efi_uintn_t efi_mmap_size;
+ #else
+@@ -189,7 +189,7 @@
+ grub_err_t err;
+
+ /* Make sure that each size is aligned to a page boundary. */
+- real_size = GRUB_LINUX_CL_END_OFFSET;
++ real_size = GRUB_LINUX_CL_OFFSET + maximal_cmdline_size;
+ prot_size = page_align (prot_size);
+ mmap_size = find_mmap_size ();
+
+@@ -662,6 +662,14 @@
+ goto fail;
+ }
+
++ if (grub_le_to_cpu16 (lh.version) >= 0x0206)
++ maximal_cmdline_size = grub_le_to_cpu32 (lh.cmdline_size) + 1;
++ else
++ maximal_cmdline_size = 256;
++
++ if (maximal_cmdline_size < 128)
++ maximal_cmdline_size = 128;
++
+ setup_sects = lh.setup_sects;
+
+ /* If SETUP_SECTS is not set, set it to the default (4). */
+@@ -675,7 +683,7 @@
+ goto fail;
+
+ params = (struct linux_kernel_params *) real_mode_mem;
+- grub_memset (params, 0, GRUB_LINUX_CL_END_OFFSET);
++ grub_memset (params, 0, GRUB_LINUX_CL_OFFSET + maximal_cmdline_size);
+ grub_memcpy (&params->setup_sects, &lh.setup_sects, sizeof (lh) - 0x1F1);
+
+ params->ps_mouse = params->padding10 = 0;
+@@ -870,7 +878,7 @@
+ grub_create_loader_cmdline (argc, argv,
+ (char *)real_mode_mem + GRUB_LINUX_CL_OFFSET
+ + sizeof (LINUX_IMAGE) - 1,
+- GRUB_LINUX_CL_END_OFFSET - GRUB_LINUX_CL_OFFSET
++ maximal_cmdline_size
+ - (sizeof (LINUX_IMAGE) - 1));
+
+ len = prot_size;
+Index: b/grub-core/loader/i386/pc/linux.c
+===================================================================
+--- a/grub-core/loader/i386/pc/linux.c
++++ b/grub-core/loader/i386/pc/linux.c
+@@ -39,7 +39,6 @@
+ GRUB_MOD_LICENSE ("GPLv3+");
+
+ #define GRUB_LINUX_CL_OFFSET 0x9000
+-#define GRUB_LINUX_CL_END_OFFSET 0x90FF
+
+ static grub_dl_t my_mod;
+
+@@ -49,6 +48,7 @@
+ static grub_addr_t grub_linux_real_target;
+ static char *grub_linux_real_chunk;
+ static grub_size_t grub_linux16_prot_size;
++static grub_size_t maximal_cmdline_size;
+
+ static grub_err_t
+ grub_linux16_boot (void)
+@@ -128,15 +128,20 @@
+ setup_sects = lh.setup_sects;
+ linux_mem_size = 0;
+
++ maximal_cmdline_size = 256;
++
+ if (lh.header == grub_cpu_to_le32 (GRUB_LINUX_MAGIC_SIGNATURE)
+ && grub_le_to_cpu16 (lh.version) >= 0x0200)
+ {
+ grub_linux_is_bzimage = (lh.loadflags & GRUB_LINUX_FLAG_BIG_KERNEL);
+ lh.type_of_loader = GRUB_LINUX_BOOT_LOADER_TYPE;
+
++ if (grub_le_to_cpu16 (lh.version) >= 0x0206)
++ maximal_cmdline_size = grub_le_to_cpu32 (lh.cmdline_size) + 1;
++
+ /* Put the real mode part at as a high location as possible. */
+ grub_linux_real_target = grub_mmap_get_lower ()
+- - GRUB_LINUX_SETUP_MOVE_SIZE;
++ - (GRUB_LINUX_CL_OFFSET + maximal_cmdline_size);
+ /* But it must not exceed the traditional area. */
+ if (grub_linux_real_target > GRUB_LINUX_OLD_REAL_MODE_ADDR)
+ grub_linux_real_target = GRUB_LINUX_OLD_REAL_MODE_ADDR;
+@@ -153,7 +158,8 @@
+ {
+ lh.cl_magic = grub_cpu_to_le16 (GRUB_LINUX_CL_MAGIC);
+ lh.cl_offset = grub_cpu_to_le16 (GRUB_LINUX_CL_OFFSET);
+- lh.setup_move_size = grub_cpu_to_le16 (GRUB_LINUX_SETUP_MOVE_SIZE);
++ lh.setup_move_size = grub_cpu_to_le16 (GRUB_LINUX_CL_OFFSET
++ + maximal_cmdline_size);
+ }
+ }
+ else
+@@ -185,12 +191,13 @@
+ goto fail;
+ }
+
+- if (grub_linux_real_target + GRUB_LINUX_SETUP_MOVE_SIZE
++ if (grub_linux_real_target + GRUB_LINUX_CL_OFFSET + maximal_cmdline_size
+ > grub_mmap_get_lower ())
+ {
+ grub_error (GRUB_ERR_OUT_OF_RANGE,
+ "too small lower memory (0x%x > 0x%x)",
+- grub_linux_real_target + GRUB_LINUX_SETUP_MOVE_SIZE,
++ grub_linux_real_target + GRUB_LINUX_CL_OFFSET
++ + maximal_cmdline_size,
+ (int) grub_mmap_get_lower ());
+ goto fail;
+ }
+@@ -263,7 +270,8 @@
+ grub_relocator_chunk_t ch;
+ err = grub_relocator_alloc_chunk_addr (relocator, &ch,
+ grub_linux_real_target,
+- GRUB_LINUX_SETUP_MOVE_SIZE);
++ GRUB_LINUX_CL_OFFSET
++ + maximal_cmdline_size);
+ if (err)
+ return err;
+ grub_linux_real_chunk = get_virtual_current_address (ch);
+@@ -294,7 +302,7 @@
+ grub_create_loader_cmdline (argc, argv,
+ (char *)grub_linux_real_chunk
+ + GRUB_LINUX_CL_OFFSET + sizeof (LINUX_IMAGE) - 1,
+- GRUB_LINUX_CL_END_OFFSET - GRUB_LINUX_CL_OFFSET
++ maximal_cmdline_size
+ - (sizeof (LINUX_IMAGE) - 1));
+
+ if (grub_linux_is_bzimage)
+Index: b/include/grub/i386/linux.h
+===================================================================
+--- a/include/grub/i386/linux.h
++++ b/include/grub/i386/linux.h
+@@ -41,7 +41,6 @@
+ #define GRUB_LINUX_VID_MODE_ASK 0xFFFD
+ #define GRUB_LINUX_VID_MODE_VESA_START 0x0300
+
+-#define GRUB_LINUX_SETUP_MOVE_SIZE 0x9100
+ #define GRUB_LINUX_CL_MAGIC 0xA33F
+
+ #ifdef __x86_64__
+@@ -130,6 +129,10 @@
+ grub_uint16_t pad1; /* Unused */
+ grub_uint32_t cmd_line_ptr; /* Points to the kernel command line */
+ grub_uint32_t initrd_addr_max; /* Highest address for initrd */
++ grub_uint32_t kernel_alignment;
++ grub_uint8_t relocatable;
++ grub_uint8_t pad[3];
++ grub_uint32_t cmdline_size;
+ } __attribute__ ((packed));
+
+ /* Boot parameters for Linux based on 2.6.12. This is used by the setup
diff --git a/master/debian/branch_parse-color.patch b/master/debian/branch_parse-color.patch
new file mode 100644
index 0000000..3d68937
--- /dev/null
+++ b/master/debian/branch_parse-color.patch
@@ -0,0 +1,1310 @@
+Description: Add a background_color command
+ Move gfxmenu color handling to video, so that gfxterm can use it too; add a
+ background_color command.
+Author: Colin Watson <cjwatson@ubuntu.com>
+Origin: upstream, http://bzr.sv.gnu.org/r/grub/branches/parse-color/
+Forwarded: http://lists.gnu.org/archive/html/grub-devel/2010-12/msg00045.html
+Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3308
+Last-Update: 2011-05-19
+
+Index: b/ChangeLog.parse-color
+===================================================================
+--- /dev/null
++++ b/ChangeLog.parse-color
+@@ -0,0 +1,44 @@
++2010-12-23 Colin Watson <cjwatson@ubuntu.com>
++
++ Move gfxmenu color handling to video, so that gfxterm can use it
++ too.
++
++ * grub-core/gfxmenu/named_colors.c: Move to ...
++ * grub-core/video/colors.c: ... here. Rename
++ grub_gui_get_named_color to grub_video_get_named_color.
++ * grub-core/gfxmenu/gui_string_util.c (my_isxdigit): Move to ...
++ * grub-core/video/colors.c (my_isxdigit): ... here.
++ * grub-core/gfxmenu/gui_string_util.c (parse_hex_color_component):
++ Move to ...
++ * grub-core/video/colors.c (parse_hex_color_component): ... here.
++ * grub-core/gfxmenu/gui_string_util.c (grub_gui_parse_color): Move
++ to ...
++ * grub-core/video/colors.c (grub_video_parse_color): ... here.
++
++ * include/grub/gui.h (grub_gui_color_t): Move to ...
++ * include/grub/video.h (grub_video_rgba_color_t): ... here.
++ * include/grub/gui.h (grub_gui_color_rgb): Move to ...
++ * include/grub/video.h (grub_video_rgba_color_rgb): ... here.
++ * include/grub/gui.h (grub_gui_map_color): Move to ...
++ * include/grub/video.h (grub_video_map_rgba_color): ... here.
++ * include/grub/gui_string_util.h (grub_gui_get_named_color): Move
++ to ...
++ * include/grub/video.h (grub_video_get_named_color): ... here.
++ * include/grub/gui_string_util.h (grub_gui_parse_color): Move to ...
++ * include/grub/video.h (grub_video_parse_color): ... here.
++
++ * grub-core/Makefile.core.def (kernel) [videoinkernel]: Add
++ video/colors.c.
++ (gfxmenu): Remove gfxmenu/named_colors.c.
++ (video) [videomodules]: Add video/colors.c.
++
++ Add a background_color command.
++
++ * grub-core/term/gfxterm.c (grub_gfxterm_background_color_cmd): New
++ function.
++ (GRUB_MOD_INIT): Register background_color command.
++ (GRUB_MOD_FINI): Unregister background_color command.
++ (redraw_screen_rect): Allow blend/replace of text layer to be
++ controlled independently from whether there is a background bitmap.
++ (grub_gfxterm_background_image_cmd): Change blend_text_bg when
++ changing bitmap.
+Index: b/grub-core/Makefile.core.def
+===================================================================
+--- a/grub-core/Makefile.core.def
++++ b/grub-core/Makefile.core.def
+@@ -178,6 +178,7 @@
+ videoinkernel = io/bufio.c;
+ videoinkernel = video/bitmap.c;
+ videoinkernel = video/bitmap_scale.c;
++ videoinkernel = video/colors.c;
+ videoinkernel = video/fb/fbblit.c;
+ videoinkernel = video/fb/fbfill.c;
+ videoinkernel = video/fb/fbutil.c;
+@@ -1056,7 +1057,6 @@
+ common = gfxmenu/gui_progress_bar.c;
+ common = gfxmenu/gui_util.c;
+ common = gfxmenu/gui_string_util.c;
+- common = gfxmenu/named_colors.c;
+ };
+
+ module = {
+@@ -1463,6 +1463,7 @@
+ module = {
+ name = video;
+ common = video/video.c;
++ common = video/colors.c;
+ enable = videomodules;
+ };
+
+Index: b/grub-core/gfxmenu/gui_label.c
+===================================================================
+--- a/grub-core/gfxmenu/gui_label.c
++++ b/grub-core/gfxmenu/gui_label.c
+@@ -48,7 +48,7 @@
+ char *text;
+ char *template;
+ grub_font_t font;
+- grub_gui_color_t color;
++ grub_video_rgba_color_t color;
+ int value;
+ enum align_mode align;
+ };
+@@ -107,7 +107,7 @@
+ grub_gui_set_viewport (&self->bounds, &vpsave);
+ grub_font_draw_string (self->text,
+ self->font,
+- grub_gui_map_color (self->color),
++ grub_video_map_rgba_color (self->color),
+ left_x,
+ grub_font_get_ascent (self->font));
+ grub_gui_restore_viewport (&vpsave);
+@@ -186,7 +186,7 @@
+ }
+ else if (grub_strcmp (name, "color") == 0)
+ {
+- grub_gui_parse_color (value, &self->color);
++ grub_video_parse_color (value, &self->color);
+ }
+ else if (grub_strcmp (name, "align") == 0)
+ {
+Index: b/grub-core/gfxmenu/gui_list.c
+===================================================================
+--- a/grub-core/gfxmenu/gui_list.c
++++ b/grub-core/gfxmenu/gui_list.c
+@@ -41,9 +41,9 @@
+ int item_spacing;
+ grub_font_t item_font;
+ grub_font_t selected_item_font;
+- grub_gui_color_t item_color;
++ grub_video_rgba_color_t item_color;
+ int selected_item_color_set;
+- grub_gui_color_t selected_item_color;
++ grub_video_rgba_color_t selected_item_color;
+
+ int draw_scrollbar;
+ int need_to_recreate_scrollbar;
+@@ -269,13 +269,13 @@
+ (is_selected && self->selected_item_font
+ ? self->selected_item_font
+ : self->item_font);
+- grub_gui_color_t text_color =
++ grub_video_rgba_color_t text_color =
+ ((is_selected && self->selected_item_color_set)
+ ? self->selected_item_color
+ : self->item_color);
+ grub_font_draw_string (item_title,
+ font,
+- grub_gui_map_color (text_color),
++ grub_video_map_rgba_color (text_color),
+ sel_leftpad + self->icon_width + icon_text_space,
+ (item_top + (item_height - (ascent + descent))
+ / 2 + ascent));
+@@ -431,7 +431,7 @@
+ }
+ else if (grub_strcmp (name, "item_color") == 0)
+ {
+- grub_gui_parse_color (value, &self->item_color);
++ grub_video_parse_color (value, &self->item_color);
+ }
+ else if (grub_strcmp (name, "selected_item_color") == 0)
+ {
+@@ -441,7 +441,7 @@
+ }
+ else
+ {
+- if (grub_gui_parse_color (value, &self->selected_item_color)
++ if (grub_video_parse_color (value, &self->selected_item_color)
+ == GRUB_ERR_NONE)
+ self->selected_item_color_set = 1;
+ }
+@@ -564,7 +564,7 @@
+ {
+ list_impl_t self;
+ grub_font_t default_font;
+- grub_gui_color_t default_fg_color;
++ grub_video_rgba_color_t default_fg_color;
+
+ self = grub_zalloc (sizeof (*self));
+ if (! self)
+@@ -576,7 +576,7 @@
+ self->visible = 1;
+
+ default_font = grub_font_get ("Unknown Regular 16");
+- default_fg_color = grub_gui_color_rgb (0, 0, 0);
++ default_fg_color = grub_video_rgba_color_rgb (0, 0, 0);
+
+ self->icon_width = 32;
+ self->icon_height = 32;
+Index: b/grub-core/gfxmenu/gui_progress_bar.c
+===================================================================
+--- a/grub-core/gfxmenu/gui_progress_bar.c
++++ b/grub-core/gfxmenu/gui_progress_bar.c
+@@ -40,10 +40,10 @@
+ int show_text;
+ char *template;
+ grub_font_t font;
+- grub_gui_color_t text_color;
+- grub_gui_color_t border_color;
+- grub_gui_color_t bg_color;
+- grub_gui_color_t fg_color;
++ grub_video_rgba_color_t text_color;
++ grub_video_rgba_color_t border_color;
++ grub_video_rgba_color_t bg_color;
++ grub_video_rgba_color_t fg_color;
+
+ char *theme_dir;
+ int need_to_recreate_pixmaps;
+@@ -109,7 +109,7 @@
+ f.height = self->bounds.height - 2;
+
+ /* Border. */
+- grub_video_fill_rect (grub_gui_map_color (self->border_color),
++ grub_video_fill_rect (grub_video_map_rgba_color (self->border_color),
+ f.x - 1, f.y - 1,
+ f.width + 2, f.height + 2);
+
+@@ -117,12 +117,12 @@
+ int barwidth = (f.width
+ * (self->value - self->start)
+ / (self->end - self->start));
+- grub_video_fill_rect (grub_gui_map_color (self->bg_color),
++ grub_video_fill_rect (grub_video_map_rgba_color (self->bg_color),
+ f.x + barwidth, f.y,
+ f.width - barwidth, f.height);
+
+ /* Bar foreground. */
+- grub_video_fill_rect (grub_gui_map_color (self->fg_color),
++ grub_video_fill_rect (grub_video_map_rgba_color (self->fg_color),
+ f.x, f.y,
+ barwidth, f.height);
+ }
+@@ -161,7 +161,8 @@
+ if (self->template)
+ {
+ grub_font_t font = self->font;
+- grub_video_color_t text_color = grub_gui_map_color (self->text_color);
++ grub_video_color_t text_color =
++ grub_video_map_rgba_color (self->text_color);
+ int width = self->bounds.width;
+ int height = self->bounds.height;
+ char *text;
+@@ -298,19 +299,19 @@
+ }
+ else if (grub_strcmp (name, "text_color") == 0)
+ {
+- grub_gui_parse_color (value, &self->text_color);
++ grub_video_parse_color (value, &self->text_color);
+ }
+ else if (grub_strcmp (name, "border_color") == 0)
+ {
+- grub_gui_parse_color (value, &self->border_color);
++ grub_video_parse_color (value, &self->border_color);
+ }
+ else if (grub_strcmp (name, "bg_color") == 0)
+ {
+- grub_gui_parse_color (value, &self->bg_color);
++ grub_video_parse_color (value, &self->bg_color);
+ }
+ else if (grub_strcmp (name, "fg_color") == 0)
+ {
+- grub_gui_parse_color (value, &self->fg_color);
++ grub_video_parse_color (value, &self->fg_color);
+ }
+ else if (grub_strcmp (name, "bar_style") == 0)
+ {
+@@ -379,9 +380,9 @@
+ self->progress.component.ops = &progress_bar_ops;
+ self->visible = 1;
+ self->font = grub_font_get ("Unknown Regular 16");
+- grub_gui_color_t black = { .red = 0, .green = 0, .blue = 0, .alpha = 255 };
+- grub_gui_color_t gray = { .red = 128, .green = 128, .blue = 128, .alpha = 255 };
+- grub_gui_color_t lightgray = { .red = 200, .green = 200, .blue = 200, .alpha = 255 };
++ grub_video_rgba_color_t black = { .red = 0, .green = 0, .blue = 0, .alpha = 255 };
++ grub_video_rgba_color_t gray = { .red = 128, .green = 128, .blue = 128, .alpha = 255 };
++ grub_video_rgba_color_t lightgray = { .red = 200, .green = 200, .blue = 200, .alpha = 255 };
+ self->text_color = black;
+ self->border_color = black;
+ self->bg_color = gray;
+Index: b/grub-core/gfxmenu/gui_string_util.c
+===================================================================
+--- a/grub-core/gfxmenu/gui_string_util.c
++++ b/grub-core/gfxmenu/gui_string_util.c
+@@ -204,124 +204,3 @@
+
+ return grub_new_substring (file_path, 0, last_slash + 1);
+ }
+-
+-static __inline int
+-my_isxdigit (char c)
+-{
+- return ((c >= '0' && c <= '9')
+- || (c >= 'a' && c <= 'f')
+- || (c >= 'A' && c <= 'F'));
+-}
+-
+-static int
+-parse_hex_color_component (const char *s, unsigned start, unsigned end)
+-{
+- unsigned len;
+- char buf[3];
+-
+- len = end - start;
+- /* Check the limits so we don't overrun the buffer. */
+- if (len < 1 || len > 2)
+- return 0;
+-
+- if (len == 1)
+- {
+- buf[0] = s[start]; /* Get the first and only hex digit. */
+- buf[1] = buf[0]; /* Duplicate the hex digit. */
+- }
+- else if (len == 2)
+- {
+- buf[0] = s[start];
+- buf[1] = s[start + 1];
+- }
+-
+- buf[2] = '\0';
+-
+- return grub_strtoul (buf, 0, 16);
+-}
+-
+-/* Parse a color string of the form "r, g, b", "#RGB", "#RGBA",
+- "#RRGGBB", or "#RRGGBBAA". */
+-grub_err_t
+-grub_gui_parse_color (const char *s, grub_gui_color_t *color)
+-{
+- grub_gui_color_t c;
+-
+- /* Skip whitespace. */
+- while (*s && grub_isspace (*s))
+- s++;
+-
+- if (*s == '#')
+- {
+- /* HTML-style. Number if hex digits:
+- [6] #RRGGBB [3] #RGB
+- [8] #RRGGBBAA [4] #RGBA */
+-
+- s++; /* Skip the '#'. */
+- /* Count the hexits to determine the format. */
+- int hexits = 0;
+- const char *end = s;
+- while (my_isxdigit (*end))
+- {
+- end++;
+- hexits++;
+- }
+-
+- /* Parse the color components based on the format. */
+- if (hexits == 3 || hexits == 4)
+- {
+- c.red = parse_hex_color_component (s, 0, 1);
+- c.green = parse_hex_color_component (s, 1, 2);
+- c.blue = parse_hex_color_component (s, 2, 3);
+- if (hexits == 4)
+- c.alpha = parse_hex_color_component (s, 3, 4);
+- else
+- c.alpha = 255;
+- }
+- else if (hexits == 6 || hexits == 8)
+- {
+- c.red = parse_hex_color_component (s, 0, 2);
+- c.green = parse_hex_color_component (s, 2, 4);
+- c.blue = parse_hex_color_component (s, 4, 6);
+- if (hexits == 8)
+- c.alpha = parse_hex_color_component (s, 6, 8);
+- else
+- c.alpha = 255;
+- }
+- else
+- return grub_error (GRUB_ERR_BAD_ARGUMENT,
+- "invalid HTML-type color string `%s'", s);
+- }
+- else if (grub_isdigit (*s))
+- {
+- /* Comma separated decimal values. */
+- c.red = grub_strtoul (s, 0, 0);
+- if ((s = grub_strchr (s, ',')) == 0)
+- return grub_error (GRUB_ERR_BAD_ARGUMENT,
+- "missing 1st comma separator in color `%s'", s);
+- s++;
+- c.green = grub_strtoul (s, 0, 0);
+- if ((s = grub_strchr (s, ',')) == 0)
+- return grub_error (GRUB_ERR_BAD_ARGUMENT,
+- "missing 2nd comma separator in color `%s'", s);
+- s++;
+- c.blue = grub_strtoul (s, 0, 0);
+- if ((s = grub_strchr (s, ',')) == 0)
+- c.alpha = 255;
+- else
+- {
+- s++;
+- c.alpha = grub_strtoul (s, 0, 0);
+- }
+- }
+- else
+- {
+- if (! grub_gui_get_named_color (s, &c))
+- return grub_error (GRUB_ERR_BAD_ARGUMENT,
+- "invalid named color `%s'", s);
+- }
+-
+- if (grub_errno == GRUB_ERR_NONE)
+- *color = c;
+- return grub_errno;
+-}
+Index: b/grub-core/gfxmenu/named_colors.c
+===================================================================
+--- a/grub-core/gfxmenu/named_colors.c
++++ /dev/null
+@@ -1,209 +0,0 @@
+-/* named_colors.c - Named color values. */
+-/*
+- * GRUB -- GRand Unified Bootloader
+- * Copyright (C) 2008 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/gui.h>
+-#include <grub/gui_string_util.h>
+-#include <grub/misc.h>
+-
+-struct named_color
+-{
+- const char *name;
+- grub_gui_color_t color;
+-};
+-
+-/*
+- Named color list generated from the list of SVG color keywords from
+- <http://www.w3.org/TR/css3-color/#svg-color>,
+- processed through the following Perl command:
+- perl -ne 'chomp;split;print "{ \"$_[0]\", RGB_COLOR($_[2]) },\n"'
+- */
+-
+-#define RGB_COLOR(r,g,b) {.red = r, .green = g, .blue = b, .alpha = 255}
+-
+-static struct named_color named_colors[] =
+-{
+- { "aliceblue", RGB_COLOR(240,248,255) },
+- { "antiquewhite", RGB_COLOR(250,235,215) },
+- { "aqua", RGB_COLOR(0,255,255) },
+- { "aquamarine", RGB_COLOR(127,255,212) },
+- { "azure", RGB_COLOR(240,255,255) },
+- { "beige", RGB_COLOR(245,245,220) },
+- { "bisque", RGB_COLOR(255,228,196) },
+- { "black", RGB_COLOR(0,0,0) },
+- { "blanchedalmond", RGB_COLOR(255,235,205) },
+- { "blue", RGB_COLOR(0,0,255) },
+- { "blueviolet", RGB_COLOR(138,43,226) },
+- { "brown", RGB_COLOR(165,42,42) },
+- { "burlywood", RGB_COLOR(222,184,135) },
+- { "cadetblue", RGB_COLOR(95,158,160) },
+- { "chartreuse", RGB_COLOR(127,255,0) },
+- { "chocolate", RGB_COLOR(210,105,30) },
+- { "coral", RGB_COLOR(255,127,80) },
+- { "cornflowerblue", RGB_COLOR(100,149,237) },
+- { "cornsilk", RGB_COLOR(255,248,220) },
+- { "crimson", RGB_COLOR(220,20,60) },
+- { "cyan", RGB_COLOR(0,255,255) },
+- { "darkblue", RGB_COLOR(0,0,139) },
+- { "darkcyan", RGB_COLOR(0,139,139) },
+- { "darkgoldenrod", RGB_COLOR(184,134,11) },
+- { "darkgray", RGB_COLOR(169,169,169) },
+- { "darkgreen", RGB_COLOR(0,100,0) },
+- { "darkgrey", RGB_COLOR(169,169,169) },
+- { "darkkhaki", RGB_COLOR(189,183,107) },
+- { "darkmagenta", RGB_COLOR(139,0,139) },
+- { "darkolivegreen", RGB_COLOR(85,107,47) },
+- { "darkorange", RGB_COLOR(255,140,0) },
+- { "darkorchid", RGB_COLOR(153,50,204) },
+- { "darkred", RGB_COLOR(139,0,0) },
+- { "darksalmon", RGB_COLOR(233,150,122) },
+- { "darkseagreen", RGB_COLOR(143,188,143) },
+- { "darkslateblue", RGB_COLOR(72,61,139) },
+- { "darkslategray", RGB_COLOR(47,79,79) },
+- { "darkslategrey", RGB_COLOR(47,79,79) },
+- { "darkturquoise", RGB_COLOR(0,206,209) },
+- { "darkviolet", RGB_COLOR(148,0,211) },
+- { "deeppink", RGB_COLOR(255,20,147) },
+- { "deepskyblue", RGB_COLOR(0,191,255) },
+- { "dimgray", RGB_COLOR(105,105,105) },
+- { "dimgrey", RGB_COLOR(105,105,105) },
+- { "dodgerblue", RGB_COLOR(30,144,255) },
+- { "firebrick", RGB_COLOR(178,34,34) },
+- { "floralwhite", RGB_COLOR(255,250,240) },
+- { "forestgreen", RGB_COLOR(34,139,34) },
+- { "fuchsia", RGB_COLOR(255,0,255) },
+- { "gainsboro", RGB_COLOR(220,220,220) },
+- { "ghostwhite", RGB_COLOR(248,248,255) },
+- { "gold", RGB_COLOR(255,215,0) },
+- { "goldenrod", RGB_COLOR(218,165,32) },
+- { "gray", RGB_COLOR(128,128,128) },
+- { "green", RGB_COLOR(0,128,0) },
+- { "greenyellow", RGB_COLOR(173,255,47) },
+- { "grey", RGB_COLOR(128,128,128) },
+- { "honeydew", RGB_COLOR(240,255,240) },
+- { "hotpink", RGB_COLOR(255,105,180) },
+- { "indianred", RGB_COLOR(205,92,92) },
+- { "indigo", RGB_COLOR(75,0,130) },
+- { "ivory", RGB_COLOR(255,255,240) },
+- { "khaki", RGB_COLOR(240,230,140) },
+- { "lavender", RGB_COLOR(230,230,250) },
+- { "lavenderblush", RGB_COLOR(255,240,245) },
+- { "lawngreen", RGB_COLOR(124,252,0) },
+- { "lemonchiffon", RGB_COLOR(255,250,205) },
+- { "lightblue", RGB_COLOR(173,216,230) },
+- { "lightcoral", RGB_COLOR(240,128,128) },
+- { "lightcyan", RGB_COLOR(224,255,255) },
+- { "lightgoldenrodyellow", RGB_COLOR(250,250,210) },
+- { "lightgray", RGB_COLOR(211,211,211) },
+- { "lightgreen", RGB_COLOR(144,238,144) },
+- { "lightgrey", RGB_COLOR(211,211,211) },
+- { "lightpink", RGB_COLOR(255,182,193) },
+- { "lightsalmon", RGB_COLOR(255,160,122) },
+- { "lightseagreen", RGB_COLOR(32,178,170) },
+- { "lightskyblue", RGB_COLOR(135,206,250) },
+- { "lightslategray", RGB_COLOR(119,136,153) },
+- { "lightslategrey", RGB_COLOR(119,136,153) },
+- { "lightsteelblue", RGB_COLOR(176,196,222) },
+- { "lightyellow", RGB_COLOR(255,255,224) },
+- { "lime", RGB_COLOR(0,255,0) },
+- { "limegreen", RGB_COLOR(50,205,50) },
+- { "linen", RGB_COLOR(250,240,230) },
+- { "magenta", RGB_COLOR(255,0,255) },
+- { "maroon", RGB_COLOR(128,0,0) },
+- { "mediumaquamarine", RGB_COLOR(102,205,170) },
+- { "mediumblue", RGB_COLOR(0,0,205) },
+- { "mediumorchid", RGB_COLOR(186,85,211) },
+- { "mediumpurple", RGB_COLOR(147,112,219) },
+- { "mediumseagreen", RGB_COLOR(60,179,113) },
+- { "mediumslateblue", RGB_COLOR(123,104,238) },
+- { "mediumspringgreen", RGB_COLOR(0,250,154) },
+- { "mediumturquoise", RGB_COLOR(72,209,204) },
+- { "mediumvioletred", RGB_COLOR(199,21,133) },
+- { "midnightblue", RGB_COLOR(25,25,112) },
+- { "mintcream", RGB_COLOR(245,255,250) },
+- { "mistyrose", RGB_COLOR(255,228,225) },
+- { "moccasin", RGB_COLOR(255,228,181) },
+- { "navajowhite", RGB_COLOR(255,222,173) },
+- { "navy", RGB_COLOR(0,0,128) },
+- { "oldlace", RGB_COLOR(253,245,230) },
+- { "olive", RGB_COLOR(128,128,0) },
+- { "olivedrab", RGB_COLOR(107,142,35) },
+- { "orange", RGB_COLOR(255,165,0) },
+- { "orangered", RGB_COLOR(255,69,0) },
+- { "orchid", RGB_COLOR(218,112,214) },
+- { "palegoldenrod", RGB_COLOR(238,232,170) },
+- { "palegreen", RGB_COLOR(152,251,152) },
+- { "paleturquoise", RGB_COLOR(175,238,238) },
+- { "palevioletred", RGB_COLOR(219,112,147) },
+- { "papayawhip", RGB_COLOR(255,239,213) },
+- { "peachpuff", RGB_COLOR(255,218,185) },
+- { "peru", RGB_COLOR(205,133,63) },
+- { "pink", RGB_COLOR(255,192,203) },
+- { "plum", RGB_COLOR(221,160,221) },
+- { "powderblue", RGB_COLOR(176,224,230) },
+- { "purple", RGB_COLOR(128,0,128) },
+- { "red", RGB_COLOR(255,0,0) },
+- { "rosybrown", RGB_COLOR(188,143,143) },
+- { "royalblue", RGB_COLOR(65,105,225) },
+- { "saddlebrown", RGB_COLOR(139,69,19) },
+- { "salmon", RGB_COLOR(250,128,114) },
+- { "sandybrown", RGB_COLOR(244,164,96) },
+- { "seagreen", RGB_COLOR(46,139,87) },
+- { "seashell", RGB_COLOR(255,245,238) },
+- { "sienna", RGB_COLOR(160,82,45) },
+- { "silver", RGB_COLOR(192,192,192) },
+- { "skyblue", RGB_COLOR(135,206,235) },
+- { "slateblue", RGB_COLOR(106,90,205) },
+- { "slategray", RGB_COLOR(112,128,144) },
+- { "slategrey", RGB_COLOR(112,128,144) },
+- { "snow", RGB_COLOR(255,250,250) },
+- { "springgreen", RGB_COLOR(0,255,127) },
+- { "steelblue", RGB_COLOR(70,130,180) },
+- { "tan", RGB_COLOR(210,180,140) },
+- { "teal", RGB_COLOR(0,128,128) },
+- { "thistle", RGB_COLOR(216,191,216) },
+- { "tomato", RGB_COLOR(255,99,71) },
+- { "turquoise", RGB_COLOR(64,224,208) },
+- { "violet", RGB_COLOR(238,130,238) },
+- { "wheat", RGB_COLOR(245,222,179) },
+- { "white", RGB_COLOR(255,255,255) },
+- { "whitesmoke", RGB_COLOR(245,245,245) },
+- { "yellow", RGB_COLOR(255,255,0) },
+- { "yellowgreen", RGB_COLOR(154,205,50) },
+- { 0, { 0, 0, 0, 0 } } /* Terminator. */
+-};
+-
+-/* Get the color named NAME. If the color was found, returns 1 and
+- stores the color into *COLOR. If the color was not found, returns 0 and
+- does not modify *COLOR. */
+-int
+-grub_gui_get_named_color (const char *name,
+- grub_gui_color_t *color)
+-{
+- int i;
+- for (i = 0; named_colors[i].name; i++)
+- {
+- if (grub_strcmp (named_colors[i].name, name) == 0)
+- {
+- *color = named_colors[i].color;
+- return 1;
+- }
+- }
+- return 0;
+-}
+Index: b/grub-core/gfxmenu/theme_loader.c
+===================================================================
+--- a/grub-core/gfxmenu/theme_loader.c
++++ b/grub-core/gfxmenu/theme_loader.c
+@@ -135,11 +135,11 @@
+ return grub_errno;
+ }
+ else if (! grub_strcmp ("title-color", name))
+- grub_gui_parse_color (value, &view->title_color);
++ grub_video_parse_color (value, &view->title_color);
+ else if (! grub_strcmp ("message-color", name))
+- grub_gui_parse_color (value, &view->message_color);
++ grub_video_parse_color (value, &view->message_color);
+ else if (! grub_strcmp ("message-bg-color", name))
+- grub_gui_parse_color (value, &view->message_bg_color);
++ grub_video_parse_color (value, &view->message_bg_color);
+ else if (! grub_strcmp ("desktop-image", name))
+ {
+ struct grub_video_bitmap *raw_bitmap;
+@@ -170,7 +170,7 @@
+ view->desktop_image = scaled_bitmap;
+ }
+ else if (! grub_strcmp ("desktop-color", name))
+- grub_gui_parse_color (value, &view->desktop_color);
++ grub_video_parse_color (value, &view->desktop_color);
+ else if (! grub_strcmp ("terminal-box", name))
+ {
+ grub_err_t err;
+Index: b/grub-core/gfxmenu/view.c
+===================================================================
+--- a/grub-core/gfxmenu/view.c
++++ b/grub-core/gfxmenu/view.c
+@@ -50,8 +50,8 @@
+ {
+ grub_gfxmenu_view_t view;
+ grub_font_t default_font;
+- grub_gui_color_t default_fg_color;
+- grub_gui_color_t default_bg_color;
++ grub_video_rgba_color_t default_fg_color;
++ grub_video_rgba_color_t default_bg_color;
+
+ view = grub_malloc (sizeof (*view));
+ if (! view)
+@@ -63,8 +63,8 @@
+ view->screen.height = height;
+
+ default_font = grub_font_get ("Unknown Regular 16");
+- default_fg_color = grub_gui_color_rgb (0, 0, 0);
+- default_bg_color = grub_gui_color_rgb (255, 255, 255);
++ default_fg_color = grub_video_rgba_color_rgb (0, 0, 0);
++ default_bg_color = grub_video_rgba_color_rgb (255, 255, 255);
+
+ view->canvas = 0;
+
+@@ -131,7 +131,7 @@
+ }
+ else
+ {
+- grub_video_fill_rect (grub_gui_map_color (view->desktop_color),
++ grub_video_fill_rect (grub_video_map_rgba_color (view->desktop_color),
+ bounds->x, bounds->y,
+ bounds->width, bounds->height);
+ }
+@@ -150,7 +150,7 @@
+ int y = 40 + grub_font_get_ascent (view->title_font);
+ grub_font_draw_string (view->title_text,
+ view->title_font,
+- grub_gui_map_color (view->title_color),
++ grub_video_map_rgba_color (view->title_color),
+ x, y);
+ }
+
+@@ -244,13 +244,13 @@
+ return;
+
+ grub_font_t font = view->message_font;
+- grub_video_color_t color = grub_gui_map_color (view->message_color);
++ grub_video_color_t color = grub_video_map_rgba_color (view->message_color);
+
+ /* Border. */
+ grub_video_fill_rect (color,
+ f.x-1, f.y-1, f.width+2, f.height+2);
+ /* Fill. */
+- grub_video_fill_rect (grub_gui_map_color (view->message_bg_color),
++ grub_video_fill_rect (grub_video_map_rgba_color (view->message_bg_color),
+ f.x, f.y, f.width, f.height);
+
+ /* Center the text. */
+Index: b/grub-core/term/gfxterm.c
+===================================================================
+--- a/grub-core/term/gfxterm.c
++++ b/grub-core/term/gfxterm.c
+@@ -130,6 +130,7 @@
+ static unsigned int bitmap_width;
+ static unsigned int bitmap_height;
+ static struct grub_video_bitmap *bitmap;
++static int blend_text_bg;
+
+ static struct grub_dirty_region dirty_region;
+
+@@ -476,26 +477,27 @@
+ /* Render background layer. */
+ grub_video_fill_rect (color, x, ty, width, h);
+ }
+-
+- /* Render text layer as blended. */
+- grub_video_blit_render_target (text_layer, GRUB_VIDEO_BLIT_BLEND, x, y,
+- x - virtual_screen.offset_x,
+- y - virtual_screen.offset_y,
+- width, height);
+ }
+ else
+ {
+ /* Render background layer. */
+ color = virtual_screen.bg_color_display;
+ grub_video_fill_rect (color, x, y, width, height);
+-
+- /* Render text layer as replaced (to get texts background color). */
+- grub_video_blit_render_target (text_layer, GRUB_VIDEO_BLIT_REPLACE, x, y,
+- x - virtual_screen.offset_x,
+- y - virtual_screen.offset_y,
+- width, height);
+ }
+
++ if (blend_text_bg)
++ /* Render text layer as blended. */
++ grub_video_blit_render_target (text_layer, GRUB_VIDEO_BLIT_BLEND, x, y,
++ x - virtual_screen.offset_x,
++ y - virtual_screen.offset_y,
++ width, height);
++ else
++ /* Render text layer as replaced (to get texts background color). */
++ grub_video_blit_render_target (text_layer, GRUB_VIDEO_BLIT_REPLACE, x, y,
++ x - virtual_screen.offset_x,
++ y - virtual_screen.offset_y,
++ width, height);
++
+ /* Restore saved viewport. */
+ grub_video_set_viewport (saved_view.x, saved_view.y,
+ saved_view.width, saved_view.height);
+@@ -1127,6 +1129,7 @@
+ {
+ grub_video_bitmap_destroy (bitmap);
+ bitmap = 0;
++ blend_text_bg = 0;
+
+ /* Mark whole screen as dirty. */
+ dirty_region_add (0, 0, window.width, window.height);
+@@ -1166,6 +1169,8 @@
+ /* If bitmap was loaded correctly, display it. */
+ if (bitmap)
+ {
++ blend_text_bg = 1;
++
+ /* Determine bitmap dimensions. */
+ bitmap_width = grub_video_bitmap_get_width (bitmap);
+ bitmap_height = grub_video_bitmap_get_height (bitmap);
+@@ -1180,6 +1185,48 @@
+ return grub_errno;
+ }
+
++static grub_err_t
++grub_gfxterm_background_color_cmd (grub_command_t cmd __attribute__ ((unused)),
++ int argc, char **args)
++{
++ grub_video_rgba_color_t color;
++ struct grub_video_render_target *old_target;
++
++ if (argc != 1)
++ return grub_error (GRUB_ERR_BAD_ARGUMENT, "missing operand");
++
++ /* Check that we have video adapter active. */
++ if (grub_video_get_info (NULL) != GRUB_ERR_NONE)
++ return grub_errno;
++
++ if (grub_video_parse_color (args[0], &color) != GRUB_ERR_NONE)
++ return grub_errno;
++
++ /* Destroy existing background bitmap if loaded. */
++ if (bitmap)
++ {
++ grub_video_bitmap_destroy (bitmap);
++ bitmap = 0;
++
++ /* Mark whole screen as dirty. */
++ dirty_region_add (0, 0, window.width, window.height);
++ }
++
++ /* Set the background and border colors. The background color needs to be
++ compatible with the text layer. */
++ grub_video_get_active_render_target (&old_target);
++ grub_video_set_active_render_target (text_layer);
++ virtual_screen.bg_color = grub_video_map_rgba_color (color);
++ grub_video_set_active_render_target (old_target);
++ virtual_screen.bg_color_display = grub_video_map_rgba_color (color);
++ blend_text_bg = 1;
++
++ /* Mark whole screen as dirty. */
++ dirty_region_add (0, 0, window.width, window.height);
++
++ return GRUB_ERR_NONE;
++}
++
+ static struct grub_term_output grub_video_term =
+ {
+ .name = "gfxterm",
+@@ -1201,6 +1248,7 @@
+ };
+
+ static grub_extcmd_t background_image_cmd_handle;
++static grub_command_t background_color_cmd_handle;
+
+ GRUB_MOD_INIT(gfxterm)
+ {
+@@ -1211,10 +1259,16 @@
+ N_("[-m (stretch|normal)] FILE"),
+ N_("Load background image for active terminal."),
+ background_image_cmd_options);
++ background_color_cmd_handle =
++ grub_register_command ("background_color",
++ grub_gfxterm_background_color_cmd,
++ N_("COLOR"),
++ N_("Set background color for active terminal."));
+ }
+
+ GRUB_MOD_FINI(gfxterm)
+ {
++ grub_unregister_command (background_color_cmd_handle);
+ grub_unregister_extcmd (background_image_cmd_handle);
+ grub_term_unregister_output (&grub_video_term);
+ }
+Index: b/include/grub/gfxmenu_view.h
+===================================================================
+--- a/include/grub/gfxmenu_view.h
++++ b/include/grub/gfxmenu_view.h
+@@ -87,11 +87,11 @@
+ grub_font_t title_font;
+ grub_font_t message_font;
+ char *terminal_font_name;
+- grub_gui_color_t title_color;
+- grub_gui_color_t message_color;
+- grub_gui_color_t message_bg_color;
++ grub_video_rgba_color_t title_color;
++ grub_video_rgba_color_t message_color;
++ grub_video_rgba_color_t message_bg_color;
+ struct grub_video_bitmap *desktop_image;
+- grub_gui_color_t desktop_color;
++ grub_video_rgba_color_t desktop_color;
+ grub_gfxmenu_box_t terminal_box;
+ char *title_text;
+ char *progress_message_text;
+Index: b/include/grub/gui.h
+===================================================================
+--- a/include/grub/gui.h
++++ b/include/grub/gui.h
+@@ -31,16 +31,6 @@
+ status changes. */
+ #define GRUB_GFXMENU_TIMEOUT_COMPONENT_ID "__timeout__"
+
+-/* A representation of a color. Unlike grub_video_color_t, this
+- representation is independent of any video mode specifics. */
+-typedef struct grub_gui_color
+-{
+- grub_uint8_t red;
+- grub_uint8_t green;
+- grub_uint8_t blue;
+- grub_uint8_t alpha;
+-} grub_gui_color_t;
+-
+ typedef struct grub_gui_component *grub_gui_component_t;
+ typedef struct grub_gui_container *grub_gui_container_t;
+ typedef struct grub_gui_list *grub_gui_list_t;
+@@ -242,23 +232,6 @@
+ r->height);
+ }
+
+-static __inline grub_gui_color_t
+-grub_gui_color_rgb (int r, int g, int b)
+-{
+- grub_gui_color_t c;
+- c.red = r;
+- c.green = g;
+- c.blue = b;
+- c.alpha = 255;
+- return c;
+-}
+-
+-static __inline grub_video_color_t
+-grub_gui_map_color (grub_gui_color_t c)
+-{
+- return grub_video_map_rgba (c.red, c.green, c.blue, c.alpha);
+-}
+-
+ static inline int
+ grub_video_have_common_points (const grub_video_rect_t *a,
+ const grub_video_rect_t *b)
+Index: b/include/grub/gui_string_util.h
+===================================================================
+--- a/include/grub/gui_string_util.h
++++ b/include/grub/gui_string_util.h
+@@ -30,8 +30,4 @@
+
+ char *grub_get_dirname (const char *file_path);
+
+-int grub_gui_get_named_color (const char *name, grub_gui_color_t *color);
+-
+-grub_err_t grub_gui_parse_color (const char *s, grub_gui_color_t *color);
+-
+ #endif /* GRUB_GUI_STRING_UTIL_HEADER */
+Index: b/include/grub/video.h
+===================================================================
+--- a/include/grub/video.h
++++ b/include/grub/video.h
+@@ -27,6 +27,15 @@
+ specific coding format. */
+ typedef grub_uint32_t grub_video_color_t;
+
++/* Video color in hardware independent format. */
++typedef struct grub_video_rgba_color
++{
++ grub_uint8_t red;
++ grub_uint8_t green;
++ grub_uint8_t blue;
++ grub_uint8_t alpha;
++} grub_video_rgba_color_t;
++
+ /* This structure is driver specific and should not be accessed directly by
+ outside code. */
+ struct grub_video_render_target;
+@@ -428,4 +437,27 @@
+
+ grub_video_driver_id_t EXPORT_FUNC (grub_video_get_driver_id) (void);
+
++static __inline grub_video_rgba_color_t
++grub_video_rgba_color_rgb (int r, int g, int b)
++{
++ grub_video_rgba_color_t c;
++ c.red = r;
++ c.green = g;
++ c.blue = b;
++ c.alpha = 255;
++ return c;
++}
++
++static __inline grub_video_color_t
++grub_video_map_rgba_color (grub_video_rgba_color_t c)
++{
++ return grub_video_map_rgba (c.red, c.green, c.blue, c.alpha);
++}
++
++int EXPORT_FUNC (grub_video_get_named_color) (const char *name,
++ grub_video_rgba_color_t *color);
++
++grub_err_t EXPORT_FUNC (grub_video_parse_color) (const char *s,
++ grub_video_rgba_color_t *color);
++
+ #endif /* ! GRUB_VIDEO_HEADER */
+Index: b/grub-core/video/colors.c
+===================================================================
+--- /dev/null
++++ b/grub-core/video/colors.c
+@@ -0,0 +1,330 @@
++/* named_colors.c - Named color values. */
++/*
++ * GRUB -- GRand Unified Bootloader
++ * Copyright (C) 2008 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/gui.h>
++#include <grub/gui_string_util.h>
++#include <grub/misc.h>
++
++struct named_color
++{
++ const char *name;
++ grub_video_rgba_color_t color;
++};
++
++/*
++ Named color list generated from the list of SVG color keywords from
++ <http://www.w3.org/TR/css3-color/#svg-color>,
++ processed through the following Perl command:
++ perl -ne 'chomp;split;print "{ \"$_[0]\", RGB_COLOR($_[2]) },\n"'
++ */
++
++#define RGB_COLOR(r,g,b) {.red = r, .green = g, .blue = b, .alpha = 255}
++
++static struct named_color named_colors[] =
++{
++ { "aliceblue", RGB_COLOR(240,248,255) },
++ { "antiquewhite", RGB_COLOR(250,235,215) },
++ { "aqua", RGB_COLOR(0,255,255) },
++ { "aquamarine", RGB_COLOR(127,255,212) },
++ { "azure", RGB_COLOR(240,255,255) },
++ { "beige", RGB_COLOR(245,245,220) },
++ { "bisque", RGB_COLOR(255,228,196) },
++ { "black", RGB_COLOR(0,0,0) },
++ { "blanchedalmond", RGB_COLOR(255,235,205) },
++ { "blue", RGB_COLOR(0,0,255) },
++ { "blueviolet", RGB_COLOR(138,43,226) },
++ { "brown", RGB_COLOR(165,42,42) },
++ { "burlywood", RGB_COLOR(222,184,135) },
++ { "cadetblue", RGB_COLOR(95,158,160) },
++ { "chartreuse", RGB_COLOR(127,255,0) },
++ { "chocolate", RGB_COLOR(210,105,30) },
++ { "coral", RGB_COLOR(255,127,80) },
++ { "cornflowerblue", RGB_COLOR(100,149,237) },
++ { "cornsilk", RGB_COLOR(255,248,220) },
++ { "crimson", RGB_COLOR(220,20,60) },
++ { "cyan", RGB_COLOR(0,255,255) },
++ { "darkblue", RGB_COLOR(0,0,139) },
++ { "darkcyan", RGB_COLOR(0,139,139) },
++ { "darkgoldenrod", RGB_COLOR(184,134,11) },
++ { "darkgray", RGB_COLOR(169,169,169) },
++ { "darkgreen", RGB_COLOR(0,100,0) },
++ { "darkgrey", RGB_COLOR(169,169,169) },
++ { "darkkhaki", RGB_COLOR(189,183,107) },
++ { "darkmagenta", RGB_COLOR(139,0,139) },
++ { "darkolivegreen", RGB_COLOR(85,107,47) },
++ { "darkorange", RGB_COLOR(255,140,0) },
++ { "darkorchid", RGB_COLOR(153,50,204) },
++ { "darkred", RGB_COLOR(139,0,0) },
++ { "darksalmon", RGB_COLOR(233,150,122) },
++ { "darkseagreen", RGB_COLOR(143,188,143) },
++ { "darkslateblue", RGB_COLOR(72,61,139) },
++ { "darkslategray", RGB_COLOR(47,79,79) },
++ { "darkslategrey", RGB_COLOR(47,79,79) },
++ { "darkturquoise", RGB_COLOR(0,206,209) },
++ { "darkviolet", RGB_COLOR(148,0,211) },
++ { "deeppink", RGB_COLOR(255,20,147) },
++ { "deepskyblue", RGB_COLOR(0,191,255) },
++ { "dimgray", RGB_COLOR(105,105,105) },
++ { "dimgrey", RGB_COLOR(105,105,105) },
++ { "dodgerblue", RGB_COLOR(30,144,255) },
++ { "firebrick", RGB_COLOR(178,34,34) },
++ { "floralwhite", RGB_COLOR(255,250,240) },
++ { "forestgreen", RGB_COLOR(34,139,34) },
++ { "fuchsia", RGB_COLOR(255,0,255) },
++ { "gainsboro", RGB_COLOR(220,220,220) },
++ { "ghostwhite", RGB_COLOR(248,248,255) },
++ { "gold", RGB_COLOR(255,215,0) },
++ { "goldenrod", RGB_COLOR(218,165,32) },
++ { "gray", RGB_COLOR(128,128,128) },
++ { "green", RGB_COLOR(0,128,0) },
++ { "greenyellow", RGB_COLOR(173,255,47) },
++ { "grey", RGB_COLOR(128,128,128) },
++ { "honeydew", RGB_COLOR(240,255,240) },
++ { "hotpink", RGB_COLOR(255,105,180) },
++ { "indianred", RGB_COLOR(205,92,92) },
++ { "indigo", RGB_COLOR(75,0,130) },
++ { "ivory", RGB_COLOR(255,255,240) },
++ { "khaki", RGB_COLOR(240,230,140) },
++ { "lavender", RGB_COLOR(230,230,250) },
++ { "lavenderblush", RGB_COLOR(255,240,245) },
++ { "lawngreen", RGB_COLOR(124,252,0) },
++ { "lemonchiffon", RGB_COLOR(255,250,205) },
++ { "lightblue", RGB_COLOR(173,216,230) },
++ { "lightcoral", RGB_COLOR(240,128,128) },
++ { "lightcyan", RGB_COLOR(224,255,255) },
++ { "lightgoldenrodyellow", RGB_COLOR(250,250,210) },
++ { "lightgray", RGB_COLOR(211,211,211) },
++ { "lightgreen", RGB_COLOR(144,238,144) },
++ { "lightgrey", RGB_COLOR(211,211,211) },
++ { "lightpink", RGB_COLOR(255,182,193) },
++ { "lightsalmon", RGB_COLOR(255,160,122) },
++ { "lightseagreen", RGB_COLOR(32,178,170) },
++ { "lightskyblue", RGB_COLOR(135,206,250) },
++ { "lightslategray", RGB_COLOR(119,136,153) },
++ { "lightslategrey", RGB_COLOR(119,136,153) },
++ { "lightsteelblue", RGB_COLOR(176,196,222) },
++ { "lightyellow", RGB_COLOR(255,255,224) },
++ { "lime", RGB_COLOR(0,255,0) },
++ { "limegreen", RGB_COLOR(50,205,50) },
++ { "linen", RGB_COLOR(250,240,230) },
++ { "magenta", RGB_COLOR(255,0,255) },
++ { "maroon", RGB_COLOR(128,0,0) },
++ { "mediumaquamarine", RGB_COLOR(102,205,170) },
++ { "mediumblue", RGB_COLOR(0,0,205) },
++ { "mediumorchid", RGB_COLOR(186,85,211) },
++ { "mediumpurple", RGB_COLOR(147,112,219) },
++ { "mediumseagreen", RGB_COLOR(60,179,113) },
++ { "mediumslateblue", RGB_COLOR(123,104,238) },
++ { "mediumspringgreen", RGB_COLOR(0,250,154) },
++ { "mediumturquoise", RGB_COLOR(72,209,204) },
++ { "mediumvioletred", RGB_COLOR(199,21,133) },
++ { "midnightblue", RGB_COLOR(25,25,112) },
++ { "mintcream", RGB_COLOR(245,255,250) },
++ { "mistyrose", RGB_COLOR(255,228,225) },
++ { "moccasin", RGB_COLOR(255,228,181) },
++ { "navajowhite", RGB_COLOR(255,222,173) },
++ { "navy", RGB_COLOR(0,0,128) },
++ { "oldlace", RGB_COLOR(253,245,230) },
++ { "olive", RGB_COLOR(128,128,0) },
++ { "olivedrab", RGB_COLOR(107,142,35) },
++ { "orange", RGB_COLOR(255,165,0) },
++ { "orangered", RGB_COLOR(255,69,0) },
++ { "orchid", RGB_COLOR(218,112,214) },
++ { "palegoldenrod", RGB_COLOR(238,232,170) },
++ { "palegreen", RGB_COLOR(152,251,152) },
++ { "paleturquoise", RGB_COLOR(175,238,238) },
++ { "palevioletred", RGB_COLOR(219,112,147) },
++ { "papayawhip", RGB_COLOR(255,239,213) },
++ { "peachpuff", RGB_COLOR(255,218,185) },
++ { "peru", RGB_COLOR(205,133,63) },
++ { "pink", RGB_COLOR(255,192,203) },
++ { "plum", RGB_COLOR(221,160,221) },
++ { "powderblue", RGB_COLOR(176,224,230) },
++ { "purple", RGB_COLOR(128,0,128) },
++ { "red", RGB_COLOR(255,0,0) },
++ { "rosybrown", RGB_COLOR(188,143,143) },
++ { "royalblue", RGB_COLOR(65,105,225) },
++ { "saddlebrown", RGB_COLOR(139,69,19) },
++ { "salmon", RGB_COLOR(250,128,114) },
++ { "sandybrown", RGB_COLOR(244,164,96) },
++ { "seagreen", RGB_COLOR(46,139,87) },
++ { "seashell", RGB_COLOR(255,245,238) },
++ { "sienna", RGB_COLOR(160,82,45) },
++ { "silver", RGB_COLOR(192,192,192) },
++ { "skyblue", RGB_COLOR(135,206,235) },
++ { "slateblue", RGB_COLOR(106,90,205) },
++ { "slategray", RGB_COLOR(112,128,144) },
++ { "slategrey", RGB_COLOR(112,128,144) },
++ { "snow", RGB_COLOR(255,250,250) },
++ { "springgreen", RGB_COLOR(0,255,127) },
++ { "steelblue", RGB_COLOR(70,130,180) },
++ { "tan", RGB_COLOR(210,180,140) },
++ { "teal", RGB_COLOR(0,128,128) },
++ { "thistle", RGB_COLOR(216,191,216) },
++ { "tomato", RGB_COLOR(255,99,71) },
++ { "turquoise", RGB_COLOR(64,224,208) },
++ { "violet", RGB_COLOR(238,130,238) },
++ { "wheat", RGB_COLOR(245,222,179) },
++ { "white", RGB_COLOR(255,255,255) },
++ { "whitesmoke", RGB_COLOR(245,245,245) },
++ { "yellow", RGB_COLOR(255,255,0) },
++ { "yellowgreen", RGB_COLOR(154,205,50) },
++ { 0, { 0, 0, 0, 0 } } /* Terminator. */
++};
++
++/* Get the color named NAME. If the color was found, returns 1 and
++ stores the color into *COLOR. If the color was not found, returns 0 and
++ does not modify *COLOR. */
++int
++grub_video_get_named_color (const char *name,
++ grub_video_rgba_color_t *color)
++{
++ int i;
++ for (i = 0; named_colors[i].name; i++)
++ {
++ if (grub_strcmp (named_colors[i].name, name) == 0)
++ {
++ *color = named_colors[i].color;
++ return 1;
++ }
++ }
++ return 0;
++}
++
++static __inline int
++my_isxdigit (char c)
++{
++ return ((c >= '0' && c <= '9')
++ || (c >= 'a' && c <= 'f')
++ || (c >= 'A' && c <= 'F'));
++}
++
++static int
++parse_hex_color_component (const char *s, unsigned start, unsigned end)
++{
++ unsigned len;
++ char buf[3];
++
++ len = end - start;
++ /* Check the limits so we don't overrun the buffer. */
++ if (len < 1 || len > 2)
++ return 0;
++
++ if (len == 1)
++ {
++ buf[0] = s[start]; /* Get the first and only hex digit. */
++ buf[1] = buf[0]; /* Duplicate the hex digit. */
++ }
++ else if (len == 2)
++ {
++ buf[0] = s[start];
++ buf[1] = s[start + 1];
++ }
++
++ buf[2] = '\0';
++
++ return grub_strtoul (buf, 0, 16);
++}
++
++/* Parse a color string of the form "r, g, b", "#RGB", "#RGBA",
++ "#RRGGBB", or "#RRGGBBAA". */
++grub_err_t
++grub_video_parse_color (const char *s, grub_video_rgba_color_t *color)
++{
++ grub_video_rgba_color_t c;
++
++ /* Skip whitespace. */
++ while (*s && grub_isspace (*s))
++ s++;
++
++ if (*s == '#')
++ {
++ /* HTML-style. Number if hex digits:
++ [6] #RRGGBB [3] #RGB
++ [8] #RRGGBBAA [4] #RGBA */
++
++ s++; /* Skip the '#'. */
++ /* Count the hexits to determine the format. */
++ int hexits = 0;
++ const char *end = s;
++ while (my_isxdigit (*end))
++ {
++ end++;
++ hexits++;
++ }
++
++ /* Parse the color components based on the format. */
++ if (hexits == 3 || hexits == 4)
++ {
++ c.red = parse_hex_color_component (s, 0, 1);
++ c.green = parse_hex_color_component (s, 1, 2);
++ c.blue = parse_hex_color_component (s, 2, 3);
++ if (hexits == 4)
++ c.alpha = parse_hex_color_component (s, 3, 4);
++ else
++ c.alpha = 255;
++ }
++ else if (hexits == 6 || hexits == 8)
++ {
++ c.red = parse_hex_color_component (s, 0, 2);
++ c.green = parse_hex_color_component (s, 2, 4);
++ c.blue = parse_hex_color_component (s, 4, 6);
++ if (hexits == 8)
++ c.alpha = parse_hex_color_component (s, 6, 8);
++ else
++ c.alpha = 255;
++ }
++ else
++ return grub_error (GRUB_ERR_BAD_ARGUMENT,
++ "invalid HTML-type color string `%s'", s);
++ }
++ else if (grub_isdigit (*s))
++ {
++ /* Comma separated decimal values. */
++ c.red = grub_strtoul (s, 0, 0);
++ if ((s = grub_strchr (s, ',')) == 0)
++ return grub_error (GRUB_ERR_BAD_ARGUMENT,
++ "missing 1st comma separator in color `%s'", s);
++ s++;
++ c.green = grub_strtoul (s, 0, 0);
++ if ((s = grub_strchr (s, ',')) == 0)
++ return grub_error (GRUB_ERR_BAD_ARGUMENT,
++ "missing 2nd comma separator in color `%s'", s);
++ s++;
++ c.blue = grub_strtoul (s, 0, 0);
++ if ((s = grub_strchr (s, ',')) == 0)
++ c.alpha = 255;
++ else
++ {
++ s++;
++ c.alpha = grub_strtoul (s, 0, 0);
++ }
++ }
++ else
++ {
++ if (! grub_video_get_named_color (s, &c))
++ return grub_error (GRUB_ERR_BAD_ARGUMENT,
++ "invalid named color `%s'", s);
++ }
++
++ if (grub_errno == GRUB_ERR_NONE)
++ *color = c;
++ return grub_errno;
++}
diff --git a/master/debian/branch_squash.patch b/master/debian/branch_squash.patch
new file mode 100644
index 0000000..594d03c
--- /dev/null
+++ b/master/debian/branch_squash.patch
@@ -0,0 +1,694 @@
+Description: Add squashfs 4 support
+Author: Vladimir Serbinenko <phcoder@gmail.com>
+Origin: upstream, http://bzr.sv.gnu.org/r/grub/branches/squash/
+Forwarded: not-needed
+Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3278
+Last-Update: 2011-05-19
+
+Index: b/Makefile.util.def
+===================================================================
+--- a/Makefile.util.def
++++ b/Makefile.util.def
+@@ -65,6 +65,7 @@
+ common = grub-core/fs/ntfscomp.c;
+ common = grub-core/fs/reiserfs.c;
+ common = grub-core/fs/sfs.c;
++ common = grub-core/fs/squash4.c;
+ common = grub-core/fs/tar.c;
+ common = grub-core/fs/udf.c;
+ common = grub-core/fs/ufs2.c;
+Index: b/grub-core/Makefile.core.def
+===================================================================
+--- a/grub-core/Makefile.core.def
++++ b/grub-core/Makefile.core.def
+@@ -985,6 +985,11 @@
+ };
+
+ module = {
++ name = squash4;
++ common = fs/squash4.c;
++};
++
++module = {
+ name = tar;
+ common = fs/tar.c;
+ };
+Index: b/grub-core/fs/squash4.c
+===================================================================
+--- /dev/null
++++ b/grub-core/fs/squash4.c
+@@ -0,0 +1,548 @@
++/* squash4.c - SquashFS */
++/*
++ * 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/>.
++ */
++
++#include <grub/err.h>
++#include <grub/file.h>
++#include <grub/mm.h>
++#include <grub/misc.h>
++#include <grub/disk.h>
++#include <grub/dl.h>
++#include <grub/types.h>
++#include <grub/fshelp.h>
++#include <grub/deflate.h>
++
++GRUB_MOD_LICENSE ("GPLv3+");
++
++/*
++ object format Pointed by
++ superblock RAW Fixed offset (0)
++ data RAW ? Fixed offset (60)
++ inode table Chunk superblock
++ dir table Chunk superblock
++ fragment table Chunk unk1
++ unk1 RAW, Chunk superblock
++ unk2 RAW superblock
++ UID/GID Chunk exttblptr
++ exttblptr RAW superblock
++
++ UID/GID table is the array ot uint32_t
++ unk1 contains pointer to unk3 followed by some chunk.
++ unk2 containts one uint64_t
++*/
++
++struct grub_squash_super
++{
++ grub_uint32_t magic;
++#define SQUASH_MAGIC 0x73717368
++ grub_uint32_t dummy1;
++ grub_uint32_t creation_time;
++ grub_uint32_t dummy2;
++ grub_uint64_t dummy3;
++ grub_uint8_t flags;
++#define SQUASH_FLAG_UNCOMPRESSED_INODES 1
++#define SQUASH_FLAG_UNCOMPRESSED_DATA 2
++#define SQUASH_FLAG_UNCOMPRESSED_FRAGMENTS 8
++ grub_uint8_t dummy4[7];
++ grub_uint16_t root_ino_offset;
++ grub_uint32_t root_ino_chunk;
++ grub_uint16_t dummy5;
++ grub_uint64_t total_size;
++ grub_uint64_t exttbloffset;
++ grub_uint64_t dummy6;
++ grub_uint64_t inodeoffset;
++ grub_uint64_t diroffset;
++ grub_uint64_t unk1offset;
++ grub_uint64_t unk2offset;
++} __attribute__ ((packed));
++
++
++/* Chunk-based */
++struct grub_squash_inode
++{
++ /* Same values as direlem types. */
++ grub_uint16_t type;
++ grub_uint16_t dummy[3];
++ grub_uint32_t mtime;
++ union
++ {
++ struct {
++ grub_uint32_t dummy;
++ grub_uint32_t chunk;
++ grub_uint32_t fragment;
++ grub_uint32_t offset;
++ grub_uint32_t size;
++ } __attribute__ ((packed)) file;
++ struct {
++ grub_uint32_t dummy1;
++ grub_uint32_t chunk;
++ grub_uint32_t dummy2;
++ grub_uint16_t size;
++ grub_uint32_t offset;
++ grub_uint16_t dummy3;
++ } __attribute__ ((packed)) dir;
++ struct {
++ grub_uint64_t dummy;
++ grub_uint32_t namelen;
++ char name[0];
++ } __attribute__ ((packed)) symlink;
++ } __attribute__ ((packed));
++} __attribute__ ((packed));
++
++/* Chunk-based. */
++struct grub_squash_dirent_header
++{
++ /* Actually the value is the number of elements - 1. */
++ grub_uint32_t nelems;
++ grub_uint64_t ino_chunk;
++} __attribute__ ((packed));
++
++struct grub_squash_dirent
++{
++ grub_uint16_t ino_offset;
++ grub_uint16_t dummy;
++ grub_uint16_t type;
++#define SQUASH_TYPE_DIR 1
++#define SQUASH_TYPE_REGULAR 2
++#define SQUASH_TYPE_SYMLINK 3
++ /* Actually the value is the length of name - 1. */
++ grub_uint16_t namelen;
++ char name[0];
++} __attribute__ ((packed));
++
++struct grub_squash_frag_desc
++{
++ grub_uint64_t offset;
++ grub_uint64_t dummy;
++} __attribute__ ((packed));
++
++#define SQUASH_CHUNK_SIZE 0x2000
++#define SQUASH_CHUNK_FLAGS 0x8000
++#define SQUASH_CHUNK_UNCOMPRESSED 0x8000
++
++struct grub_squash_data
++{
++ grub_disk_t disk;
++ struct grub_squash_super sb;
++ struct grub_squash_inode ino;
++ grub_uint64_t fragments;
++};
++
++struct grub_fshelp_node
++{
++ struct grub_squash_data *data;
++ struct grub_squash_inode ino;
++ grub_uint32_t ino_chunk;
++ grub_uint16_t ino_offset;
++};
++
++static grub_err_t
++read_chunk (grub_disk_t disk, void *buf, grub_size_t len,
++ grub_uint64_t chunk, grub_off_t offset)
++{
++ grub_uint64_t chunk_start;
++ chunk_start = grub_le_to_cpu64 (chunk);
++ while (len > 0)
++ {
++ grub_uint64_t csize;
++ grub_uint16_t d;
++ grub_err_t err;
++ while (1)
++ {
++ err = grub_disk_read (disk, chunk_start >> GRUB_DISK_SECTOR_BITS,
++ chunk_start & (GRUB_DISK_SECTOR_SIZE - 1),
++ sizeof (d), &d);
++ if (err)
++ return err;
++ if (offset < SQUASH_CHUNK_SIZE)
++ break;
++ offset -= SQUASH_CHUNK_SIZE;
++ chunk_start += 2 + (grub_le_to_cpu16 (d) & ~SQUASH_CHUNK_FLAGS);
++ }
++
++ csize = SQUASH_CHUNK_SIZE - offset;
++ if (csize > len)
++ csize = len;
++
++ if (grub_le_to_cpu16 (d) & SQUASH_CHUNK_UNCOMPRESSED)
++ {
++ grub_disk_addr_t a = chunk_start + 2 + offset;
++ err = grub_disk_read (disk, (a >> GRUB_DISK_SECTOR_BITS),
++ a & (GRUB_DISK_SECTOR_SIZE - 1),
++ csize, buf);
++ if (err)
++ return err;
++ }
++ else
++ {
++ char *tmp;
++ grub_size_t bsize = grub_le_to_cpu16 (d) & ~SQUASH_CHUNK_FLAGS;
++ grub_disk_addr_t a = chunk_start + 2;
++ tmp = grub_malloc (bsize);
++ if (!tmp)
++ return grub_errno;
++ /* FIXME: buffer uncompressed data. */
++ err = grub_disk_read (disk, (a >> GRUB_DISK_SECTOR_BITS),
++ a & (GRUB_DISK_SECTOR_SIZE - 1),
++ bsize, tmp);
++ if (err)
++ {
++ grub_free (tmp);
++ return err;
++ }
++
++ if (grub_zlib_decompress (tmp, bsize, offset,
++ buf, csize) < 0)
++ {
++ grub_free (tmp);
++ return grub_errno;
++ }
++ grub_free (tmp);
++ }
++ len -= csize;
++ offset += csize;
++ buf = (char *) buf + csize;
++ }
++ return GRUB_ERR_NONE;
++}
++
++static struct grub_squash_data *
++squash_mount (grub_disk_t disk)
++{
++ struct grub_squash_super sb;
++ grub_err_t err;
++ struct grub_squash_data *data;
++ grub_uint64_t frag;
++
++ err = grub_disk_read (disk, 0, 0, sizeof (sb), &sb);
++ if (grub_errno == GRUB_ERR_OUT_OF_RANGE)
++ grub_error (GRUB_ERR_BAD_FS, "not a squash4");
++ if (err)
++ return NULL;
++ if (grub_le_to_cpu32 (sb.magic) != SQUASH_MAGIC)
++ {
++ grub_error (GRUB_ERR_BAD_FS, "not squash4");
++ return NULL;
++ }
++
++ err = grub_disk_read (disk, grub_le_to_cpu32 (sb.unk1offset)
++ >> GRUB_DISK_SECTOR_BITS,
++ grub_le_to_cpu32 (sb.unk1offset)
++ & (GRUB_DISK_SECTOR_SIZE - 1), sizeof (frag), &frag);
++ if (grub_errno == GRUB_ERR_OUT_OF_RANGE)
++ grub_error (GRUB_ERR_BAD_FS, "not a squash4");
++ if (err)
++ return NULL;
++
++ data = grub_malloc (sizeof (*data));
++ if (!data)
++ return NULL;
++ data->sb = sb;
++ data->disk = disk;
++ data->fragments = frag;
++
++ return data;
++}
++
++static char *
++grub_squash_read_symlink (grub_fshelp_node_t node)
++{
++ char *ret;
++ grub_err_t err;
++ ret = grub_malloc (grub_le_to_cpu32 (node->ino.symlink.namelen) + 1);
++
++ err = read_chunk (node->data->disk, ret,
++ grub_le_to_cpu32 (node->ino.symlink.namelen),
++ grub_le_to_cpu64 (node->data->sb.inodeoffset)
++ + node->ino_chunk,
++ node->ino_offset + (node->ino.symlink.name
++ - (char *) &node->ino));
++ if (err)
++ {
++ grub_free (ret);
++ return NULL;
++ }
++ ret[grub_le_to_cpu32 (node->ino.symlink.namelen)] = 0;
++ return ret;
++}
++
++static int
++grub_squash_iterate_dir (grub_fshelp_node_t dir,
++ int NESTED_FUNC_ATTR
++ (*hook) (const char *filename,
++ enum grub_fshelp_filetype filetype,
++ grub_fshelp_node_t node))
++{
++ grub_uint32_t off = grub_le_to_cpu16 (dir->ino.dir.offset);
++ grub_uint32_t endoff;
++ unsigned i;
++
++ /* FIXME: why - 3 ? */
++ endoff = grub_le_to_cpu32 (dir->ino.dir.size) + off - 3;
++
++ while (off < endoff)
++ {
++ struct grub_squash_dirent_header dh;
++ grub_err_t err;
++
++ err = read_chunk (dir->data->disk, &dh, sizeof (dh),
++ grub_le_to_cpu64 (dir->data->sb.diroffset)
++ + grub_le_to_cpu32 (dir->ino.dir.chunk), off);
++ if (err)
++ return 0;
++ off += sizeof (dh);
++ for (i = 0; i < (unsigned) grub_le_to_cpu16 (dh.nelems) + 1; i++)
++ {
++ char *buf;
++ int r;
++ struct grub_fshelp_node *node;
++ enum grub_fshelp_filetype filetype = GRUB_FSHELP_REG;
++ struct grub_squash_dirent di;
++ struct grub_squash_inode ino;
++
++ err = read_chunk (dir->data->disk, &di, sizeof (di),
++ grub_le_to_cpu64 (dir->data->sb.diroffset)
++ + grub_le_to_cpu32 (dir->ino.dir.chunk), off);
++ if (err)
++ return 0;
++ off += sizeof (di);
++
++ err = read_chunk (dir->data->disk, &ino, sizeof (ino),
++ grub_le_to_cpu64 (dir->data->sb.inodeoffset)
++ + grub_le_to_cpu32 (dh.ino_chunk),
++ grub_cpu_to_le16 (di.ino_offset));
++ if (err)
++ return 0;
++
++ buf = grub_malloc (grub_le_to_cpu16 (di.namelen) + 2);
++ if (!buf)
++ return 0;
++ err = read_chunk (dir->data->disk, buf,
++ grub_le_to_cpu16 (di.namelen) + 1,
++ grub_le_to_cpu64 (dir->data->sb.diroffset)
++ + grub_le_to_cpu32 (dir->ino.dir.chunk), off);
++ if (err)
++ return 0;
++
++ off += grub_le_to_cpu16 (di.namelen) + 1;
++ buf[grub_le_to_cpu16 (di.namelen) + 1] = 0;
++ if (grub_le_to_cpu16 (di.type) == SQUASH_TYPE_DIR)
++ filetype = GRUB_FSHELP_DIR;
++ if (grub_le_to_cpu16 (di.type) == SQUASH_TYPE_SYMLINK)
++ filetype = GRUB_FSHELP_SYMLINK;
++
++ node = grub_malloc (sizeof (*node));
++ if (! node)
++ return 0;
++ *node = *dir;
++ node->ino = ino;
++ node->ino_chunk = grub_le_to_cpu32 (dh.ino_chunk);
++ node->ino_offset = grub_le_to_cpu16 (di.ino_offset);
++
++ r = hook (buf, filetype, node);
++
++ grub_free (buf);
++ if (r)
++ return r;
++ }
++ }
++ return 0;
++}
++
++static grub_err_t
++make_root_node (struct grub_squash_data *data, struct grub_fshelp_node *root)
++{
++ grub_memset (root, 0, sizeof (*root));
++ root->data = data;
++
++ return read_chunk (data->disk, &root->ino, sizeof (root->ino),
++ grub_le_to_cpu64 (data->sb.inodeoffset)
++ + grub_le_to_cpu16 (data->sb.root_ino_chunk),
++ grub_cpu_to_le16 (data->sb.root_ino_offset));
++}
++
++static grub_err_t
++grub_squash_dir (grub_device_t device, const char *path,
++ int (*hook) (const char *filename,
++ const struct grub_dirhook_info *info))
++{
++ auto int NESTED_FUNC_ATTR iterate (const char *filename,
++ enum grub_fshelp_filetype filetype,
++ grub_fshelp_node_t node);
++
++ int NESTED_FUNC_ATTR iterate (const char *filename,
++ enum grub_fshelp_filetype filetype,
++ grub_fshelp_node_t node)
++ {
++ struct grub_dirhook_info info;
++ grub_memset (&info, 0, sizeof (info));
++ info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);
++ info.mtimeset = 1;
++ info.mtime = grub_le_to_cpu32 (node->ino.mtime);
++ return hook (filename, &info);
++ }
++
++ struct grub_squash_data *data = 0;
++ struct grub_fshelp_node *fdiro = 0;
++ struct grub_fshelp_node root;
++ grub_err_t err;
++
++ data = squash_mount (device->disk);
++ if (! data)
++ return grub_errno;
++
++ err = make_root_node (data, &root);
++ if (err)
++ return err;
++
++ grub_fshelp_find_file (path, &root, &fdiro, grub_squash_iterate_dir,
++ grub_squash_read_symlink, GRUB_FSHELP_DIR);
++ if (!grub_errno)
++ grub_squash_iterate_dir (fdiro, iterate);
++
++ grub_free (data);
++
++ return grub_errno;
++}
++
++static grub_err_t
++grub_squash_open (struct grub_file *file, const char *name)
++{
++ struct grub_squash_data *data = 0;
++ struct grub_fshelp_node *fdiro = 0;
++ struct grub_fshelp_node root;
++ grub_err_t err;
++
++ data = squash_mount (file->device->disk);
++ if (! data)
++ return grub_errno;
++
++ err = make_root_node (data, &root);
++ if (err)
++ return err;
++
++ grub_fshelp_find_file (name, &root, &fdiro, grub_squash_iterate_dir,
++ grub_squash_read_symlink, GRUB_FSHELP_REG);
++ if (grub_errno)
++ {
++ grub_free (data);
++ return grub_errno;
++ }
++
++ file->data = data;
++ data->ino = fdiro->ino;
++ file->size = grub_le_to_cpu32 (fdiro->ino.file.size);
++
++ return GRUB_ERR_NONE;
++}
++
++static grub_ssize_t
++grub_squash_read_data (struct grub_squash_data *data,
++ grub_disk_t disk, const struct grub_squash_inode *ino,
++ grub_off_t off, char *buf, grub_size_t len)
++{
++ grub_err_t err;
++ grub_uint64_t a, b;
++ int compressed = 0;
++
++ if (grub_le_to_cpu16 (ino->file.fragment) == 0xffff)
++ {
++ if (grub_le_to_cpu32 (ino->file.chunk))
++ a = grub_le_to_cpu32 (ino->file.chunk);
++ else
++ a = sizeof (struct grub_squash_super);
++ compressed = !(data->sb.flags & SQUASH_FLAG_UNCOMPRESSED_DATA);
++ }
++ else
++ {
++ struct grub_squash_frag_desc frag;
++ err = read_chunk (disk, &frag, sizeof (frag),
++ data->fragments, sizeof (frag)
++ * grub_le_to_cpu16 (ino->file.fragment));
++ if (err)
++ return -1;
++ a = grub_le_to_cpu64 (frag.offset) + grub_le_to_cpu32 (ino->file.chunk);
++ compressed = !(data->sb.flags & SQUASH_FLAG_UNCOMPRESSED_FRAGMENTS);
++ }
++
++ b = grub_le_to_cpu32 (data->ino.file.offset) + off;
++
++ /* FIXME: cache uncompressed chunks. */
++ if (compressed)
++ err = grub_zlib_disk_read (disk, a, b, buf, len);
++ else
++ err = grub_disk_read (disk, (a + b) >> GRUB_DISK_SECTOR_BITS,
++ (a + b) & (GRUB_DISK_SECTOR_SIZE - 1), len, buf);
++ if (err)
++ return -1;
++ return len;
++}
++
++static grub_ssize_t
++grub_squash_read (grub_file_t file, char *buf, grub_size_t len)
++{
++ struct grub_squash_data *data = file->data;
++
++ return grub_squash_read_data (data, file->device->disk, &data->ino,
++ file->offset, buf, len);
++}
++
++static grub_err_t
++grub_squash_close (grub_file_t file)
++{
++ grub_free (file->data);
++ return GRUB_ERR_NONE;
++}
++
++static grub_err_t
++grub_squash_mtime (grub_device_t dev, grub_int32_t *tm)
++{
++ struct grub_squash_data *data = 0;
++
++ data = squash_mount (dev->disk);
++ if (! data)
++ return grub_errno;
++ *tm = grub_le_to_cpu32 (data->sb.creation_time);
++ grub_free (data);
++ return GRUB_ERR_NONE;
++}
++
++static struct grub_fs grub_squash_fs =
++ {
++ .name = "squash4",
++ .dir = grub_squash_dir,
++ .open = grub_squash_open,
++ .read = grub_squash_read,
++ .close = grub_squash_close,
++ .mtime = grub_squash_mtime,
++#ifdef GRUB_UTIL
++ .reserved_first_sector = 0,
++#endif
++ .next = 0
++ };
++
++GRUB_MOD_INIT(squash4)
++{
++ grub_fs_register (&grub_squash_fs);
++}
++
++GRUB_MOD_FINI(squash4)
++{
++ grub_fs_unregister (&grub_squash_fs);
++}
++
+Index: b/grub-core/io/gzio.c
+===================================================================
+--- a/grub-core/io/gzio.c
++++ b/grub-core/io/gzio.c
+@@ -41,6 +41,7 @@
+ #include <grub/fs.h>
+ #include <grub/file.h>
+ #include <grub/dl.h>
++#include <grub/disk.h>
+ #include <grub/deflate.h>
+
+ GRUB_MOD_LICENSE ("GPLv3+");
+@@ -64,6 +65,9 @@
+ /* If input is in memory following fields are used instead of file. */
+ grub_size_t mem_input_size, mem_input_off;
+ grub_uint8_t *mem_input;
++ grub_disk_addr_t disk_input_off;
++ grub_disk_addr_t disk_input_start;
++ grub_disk_t disk_input;
+ /* The offset at which the data starts in the underlying file. */
+ grub_off_t data_offset;
+ /* The type of current block. */
+@@ -384,8 +388,21 @@
+ return 0;
+ }
+
+- if (grub_file_tell (gzio->file) == (grub_off_t) gzio->data_offset
+- || gzio->inbuf_d == INBUFSIZ)
++ if (gzio->disk_input && (gzio->disk_input_off == gzio->data_offset
++ || gzio->inbuf_d == INBUFSIZ))
++ {
++ grub_disk_addr_t d = gzio->disk_input_start + gzio->disk_input_off;
++ gzio->inbuf_d = 0;
++ grub_disk_read (gzio->disk_input,
++ d >> GRUB_DISK_SECTOR_BITS,
++ d & (GRUB_DISK_SECTOR_SIZE - 1),
++ INBUFSIZ, gzio->inbuf);
++ gzio->disk_input_off += INBUFSIZ;
++ }
++
++ if (gzio->file && (grub_file_tell (gzio->file)
++ == (grub_off_t) gzio->data_offset
++ || gzio->inbuf_d == INBUFSIZ))
+ {
+ gzio->inbuf_d = 0;
+ grub_file_read (gzio->file, gzio->inbuf, INBUFSIZ);
+@@ -403,8 +420,10 @@
+ grub_error (GRUB_ERR_OUT_OF_RANGE,
+ "attempt to seek outside of the file");
+ else
+- gzio->mem_input_off = gzio->data_offset;
++ gzio->mem_input_off = off;
+ }
++ else if (gzio->disk_input)
++ gzio->disk_input_off = off;
+ else
+ grub_file_seek (gzio->file, off);
+ }
+@@ -1298,6 +1317,34 @@
+ return ret;
+ }
+
++grub_err_t
++grub_zlib_disk_read (grub_disk_t disk, grub_disk_addr_t zlibstart,
++ grub_off_t off, char *outbuf, grub_size_t outsize)
++{
++ grub_gzio_t gzio = 0;
++ grub_ssize_t ret;
++
++ gzio = grub_zalloc (sizeof (*gzio));
++ if (! gzio)
++ return -1;
++
++ gzio->disk_input_off = 0;
++ gzio->disk_input_start = zlibstart;
++ gzio->disk_input = disk;
++
++ if (!test_zlib_header (gzio))
++ {
++ grub_free (gzio);
++ return -1;
++ }
++
++ ret = grub_gzio_read_real (gzio, off, outbuf, outsize);
++ grub_free (gzio);
++
++ /* FIXME: Check Adler. */
++ return ret < 0 ? grub_errno : GRUB_ERR_NONE;
++}
++
+
+
+ static struct grub_fs grub_gzio_fs =
+Index: b/include/grub/deflate.h
+===================================================================
+--- a/include/grub/deflate.h
++++ b/include/grub/deflate.h
+@@ -23,4 +23,8 @@
+ grub_zlib_decompress (char *inbuf, grub_size_t insize, grub_off_t off,
+ char *outbuf, grub_size_t outsize);
+
++grub_err_t
++grub_zlib_disk_read (grub_disk_t disk, grub_disk_addr_t zlibstart,
++ grub_off_t off, char *outbuf, grub_size_t outsize);
++
+ #endif
diff --git a/master/debian/btrfs_stat.patch b/master/debian/btrfs_stat.patch
new file mode 100644
index 0000000..7e162e6
--- /dev/null
+++ b/master/debian/btrfs_stat.patch
@@ -0,0 +1,36 @@
+Description: Cope with btrfs / inside an encrypted block device
+ If / is inside an encrypted block device, then grub-probe can't tell what
+ its filesystem type is. Work around this.
+Author: alexeagar@gmail.com
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/757631
+Forwarded: no
+Last-Update: 2011-06-15
+
+Index: b/util/grub.d/10_linux.in
+===================================================================
+--- a/util/grub.d/10_linux.in
++++ b/util/grub.d/10_linux.in
+@@ -56,7 +56,8 @@
+ LINUX_ROOT_DEVICE=UUID=${GRUB_DEVICE_UUID}
+ fi
+
+-if [ "x`${grub_probe} --device ${GRUB_DEVICE} --target=fs 2>/dev/null || true`" = xbtrfs ]; then
++if [ "x`${grub_probe} --device ${GRUB_DEVICE} --target=fs 2>/dev/null || true`" = xbtrfs ] \
++ || [ "x`stat -f --printf=%T /`" = xbtrfs ]; then
+ rootsubvol="`make_system_path_relative_to_its_root /`"
+ rootsubvol="${rootsubvol#/}"
+ if [ "x${rootsubvol}" != x ]; then
+Index: b/util/grub.d/20_linux_xen.in
+===================================================================
+--- a/util/grub.d/20_linux_xen.in
++++ b/util/grub.d/20_linux_xen.in
+@@ -56,7 +56,8 @@
+ LINUX_ROOT_DEVICE=UUID=${GRUB_DEVICE_UUID}
+ fi
+
+-if [ "x`${grub_probe} --device ${GRUB_DEVICE} --target=fs 2>/dev/null || true`" = xbtrfs ]; then
++if [ "x`${grub_probe} --device ${GRUB_DEVICE} --target=fs 2>/dev/null || true`" = xbtrfs ] \
++ || [ "x`stat -f --printf=%T /`" = xbtrfs ]; then
+ rootsubvol="`make_system_path_relative_to_its_root /`"
+ rootsubvol="${rootsubvol#/}"
+ if [ "x${rootsubvol}" != x ]; then
diff --git a/master/debian/core_in_fs.patch b/master/debian/core_in_fs.patch
new file mode 100644
index 0000000..7b597ea
--- /dev/null
+++ b/master/debian/core_in_fs.patch
@@ -0,0 +1,31 @@
+Index: b/util/grub-setup.c
+===================================================================
+--- a/util/grub-setup.c
++++ b/util/grub-setup.c
+@@ -76,6 +76,7 @@
+
+ #define DEFAULT_BOOT_FILE "boot.img"
+ #define DEFAULT_CORE_FILE "core.img"
++#define CORE_IMG_IN_FS "setup_left_core_image_in_filesystem"
+
+ #ifdef GRUB_MACHINE_SPARC64
+ #define grub_target_to_host16(x) grub_be_to_cpu16(x)
+@@ -489,6 +490,8 @@
+
+ grub_free (sectors);
+
++ unlink (DEFAULT_DIRECTORY "/" CORE_IMG_IN_FS);
++
+ goto finish;
+ }
+ #endif
+@@ -514,6 +517,9 @@
+ /* The core image must be put on a filesystem unfortunately. */
+ grub_util_info ("will leave the core image on the filesystem");
+
++ fp = fopen (DEFAULT_DIRECTORY "/" CORE_IMG_IN_FS, "w");
++ fclose (fp);
++
+ /* Make sure that GRUB reads the identical image as the OS. */
+ tmp_img = xmalloc (core_size);
+ core_path_dev_full = grub_util_get_path (dir, core_file);
diff --git a/master/debian/dirlen.patch b/master/debian/dirlen.patch
new file mode 100644
index 0000000..1268456
--- /dev/null
+++ b/master/debian/dirlen.patch
@@ -0,0 +1,19 @@
+Description: Ignore entries with direct.inode = 0.
+Author: Samuel Thibault <samuel.thibault@ens-lyon.org>
+Origin: upstream, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3749
+Forwarded: not-needed
+Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3749
+Last-Update: 2012-06-08
+
+--- a/grub-core/fs/ext2.c 2012-01-14 10:30:43 +0000
++++ b/grub-core/fs/ext2.c 2012-01-14 10:55:20 +0000
+@@ -685,7 +685,7 @@ grub_ext2_iterate_dir (grub_fshelp_node_
+ if (dirent.direntlen == 0)
+ return 0;
+
+- if (dirent.namelen != 0)
++ if (dirent.inode != 0 && dirent.namelen != 0)
+ {
+ char filename[dirent.namelen + 1];
+ struct grub_fshelp_node *fdiro;
+
diff --git a/master/debian/disable_floppies.patch b/master/debian/disable_floppies.patch
new file mode 100644
index 0000000..6bb2862
--- /dev/null
+++ b/master/debian/disable_floppies.patch
@@ -0,0 +1,28 @@
+
+Author: Robert Millan
+
+An ugly kludge. Should this be merged upstream?
+
+Index: b/grub-core/kern/emu/hostdisk.c
+===================================================================
+--- a/grub-core/kern/emu/hostdisk.c
++++ b/grub-core/kern/emu/hostdisk.c
+@@ -1077,6 +1077,18 @@
+ continue;
+ }
+
++ if (! strncmp (p, "/dev/fd", sizeof ("/dev/fd") - 1))
++ {
++ char *q = p + sizeof ("/dev/fd") - 1;
++ if (*q >= '0' && *q <= '9')
++ {
++ free (map[drive].drive);
++ map[drive].drive = NULL;
++ grub_util_info ("`%s' looks like a floppy drive, skipping", p);
++ continue;
++ }
++ }
++
+ #ifdef __linux__
+ /* On Linux, the devfs uses symbolic links horribly, and that
+ confuses the interface very much, so use realpath to expand
diff --git a/master/debian/dpkg_version_comparison.patch b/master/debian/dpkg_version_comparison.patch
new file mode 100644
index 0000000..6b23c61
--- /dev/null
+++ b/master/debian/dpkg_version_comparison.patch
@@ -0,0 +1,30 @@
+Description: Improve handling of Debian kernel version numbers
+Author: Robert Millan <rmh@aybabtu.com>
+Forwarded: not-needed
+Last-Update: 2011-04-21
+
+Index: b/util/grub-mkconfig_lib.in
+===================================================================
+--- a/util/grub-mkconfig_lib.in
++++ b/util/grub-mkconfig_lib.in
+@@ -172,8 +172,9 @@
+
+ version_test_gt ()
+ {
+- local a="`echo "$1" | sed -e "s/[^-]*-//"`"
+- local b="`echo "$2" | sed -e "s/[^-]*-//"`"
++ local sedexp="s/[^-]*-//;s/[._-]\(pre\|rc\|test\|git\|old\|trunk\)/~\1/g"
++ local a="`echo "$1" | sed -e "$sedexp"`"
++ local b="`echo "$2" | sed -e "$sedexp"`"
+ local cmp=gt
+ if [ "x$b" = "x" ] ; then
+ return 0
+@@ -183,7 +184,7 @@
+ *.old:*) a="`echo -n "$a" | sed -e 's/\.old$//'`" ; cmp=gt ;;
+ *:*.old) b="`echo -n "$b" | sed -e 's/\.old$//'`" ; cmp=ge ;;
+ esac
+- version_test_numeric "$a" "$cmp" "$b"
++ dpkg --compare-versions "$a" $cmp "$b"
+ return "$?"
+ }
+
diff --git a/master/debian/efi_disk_cache.patch b/master/debian/efi_disk_cache.patch
new file mode 100644
index 0000000..478e144
--- /dev/null
+++ b/master/debian/efi_disk_cache.patch
@@ -0,0 +1,26 @@
+Description: Bump the values of GRUB_DISK_CACHE_SIZE and GRUB_DISK_CACHE_BITS
+ on EFI systems (and only on EFI sytems) to dramatically reduce the load times
+ for vmlinux and initrd. Forwarding this isn't required as upstream trunk
+ has completely rewritten how this all works.
+Author: Adam Conrad <adconrad@debian.org>
+Origin: other, http://blog.fpmurphy.com/2010/03/grub2-efi-support.html
+Bug-Ubuntu: https://bugs.launchpad.net/ubuntu/+source/grub2/+bug/944347
+Forwarded: not-needed
+Last-Update: 2012-03-05
+
+Index: b/include/grub/disk.h
+===================================================================
+--- a/include/grub/disk.h
++++ b/include/grub/disk.h
+@@ -137,7 +137,11 @@
+
+ /* The size of a disk cache in 512B units. Must be at least as big as the
+ largest supported sector size, currently 16K. */
++#ifdef GRUB_MACHINE_EFI
++#define GRUB_DISK_CACHE_BITS 10
++#else
+ #define GRUB_DISK_CACHE_BITS 6
++#endif
+ #define GRUB_DISK_CACHE_SIZE (1 << GRUB_DISK_CACHE_BITS)
+
+ /* Return value of grub_disk_get_size() in case disk size is unknown. */
diff --git a/master/debian/efiemu_fix.patch b/master/debian/efiemu_fix.patch
new file mode 100644
index 0000000..5dba671
--- /dev/null
+++ b/master/debian/efiemu_fix.patch
@@ -0,0 +1,134 @@
+Description: Fix efiemu
+ Without this, lzo.patch causes efiemu not to be built.
+Author: Vladimir Serbinenko <phcoder@gmail.com>
+Origin: upstream, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3740
+Origin: upstream, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/4066
+Forwarded: not-needed
+Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3740
+Last-Update: 2012-03-19
+
+Index: b/configure.ac
+===================================================================
+--- a/configure.ac
++++ b/configure.ac
+@@ -479,6 +479,42 @@
+ esac
+ AC_MSG_RESULT([$TARGET_OBJ2ELF])
+
++
++AC_ARG_ENABLE([efiemu],
++ [AS_HELP_STRING([--enable-efiemu],
++ [build and install the efiemu runtimes (default=guessed)])])
++if test x"$enable_efiemu" = xno ; then
++ efiemu_excuse="explicitly disabled"
++fi
++if test x"$target_cpu" != xi386 ; then
++ efiemu_excuse="only available on i386"
++fi
++if test x"$platform" = xefi ; then
++ efiemu_excuse="not available on efi"
++fi
++if test x"$efiemu_excuse" = x ; then
++ AC_CACHE_CHECK([whether options required for efiemu work], grub_cv_cc_efiemu, [
++ SAVED_CFLAGS="$CFLAGS"
++ CFLAGS="$CFLAGS -m64 -mcmodel=large -mno-red-zone -nostdlib"
++ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
++ [grub_cv_cc_efiemu=yes],
++ [grub_cv_cc_efiemu=no])
++ CFLAGS="$SAVED_CFLAGS"
++ ])
++ if test x$grub_cv_cc_efiemu = xno; then
++ efiemu_excuse="cannot compile with -m64 -mcmodel=large -mno-red-zone -nostdlib"
++ fi
++fi
++if test x"$enable_efiemu" = xyes && test x"$efiemu_excuse" != x ; then
++ AC_MSG_ERROR([efiemu runtime was explicitly requested but can't be compiled])
++fi
++if test x"$efiemu_excuse" = x ; then
++enable_efiemu=yes
++else
++enable_efiemu=no
++fi
++AC_SUBST([enable_efiemu])
++
+ if test "x$target_m32" = x1; then
+ # Force 32-bit mode.
+ TARGET_CFLAGS="$TARGET_CFLAGS -m32"
+@@ -638,39 +674,6 @@
+ grub_I386_ASM_ADDR32
+ fi
+
+-AC_ARG_ENABLE([efiemu],
+- [AS_HELP_STRING([--enable-efiemu],
+- [build and install the efiemu runtimes (default=guessed)])])
+-if test x"$enable_efiemu" = xno ; then
+- efiemu_excuse="explicitly disabled"
+-fi
+-if test x"$target_cpu" != xi386 ; then
+- efiemu_excuse="only available on i386"
+-fi
+-if test x"$platform" = xefi ; then
+- efiemu_excuse="not available on efi"
+-fi
+-if test x"$efiemu_excuse" = x ; then
+- AC_CACHE_CHECK([whether options required for efiemu work], grub_cv_cc_efiemu, [
+- CFLAGS="$CFLAGS -m64 -mcmodel=large -mno-red-zone -nostdlib"
+- AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
+- [grub_cv_cc_efiemu=yes],
+- [grub_cv_cc_efiemu=no])
+- ])
+- if test x$grub_cv_cc_efiemu = xno; then
+- efiemu_excuse="cannot compile with -m64 -mcmodel=large -mno-red-zone -nostdlib"
+- fi
+-fi
+-if test x"$enable_efiemu" = xyes && test x"$efiemu_excuse" != x ; then
+- AC_MSG_ERROR([efiemu runtime was explicitly requested but can't be compiled])
+-fi
+-if test x"$efiemu_excuse" = x ; then
+-enable_efiemu=yes
+-else
+-enable_efiemu=no
+-fi
+-AC_SUBST([enable_efiemu])
+-
+ if test "$platform" != emu; then
+ AC_CACHE_CHECK([whether -nostdinc -isystem works], [grub_cv_cc_isystem], [
+ SAVED_CPPFLAGS="$CPPFLAGS"
+Index: b/grub-core/efiemu/runtime/efiemu.c
+===================================================================
+--- a/grub-core/efiemu/runtime/efiemu.c
++++ b/grub-core/efiemu/runtime/efiemu.c
+@@ -21,6 +21,12 @@
+ As it emulates only runtime serviceit isn't able
+ to chainload EFI bootloader on non-EFI system (TODO) */
+
++#ifdef __i386__
++#include <grub/i386/types.h>
++#else
++#include <grub/x86_64/types.h>
++#endif
++
+ #include <grub/symbol.h>
+ #include <grub/types.h>
+ #include <grub/efi/api.h>
+@@ -369,16 +375,16 @@
+ switch (cur_relloc->size)
+ {
+ case 8:
+- *((grub_uint64_t *) UINT_TO_PTR (cur_relloc->addr)) += corr;
++ *((grub_uint64_t *) (grub_addr_t) cur_relloc->addr) += corr;
+ break;
+ case 4:
+- *((grub_uint32_t *) UINT_TO_PTR (cur_relloc->addr)) += corr;
++ *((grub_uint32_t *) (grub_addr_t) cur_relloc->addr) += corr;
+ break;
+ case 2:
+- *((grub_uint16_t *) UINT_TO_PTR (cur_relloc->addr)) += corr;
++ *((grub_uint16_t *) (grub_addr_t) cur_relloc->addr) += corr;
+ break;
+ case 1:
+- *((grub_uint8_t *) UINT_TO_PTR (cur_relloc->addr)) += corr;
++ *((grub_uint8_t *) (grub_addr_t) cur_relloc->addr) += corr;
+ break;
+ }
+ }
diff --git a/master/debian/fat_uuid.patch b/master/debian/fat_uuid.patch
new file mode 100644
index 0000000..b7c0a46
--- /dev/null
+++ b/master/debian/fat_uuid.patch
@@ -0,0 +1,25 @@
+Description: Make FAT UUID uppercase to match Linux
+Author: Vladimir Serbinenko <phcoder@gmail.com>
+Origin: upstream, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3482
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/948716
+Forwarded: not-needed
+Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3482
+Last-Update: 2012-03-19
+
+Index: b/grub-core/fs/fat.c
+===================================================================
+--- a/grub-core/fs/fat.c
++++ b/grub-core/fs/fat.c
+@@ -836,9 +836,12 @@
+ data = grub_fat_mount (disk);
+ if (data)
+ {
++ char *ptr;
+ *uuid = grub_xasprintf ("%04x-%04x",
+ (grub_uint16_t) (data->uuid >> 16),
+ (grub_uint16_t) data->uuid);
++ for (ptr = *uuid; ptr && *ptr; ptr++)
++ *ptr = grub_toupper (*ptr);
+ }
+ else
+ *uuid = NULL;
diff --git a/master/debian/gcc_4_6_space.patch b/master/debian/gcc_4_6_space.patch
new file mode 100644
index 0000000..7aaa536
--- /dev/null
+++ b/master/debian/gcc_4_6_space.patch
@@ -0,0 +1,33 @@
+Description: Build with -fno-asynchronous-unwind-tables to save space
+Author: Vladimir Serbinenko <phcoder@gmail.com>
+Origin: upstream, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3589
+Last-Update: 2012-03-06
+
+Index: b/configure.ac
+===================================================================
+--- a/configure.ac
++++ b/configure.ac
+@@ -415,6 +415,23 @@
+ fi
+ fi
+
++# By default, GCC 4.6 generates .eh_frame sections containing unwind
++# information in some cases where it previously did not. GRUB doesn't need
++# these and they just use up vital space. Restore the old compiler
++# behaviour.
++AC_CACHE_CHECK([whether -fno-asynchronous-unwind-tables works], [grub_cv_cc_fno_asynchronous_unwind_tables], [
++ SAVE_CFLAGS="$CFLAGS"
++ CFLAGS="$CFLAGS -fno-dwarf2-cfi-asm"
++ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
++ [grub_cv_cc_fno_asynchronous_unwind_tables=yes],
++ [grub_cv_cc_fno_asynchronous_unwind_tables=no])
++ CFLAGS="$SAVE_CFLAGS"
++])
++
++if test "x$grub_cv_cc_fno_asynchronous_unwind_tables" = xyes; then
++ TARGET_CFLAGS="$TARGET_CFLAGS -fno-asynchronous-unwind-tables"
++fi
++
+ grub_apple_target_cc
+ if test x$grub_cv_apple_target_cc = xyes ; then
+ TARGET_CPPFLAGS="$TARGET_CPPFLAGS -DAPPLE_CC=1"
diff --git a/master/debian/gfxpayload_keep_default.patch b/master/debian/gfxpayload_keep_default.patch
new file mode 100644
index 0000000..43cfb6f
--- /dev/null
+++ b/master/debian/gfxpayload_keep_default.patch
@@ -0,0 +1,38 @@
+Description: Disable gfxpayload=keep by default
+ Setting gfxpayload=keep has been known to cause efifb to be inappropriately
+ enabled. In any case, with the current Linux kernel the result of this
+ option is that early kernelspace will be unable to print anything to the
+ console, so (for example) if boot fails and you end up dumped to an
+ initramfs prompt, you won't be able to see anything on the screen. As such
+ it shouldn't be enabled by default in Debian, no matter what kernel options
+ are enabled.
+ .
+ gfxpayload=keep is a good idea but rather ahead of its time ...
+Author: Colin Watson <cjwatson@debian.org>
+Bug-Debian: http://bugs.debian.org/567245
+Forwarded: no
+Last-Update: 2010-03-09
+
+Index: b/util/grub.d/10_linux.in
+===================================================================
+--- a/util/grub.d/10_linux.in
++++ b/util/grub.d/10_linux.in
+@@ -77,17 +77,7 @@
+
+ # Use ELILO's generic "efifb" when it's known to be available.
+ # FIXME: We need an interface to select vesafb in case efifb can't be used.
+- if [ "x$GRUB_GFXPAYLOAD_LINUX" = x ]; then
+- cat << EOF
+- load_video
+-EOF
+- if grep -qx "CONFIG_FB_EFI=y" "${config}" 2> /dev/null \
+- && grep -qx "CONFIG_VT_HW_CONSOLE_BINDING=y" "${config}" 2> /dev/null; then
+- cat << EOF
+- set gfxpayload=keep
+-EOF
+- fi
+- else
++ if [ "x$GRUB_GFXPAYLOAD_LINUX" != x ]; then
+ if [ "x$GRUB_GFXPAYLOAD_LINUX" != xtext ]; then
+ cat << EOF
+ load_video
diff --git a/master/debian/gfxterm_background.patch b/master/debian/gfxterm_background.patch
new file mode 100644
index 0000000..6fa0ff8
--- /dev/null
+++ b/master/debian/gfxterm_background.patch
@@ -0,0 +1,69 @@
+Description: Fix gfxterm background_color regression
+Author: Colin Watson <cjwatson@ubuntu.com>
+Forwarded: http://lists.gnu.org/archive/html/grub-devel/2011-06/msg00085.html
+Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3368
+Last-Update: 2011-06-28
+
+Index: b/grub-core/term/gfxterm.c
+===================================================================
+--- a/grub-core/term/gfxterm.c
++++ b/grub-core/term/gfxterm.c
+@@ -131,6 +131,7 @@
+ static unsigned int bitmap_height;
+ static struct grub_video_bitmap *bitmap;
+ static int blend_text_bg;
++static grub_video_rgba_color_t default_bg_color = { 0, 0, 0, 0 };
+
+ static struct grub_dirty_region dirty_region;
+
+@@ -266,7 +267,8 @@
+
+ grub_video_set_active_render_target (render_target);
+
+- virtual_screen.bg_color_display = grub_video_map_rgba(0, 0, 0, 0);
++ virtual_screen.bg_color_display =
++ grub_video_map_rgba_color (default_bg_color);
+
+ /* Clear out text buffer. */
+ for (i = 0; i < virtual_screen.columns * virtual_screen.rows; i++)
+@@ -338,8 +340,8 @@
+ double_redraw = mode_info.mode_type & GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED
+ && !(mode_info.mode_type & GRUB_VIDEO_MODE_TYPE_UPDATING_SWAP);
+
+- /* Make sure screen is black. */
+- color = grub_video_map_rgb (0, 0, 0);
++ /* Make sure screen is set to the default background color. */
++ color = grub_video_map_rgba_color (default_bg_color);
+ grub_video_fill_rect (color, 0, 0, mode_info.width, mode_info.height);
+ if (double_redraw)
+ {
+@@ -1189,7 +1191,6 @@
+ grub_gfxterm_background_color_cmd (grub_command_t cmd __attribute__ ((unused)),
+ int argc, char **args)
+ {
+- grub_video_rgba_color_t color;
+ struct grub_video_render_target *old_target;
+
+ if (argc != 1)
+@@ -1199,7 +1200,7 @@
+ if (grub_video_get_info (NULL) != GRUB_ERR_NONE)
+ return grub_errno;
+
+- if (grub_video_parse_color (args[0], &color) != GRUB_ERR_NONE)
++ if (grub_video_parse_color (args[0], &default_bg_color) != GRUB_ERR_NONE)
+ return grub_errno;
+
+ /* Destroy existing background bitmap if loaded. */
+@@ -1216,9 +1217,10 @@
+ compatible with the text layer. */
+ grub_video_get_active_render_target (&old_target);
+ grub_video_set_active_render_target (text_layer);
+- virtual_screen.bg_color = grub_video_map_rgba_color (color);
++ virtual_screen.bg_color = grub_video_map_rgba_color (default_bg_color);
+ grub_video_set_active_render_target (old_target);
+- virtual_screen.bg_color_display = grub_video_map_rgba_color (color);
++ virtual_screen.bg_color_display =
++ grub_video_map_rgba_color (default_bg_color);
+ blend_text_bg = 1;
+
+ /* Mark whole screen as dirty. */
diff --git a/master/debian/grub.cfg_400.patch b/master/debian/grub.cfg_400.patch
new file mode 100644
index 0000000..1ac8d44
--- /dev/null
+++ b/master/debian/grub.cfg_400.patch
@@ -0,0 +1,15 @@
+Index: b/util/grub-mkconfig.in
+===================================================================
+--- a/util/grub-mkconfig.in
++++ b/util/grub-mkconfig.in
+@@ -293,6 +293,10 @@
+ esac
+ done
+
++if [ "x${grub_cfg}" != "x" ] && ! grep "^password " ${grub_cfg}.new >/dev/null; then
++ chmod 444 ${grub_cfg}.new || true
++fi
++
+ if test "x${grub_cfg}" != "x" ; then
+ if ! ${grub_script_check} ${grub_cfg}.new; then
+ echo "Syntax errors are detected in generated GRUB config file." >&2
diff --git a/master/debian/grub_legacy_0_based_partitions.patch b/master/debian/grub_legacy_0_based_partitions.patch
new file mode 100644
index 0000000..f245434
--- /dev/null
+++ b/master/debian/grub_legacy_0_based_partitions.patch
@@ -0,0 +1,43 @@
+Index: b/grub-core/kern/emu/hostdisk.c
+===================================================================
+--- a/grub-core/kern/emu/hostdisk.c
++++ b/grub-core/kern/emu/hostdisk.c
+@@ -1131,7 +1131,7 @@
+ char *bsd_part_str = NULL;
+
+ if (dos_part >= 0)
+- dos_part_str = xasprintf (",%d", dos_part + 1);
++ dos_part_str = xasprintf (",%d", dos_part + (getenv ("GRUB_LEGACY_0_BASED_PARTITIONS") ? 0 : 1));
+
+ if (bsd_part >= 0)
+ bsd_part_str = xasprintf (",%d", bsd_part + 1);
+@@ -1619,6 +1619,29 @@
+
+ if (start == part_start)
+ {
++ if (getenv ("GRUB_LEGACY_0_BASED_PARTITIONS"))
++ {
++ int dos_part, bsd_part;
++ char *fullname, *comma;
++
++ if (partition->parent)
++ {
++ dos_part = partition->parent->number;
++ bsd_part = partition->number;
++ }
++ else
++ {
++ dos_part = partition->number;
++ bsd_part = -1;
++ }
++
++ fullname = make_device_name (drive, dos_part, bsd_part);
++ comma = strchr (fullname, ',');
++ partname = comma ? xstrdup (comma + 1) : NULL;
++ free (fullname);
++ return 1;
++ }
++
+ partname = grub_partition_get_name (partition);
+ return 1;
+ }
diff --git a/master/debian/handle_new_autotools.patch b/master/debian/handle_new_autotools.patch
new file mode 100644
index 0000000..91f72b4
--- /dev/null
+++ b/master/debian/handle_new_autotools.patch
@@ -0,0 +1,535 @@
+Description: Handle new autotools, and add some missing quotes in the process
+ Backported by Colin Watson; I modified this to keep update-grub_lib in
+ place until such time as we upgrade to a newer upstream snapshot.
+Author: Vladimir Serbinenko <phcoder@gmail.com>
+Origin: backport, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3766
+Last-Update: 2012-01-31
+
+Index: b/Makefile.am
+===================================================================
+--- a/Makefile.am
++++ b/Makefile.am
+@@ -101,8 +101,8 @@
+ # Install config.h into platformdir
+ platform_HEADERS = config.h
+
+-pkglib_DATA += grub-mkconfig_lib
+-pkglib_DATA += update-grub_lib
++pkgdata_DATA += grub-mkconfig_lib
++pkgdata_DATA += update-grub_lib
+
+
+ if COND_i386_coreboot
+Index: b/conf/Makefile.common
+===================================================================
+--- a/conf/Makefile.common
++++ b/conf/Makefile.common
+@@ -137,7 +137,7 @@
+
+ man_MANS =
+ noinst_DATA =
+-pkglib_DATA =
++pkgdata_DATA =
+ bin_SCRIPTS =
+ sbin_SCRIPTS =
+ bin_PROGRAMS =
+@@ -147,7 +147,6 @@
+ grubconf_DATA =
+ check_PROGRAMS =
+ noinst_SCRIPTS =
+-pkglib_SCRIPTS =
+ noinst_PROGRAMS =
+ grubconf_SCRIPTS =
+ noinst_LIBRARIES =
+Index: b/tests/util/grub-shell-tester.in
+===================================================================
+--- a/tests/util/grub-shell-tester.in
++++ b/tests/util/grub-shell-tester.in
+@@ -19,18 +19,17 @@
+ # Initialize some variables.
+ transform="@program_transform_name@"
+
+-prefix=@prefix@
+-exec_prefix=@exec_prefix@
+-bindir=@bindir@
+-libdir=@libdir@
+-builddir=@builddir@
++prefix="@prefix@"
++exec_prefix="@exec_prefix@"
++datarootdir="@datarootdir@"
++builddir="@builddir@"
+ PACKAGE_NAME=@PACKAGE_NAME@
+ PACKAGE_TARNAME=@PACKAGE_TARNAME@
+ PACKAGE_VERSION=@PACKAGE_VERSION@
+ target_cpu=@target_cpu@
+
+ # Force build directory components
+-PATH=${builddir}:$PATH
++PATH="${builddir}:$PATH"
+ export PATH
+
+ # Usage: usage
+@@ -85,23 +84,23 @@
+ if [ "x${source}" = x ] ; then
+ tmpfile=`mktemp "${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` || exit 1
+ while read REPLY; do
+- echo $REPLY >> ${tmpfile}
++ echo $REPLY >> "${tmpfile}"
+ done
+- source=${tmpfile}
++ source="${tmpfile}"
+ fi
+
+ outfile1=`mktemp "${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` || exit 1
+-@builddir@/grub-shell --qemu-opts="${qemuopts}" --modules=${modules} ${source} >${outfile1}
++"@builddir@/grub-shell" --qemu-opts="${qemuopts}" --modules=${modules} "${source}" >"${outfile1}"
+
+ outfile2=`mktemp "${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` || exit 1
+-bash ${source} >${outfile2}
++bash "${source}" >"${outfile2}"
+
+-if ! diff -q ${outfile1} ${outfile2} >/dev/null
++if ! diff -q "${outfile1}" "${outfile2}" >/dev/null
+ then
+ echo "${source}: GRUB and BASH outputs did not match (see diff -u ${outfile1} ${outfile2})"
+ status=1
+ else
+- rm -f ${outfile1} ${outfile2}
++ rm -f "${outfile1}" "${outfile2}"
+ fi
+
+ exit $status
+Index: b/tests/util/grub-shell.in
+===================================================================
+--- a/tests/util/grub-shell.in
++++ b/tests/util/grub-shell.in
+@@ -19,11 +19,10 @@
+ # Initialize some variables.
+ transform="@program_transform_name@"
+
+-prefix=@prefix@
+-exec_prefix=@exec_prefix@
+-bindir=@bindir@
+-libdir=@libdir@
+-builddir=@builddir@
++prefix="@prefix@"
++exec_prefix="@exec_prefix@"
++datarootdir="@datarootdir@"
++builddir="@builddir@"
+ PACKAGE_NAME=@PACKAGE_NAME@
+ PACKAGE_TARNAME=@PACKAGE_TARNAME@
+ PACKAGE_VERSION=@PACKAGE_VERSION@
+@@ -31,7 +30,7 @@
+ platform=@platform@
+
+ # Force build directory components
+-PATH=${builddir}:$PATH
++PATH="${builddir}:$PATH"
+ export PATH
+
+ # Usage: usage
+@@ -140,9 +139,9 @@
+
+ isofile=`mktemp "${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` || exit 1
+ if [ x$boot != xnet ]; then
+- sh @builddir@/grub-mkrescue --grub-mkimage=${builddir}/grub-mkimage --output=${isofile} --override-directory=${builddir}/grub-core \
++ sh "@builddir@/grub-mkrescue" "--grub-mkimage=${builddir}/grub-mkimage" "--output=${isofile}" "--override-directory=${builddir}/grub-core" \
+ --rom-directory="${rom_directory}" \
+- /boot/grub/grub.cfg=${cfgfile} /boot/grub/testcase.cfg=${source} \
++ "/boot/grub/grub.cfg=${cfgfile}" "/boot/grub/testcase.cfg=${source}" \
+ ${files} >/dev/null 2>&1
+ fi
+ if [ x$boot = xhd ]; then
+@@ -173,12 +172,12 @@
+
+ if [ x$boot = xnet ]; then
+ netdir=`mktemp -d "${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` || exit 1
+- sh @builddir@/grub-mknetdir --grub-mkimage=${builddir}/grub-mkimage --override-directory=${builddir}/grub-core --net-directory=$netdir
+- cp ${cfgfile} $netdir/boot/grub/grub.cfg
+- cp ${source} $netdir/boot/grub/testcase.cfg
+- ${qemu} ${qemuopts} -nographic -serial file:/dev/stdout -monitor file:/dev/null -boot n -net user,tftp=$netdir,bootfile=/boot/grub/$target_cpu-$platform/core.0 -net nic | cat | tr -d "\r"
++ sh "@builddir@/grub-mknetdir" "--grub-mkimage=${builddir}/grub-mkimage" "--override-directory=${builddir}/grub-core" "--net-directory=$netdir"
++ cp "${cfgfile}" "$netdir/boot/grub/grub.cfg"
++ cp "${source}" "$netdir/boot/grub/testcase.cfg"
++ "${qemu}" ${qemuopts} -nographic -serial file:/dev/stdout -monitor file:/dev/null -boot n -net "user,tftp=$netdir,bootfile=/boot/grub/$target_cpu-$platform/core.0" -net nic | cat | tr -d "\r"
+ else
+- ${qemu} ${qemuopts} -nographic -serial file:/dev/stdout -monitor file:/dev/null -${device} ${isofile} ${bootdev} | cat | tr -d "\r"
++ "${qemu}" ${qemuopts} -nographic -serial file:/dev/stdout -monitor file:/dev/null -${device} ${isofile} ${bootdev} | cat | tr -d "\r"
+ fi
+ rm -f "${isofile}" "${imgfile}"
+ rm -rf "${rom_directory}"
+Index: b/util/grub-install.in
+===================================================================
+--- a/util/grub-install.in
++++ b/util/grub-install.in
+@@ -21,6 +21,7 @@
+
+ prefix="@prefix@"
+ exec_prefix="@exec_prefix@"
++datarootdir="@datarootdir@"
+ sbindir="@sbindir@"
+ bindir="@bindir@"
+ libdir="@libdir@"
+@@ -32,6 +33,7 @@
+ platform=@platform@
+ host_os=@host_os@
+ pkglibdir="${libdir}/`echo ${PACKAGE_TARNAME}/${target_cpu}-${platform} | sed ${transform}`"
++datadir="@datadir@"
+ localedir="@datadir@/locale"
+
+ self="`basename $0`"
+Index: b/util/grub-mkconfig.in
+===================================================================
+--- a/util/grub-mkconfig.in
++++ b/util/grub-mkconfig.in
+@@ -18,26 +18,27 @@
+ # along with GRUB. If not, see <http://www.gnu.org/licenses/>.
+
+ transform="@program_transform_name@"
+-
+-prefix=@prefix@
+-exec_prefix=@exec_prefix@
+-sbindir=@sbindir@
+-bindir=@bindir@
+-libdir=@libdir@
+-sysconfdir=@sysconfdir@
++prefix="@prefix@"
++exec_prefix="@exec_prefix@"
++datarootdir="@datarootdir@"
++
++prefix="@prefix@"
++exec_prefix="@exec_prefix@"
++sbindir="@sbindir@"
++bindir="@bindir@"
++sysconfdir="@sysconfdir@"
+ PACKAGE_NAME=@PACKAGE_NAME@
+ PACKAGE_VERSION=@PACKAGE_VERSION@
+ host_os=@host_os@
+-datarootdir=@datarootdir@
+-datadir=@datadir@
+-pkgdatadir=${datadir}/`echo @PACKAGE_TARNAME@ | sed "${transform}"`
++datadir="@datadir@"
++pkgdatadir="${datadir}/`echo @PACKAGE_TARNAME@ | sed "${transform}"`"
+ grub_cfg=""
+-grub_mkconfig_dir=${sysconfdir}/grub.d
++grub_mkconfig_dir="${sysconfdir}"/grub.d
+
+ self=`basename $0`
+
+-grub_mkdevicemap=${sbindir}/`echo grub-mkdevicemap | sed "${transform}"`
+-grub_probe=${sbindir}/`echo grub-probe | sed "${transform}"`
++grub_mkdevicemap="${sbindir}/`echo grub-mkdevicemap | sed "${transform}"`"
++grub_probe="${sbindir}/`echo grub-probe | sed "${transform}"`"
+ grub_script_check="${bindir}/`echo grub-script-check | sed "${transform}"`"
+
+ GRUB_PREFIX=`echo '/@bootdirname@/@grubdirname@' | sed "s,//*,/,g"`
+@@ -95,7 +96,7 @@
+ esac
+ done
+
+-. ${libdir}/grub/grub-mkconfig_lib
++. "${datadir}/grub/grub-mkconfig_lib"
+
+ if [ "x$EUID" = "x" ] ; then
+ EUID=`id -u`
+Index: b/util/grub-mknetdir.in
+===================================================================
+--- a/util/grub-mknetdir.in
++++ b/util/grub-mknetdir.in
+@@ -19,25 +19,23 @@
+ # Initialize some variables.
+ transform="@program_transform_name@"
+
+-prefix=@prefix@
+-exec_prefix=@exec_prefix@
+-sbindir=@sbindir@
+-bindir=@bindir@
+-libdir=@libdir@
++prefix="@prefix@"
++exec_prefix="@exec_prefix@"
++datarootdir="@datarootdir@"
++bindir="@bindir@"
++libdir="@libdir@"
+ PACKAGE_NAME=@PACKAGE_NAME@
+ PACKAGE_TARNAME=@PACKAGE_TARNAME@
+ PACKAGE_VERSION=@PACKAGE_VERSION@
+ target_cpu=@target_cpu@
+ platform=@platform@
+ host_os=@host_os@
+-pkglibdir=${libdir}/`echo ${PACKAGE_TARNAME}/${target_cpu}-${platform} | sed ${transform}`
+-localedir=@datadir@/locale
+ native_platform=@platform@
+ pkglib_DATA="moddep.lst command.lst fs.lst partmap.lst parttool.lst handler.lst video.lst crypto.lst terminal.lst"
+
+ self=`basename $0`
+
+-grub_mkimage=${bindir}/`echo grub-mkimage | sed ${transform}`
++grub_mkimage="${bindir}/`echo grub-mkimage | sed ${transform}`"
+ rootdir=/srv/tftp
+ grub_prefix=`echo /boot/grub | sed ${transform}`
+ modules=
+@@ -48,7 +46,7 @@
+ debug=no
+ debug_image=
+ subdir=`echo /boot/grub | sed ${transform}`
+-pc_dir=${libdir}/$(echo ${PACKAGE_TARNAME} | sed ${transform})/i386-pc
++pc_dir="${libdir}/$(echo ${PACKAGE_TARNAME} | sed ${transform})/i386-pc"
+
+ # Usage: usage
+ # Print the usage.
+@@ -170,12 +168,12 @@
+ config_opt=
+ mkdir -p "$grubdir" || exit 1
+
+- for file in ${grubdir}/*.mod ${grubdir}/*.lst ${grubdir}/*.img ${grubdir}/efiemu??.o; do
+- if test -f $file && [ "`basename $file`" != menu.lst ]; then
+- rm -f $file || exit 1
++ for file in "${grubdir}"/*.mod "${grubdir}"/*.lst "${grubdir}"/*.img "${grubdir}"/efiemu??.o; do
++ if test -f "$file" && [ "`basename $file`" != menu.lst ]; then
++ rm -f "$file" || exit 1
+ fi
+ done
+- for file in ${input_dir}/*.mod; do
++ for file in "${input_dir}"/*.mod; do
+ if test -f "$file"; then
+ cp -f "$file" "$grubdir/"
+ fi
+@@ -213,7 +211,7 @@
+ source ${subdir}/grub.cfg
+ EOF
+
+- $grub_mkimage ${config_opt} -d "${input_dir}" -O ${mkimage_target} --output=${grubdir}/core.$ext --prefix=$prefix $modules $netmodules || exit 1
++ "$grub_mkimage" ${config_opt} -d "${input_dir}" -O ${mkimage_target} "--output=${grubdir}/core.$ext" "--prefix=$prefix" $modules $netmodules || exit 1
+ echo "Netboot directory for ${platform} created. Configure your DHCP server to point to ${subdir}/${platform}/core.$ext"
+ }
+
+Index: b/util/grub-mkrescue.in
+===================================================================
+--- a/util/grub-mkrescue.in
++++ b/util/grub-mkrescue.in
+@@ -18,12 +18,14 @@
+ # along with GRUB. If not, see <http://www.gnu.org/licenses/>.
+
+ # Initialize some variables.
++
+ transform="@program_transform_name@"
+
+-prefix=@prefix@
+-exec_prefix=@exec_prefix@
+-bindir=@bindir@
+-libdir=@libdir@
++prefix="@prefix@"
++exec_prefix="@exec_prefix@"
++datarootdir="@datarootdir@"
++bindir="@bindir@"
++libdir="@libdir@"
+ PACKAGE_NAME=@PACKAGE_NAME@
+ PACKAGE_TARNAME=@PACKAGE_TARNAME@
+ PACKAGE_VERSION=@PACKAGE_VERSION@
+Index: b/util/grub.d/00_header.in
+===================================================================
+--- a/util/grub.d/00_header.in
++++ b/util/grub.d/00_header.in
+@@ -19,13 +19,13 @@
+
+ transform="@program_transform_name@"
+
+-prefix=@prefix@
+-exec_prefix=@exec_prefix@
+-libdir=@libdir@
++prefix="@prefix@"
++exec_prefix="@exec_prefix@"
++datarootdir="@datarootdir@"
+ locale_dir=`echo ${GRUB_PREFIX}/locale | sed ${transform}`
+ grub_lang=`echo $LANG | cut -d . -f 1`
+
+-. ${libdir}/grub/grub-mkconfig_lib
++. "@datadir@/grub/grub-mkconfig_lib"
+
+ # Do this as early as possible, since other commands might depend on it.
+ # (e.g. the `loadfont' command might need lvm or raid modules)
+@@ -112,7 +112,7 @@
+ done
+
+ if [ "x$serial" = x1 ]; then
+- if ! test -e ${GRUB_PREFIX}/serial.mod ; then
++ if ! test -e "${GRUB_PREFIX}/serial.mod" ; then
+ echo "Serial terminal not available on this platform." >&2 ; exit 1
+ fi
+
+Index: b/util/grub.d/10_hurd.in
+===================================================================
+--- a/util/grub.d/10_hurd.in
++++ b/util/grub.d/10_hurd.in
+@@ -17,10 +17,10 @@
+ # You should have received a copy of the GNU General Public License
+ # along with GRUB. If not, see <http://www.gnu.org/licenses/>.
+
+-prefix=@prefix@
+-exec_prefix=@exec_prefix@
+-libdir=@libdir@
+-. ${libdir}/grub/grub-mkconfig_lib
++prefix="@prefix@"
++exec_prefix="@exec_prefix@"
++datarootdir="@datarootdir@"
++. "@datadir@/grub/grub-mkconfig_lib"
+
+ CLASS="--class gnu --class os"
+
+Index: b/util/grub.d/10_kfreebsd.in
+===================================================================
+--- a/util/grub.d/10_kfreebsd.in
++++ b/util/grub.d/10_kfreebsd.in
+@@ -17,14 +17,13 @@
+ # You should have received a copy of the GNU General Public License
+ # along with GRUB. If not, see <http://www.gnu.org/licenses/>.
+
+-prefix=@prefix@
+-exec_prefix=@exec_prefix@
+-bindir=@bindir@
+-libdir=@libdir@
+-. ${libdir}/grub/grub-mkconfig_lib
++prefix="@prefix@"
++exec_prefix="@exec_prefix@"
++datarootdir="@datarootdir@"
++. "@datadir@/grub/grub-mkconfig_lib"
+
+ export TEXTDOMAIN=@PACKAGE@
+-export TEXTDOMAINDIR=@localedir@
++export TEXTDOMAINDIR="@localedir@"
+
+ CLASS="--class os"
+
+Index: b/util/grub.d/10_linux.in
+===================================================================
+--- a/util/grub.d/10_linux.in
++++ b/util/grub.d/10_linux.in
+@@ -17,14 +17,14 @@
+ # You should have received a copy of the GNU General Public License
+ # along with GRUB. If not, see <http://www.gnu.org/licenses/>.
+
+-prefix=@prefix@
+-exec_prefix=@exec_prefix@
+-bindir=@bindir@
+-libdir=@libdir@
+-. ${libdir}/grub/grub-mkconfig_lib
++prefix="@prefix@"
++exec_prefix="@exec_prefix@"
++datarootdir="@datarootdir@"
++
++. "@datadir@/grub/grub-mkconfig_lib"
+
+ export TEXTDOMAIN=@PACKAGE@
+-export TEXTDOMAINDIR=@localedir@
++export TEXTDOMAINDIR="@localedir@"
+
+ CLASS="--class gnu-linux --class gnu --class os"
+
+Index: b/util/grub.d/10_netbsd.in
+===================================================================
+--- a/util/grub.d/10_netbsd.in
++++ b/util/grub.d/10_netbsd.in
+@@ -17,14 +17,13 @@
+ # You should have received a copy of the GNU General Public License
+ # along with GRUB. If not, see <http://www.gnu.org/licenses/>.
+
+-prefix=@prefix@
+-exec_prefix=@exec_prefix@
+-bindir=@bindir@
+-libdir=@libdir@
+-. ${libdir}/grub/grub-mkconfig_lib
++prefix="@prefix@"
++exec_prefix="@exec_prefix@"
++datarootdir="@datarootdir@"
++. "@datadir@/grub/grub-mkconfig_lib"
+
+ export TEXTDOMAIN=@PACKAGE@
+-export TEXTDOMAINDIR=@localedir@
++export TEXTDOMAINDIR="@localedir@"
+
+ if [ "x${GRUB_DISTRIBUTOR}" = "x" ] ; then
+ OS="NetBSD"
+Index: b/util/grub.d/10_windows.in
+===================================================================
+--- a/util/grub.d/10_windows.in
++++ b/util/grub.d/10_windows.in
+@@ -17,10 +17,11 @@
+ # You should have received a copy of the GNU General Public License
+ # along with GRUB. If not, see <http://www.gnu.org/licenses/>.
+
+-prefix=@prefix@
+-exec_prefix=@exec_prefix@
+-libdir=@libdir@
+-. ${libdir}/grub/grub-mkconfig_lib
++prefix="@prefix@"
++exec_prefix="@exec_prefix@"
++datarootdir="@datarootdir@"
++
++. "@datadir@/grub/grub-mkconfig_lib"
+
+ case "`uname 2>/dev/null`" in
+ CYGWIN*) ;;
+Index: b/util/grub.d/20_linux_xen.in
+===================================================================
+--- a/util/grub.d/20_linux_xen.in
++++ b/util/grub.d/20_linux_xen.in
+@@ -17,14 +17,14 @@
+ # You should have received a copy of the GNU General Public License
+ # along with GRUB. If not, see <http://www.gnu.org/licenses/>.
+
+-prefix=@prefix@
+-exec_prefix=@exec_prefix@
+-bindir=@bindir@
+-libdir=@libdir@
+-. ${libdir}/grub/grub-mkconfig_lib
++prefix="@prefix@"
++exec_prefix="@exec_prefix@"
++datarootdir="@datarootdir@"
++
++. "@datadir@/grub/grub-mkconfig_lib"
+
+ export TEXTDOMAIN=@PACKAGE@
+-export TEXTDOMAINDIR=@localedir@
++export TEXTDOMAINDIR="@localedir@"
+
+ CLASS="--class gnu-linux --class gnu --class os --class xen"
+
+Index: b/util/grub.d/30_os-prober.in
+===================================================================
+--- a/util/grub.d/30_os-prober.in
++++ b/util/grub.d/30_os-prober.in
+@@ -17,11 +17,11 @@
+ # You should have received a copy of the GNU General Public License
+ # along with GRUB. If not, see <http://www.gnu.org/licenses/>.
+
+-prefix=@prefix@
+-exec_prefix=@exec_prefix@
+-libdir=@libdir@
++prefix="@prefix@"
++exec_prefix="@exec_prefix@"
++datarootdir="@datarootdir@"
+
+-. ${libdir}/grub/grub-mkconfig_lib
++. "@datadir@/grub/grub-mkconfig_lib"
+
+ if [ "x${GRUB_DISABLE_OS_PROBER}" = "xtrue" ]; then
+ exit 0
+Index: b/util/update-grub_lib.in
+===================================================================
+--- a/util/update-grub_lib.in
++++ b/util/update-grub_lib.in
+@@ -14,10 +14,10 @@
+ # You should have received a copy of the GNU General Public License
+ # along with GRUB. If not, see <http://www.gnu.org/licenses/>.
+
+-prefix=@prefix@
+-exec_prefix=@exec_prefix@
+-libdir=@libdir@
++prefix="@prefix@"
++exec_prefix="@exec_prefix@"
++datarootdir="@datarootdir@"
+
+-. ${libdir}/grub/grub-mkconfig_lib
++. "@datadir@/grub/grub-mkconfig_lib"
+
+ grub_warn "update-grub_lib is deprecated, use grub-mkconfig_lib instead"
diff --git a/master/debian/hurd.patch b/master/debian/hurd.patch
new file mode 100644
index 0000000..cb04f13
--- /dev/null
+++ b/master/debian/hurd.patch
@@ -0,0 +1,37 @@
+Description: Fix hurd build by disabling zfs code.
+Author: Samuel Thibault <samuel.thibault@ens-lyon.org>
+Origin: upstream, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/4237
+Forwarded: not-needed
+Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/4237
+Last-Update: 2012-06-08
+
+--- a/grub-core/kern/emu/getroot.c 2012-04-21 14:49:56 +0000
++++ b/grub-core/kern/emu/getroot.c 2012-04-22 19:02:55 +0000
+@@ -241,6 +241,8 @@
+
+ #endif /* __linux__ */
+
++#if !defined (__GNU__)
++
+ static char *
+ find_device_from_pool (const char *poolname)
+ {
+@@ -322,6 +323,8 @@
+ return device;
+ }
+
++#endif
++
+ #ifdef __MINGW32__
+
+ char *
+@@ -331,6 +331,8 @@
+ return 0;
+ }
+
++#elif defined (__GNU__)
++
+ #elif ! defined(__CYGWIN__)
+
+ char *
+
diff --git a/master/debian/install_stage2_confusion.patch b/master/debian/install_stage2_confusion.patch
new file mode 100644
index 0000000..ff840ef
--- /dev/null
+++ b/master/debian/install_stage2_confusion.patch
@@ -0,0 +1,24 @@
+Description: If GRUB Legacy is still around, tell packaging to ignore it
+Author: Colin Watson <cjwatson@debian.org>
+Bug-Debian: http://bugs.debian.org/586143
+Forwarded: not-needed
+Last-Update: 2010-06-18
+
+Index: b/util/grub-install.in
+===================================================================
+--- a/util/grub-install.in
++++ b/util/grub-install.in
+@@ -660,6 +660,13 @@
+ fi
+ fi
+
++# If vestiges of GRUB Legacy still exist, tell the Debian packaging that
++# they can ignore them.
++if test -z "$rootdir" && \
++ test -e /boot/grub/stage2 && test -e /boot/grub/menu.lst; then
++ touch /boot/grub/grub2-installed
++fi
++
+ echo "Installation finished. No error reported."
+
+ # Bye.
diff --git a/master/debian/kfreebsd-9_ada_devices.patch b/master/debian/kfreebsd-9_ada_devices.patch
new file mode 100644
index 0000000..e1c22e4
--- /dev/null
+++ b/master/debian/kfreebsd-9_ada_devices.patch
@@ -0,0 +1,71 @@
+2011-06-16 Robert Millan <rmh@gnu.org>
+
+ Detect `ataraid' devices on GNU/kFreeBSD. Fix for ATA devices using
+ `ata' driver on kernel of FreeBSD 9.
+
+ * util/deviceiter.c [__FreeBSD_kernel__] (get_ada_disk_name)
+ (get_ataraid_disk_name): New functions.
+ [__FreeBSD_kernel__] (grub_util_iterate_devices): Scan for ataraid
+ (/dev/ar[0-9]+) and ada (/dev/ada[0-9]+) devices using
+ get_ataraid_disk_name() and get_ada_disk_name().
+
+=== modified file 'util/deviceiter.c'
+--- a/util/deviceiter.c
++++ b/util/deviceiter.c
+@@ -286,6 +286,20 @@
+ #endif
+ }
+
++#ifdef __FreeBSD_kernel__
++static void
++get_ada_disk_name (char *name, int unit)
++{
++ sprintf (name, "/dev/ada%d", unit);
++}
++
++static void
++get_ataraid_disk_name (char *name, int unit)
++{
++ sprintf (name, "/dev/ar%d", unit);
++}
++#endif
++
+ #ifdef __linux__
+ static void
+ get_virtio_disk_name (char *name, int unit)
+@@ -620,6 +634,35 @@
+ }
+ }
+
++#ifdef __FreeBSD_kernel__
++ /* IDE disks using ATA Direct Access driver. */
++ if (get_kfreebsd_version () >= 800000)
++ for (i = 0; i < 96; i++)
++ {
++ char name[16];
++
++ get_ada_disk_name (name, i);
++ if (check_device_readable_unique (name))
++ {
++ if (hook (name, 0))
++ goto out;
++ }
++ }
++
++ /* ATARAID disks. */
++ for (i = 0; i < 8; i++)
++ {
++ char name[20];
++
++ get_ataraid_disk_name (name, i);
++ if (check_device_readable_unique (name))
++ {
++ if (hook (name, 0))
++ goto out;
++ }
++ }
++#endif
++
+ #ifdef __linux__
+ /* Virtio disks. */
+ for (i = 0; i < 26; i++)
diff --git a/master/debian/kfreebsd_lvm.patch b/master/debian/kfreebsd_lvm.patch
new file mode 100644
index 0000000..8583cc9
--- /dev/null
+++ b/master/debian/kfreebsd_lvm.patch
@@ -0,0 +1,187 @@
+2011-10-09 Robert Millan <rmh@gnu.org>
+
+ LVM support for FreeBSD and GNU/kFreeBSD.
+
+ * util/lvm.c (grub_util_lvm_isvolume): Enable on FreeBSD and
+ GNU/kFreeBSD.
+ (LVM_DEV_MAPPER_STRING): Move from here ...
+ * include/grub/util/lvm.h (LVM_DEV_MAPPER_STRING): ... to here.
+ * util/getroot.c: Include `<grub/util/lvm.h>'.
+ (grub_util_get_dev_abstraction): Enable
+ grub_util_biosdisk_is_present() on FreeBSD and GNU/kFreeBSD.
+ Check for LVM abstraction on FreeBSD and GNU/kFreeBSD.
+ (grub_util_get_grub_dev): Replace "/dev/mapper/" with
+ `LVM_DEV_MAPPER_STRING'. Enable LVM and mdRAID only on platforms that
+ support it.
+ * util/grub-setup.c (main): Check for LVM also on FreeBSD and
+ GNU/kFreeBSD.
+ * util/grub.d/10_kfreebsd.in: Load `geom_linux_lvm' kernel module
+ when LVM abstraction is required for ${GRUB_DEVICE}.
+
+--- a/grub-core/kern/emu/getroot.c
++++ b/grub-core/kern/emu/getroot.c
+@@ -33,6 +33,7 @@
+ #include <stdlib.h>
+ #include <stdint.h>
+ #include <grub/util/misc.h>
++#include <grub/util/lvm.h>
+
+ #ifdef HAVE_DEVICE_MAPPER
+ # include <libdevmapper.h>
+@@ -709,11 +710,13 @@
+ int
+ grub_util_get_dev_abstraction (const char *os_dev __attribute__((unused)))
+ {
+-#ifdef __linux__
++#if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+ /* User explicitly claims that this drive is visible by BIOS. */
+ if (grub_util_biosdisk_is_present (os_dev))
+ return GRUB_DEV_ABSTRACTION_NONE;
++#endif
+
++#if defined(__linux__)
+ /* Check for LVM. */
+ if (grub_util_is_lvm (os_dev))
+ return GRUB_DEV_ABSTRACTION_LVM;
+@@ -723,6 +726,12 @@
+ return GRUB_DEV_ABSTRACTION_RAID;
+ #endif
+
++#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
++ /* Check for LVM. */
++ if (!strncmp (os_dev, LVM_DEV_MAPPER_STRING, sizeof(LVM_DEV_MAPPER_STRING)-1))
++ return GRUB_DEV_ABSTRACTION_LVM;
++#endif
++
+ /* No abstraction found. */
+ return GRUB_DEV_ABSTRACTION_NONE;
+ }
+@@ -815,11 +824,12 @@
+
+ switch (grub_util_get_dev_abstraction (os_dev))
+ {
++#if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+ case GRUB_DEV_ABSTRACTION_LVM:
+
+ {
+ unsigned short i, len;
+- grub_size_t offset = sizeof ("/dev/mapper/") - 1;
++ grub_size_t offset = sizeof (LVM_DEV_MAPPER_STRING) - 1;
+
+ len = strlen (os_dev) - offset + 1;
+ grub_dev = xmalloc (len);
+@@ -833,7 +843,9 @@
+ }
+
+ break;
++#endif
+
++#ifdef __linux__
+ case GRUB_DEV_ABSTRACTION_RAID:
+
+ if (os_dev[7] == '_' && os_dev[8] == 'd')
+@@ -909,7 +921,6 @@
+ else
+ grub_util_error ("unknown kind of RAID device `%s'", os_dev);
+
+-#ifdef __linux__
+ {
+ char *mdadm_name = get_mdadm_uuid (os_dev);
+ struct stat st;
+@@ -934,9 +945,8 @@
+ free (mdadm_name);
+ }
+ }
+-#endif /* __linux__ */
+-
+ break;
++#endif /* __linux__ */
+
+ default: /* GRUB_DEV_ABSTRACTION_NONE */
+ grub_dev = grub_util_biosdisk_get_grub_dev (os_dev);
+--- a/include/grub/util/lvm.h
++++ b/include/grub/util/lvm.h
+@@ -20,7 +20,14 @@
+ #ifndef GRUB_LVM_UTIL_HEADER
+ #define GRUB_LVM_UTIL_HEADER 1
+
++#if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
++
+ #ifdef __linux__
++#define LVM_DEV_MAPPER_STRING "/dev/mapper/"
++#else
++#define LVM_DEV_MAPPER_STRING "/dev/linux_lvm/"
++#endif
++
+ int grub_util_lvm_isvolume (char *name);
+ #endif
+
+--- a/util/grub-setup.c
++++ b/util/grub-setup.c
+@@ -959,10 +959,12 @@
+ arguments.dir ? : DEFAULT_DIRECTORY);
+ }
+
+-#ifdef __linux__
++#if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+ if (grub_util_lvm_isvolume (root_dev))
+ must_embed = 1;
++#endif
+
++#ifdef __linux__
+ if (root_dev[0] == 'm' && root_dev[1] == 'd'
+ && ((root_dev[2] >= '0' && root_dev[2] <= '9') || root_dev[2] == '/'))
+ {
+--- a/util/grub.d/10_kfreebsd.in
++++ b/util/grub.d/10_kfreebsd.in
+@@ -98,6 +98,23 @@
+
+ load_kfreebsd_module acpi true
+
++ for abstraction in dummy $(grub-probe -t abstraction --device ${GRUB_DEVICE}) ; do
++ case $abstraction in
++ lvm) load_kfreebsd_module geom_linux_lvm false ;;
++ esac
++ done
++
++ case "$(grub-probe -t abstraction --device ${GRUB_DEVICE})" in
++ lvm)
++ test -e "${module_dir}/geom_linux_lvm.ko"
++
++ printf '%s\n' "${prepare_module_dir_cache}"
++ cat << EOF
++ kfreebsd_module_elf ${module_dir_rel}/geom_linux_lvm.ko
++EOF
++ ;;
++ esac
++
+ case "${kfreebsd_fs}" in
+ zfs)
+ load_kfreebsd_module opensolaris false
+--- a/util/lvm.c
++++ b/util/lvm.c
+@@ -17,8 +17,7 @@
+ * along with GRUB. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+-/* We only support LVM on Linux. */
+-#ifdef __linux__
++#if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+ #include <grub/emu/misc.h>
+ #include <grub/util/misc.h>
+ #include <grub/util/lvm.h>
+@@ -26,8 +25,6 @@
+ #include <string.h>
+ #include <sys/stat.h>
+
+-#define LVM_DEV_MAPPER_STRING "/dev/mapper/"
+-
+ int
+ grub_util_lvm_isvolume (char *name)
+ {
+@@ -49,4 +46,4 @@
+ return 1;
+ }
+
+-#endif /* ! __linux__ */
++#endif
diff --git a/master/debian/kfreebsd_mfi_devices.patch b/master/debian/kfreebsd_mfi_devices.patch
new file mode 100644
index 0000000..6b0992e
--- /dev/null
+++ b/master/debian/kfreebsd_mfi_devices.patch
@@ -0,0 +1,35 @@
+--- a/util/deviceiter.c
++++ b/util/deviceiter.c
+@@ -298,6 +298,12 @@
+ {
+ sprintf (name, "/dev/ar%d", unit);
+ }
++
++static void
++get_mfi_disk_name (char *name, int unit)
++{
++ sprintf (name, "/dev/mfid%d", unit);
++}
+ #endif
+
+ #ifdef __linux__
+@@ -658,6 +664,19 @@
+ if (check_device_readable_unique (name))
+ {
+ if (hook (name, 0))
++ goto out;
++ }
++ }
++
++ /* LSI MegaRAID SAS. */
++ for (i = 0; i < 32; i++)
++ {
++ char name[20];
++
++ get_mfi_disk_name (name, i);
++ if (check_device_readable_unique (name))
++ {
++ if (hook (name, 0))
+ goto out;
+ }
+ }
diff --git a/master/debian/lazy_stat.patch b/master/debian/lazy_stat.patch
new file mode 100644
index 0000000..b2cdfd2
--- /dev/null
+++ b/master/debian/lazy_stat.patch
@@ -0,0 +1,73 @@
+Description: Don't stat devices unless we have to
+Author: Vladimir Serbinenko <phcoder@gmail.com>
+Author: Colin Watson <cjwatson@ubuntu.com>
+Bug-Debian: http://bugs.debian.org/627587
+Forwarded: yes
+Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3318
+Last-Update: 2011-05-31
+
+Index: b/grub-core/kern/emu/getroot.c
+===================================================================
+--- a/grub-core/kern/emu/getroot.c
++++ b/grub-core/kern/emu/getroot.c
+@@ -358,7 +358,7 @@
+
+ if (S_ISLNK (st.st_mode)) {
+ #ifdef __linux__
+- if (strcmp (dir, "mapper") == 0) {
++ if (strcmp (dir, "mapper") == 0 || strcmp (dir, "/dev/mapper") == 0) {
+ /* Follow symbolic links under /dev/mapper/; the canonical name
+ may be something like /dev/dm-0, but the names under
+ /dev/mapper/ are more human-readable and so we prefer them if
+@@ -609,20 +609,27 @@
+
+ if (os_dev)
+ {
+- if (stat (os_dev, &st) >= 0)
+- dev = st.st_rdev;
+- else
+- grub_util_error ("cannot stat `%s'", os_dev);
+- free (os_dev);
++ char *tmp = os_dev;
++ os_dev = canonicalize_file_name (os_dev);
++ free (tmp);
+ }
+- else
++
++ if (os_dev)
+ {
+- if (stat (dir, &st) >= 0)
+- dev = st.st_dev;
+- else
+- grub_util_error ("cannot stat `%s'", dir);
++ if (strncmp (os_dev, "/dev/dm-", sizeof ("/dev/dm-") - 1) != 0)
++ return os_dev;
++ if (stat (os_dev, &st) < 0)
++ grub_util_error ("cannot stat `%s'", os_dev);
++ free (os_dev);
++ dev = st.st_rdev;
++ return grub_find_device ("/dev/mapper", dev);
+ }
+
++ if (stat (dir, &st) < 0)
++ grub_util_error ("cannot stat `%s'", dir);
++
++ dev = st.st_dev;
++
+ #ifdef __CYGWIN__
+ /* Cygwin specific function. */
+ os_dev = grub_find_device (dir, dev);
+Index: b/grub-core/kern/emu/hostdisk.c
+===================================================================
+--- a/grub-core/kern/emu/hostdisk.c
++++ b/grub-core/kern/emu/hostdisk.c
+@@ -1420,7 +1420,8 @@
+ if (tree)
+ dm_tree_free (tree);
+ free (path);
+- char *ret = grub_find_device (NULL, (major << 8) | minor);
++ char *ret = grub_find_device ("/dev/mapper",
++ (major << 8) | minor);
+ return ret;
+ }
+
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)
diff --git a/master/debian/mkconfig_gnumach.patch b/master/debian/mkconfig_gnumach.patch
new file mode 100644
index 0000000..2c28ef5
--- /dev/null
+++ b/master/debian/mkconfig_gnumach.patch
@@ -0,0 +1,53 @@
+Description: Add support for GRUB_CMDLINE_GNUMACH
+Author: Samuel Thibault <samuel.thibault@ens-lyon.org>
+Origin: upstream, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3942
+Last-Update: 2012-03-05
+
+Index: b/docs/grub.texi
+===================================================================
+--- a/docs/grub.texi
++++ b/docs/grub.texi
+@@ -1167,6 +1167,9 @@
+ As @samp{GRUB_CMDLINE_LINUX} and @samp{GRUB_CMDLINE_LINUX_DEFAULT}, but for
+ NetBSD.
+
++@item GRUB_CMDLINE_GNUMACH
++As @samp{GRUB_CMDLINE_LINUX}, but for GNU Mach.
++
+ @item GRUB_CMDLINE_XEN
+ @itemx GRUB_CMDLINE_XEN_DEFAULT
+ The values of these options are appended to the values of
+Index: b/util/grub-mkconfig.in
+===================================================================
+--- a/util/grub-mkconfig.in
++++ b/util/grub-mkconfig.in
+@@ -244,6 +244,7 @@
+ GRUB_CMDLINE_LINUX_XEN_REPLACE_DEFAULT \
+ GRUB_CMDLINE_NETBSD \
+ GRUB_CMDLINE_NETBSD_DEFAULT \
++ GRUB_CMDLINE_GNUMACH \
+ GRUB_TERMINAL_INPUT \
+ GRUB_TERMINAL_OUTPUT \
+ GRUB_SERIAL_COMMAND \
+Index: b/util/grub.d/10_hurd.in
+===================================================================
+--- a/util/grub.d/10_hurd.in
++++ b/util/grub.d/10_hurd.in
+@@ -84,7 +84,7 @@
+ message="$(gettext_printf "Loading GNU Mach ...")"
+ cat << EOF
+ echo '$message'
+- multiboot ${kernel} root=device:${GRUB_DEVICE#/dev/}
++ multiboot ${kernel} root=device:${GRUB_DEVICE#/dev/} ${GRUB_CMDLINE_GNUMACH}
+ EOF
+ save_default_entry | sed -e "s/^/\t/"
+ prepare_grub_to_access_device ${GRUB_DEVICE} | sed -e "s/^/\t/"
+@@ -108,7 +108,7 @@
+ message="$(gettext_printf "Loading GNU Mach ...")"
+ cat << EOF
+ echo '$message'
+- multiboot ${kernel} root=device:${GRUB_DEVICE#/dev/} -s
++ multiboot ${kernel} root=device:${GRUB_DEVICE#/dev/} -s ${GRUB_CMDLINE_GNUMACH}
+ EOF
+ prepare_grub_to_access_device ${GRUB_DEVICE} | sed -e "s/^/\t/"
+ message="$(gettext_printf "Loading the Hurd ...")"
diff --git a/master/debian/mkconfig_loopback.patch b/master/debian/mkconfig_loopback.patch
new file mode 100644
index 0000000..1c04063
--- /dev/null
+++ b/master/debian/mkconfig_loopback.patch
@@ -0,0 +1,84 @@
+Description: Handle filesystems loop-mounted on file images
+ Improve prepare_grub_to_access_device to emit appropriate commands for such
+ filesystems, and ignore them in Linux grub.d scripts.
+ .
+ This is needed for Ubuntu's Wubi installation method.
+ .
+ This patch isn't inherently Debian/Ubuntu-specific. losetup and
+ /proc/mounts are Linux-specific, though, so we might need to refine this
+ before sending it upstream. The changes to the Linux grub.d scripts might
+ be better handled by integrating 10_lupin properly instead.
+
+Index: b/util/grub-mkconfig_lib.in
+===================================================================
+--- a/util/grub-mkconfig_lib.in
++++ b/util/grub-mkconfig_lib.in
+@@ -105,6 +105,21 @@
+ {
+ device="$1"
+
++ loop_file=
++ case ${device} in
++ /dev/loop/*|/dev/loop[0-9])
++ grub_loop_device="${device#/dev/}"
++ loop_file=`losetup "${device}" | sed -e "s/^[^(]*(\([^)]\+\)).*/\1/"`
++ case $loop_file in
++ /dev/*) ;;
++ *)
++ loop_device="${device}"
++ device=`"${grub_probe}" --target=device "${loop_file}"`
++ ;;
++ esac
++ ;;
++ esac
++
+ if dmsetup status $device 2>/dev/null | grep -q 'crypt[[:space:]]$'; then
+ grub_warn \
+ "$device is a crypto device, which GRUB cannot read directly. Some" \
+@@ -141,6 +156,14 @@
+ if fs_uuid="`"${grub_probe}" --device "${device}" --target=fs_uuid 2> /dev/null`" ; then
+ echo "search --no-floppy --fs-uuid --set=root ${fs_uuid}"
+ fi
++
++ if [ "x${loop_file}" != x ]; then
++ loop_mountpoint="$(awk '"'${loop_file}'" ~ "^"$2 && $2 != "/" { print $2 }' /proc/mounts | tail -n1)"
++ if [ "x${loop_mountpoint}" != x ]; then
++ echo "loopback ${grub_loop_device} ${loop_file#$loop_mountpoint}"
++ echo "set root=(${grub_loop_device})"
++ fi
++ fi
+ }
+
+ grub_file_is_not_garbage ()
+Index: b/util/grub.d/10_linux.in
+===================================================================
+--- a/util/grub.d/10_linux.in
++++ b/util/grub.d/10_linux.in
+@@ -40,6 +40,11 @@
+ case ${GRUB_DEVICE} in
+ /dev/loop/*|/dev/loop[0-9])
+ GRUB_DEVICE=`losetup ${GRUB_DEVICE} | sed -e "s/^[^(]*(\([^)]\+\)).*/\1/"`
++ # We can't cope with devices loop-mounted from files here.
++ case ${GRUB_DEVICE} in
++ /dev/*) ;;
++ *) exit 0 ;;
++ esac
+ ;;
+ esac
+
+Index: b/util/grub.d/20_linux_xen.in
+===================================================================
+--- a/util/grub.d/20_linux_xen.in
++++ b/util/grub.d/20_linux_xen.in
+@@ -40,6 +40,11 @@
+ case ${GRUB_DEVICE} in
+ /dev/loop/*|/dev/loop[0-9])
+ GRUB_DEVICE=`losetup ${GRUB_DEVICE} | sed -e "s/^[^(]*(\([^)]\+\)).*/\1/"`
++ # We can't cope with devices loop-mounted from files here.
++ case ${GRUB_DEVICE} in
++ /dev/*) ;;
++ *) exit 0 ;;
++ esac
+ ;;
+ esac
+
diff --git a/master/debian/mkconfig_skip_dmcrypt.patch b/master/debian/mkconfig_skip_dmcrypt.patch
new file mode 100644
index 0000000..4e74652
--- /dev/null
+++ b/master/debian/mkconfig_skip_dmcrypt.patch
@@ -0,0 +1,30 @@
+Description: Warn and return without error if /boot is a dm-crypt device
+ With any luck the administrator knows what they're doing; in any event, we
+ probably can't improve matters by having update-grub exit non-zero.
+Author: Marc Haber <mh+debian-bugs@zugschlus.de>
+Author: Colin Watson <cjwatson@debian.org>
+Origin: other, http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=542165#25
+Bug-Debian: http://bugs.debian.org/542165
+Forwarded: no
+Last-Update: 2010-06-05
+
+Index: b/util/grub-mkconfig_lib.in
+===================================================================
+--- a/util/grub-mkconfig_lib.in
++++ b/util/grub-mkconfig_lib.in
+@@ -105,6 +105,15 @@
+ {
+ device="$1"
+
++ if dmsetup status $device 2>/dev/null | grep -q 'crypt[[:space:]]$'; then
++ grub_warn \
++ "$device is a crypto device, which GRUB cannot read directly. Some" \
++ "necessary modules may be missing from /boot/grub/grub.cfg. You may" \
++ "need to list them in GRUB_PRELOAD_MODULES in /etc/default/grub. See" \
++ "http://bugs.debian.org/542165 for details."
++ return 0
++ fi
++
+ # Abstraction modules aren't auto-loaded.
+ abstraction="`"${grub_probe}" --device "${device}" --target=abstraction`"
+ for module in ${abstraction} ; do
diff --git a/master/debian/mkconfig_skip_readme.patch b/master/debian/mkconfig_skip_readme.patch
new file mode 100644
index 0000000..e354c2c
--- /dev/null
+++ b/master/debian/mkconfig_skip_readme.patch
@@ -0,0 +1,20 @@
+Description: Skip */README* as well as README*
+Author: Colin Watson <cjwatson@ubuntu.com>
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/537123
+Forwarded: yes
+Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3422
+Last-Update: 2011-09-05
+
+Index: b/util/grub-mkconfig_lib.in
+===================================================================
+--- a/util/grub-mkconfig_lib.in
++++ b/util/grub-mkconfig_lib.in
+@@ -171,7 +171,7 @@
+ if test -f "$1" ; then
+ case "$1" in
+ *.dpkg-*) return 1 ;; # debian dpkg
+- README*) return 1 ;; # documentation
++ README*|*/README*) return 1 ;; # documentation
+ esac
+ else
+ return 1
diff --git a/master/debian/mkrescue_diet.patch b/master/debian/mkrescue_diet.patch
new file mode 100644
index 0000000..57246b2
--- /dev/null
+++ b/master/debian/mkrescue_diet.patch
@@ -0,0 +1,54 @@
+Description: Allow reducing size of xorriso-created rescue images
+ This lets us create smaller images that will fit on floppy disks. It has
+ been approved by the upstream maintainer but has not yet been applied.
+Author: Thomas Schmitt <scdbackup@gmx.net>
+Origin: other, http://lists.gnu.org/archive/html/grub-devel/2010-05/msg00100.html
+Forwarded: yes
+Last-Update: 2010-06-02
+
+Index: b/util/grub-mkrescue.in
+===================================================================
+--- a/util/grub-mkrescue.in
++++ b/util/grub-mkrescue.in
+@@ -44,6 +44,7 @@
+ grub_mkimage=${bindir}/`echo grub-mkimage | sed ${transform}`
+
+ xorriso=xorriso
++diet=no
+
+ # Usage: usage
+ # Print the usage.
+@@ -59,6 +60,7 @@
+ --rom-directory=DIR save rom images in DIR [optional]
+ --xorriso=FILE use FILE as xorriso [optional]
+ --grub-mkimage=FILE use FILE as grub-mkimage
++ --diet apply size reducing measures [optional]
+
+ $self generates a bootable rescue image with specified source files, source
+ directories, or mkisofs options listed by: xorriso -as mkisofs -help
+@@ -133,6 +135,9 @@
+ --xorriso=*)
+ xorriso=`echo "${option}/" | sed 's/--xorriso=//'` ;;
+
++ --diet)
++ diet=yes ;;
++
+ *)
+ source="${source} ${option} $@"; break ;;
+ esac
+@@ -307,7 +312,14 @@
+ fi
+
+ # build iso image
+-"${xorriso}" -as mkisofs -graft-points ${grub_mkisofs_arguments} --protective-msdos-label -o ${output_image} -r ${iso9660_dir} --sort-weight 0 / --sort-weight 1 /boot ${source}
++if [ "${diet}" = yes ]; then
++ if [ -e "${output_image}" ]; then
++ rm "${output_image}" || exit 1
++ fi
++ "${xorriso}" -report_about HINT -as mkisofs -graft-points -no-pad ${grub_mkisofs_arguments} --protective-msdos-label -r ${iso9660_dir} --sort-weight 0 / --sort-weight 1 /boot ${source} | cat >"${output_image}"
++else
++ "${xorriso}" -report_about HINT -as mkisofs -graft-points ${grub_mkisofs_arguments} --protective-msdos-label -o ${output_image} -r ${iso9660_dir} --sort-weight 0 / --sort-weight 1 /boot ${source}
++fi
+ rm -rf ${iso9660_dir}
+
+ rm -f ${embed_img}
diff --git a/master/debian/mkrescue_efi_modules.patch b/master/debian/mkrescue_efi_modules.patch
new file mode 100644
index 0000000..47029f4
--- /dev/null
+++ b/master/debian/mkrescue_efi_modules.patch
@@ -0,0 +1,22 @@
+Description: Build part_msdos and vfat into EFI boot images
+Author: Mario Limonciello <Mario_Limonciello@dell.com>
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/677758
+Forwarded: http://lists.gnu.org/archive/html/grub-devel/2011-01/msg00028.html
+Last-Update: 2011-04-11
+
+Index: b/util/grub-mkrescue.in
+===================================================================
+--- a/util/grub-mkrescue.in
++++ b/util/grub-mkrescue.in
+@@ -288,9 +288,9 @@
+ mkdir -p "${efi_dir}/efi/boot"
+
+ # build bootx64.efi
+- make_image "${efi64_dir}" x86_64-efi "${efi_dir}"/efi/boot/bootx64.efi ""
++ make_image "${efi64_dir}" x86_64-efi "${efi_dir}"/efi/boot/bootx64.efi "part_msdos fat"
+ # build bootia32.efi
+- make_image "${efi32_dir}" i386-efi "${efi_dir}"/efi/boot/bootia32.efi ""
++ make_image "${efi32_dir}" i386-efi "${efi_dir}"/efi/boot/bootia32.efi "part_msdos fat"
+ if [ -e "${efi_dir}"/efi/boot/bootia32.efi ]; then
+ # For old macs. Suggested by Peter Jones.
+ cp "${efi_dir}"/efi/boot/bootia32.efi "${efi_dir}"/efi/boot/boot.efi
diff --git a/master/debian/no_libzfs.patch b/master/debian/no_libzfs.patch
new file mode 100644
index 0000000..5b9b7eb
--- /dev/null
+++ b/master/debian/no_libzfs.patch
@@ -0,0 +1,227 @@
+--- a/grub-core/kern/emu/getroot.c
++++ b/grub-core/kern/emu/getroot.c
+@@ -32,6 +32,9 @@
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <stdint.h>
++#ifdef HAVE_LIMITS_H
++#include <limits.h>
++#endif
+ #include <grub/util/misc.h>
+ #include <grub/util/lvm.h>
+
+@@ -238,7 +241,67 @@
+
+ #endif /* __linux__ */
+
+-#if defined(HAVE_LIBZFS) && defined(HAVE_LIBNVPAIR)
++static char *
++find_device_from_pool (const char *poolname)
++{
++ char *device;
++ char *cmd;
++ FILE *fp;
++ int ret;
++ char *line;
++ size_t len;
++ int st;
++
++ char name[PATH_MAX], state[256], readlen[256], writelen[256], cksum[256], notes[256];
++ unsigned int dummy;
++
++ cmd = xasprintf ("zpool status %s", poolname);
++ fp = popen (cmd, "r");
++ free (cmd);
++
++ st = 0;
++ while (st < 3)
++ {
++ line = NULL;
++ ret = getline (&line, &len, fp);
++ if (ret == -1)
++ {
++ pclose (fp);
++ return NULL;
++ }
++
++ if (sscanf (line, " %s %s %s %s %s %s", name, state, readlen, writelen, cksum, notes) >= 5)
++ switch (st)
++ {
++ case 0:
++ if (!strcmp (name, "NAME")
++ && !strcmp (state, "STATE")
++ && !strcmp (readlen, "READ")
++ && !strcmp (writelen, "WRITE")
++ && !strcmp (cksum, "CKSUM"))
++ st++;
++ break;
++ case 1:
++ if (!strcmp (name, poolname))
++ st++;
++ break;
++ case 2:
++ if (strcmp (name, "mirror") && !sscanf (name, "mirror-%u", &dummy)
++ && !sscanf (name, "raidz%u", &dummy)
++ && !strcmp (state, "ONLINE"))
++ st++;
++ break;
++ }
++
++ free (line);
++ }
++ pclose (fp);
++
++ device = xasprintf ("/dev/%s", name);
++
++ return device;
++}
++
+ static char *
+ find_root_device_from_libzfs (const char *dir)
+ {
+@@ -250,49 +313,7 @@
+ if (! poolname)
+ return NULL;
+
+- {
+- zpool_handle_t *zpool;
+- libzfs_handle_t *libzfs;
+- nvlist_t *config, *vdev_tree;
+- nvlist_t **children, **path;
+- unsigned int nvlist_count;
+- unsigned int i;
+-
+- libzfs = grub_get_libzfs_handle ();
+- if (! libzfs)
+- return NULL;
+-
+- zpool = zpool_open (libzfs, poolname);
+- config = zpool_get_config (zpool, NULL);
+-
+- if (nvlist_lookup_nvlist (config, "vdev_tree", &vdev_tree) != 0)
+- error (1, errno, "nvlist_lookup_nvlist (\"vdev_tree\")");
+-
+- if (nvlist_lookup_nvlist_array (vdev_tree, "children", &children, &nvlist_count) != 0)
+- error (1, errno, "nvlist_lookup_nvlist_array (\"children\")");
+- assert (nvlist_count > 0);
+-
+- while (nvlist_lookup_nvlist_array (children[0], "children",
+- &children, &nvlist_count) == 0)
+- assert (nvlist_count > 0);
+-
+- for (i = 0; i < nvlist_count; i++)
+- {
+- if (nvlist_lookup_string (children[i], "path", &device) != 0)
+- error (1, errno, "nvlist_lookup_string (\"path\")");
+-
+- struct stat st;
+- if (stat (device, &st) == 0)
+- {
+- device = xstrdup (device);
+- break;
+- }
+-
+- device = NULL;
+- }
+-
+- zpool_close (zpool);
+- }
++ device = find_device_from_pool (poolname);
+
+ free (poolname);
+ if (poolfs)
+@@ -300,7 +321,6 @@
+
+ return device;
+ }
+-#endif
+
+ #ifdef __MINGW32__
+
+@@ -603,10 +623,8 @@
+ os_dev = grub_find_root_device_from_mountinfo (dir, NULL);
+ #endif /* __linux__ */
+
+-#if defined(HAVE_LIBZFS) && defined(HAVE_LIBNVPAIR)
+ if (!os_dev)
+ os_dev = find_root_device_from_libzfs (dir);
+-#endif
+
+ if (os_dev)
+ {
+@@ -708,7 +726,7 @@
+ }
+
+ int
+-grub_util_get_dev_abstraction (const char *os_dev __attribute__((unused)))
++grub_util_get_dev_abstraction (const char *os_dev)
+ {
+ #if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+ /* User explicitly claims that this drive is visible by BIOS. */
+--- a/grub-core/kern/emu/misc.c
++++ b/grub-core/kern/emu/misc.c
+@@ -287,7 +287,6 @@
+ }
+ #endif /* HAVE_LIBZFS */
+
+-#if defined(HAVE_LIBZFS) && defined(HAVE_LIBNVPAIR)
+ /* ZFS has similar problems to those of btrfs (see above). */
+ void
+ grub_find_zpool_from_dir (const char *dir, char **poolname, char **poolfs)
+@@ -348,7 +347,6 @@
+ else
+ *poolfs = xstrdup ("");
+ }
+-#endif
+
+ /* This function never prints trailing slashes (so that its output
+ can be appended a slash unconditionally). */
+@@ -361,22 +359,18 @@
+ dev_t num;
+ size_t len;
+
+-#if defined(HAVE_LIBZFS) && defined(HAVE_LIBNVPAIR)
+ char *poolfs = NULL;
+-#endif
+
+ /* canonicalize. */
+ p = canonicalize_file_name (path);
+ if (p == NULL)
+ grub_util_error ("failed to get canonical path of %s", path);
+
+-#if defined(HAVE_LIBZFS) && defined(HAVE_LIBNVPAIR)
+ /* For ZFS sub-pool filesystems, could be extended to others (btrfs?). */
+ {
+ char *dummy;
+ grub_find_zpool_from_dir (p, &dummy, &poolfs);
+ }
+-#endif
+
+ len = strlen (p) + 1;
+ buf = xstrdup (p);
+@@ -428,10 +422,8 @@
+ }
+ #endif
+ free (buf2);
+-#if defined(HAVE_LIBZFS) && defined(HAVE_LIBNVPAIR)
+ if (poolfs)
+ return xasprintf ("/%s/@", poolfs);
+-#endif
+ return xstrdup ("");
+ }
+ else
+@@ -488,14 +480,12 @@
+ len--;
+ }
+
+-#if defined(HAVE_LIBZFS) && defined(HAVE_LIBNVPAIR)
+ if (poolfs)
+ {
+ ret = xasprintf ("/%s/@%s", poolfs, buf3);
+ free (buf3);
+ }
+ else
+-#endif
+ ret = buf3;
+
+ return ret;
diff --git a/master/debian/olpc_prefix_hack.patch b/master/debian/olpc_prefix_hack.patch
new file mode 100644
index 0000000..79c2a5b
--- /dev/null
+++ b/master/debian/olpc_prefix_hack.patch
@@ -0,0 +1,50 @@
+
+This sucks, but it's better than what OFW was giving us.
+
+Index: b/grub-core/kern/ieee1275/init.c
+===================================================================
+--- a/grub-core/kern/ieee1275/init.c
++++ b/grub-core/kern/ieee1275/init.c
+@@ -53,6 +53,7 @@
+ grub_ieee1275_exit ();
+ }
+
++#ifndef __i386__
+ /* Translate an OF filesystem path (separated by backslashes), into a GRUB
+ path (separated by forward slashes). */
+ static void
+@@ -67,13 +68,16 @@
+ backslash = grub_strchr (filepath, '\\');
+ }
+ }
++#endif
+
+ void
+ grub_machine_set_prefix (void)
+ {
++#ifndef __i386__
+ char bootpath[64]; /* XXX check length */
+ char *filename;
+ char *prefix;
++#endif
+
+ if (grub_prefix[0])
+ {
+@@ -82,6 +86,9 @@
+ return;
+ }
+
++#ifdef __i386__
++ grub_env_set ("prefix", "(sd,1)/");
++#else
+ if (grub_ieee1275_get_property (grub_ieee1275_chosen, "bootpath", &bootpath,
+ sizeof (bootpath), 0))
+ {
+@@ -120,6 +127,7 @@
+
+ grub_free (filename);
+ grub_free (prefix);
++#endif
+ }
+
+ /* Claim some available memory in the first /memory node. */
diff --git a/master/debian/partition_performance.patch b/master/debian/partition_performance.patch
new file mode 100644
index 0000000..79fb453
--- /dev/null
+++ b/master/debian/partition_performance.patch
@@ -0,0 +1,36 @@
+Description: Give up scanning partitions after ten consecutive open failures
+ Scanning all the way up to 10000 is excessive and can cause serious
+ performance problems in some configurations.
+Author: Colin Watson <cjwatson@ubuntu.com>
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/787461
+Forwarded: yes
+Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3320
+Last-Update: 2011-05-27
+
+Index: b/grub-core/kern/emu/hostdisk.c
+===================================================================
+--- a/grub-core/kern/emu/hostdisk.c
++++ b/grub-core/kern/emu/hostdisk.c
+@@ -564,6 +564,7 @@
+ int i;
+ char real_dev[PATH_MAX];
+ struct linux_partition_cache *cache;
++ int missing = 0;
+
+ strcpy(real_dev, dev);
+
+@@ -602,7 +603,13 @@
+
+ fd = open (real_dev, O_RDONLY);
+ if (fd == -1)
+- continue;
++ {
++ if (missing++ < 10)
++ continue;
++ else
++ return 0;
++ }
++ missing = 0;
+ close (fd);
+
+ start = find_partition_start (real_dev);
diff --git a/master/debian/probe_canonicalise.patch b/master/debian/probe_canonicalise.patch
new file mode 100644
index 0000000..ba40995
--- /dev/null
+++ b/master/debian/probe_canonicalise.patch
@@ -0,0 +1,26 @@
+Description: Canonicalise path argument to grub-probe
+ This fixes use of "/path/.." as in grub-install for EFI, as well as
+ handling symlinks correctly.
+Author: Mario Limonciello <mario_limonciello@dell.com>
+Author: Colin Watson <cjwatson@ubuntu.com>
+Bug-Debian: http://bugs.debian.org/637768
+Forwarded: yes
+Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3401
+Last-Update: 2011-08-15
+
+Index: b/util/grub-probe.c
+===================================================================
+--- a/util/grub-probe.c
++++ b/util/grub-probe.c
+@@ -108,7 +108,10 @@
+ #endif
+ }
+ else
+- device_name = grub_guess_root_device (path);
++ {
++ grub_path = canonicalize_file_name (path);
++ device_name = grub_guess_root_device (grub_path);
++ }
+
+ if (! device_name)
+ grub_util_error ("cannot find a device for %s (is /dev mounted?)", path);
diff --git a/master/debian/qemu_img_exists.patch b/master/debian/qemu_img_exists.patch
new file mode 100644
index 0000000..b560067
--- /dev/null
+++ b/master/debian/qemu_img_exists.patch
@@ -0,0 +1,18 @@
+Description: Skip partmap test if qemu-img doesn't exist (e.g. on the Hurd)
+Author: Colin Watson <cjwatson@debian.org>
+Forwarded: no
+Last-Update: 2010-11-22
+
+Index: b/tests/partmap_test.in
+===================================================================
+--- a/tests/partmap_test.in
++++ b/tests/partmap_test.in
+@@ -51,6 +51,8 @@
+ echo
+ }
+
++which qemu-img >/dev/null 2>&1 || exit 77
++
+ imgfile=`mktemp "${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` || exit 1
+ outfile=`mktemp "${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` || exit 1
+
diff --git a/master/debian/series b/master/debian/series
new file mode 100644
index 0000000..95505f9
--- /dev/null
+++ b/master/debian/series
@@ -0,0 +1,45 @@
+olpc_prefix_hack.patch
+core_in_fs.patch
+dpkg_version_comparison.patch
+grub_legacy_0_based_partitions.patch
+disable_floppies.patch
+grub.cfg_400.patch
+gfxpayload_keep_default.patch
+mkrescue_diet.patch
+mkconfig_skip_dmcrypt.patch
+install_stage2_confusion.patch
+qemu_img_exists.patch
+branch_devmapper.patch
+branch_squash.patch
+branch_longlinuxcmd.patch
+branch_parse-color.patch
+branch_embed-sectors.patch
+branch_fuse.patch
+mkrescue_efi_modules.patch
+mkconfig_loopback.patch
+lazy_stat.patch
+btrfs_stat.patch
+partition_performance.patch
+kfreebsd-9_ada_devices.patch
+gfxterm_background.patch
+zfs_packed_la_array.patch
+xen_replace.patch
+kfreebsd_mfi_devices.patch
+probe_canonicalise.patch
+mkconfig_skip_readme.patch
+kfreebsd_lvm.patch
+zfs_update.patch
+no_libzfs.patch
+xfs_invalid_bmap.patch
+handle_new_autotools.patch
+bash-completion_identifiers.patch
+mkconfig_gnumach.patch
+gcc_4_6_space.patch
+lzo.patch
+fat_uuid.patch
+efiemu_fix.patch
+4k_sectors.patch
+efi_disk_cache.patch
+dirlen.patch
+hurd.patch
+userland-part.patch
diff --git a/master/debian/userland-part.patch b/master/debian/userland-part.patch
new file mode 100644
index 0000000..16d2156
--- /dev/null
+++ b/master/debian/userland-part.patch
@@ -0,0 +1,149 @@
+Description: Handle hurd userspace partitions.
+Author: Samuel Thibault <samuel.thibault@ens-lyon.org>
+Origin: upstream, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/4290
+Forwarded: not-needed
+Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/4290
+Last-Update: 2012-06-08
+
+--- a/grub-core/kern/emu/getroot.c 2012-05-03 20:59:16 +0000
++++ b/grub-core/kern/emu/getroot.c 2012-05-03 21:41:46 +0000
+@@ -337,6 +337,75 @@
+
+ #elif defined (__GNU__)
+
++static char *
++find_hurd_root_device (const char *path)
++{
++ file_t file;
++ error_t err;
++ char *argz = NULL, *name = NULL, *ret;
++ size_t argz_len = 0;
++ int i;
++
++ file = file_name_lookup (path, 0, 0);
++ if (file == MACH_PORT_NULL)
++ grub_util_error ("cannot open `%s': %s", path, strerror (errno));
++
++ /* This returns catenated 0-terminated strings. */
++ err = file_get_fs_options (file, &argz, &argz_len);
++ if (err)
++ grub_util_error ("cannot get filesystem options "
++ "for path `%s': %s", path, strerror(err));
++ if (argz_len == 0)
++ /* TRANSLATORS: a "translator" is similar to a filesystem, but handled by a
++ * userland daemon. */
++ grub_util_error ("translator is empty for path `%s'", path);
++
++ /* Make sure the string is terminated. */
++ argz[argz_len-1] = 0;
++
++ /* Skip first word (translator path) and options. */
++ for (i = strlen (argz) + 1; i < argz_len; i += strlen (argz + i) + 1)
++ {
++ if (argz[i] != '-')
++ {
++ /* Non-option. Only accept one, assumed to be the FS path. */
++ /* XXX: this should be replaced by an RPC to the translator. */
++ if (name)
++ /* TRANSLATORS: we expect to get something like
++ /hurd/foobar --option1 --option2=baz /dev/something
++ */
++ grub_util_error ("translator `%s' for path `%s' has several "
++ "non-option words, at least `%s' and `%s'",
++ argz, path, name, argz + i);
++ name = argz + i;
++ }
++ }
++
++ if (!name)
++ /* TRANSLATORS: we expect to get something like
++ /hurd/foobar --option1 --option2=baz /dev/something
++ */
++ grub_util_error ("translator `%s' for path `%s' is given only options, "
++ "cannot find device part", argz, path);
++
++ if (strncmp (name, "device:", sizeof ("device:") - 1) == 0)
++ {
++ char *dev_name = name + sizeof ("device:") - 1;
++ size_t size = sizeof ("/dev/") - 1 + strlen (dev_name) + 1;
++ char *next;
++ ret = malloc (size);
++ next = stpncpy (ret, "/dev/", size);
++ stpncpy (next, dev_name, size - (next - ret));
++ }
++ else if (!strncmp (name, "file:", sizeof ("file:") - 1))
++ ret = strdup (name + sizeof ("file:") - 1);
++ else
++ ret = strdup (name);
++
++ munmap (argz, argz_len);
++ return ret;
++}
++
+ #elif ! defined(__CYGWIN__)
+
+ char *
+@@ -565,61 +634,8 @@
+ {
+ char *os_dev = NULL;
+ #ifdef __GNU__
+- file_t file;
+- mach_port_t *ports;
+- int *ints;
+- loff_t *offsets;
+- char *data;
+- error_t err;
+- mach_msg_type_number_t num_ports = 0, num_ints = 0, num_offsets = 0, data_len = 0;
+- size_t name_len;
+-
+- file = file_name_lookup (dir, 0, 0);
+- if (file == MACH_PORT_NULL)
+- return 0;
+-
+- err = file_get_storage_info (file,
+- &ports, &num_ports,
+- &ints, &num_ints,
+- &offsets, &num_offsets,
+- &data, &data_len);
+-
+- if (num_ints < 1)
+- grub_util_error ("Storage info for `%s' does not include type", dir);
+- if (ints[0] != STORAGE_DEVICE)
+- grub_util_error ("Filesystem of `%s' is not stored on local disk", dir);
+-
+- if (num_ints < 5)
+- grub_util_error ("Storage info for `%s' does not include name", dir);
+- name_len = ints[4];
+- if (name_len < data_len)
+- grub_util_error ("Bogus name length for storage info for `%s'", dir);
+- if (data[name_len - 1] != '\0')
+- grub_util_error ("Storage name for `%s' not NUL-terminated", dir);
+-
+- os_dev = xmalloc (strlen ("/dev/") + data_len);
+- memcpy (os_dev, "/dev/", strlen ("/dev/"));
+- memcpy (os_dev + strlen ("/dev/"), data, data_len);
+-
+- if (ports && num_ports > 0)
+- {
+- mach_msg_type_number_t i;
+- for (i = 0; i < num_ports; i++)
+- {
+- mach_port_t port = ports[i];
+- if (port != MACH_PORT_NULL)
+- mach_port_deallocate (mach_task_self(), port);
+- }
+- munmap ((caddr_t) ports, num_ports * sizeof (*ports));
+- }
+-
+- if (ints && num_ints > 0)
+- munmap ((caddr_t) ints, num_ints * sizeof (*ints));
+- if (offsets && num_offsets > 0)
+- munmap ((caddr_t) offsets, num_offsets * sizeof (*offsets));
+- if (data && data_len > 0)
+- munmap (data, data_len);
+- mach_port_deallocate (mach_task_self (), file);
++ /* GNU/Hurd specific function. */
++ os_dev = find_hurd_root_device (dir);
+ #else /* !__GNU__ */
+ struct stat st;
+ dev_t dev;
diff --git a/master/debian/xen_replace.patch b/master/debian/xen_replace.patch
new file mode 100644
index 0000000..84df6b3
--- /dev/null
+++ b/master/debian/xen_replace.patch
@@ -0,0 +1,64 @@
+Description: New GRUB_CMDLINE_LINUX_XEN_REPLACE* options
+ Honour GRUB_CMDLINE_LINUX_XEN_REPLACE and
+ GRUB_CMDLINE_LINUX_XEN_REPLACE_DEFAULT, which replace GRUB_CMDLINE_LINUX
+ and GRUB_CMDLINE_LINUX_DEFAULT (complementing the existing options which
+ append).
+Author: Colin Watson <cjwatson@ubuntu.com>
+Bug-Debian: http://bugs.debian.org/617538
+Forwarded: yes
+Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3294
+Last-Update: 2011-08-08
+
+Index: b/docs/grub.texi
+===================================================================
+--- a/docs/grub.texi
++++ b/docs/grub.texi
+@@ -1169,8 +1169,14 @@
+
+ @item GRUB_CMDLINE_XEN
+ @itemx GRUB_CMDLINE_XEN_DEFAULT
+-As @samp{GRUB_CMDLINE_LINUX} and @samp{GRUB_CMDLINE_LINUX_DEFAULT}, but for
+-Linux and Xen.
++The values of these options are appended to the values of
++@samp{GRUB_CMDLINE_LINUX} and @samp{GRUB_CMDLINE_LINUX_DEFAULT} for Linux
++and Xen menu entries.
++
++@item GRUB_CMDLINE_LINUX_XEN_REPLACE
++@item GRUB_CMDLINE_LINUX_XEN_REPLACE_DEFAULT
++The values of these options replace the values of @samp{GRUB_CMDLINE_LINUX}
++and @samp{GRUB_CMDLINE_LINUX_DEFAULT} for Linux and Xen menu entries.
+
+ @item GRUB_DISABLE_LINUX_UUID
+ Normally, @command{grub-mkconfig} will generate menu entries that use
+Index: b/util/grub.d/20_linux_xen.in
+===================================================================
+--- a/util/grub.d/20_linux_xen.in
++++ b/util/grub.d/20_linux_xen.in
+@@ -56,6 +56,14 @@
+ LINUX_ROOT_DEVICE=UUID=${GRUB_DEVICE_UUID}
+ fi
+
++# Allow overriding GRUB_CMDLINE_LINUX and GRUB_CMDLINE_LINUX_DEFAULT.
++if [ "${GRUB_CMDLINE_LINUX_XEN_REPLACE}" ]; then
++ GRUB_CMDLINE_LINUX="${GRUB_CMDLINE_LINUX_XEN_REPLACE}"
++fi
++if [ "${GRUB_CMDLINE_LINUX_XEN_REPLACE_DEFAULT}" ]; then
++ GRUB_CMDLINE_LINUX_DEFAULT="${GRUB_CMDLINE_LINUX_XEN_REPLACE_DEFAULT}"
++fi
++
+ if [ "x`${grub_probe} --device ${GRUB_DEVICE} --target=fs 2>/dev/null || true`" = xbtrfs ] \
+ || [ "x`stat -f --printf=%T /`" = xbtrfs ]; then
+ rootsubvol="`make_system_path_relative_to_its_root /`"
+Index: b/util/grub-mkconfig.in
+===================================================================
+--- a/util/grub-mkconfig.in
++++ b/util/grub-mkconfig.in
+@@ -239,6 +239,8 @@
+ GRUB_CMDLINE_LINUX_DEFAULT \
+ GRUB_CMDLINE_XEN \
+ GRUB_CMDLINE_XEN_DEFAULT \
++ GRUB_CMDLINE_LINUX_XEN_REPLACE \
++ GRUB_CMDLINE_LINUX_XEN_REPLACE_DEFAULT \
+ GRUB_CMDLINE_NETBSD \
+ GRUB_CMDLINE_NETBSD_DEFAULT \
+ GRUB_TERMINAL_INPUT \
diff --git a/master/debian/xfs_invalid_bmap.patch b/master/debian/xfs_invalid_bmap.patch
new file mode 100644
index 0000000..71d04de
--- /dev/null
+++ b/master/debian/xfs_invalid_bmap.patch
@@ -0,0 +1,188 @@
+Description: Rewrite XFS btree parsing; fixes invalid BMAP
+Author: Vladimir Serbinenko <phcoder@gmail.com>
+Bug: http://savannah.gnu.org/bugs/?34213
+Bug-Debian: http://bugs.debian.org/657776
+Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3443
+Last-Update: 2012-01-29
+
+Index: b/grub-core/fs/xfs.c
+===================================================================
+--- a/grub-core/fs/xfs.c
++++ b/grub-core/fs/xfs.c
+@@ -111,7 +111,9 @@
+ grub_uint64_t nblocks;
+ grub_uint32_t extsize;
+ grub_uint32_t nextents;
+- grub_uint8_t unused3[20];
++ grub_uint16_t unused3;
++ grub_uint8_t fork_offset;
++ grub_uint8_t unused4[17];
+ union
+ {
+ char raw[156];
+@@ -145,7 +147,7 @@
+ grub_disk_t disk;
+ int pos;
+ int bsize;
+- int agsize;
++ grub_uint32_t agsize;
+ struct grub_fshelp_node diropen;
+ };
+
+@@ -159,33 +161,67 @@
+ #define FILETYPE_INO_DIRECTORY 0040000
+ #define FILETYPE_INO_SYMLINK 0120000
+
+-#define GRUB_XFS_INO_AGBITS(data) \
+- ((data)->sblock.log2_agblk + (data)->sblock.log2_inop)
+-#define GRUB_XFS_INO_INOINAG(data, ino) \
+- (grub_be_to_cpu64 (ino) & ((1LL << GRUB_XFS_INO_AGBITS (data)) - 1))
+-#define GRUB_XFS_INO_AG(data,ino) \
+- (grub_be_to_cpu64 (ino) >> GRUB_XFS_INO_AGBITS (data))
+-
+-#define GRUB_XFS_FSB_TO_BLOCK(data, fsb) \
+- (((fsb) >> (data)->sblock.log2_agblk) * (data)->agsize \
+- + ((fsb) & ((1LL << (data)->sblock.log2_agblk) - 1)))
+-
+-#define GRUB_XFS_EXTENT_OFFSET(exts,ex) \
+- ((grub_be_to_cpu32 (exts[ex][0]) & ~(1 << 31)) << 23 \
+- | grub_be_to_cpu32 (exts[ex][1]) >> 9)
+-
+-#define GRUB_XFS_EXTENT_BLOCK(exts,ex) \
+- ((grub_uint64_t) (grub_be_to_cpu32 (exts[ex][1]) \
+- & (0x1ff)) << 43 \
+- | (grub_uint64_t) grub_be_to_cpu32 (exts[ex][2]) << 11 \
+- | grub_be_to_cpu32 (exts[ex][3]) >> 21)
+-
+-#define GRUB_XFS_EXTENT_SIZE(exts,ex) \
+- (grub_be_to_cpu32 (exts[ex][3]) & ((1 << 20) - 1))
+-
+-#define GRUB_XFS_ROUND_TO_DIRENT(pos) ((((pos) + 8 - 1) / 8) * 8)
+-#define GRUB_XFS_NEXT_DIRENT(pos,len) \
+- (pos) + GRUB_XFS_ROUND_TO_DIRENT (8 + 1 + len + 2)
++static inline int
++GRUB_XFS_INO_AGBITS(struct grub_xfs_data *data)
++{
++ return ((data)->sblock.log2_agblk + (data)->sblock.log2_inop);
++}
++
++static inline grub_uint64_t
++GRUB_XFS_INO_INOINAG (struct grub_xfs_data *data,
++ grub_uint64_t ino)
++{
++ return (grub_be_to_cpu64 (ino) & ((1LL << GRUB_XFS_INO_AGBITS (data)) - 1));
++}
++
++static inline grub_uint64_t
++GRUB_XFS_INO_AG (struct grub_xfs_data *data,
++ grub_uint64_t ino)
++{
++ return (grub_be_to_cpu64 (ino) >> GRUB_XFS_INO_AGBITS (data));
++}
++
++static inline grub_disk_addr_t
++GRUB_XFS_FSB_TO_BLOCK (struct grub_xfs_data *data, grub_disk_addr_t fsb)
++{
++ return ((fsb >> data->sblock.log2_agblk) * data->agsize
++ + (fsb & ((1LL << data->sblock.log2_agblk) - 1)));
++}
++
++static inline grub_uint64_t
++GRUB_XFS_EXTENT_OFFSET (grub_xfs_extent *exts, int ex)
++{
++ return ((grub_be_to_cpu32 (exts[ex][0]) & ~(1 << 31)) << 23
++ | grub_be_to_cpu32 (exts[ex][1]) >> 9);
++}
++
++static inline grub_uint64_t
++GRUB_XFS_EXTENT_BLOCK (grub_xfs_extent *exts, int ex)
++{
++ return ((grub_uint64_t) (grub_be_to_cpu32 (exts[ex][1])
++ & (0x1ff)) << 43
++ | (grub_uint64_t) grub_be_to_cpu32 (exts[ex][2]) << 11
++ | grub_be_to_cpu32 (exts[ex][3]) >> 21);
++}
++
++static inline grub_uint64_t
++GRUB_XFS_EXTENT_SIZE (grub_xfs_extent *exts, int ex)
++{
++ return (grub_be_to_cpu32 (exts[ex][3]) & ((1 << 20) - 1));
++}
++
++static inline int
++GRUB_XFS_ROUND_TO_DIRENT (int pos)
++{
++ return ((((pos) + 8 - 1) / 8) * 8);
++}
++
++static inline int
++GRUB_XFS_NEXT_DIRENT (int pos, int len)
++{
++ return (pos) + GRUB_XFS_ROUND_TO_DIRENT (8 + 1 + len + 2);
++}
++
+
+ static inline grub_uint64_t
+ grub_xfs_inode_block (struct grub_xfs_data *data,
+@@ -241,13 +277,23 @@
+ if (node->inode.format == XFS_INODE_FORMAT_BTREE)
+ {
+ grub_uint64_t *keys;
++ int recoffset;
+
+- leaf = grub_malloc (node->data->sblock.bsize);
++ leaf = grub_malloc (node->data->bsize);
+ if (leaf == 0)
+ return 0;
+
+ nrec = grub_be_to_cpu16 (node->inode.data.btree.numrecs);
+ keys = &node->inode.data.btree.keys[0];
++ if (node->inode.fork_offset)
++ recoffset = (node->inode.fork_offset
++ - ((char *) &node->inode.data.btree.keys - (char *) &node->inode))
++ / (2 * sizeof (grub_uint64_t));
++ else
++ recoffset = ((1 << node->data->sblock.log2_inode)
++ - ((char *) &node->inode.data.btree.keys
++ - (char *) &node->inode))
++ / (2 * sizeof (grub_uint64_t));
+ do
+ {
+ int i;
+@@ -264,12 +310,9 @@
+ grub_free (leaf);
+ return 0;
+ }
+-
+ if (grub_disk_read (node->data->disk,
+- grub_be_to_cpu64 (keys[i - 1 + nrec])
+- << (node->data->sblock.log2_bsize
+- - GRUB_DISK_SECTOR_BITS),
+- 0, node->data->sblock.bsize, leaf))
++ GRUB_XFS_FSB_TO_BLOCK (node->data, grub_be_to_cpu64 (keys[i - 1 + recoffset])) << (node->data->sblock.log2_bsize - GRUB_DISK_SECTOR_BITS),
++ 0, node->data->bsize, leaf))
+ return 0;
+
+ if (grub_strncmp ((char *) leaf->magic, "BMAP", 4))
+@@ -281,7 +324,11 @@
+
+ nrec = grub_be_to_cpu16 (leaf->numrecs);
+ keys = &leaf->keys[0];
+- } while (leaf->level);
++ recoffset = ((node->data->bsize - ((char *) &leaf->keys
++ - (char *) leaf))
++ / (2 * sizeof (grub_uint64_t)));
++ }
++ while (leaf->level);
+ exts = (grub_xfs_extent *) keys;
+ }
+ else if (node->inode.format == XFS_INODE_FORMAT_EXT)
+@@ -328,7 +375,7 @@
+ grub_xfs_read_file (grub_fshelp_node_t node,
+ void NESTED_FUNC_ATTR (*read_hook) (grub_disk_addr_t sector,
+ unsigned offset, unsigned length),
+- int pos, grub_size_t len, char *buf)
++ grub_off_t pos, grub_size_t len, char *buf)
+ {
+ return grub_fshelp_read_file (node->data->disk, node, read_hook,
+ pos, len, buf, grub_xfs_read_block,
diff --git a/master/debian/zfs_packed_la_array.patch b/master/debian/zfs_packed_la_array.patch
new file mode 100644
index 0000000..e31778b
--- /dev/null
+++ b/master/debian/zfs_packed_la_array.patch
@@ -0,0 +1,17 @@
+2011-08-03 Robert Millan <rmh@gnu.org>
+
+ * include/grub/zfs/zap_leaf.h (typedef union zap_leaf_chunk): Mark
+ la_array as packed.
+ Reported by: Zachary Bedell
+
+--- a/include/grub/zfs/zap_leaf.h
++++ b/include/grub/zfs/zap_leaf.h
+@@ -90,7 +90,7 @@
+ {
+ grub_uint8_t la_array[ZAP_LEAF_ARRAY_BYTES];
+ grub_uint64_t la_array64;
+- };
++ } __attribute__ ((packed));
+ grub_uint16_t la_next; /* next blk or CHAIN_END */
+ } l_array;
+ struct zap_leaf_free {
diff --git a/master/debian/zfs_update.patch b/master/debian/zfs_update.patch
new file mode 100644
index 0000000..12e4599
--- /dev/null
+++ b/master/debian/zfs_update.patch
@@ -0,0 +1,2415 @@
+
+Revisions:
+
+3340: ZFS zlib support
+3474: Fix 2G limit on ZFS
+3486: ZFS fixes
+3488: ZFS multi-device and version 33 support
+3494: Fix memory leak
+3518: Rewrite RAIDZ part based on reverse engineering
+3519: Fix RAIDZ(2) for >= 5 devices
+3520: Add ability to sustain a single drive failure on both raidz and raidz2
+3521: Support raidz3
+3533: Support second redundancy strip on raidz(2,3)
+3534: Support case-insensitive ZFS subvolumes
+3535: Support third redundancy strip on raidz3
+
+--- a/grub-core/fs/zfs/zfs.c
++++ b/grub-core/fs/zfs/zfs.c
+@@ -51,6 +51,7 @@
+ #include <grub/zfs/sa_impl.h>
+ #include <grub/zfs/dsl_dir.h>
+ #include <grub/zfs/dsl_dataset.h>
++#include <grub/deflate.h>
+
+ GRUB_MOD_LICENSE ("GPLv3+");
+
+@@ -139,6 +140,27 @@
+ grub_zfs_endian_t endian;
+ } dnode_end_t;
+
++struct grub_zfs_device_desc
++{
++ enum { DEVICE_LEAF, DEVICE_MIRROR, DEVICE_RAIDZ } type;
++ grub_uint64_t id;
++ grub_uint64_t guid;
++
++ /* Valid only for non-leafs. */
++ unsigned n_children;
++ struct grub_zfs_device_desc *children;
++
++ /* Valid only for RAIDZ. */
++ unsigned nparity;
++ unsigned ashift;
++
++ /* Valid only for leaf devices. */
++ grub_device_t dev;
++ grub_disk_addr_t vdev_phys_sector;
++ uberblock_t current_uberblock;
++ int original;
++};
++
+ struct grub_zfs_data
+ {
+ /* cache for a file block of the currently zfs_open()-ed file */
+@@ -153,23 +175,45 @@
+ grub_uint64_t dnode_end;
+ grub_zfs_endian_t dnode_endian;
+
+- uberblock_t current_uberblock;
+- grub_disk_t disk;
+-
+ dnode_end_t mos;
+ dnode_end_t mdn;
+ dnode_end_t dnode;
+
+- grub_disk_addr_t vdev_phys_sector;
++ struct grub_zfs_device_desc *devices_attached;
++ unsigned n_devices_attached;
++ unsigned n_devices_allocated;
++ struct grub_zfs_device_desc *device_original;
++
++ uberblock_t current_uberblock;
++
++ int mounted;
++ grub_uint64_t guid;
+ };
+
++static grub_err_t
++zlib_decompress (void *s, void *d,
++ grub_size_t slen, grub_size_t dlen)
++{
++ if (grub_zlib_decompress (s, slen, 0, d, dlen) < 0)
++ return grub_errno;
++ return GRUB_ERR_NONE;
++}
++
+ static decomp_entry_t decomp_table[ZIO_COMPRESS_FUNCTIONS] = {
+ {"inherit", NULL}, /* ZIO_COMPRESS_INHERIT */
+ {"on", lzjb_decompress}, /* ZIO_COMPRESS_ON */
+ {"off", NULL}, /* ZIO_COMPRESS_OFF */
+ {"lzjb", lzjb_decompress}, /* ZIO_COMPRESS_LZJB */
+ {"empty", NULL}, /* ZIO_COMPRESS_EMPTY */
+- {"gzip", NULL}, /* ZIO_COMPRESS_GZIP */
++ {"gzip-1", zlib_decompress}, /* ZIO_COMPRESS_GZIP1 */
++ {"gzip-2", zlib_decompress}, /* ZIO_COMPRESS_GZIP2 */
++ {"gzip-3", zlib_decompress}, /* ZIO_COMPRESS_GZIP3 */
++ {"gzip-4", zlib_decompress}, /* ZIO_COMPRESS_GZIP4 */
++ {"gzip-5", zlib_decompress}, /* ZIO_COMPRESS_GZIP5 */
++ {"gzip-6", zlib_decompress}, /* ZIO_COMPRESS_GZIP6 */
++ {"gzip-7", zlib_decompress}, /* ZIO_COMPRESS_GZIP7 */
++ {"gzip-8", zlib_decompress}, /* ZIO_COMPRESS_GZIP8 */
++ {"gzip-9", zlib_decompress}, /* ZIO_COMPRESS_GZIP9 */
+ };
+
+ static grub_err_t zio_read_data (blkptr_t * bp, grub_zfs_endian_t endian,
+@@ -224,7 +268,7 @@
+ */
+ static grub_err_t
+ zio_checksum_verify (zio_cksum_t zc, grub_uint32_t checksum,
+- grub_zfs_endian_t endian, char *buf, int size)
++ grub_zfs_endian_t endian, char *buf, grub_size_t size)
+ {
+ zio_eck_t *zec = (zio_eck_t *) (buf + size) - 1;
+ zio_checksum_info_t *ci = &zio_checksum_table[checksum];
+@@ -253,13 +297,13 @@
+ || (actual_cksum.zc_word[2] != zc.zc_word[2])
+ || (actual_cksum.zc_word[3] != zc.zc_word[3]))
+ {
+- grub_dprintf ("zfs", "checksum %d verification failed\n", checksum);
+- grub_dprintf ("zfs", "actual checksum %16llx %16llx %16llx %16llx\n",
++ grub_dprintf ("zfs", "checksum %s verification failed\n", ci->ci_name);
++ grub_dprintf ("zfs", "actual checksum %016llx %016llx %016llx %016llx\n",
+ (unsigned long long) actual_cksum.zc_word[0],
+ (unsigned long long) actual_cksum.zc_word[1],
+ (unsigned long long) actual_cksum.zc_word[2],
+ (unsigned long long) actual_cksum.zc_word[3]);
+- grub_dprintf ("zfs", "expected checksum %16llx %16llx %16llx %16llx\n",
++ grub_dprintf ("zfs", "expected checksum %016llx %016llx %016llx %016llx\n",
+ (unsigned long long) zc.zc_word[0],
+ (unsigned long long) zc.zc_word[1],
+ (unsigned long long) zc.zc_word[2],
+@@ -319,7 +363,7 @@
+ *
+ */
+ static grub_err_t
+-uberblock_verify (uberblock_phys_t * ub, int offset)
++uberblock_verify (uberblock_phys_t * ub, grub_uint64_t offset)
+ {
+ uberblock_t *uber = &ub->ubp_uberblock;
+ grub_err_t err;
+@@ -392,7 +436,7 @@
+ }
+
+ static grub_uint64_t
+-dva_get_offset (dva_t * dva, grub_zfs_endian_t endian)
++dva_get_offset (const dva_t *dva, grub_zfs_endian_t endian)
+ {
+ grub_dprintf ("zfs", "dva=%llx, %llx\n",
+ (unsigned long long) dva->dva_word[0],
+@@ -401,6 +445,842 @@
+ endian) << SPA_MINBLOCKSHIFT;
+ }
+
++static grub_err_t
++zfs_fetch_nvlist (struct grub_zfs_device_desc *diskdesc, char **nvlist)
++{
++ grub_err_t err;
++
++ *nvlist = grub_malloc (VDEV_PHYS_SIZE);
++ if (!diskdesc->dev)
++ return grub_error (GRUB_ERR_BAD_FS, "member drive unknown");
++
++ /* Read in the vdev name-value pair list (112K). */
++ err = grub_disk_read (diskdesc->dev->disk, diskdesc->vdev_phys_sector, 0,
++ VDEV_PHYS_SIZE, *nvlist);
++ if (err)
++ {
++ grub_free (*nvlist);
++ *nvlist = 0;
++ return err;
++ }
++ return GRUB_ERR_NONE;
++}
++
++static grub_err_t
++fill_vdev_info_real (struct grub_zfs_data *data,
++ const char *nvlist,
++ struct grub_zfs_device_desc *fill,
++ struct grub_zfs_device_desc *insert)
++{
++ char *type;
++
++ type = grub_zfs_nvlist_lookup_string (nvlist, ZPOOL_CONFIG_TYPE);
++
++ if (!type)
++ return grub_errno;
++
++ if (!grub_zfs_nvlist_lookup_uint64 (nvlist, "id", &(fill->id)))
++ return grub_error (GRUB_ERR_BAD_FS, "couldn't find vdev id");
++
++ if (!grub_zfs_nvlist_lookup_uint64 (nvlist, "guid", &(fill->guid)))
++ return grub_error (GRUB_ERR_BAD_FS, "couldn't find vdev id");
++
++ if (grub_strcmp (type, VDEV_TYPE_DISK) == 0
++ || grub_strcmp (type, VDEV_TYPE_FILE) == 0)
++ {
++ fill->type = DEVICE_LEAF;
++
++ if (!fill->dev && fill->guid == insert->guid)
++ {
++ fill->dev = insert->dev;
++ fill->vdev_phys_sector = insert->vdev_phys_sector;
++ fill->current_uberblock = insert->current_uberblock;
++ fill->original = insert->original;
++ if (!data->device_original)
++ data->device_original = fill;
++ }
++
++ return GRUB_ERR_NONE;
++ }
++
++ if (grub_strcmp (type, VDEV_TYPE_MIRROR) == 0
++ || grub_strcmp (type, VDEV_TYPE_RAIDZ) == 0)
++ {
++ int nelm, i;
++
++ if (grub_strcmp (type, VDEV_TYPE_MIRROR) == 0)
++ fill->type = DEVICE_MIRROR;
++ else
++ {
++ grub_uint64_t par;
++ fill->type = DEVICE_RAIDZ;
++ if (!grub_zfs_nvlist_lookup_uint64 (nvlist, "nparity", &par))
++ return grub_error (GRUB_ERR_BAD_FS, "couldn't find raidz parity");
++ fill->nparity = par;
++ if (!grub_zfs_nvlist_lookup_uint64 (nvlist, "ashift", &par))
++ return grub_error (GRUB_ERR_BAD_FS, "couldn't find raidz ashift");
++ fill->ashift = par;
++ }
++
++ nelm = grub_zfs_nvlist_lookup_nvlist_array_get_nelm (nvlist, ZPOOL_CONFIG_CHILDREN);
++
++ if (nelm <= 0)
++ return grub_error (GRUB_ERR_BAD_FS, "incorrect mirror VDEV");
++
++ if (!fill->children)
++ {
++ fill->n_children = nelm;
++
++ fill->children = grub_zalloc (fill->n_children
++ * sizeof (fill->children[0]));
++ }
++
++ for (i = 0; i < nelm; i++)
++ {
++ char *child;
++ grub_err_t err;
++
++ child = grub_zfs_nvlist_lookup_nvlist_array
++ (nvlist, ZPOOL_CONFIG_CHILDREN, i);
++
++ err = fill_vdev_info_real (data, child, &fill->children[i], insert);
++
++ grub_free (child);
++
++ if (err)
++ return err;
++ }
++ return GRUB_ERR_NONE;
++ }
++
++ return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, "vdev %s isn't supported",
++ type);
++}
++
++static grub_err_t
++fill_vdev_info (struct grub_zfs_data *data,
++ char *nvlist, struct grub_zfs_device_desc *diskdesc)
++{
++ grub_uint64_t id;
++ unsigned i;
++
++ if (!grub_zfs_nvlist_lookup_uint64 (nvlist, "id", &id))
++ return grub_error (GRUB_ERR_BAD_FS, "couldn't find vdev id");
++
++ for (i = 0; i < data->n_devices_attached; i++)
++ if (data->devices_attached[i].id == id)
++ return fill_vdev_info_real (data, nvlist, &data->devices_attached[i],
++ diskdesc);
++
++ data->n_devices_attached++;
++ if (data->n_devices_attached > data->n_devices_allocated)
++ {
++ void *tmp;
++ data->n_devices_allocated = 2 * data->n_devices_attached + 1;
++ data->devices_attached
++ = grub_realloc (tmp = data->devices_attached,
++ data->n_devices_allocated
++ * sizeof (data->devices_attached[0]));
++ if (!data->devices_attached)
++ {
++ data->devices_attached = tmp;
++ return grub_errno;
++ }
++ }
++
++ grub_memset (&data->devices_attached[data->n_devices_attached - 1],
++ 0, sizeof (data->devices_attached[data->n_devices_attached - 1]));
++
++ return fill_vdev_info_real (data, nvlist,
++ &data->devices_attached[data->n_devices_attached - 1],
++ diskdesc);
++}
++
++/*
++ * Check the disk label information and retrieve needed vdev name-value pairs.
++ *
++ */
++static grub_err_t
++check_pool_label (struct grub_zfs_data *data,
++ struct grub_zfs_device_desc *diskdesc)
++{
++ grub_uint64_t pool_state, txg = 0;
++ char *nvlist;
++#if 0
++ char *nv;
++#endif
++ grub_uint64_t poolguid;
++ grub_uint64_t version;
++ int found;
++ grub_err_t err;
++
++ err = zfs_fetch_nvlist (diskdesc, &nvlist);
++ if (err)
++ return err;
++
++ grub_dprintf ("zfs", "check 2 passed\n");
++
++ found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_POOL_STATE,
++ &pool_state);
++ if (! found)
++ {
++ grub_free (nvlist);
++ if (! grub_errno)
++ grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_POOL_STATE " not found");
++ return grub_errno;
++ }
++ grub_dprintf ("zfs", "check 3 passed\n");
++
++ if (pool_state == POOL_STATE_DESTROYED)
++ {
++ grub_free (nvlist);
++ return grub_error (GRUB_ERR_BAD_FS, "zpool is marked as destroyed");
++ }
++ grub_dprintf ("zfs", "check 4 passed\n");
++
++ found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_POOL_TXG, &txg);
++ if (!found)
++ {
++ grub_free (nvlist);
++ if (! grub_errno)
++ grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_POOL_TXG " not found");
++ return grub_errno;
++ }
++ grub_dprintf ("zfs", "check 6 passed\n");
++
++ /* not an active device */
++ if (txg == 0)
++ {
++ grub_free (nvlist);
++ return grub_error (GRUB_ERR_BAD_FS, "zpool isn't active");
++ }
++ grub_dprintf ("zfs", "check 7 passed\n");
++
++ found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_VERSION,
++ &version);
++ if (! found)
++ {
++ grub_free (nvlist);
++ if (! grub_errno)
++ grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_VERSION " not found");
++ return grub_errno;
++ }
++ grub_dprintf ("zfs", "check 8 passed\n");
++
++ if (version > SPA_VERSION)
++ {
++ grub_free (nvlist);
++ return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
++ "too new version %llu > %llu",
++ (unsigned long long) version,
++ (unsigned long long) SPA_VERSION);
++ }
++ grub_dprintf ("zfs", "check 9 passed\n");
++
++ found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_GUID,
++ &(diskdesc->guid));
++ if (! found)
++ {
++ grub_free (nvlist);
++ if (! grub_errno)
++ grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_GUID " not found");
++ return grub_errno;
++ }
++
++ found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_POOL_GUID,
++ &poolguid);
++ if (! found)
++ {
++ grub_free (nvlist);
++ if (! grub_errno)
++ grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_POOL_GUID " not found");
++ return grub_errno;
++ }
++
++ grub_dprintf ("zfs", "check 11 passed\n");
++
++ if (data->mounted && data->guid != poolguid)
++ return grub_error (GRUB_ERR_BAD_FS, "another zpool");
++ else
++ data->guid = poolguid;
++
++ {
++ char *nv;
++ nv = grub_zfs_nvlist_lookup_nvlist (nvlist, ZPOOL_CONFIG_VDEV_TREE);
++
++ if (!nv)
++ {
++ grub_free (nvlist);
++ return grub_error (GRUB_ERR_BAD_FS, "couldn't find vdev tree");
++ }
++ err = fill_vdev_info (data, nv, diskdesc);
++ if (err)
++ {
++ grub_free (nvlist);
++ return err;
++ }
++ }
++ grub_dprintf ("zfs", "check 10 passed\n");
++
++ grub_free (nvlist);
++
++ return GRUB_ERR_NONE;
++}
++
++static grub_err_t
++scan_disk (grub_device_t dev, struct grub_zfs_data *data,
++ int original)
++{
++ int label = 0;
++ uberblock_phys_t *ub_array, *ubbest = NULL;
++ vdev_boot_header_t *bh;
++ grub_err_t err;
++ int vdevnum;
++ struct grub_zfs_device_desc desc;
++
++ ub_array = grub_malloc (VDEV_UBERBLOCK_RING);
++ if (!ub_array)
++ return grub_errno;
++
++ bh = grub_malloc (VDEV_BOOT_HEADER_SIZE);
++ if (!bh)
++ {
++ grub_free (ub_array);
++ return grub_errno;
++ }
++
++ vdevnum = VDEV_LABELS;
++
++ desc.dev = dev;
++ desc.original = original;
++
++ /* Don't check back labels on CDROM. */
++ if (grub_disk_get_size (dev->disk) == GRUB_DISK_SIZE_UNKNOWN)
++ vdevnum = VDEV_LABELS / 2;
++
++ for (label = 0; ubbest == NULL && label < vdevnum; label++)
++ {
++ desc.vdev_phys_sector
++ = label * (sizeof (vdev_label_t) >> SPA_MINBLOCKSHIFT)
++ + ((VDEV_SKIP_SIZE + VDEV_BOOT_HEADER_SIZE) >> SPA_MINBLOCKSHIFT)
++ + (label < VDEV_LABELS / 2 ? 0 : grub_disk_get_size (dev->disk)
++ - VDEV_LABELS * (sizeof (vdev_label_t) >> SPA_MINBLOCKSHIFT));
++
++ /* Read in the uberblock ring (128K). */
++ err = grub_disk_read (dev->disk, desc.vdev_phys_sector
++ + (VDEV_PHYS_SIZE >> SPA_MINBLOCKSHIFT),
++ 0, VDEV_UBERBLOCK_RING, (char *) ub_array);
++ if (err)
++ {
++ grub_errno = GRUB_ERR_NONE;
++ continue;
++ }
++ grub_dprintf ("zfs", "label ok %d\n", label);
++
++ ubbest = find_bestub (ub_array, desc.vdev_phys_sector);
++ if (!ubbest)
++ {
++ grub_dprintf ("zfs", "No uberblock found\n");
++ grub_errno = GRUB_ERR_NONE;
++ continue;
++ }
++
++ grub_memmove (&(desc.current_uberblock),
++ &ubbest->ubp_uberblock, sizeof (uberblock_t));
++ if (original)
++ grub_memmove (&(data->current_uberblock),
++ &ubbest->ubp_uberblock, sizeof (uberblock_t));
++
++ err = check_pool_label (data, &desc);
++ if (err)
++ {
++ grub_errno = GRUB_ERR_NONE;
++ continue;
++ }
++#if 0
++ if (find_best_root &&
++ vdev_uberblock_compare (&ubbest->ubp_uberblock,
++ &(current_uberblock)) <= 0)
++ continue;
++#endif
++ grub_free (ub_array);
++ grub_free (bh);
++ return GRUB_ERR_NONE;
++ }
++
++ grub_free (ub_array);
++ grub_free (bh);
++
++ return grub_error (GRUB_ERR_BAD_FS, "couldn't find a valid label");
++}
++
++static grub_err_t
++scan_devices (struct grub_zfs_data *data)
++{
++ auto int hook (const char *name);
++ int hook (const char *name)
++ {
++ grub_device_t dev;
++ grub_err_t err;
++ dev = grub_device_open (name);
++ if (!dev)
++ return 0;
++ if (!dev->disk)
++ {
++ grub_device_close (dev);
++ return 0;
++ }
++ err = scan_disk (dev, data, 0);
++ if (err == GRUB_ERR_BAD_FS)
++ {
++ grub_device_close (dev);
++ grub_errno = GRUB_ERR_NONE;
++ return 0;
++ }
++ if (err)
++ {
++ grub_device_close (dev);
++ grub_print_error ();
++ return 0;
++ }
++
++ return 0;
++ }
++ grub_device_iterate (hook);
++ return GRUB_ERR_NONE;
++}
++
++static inline void
++xor (grub_uint64_t *a, const grub_uint64_t *b, grub_size_t s)
++{
++ s /= sizeof (grub_uint64_t);
++ while (s--)
++ *a++ ^= *b++;
++}
++
++/* x**y. */
++static grub_uint8_t powx[255 * 2];
++/* Such an s that x**s = y */
++static int powx_inv[256];
++static const grub_uint8_t poly = 0x1d;
++
++/* perform the operation a ^= b * (x ** (known_idx * recovery_pow) ) */
++static inline void
++xor_out (void *a_in, const void *b_in, grub_size_t s,
++ int known_idx, int recovery_pow)
++{
++ int add;
++ grub_uint8_t *a = a_in;
++ const grub_uint8_t *b = b_in;
++
++ /* Simple xor. */
++ if (known_idx == 0 || recovery_pow == 0)
++ {
++ xor (a_in, b_in, s);
++ return;
++ }
++ add = (known_idx * recovery_pow) % 255;
++ for (;s--; b++, a++)
++ if (*b)
++ *a ^= powx[powx_inv[*b] + add];
++}
++
++static inline grub_uint8_t
++gf_mul (grub_uint8_t a, grub_uint8_t b)
++{
++ if (a == 0 || b == 0)
++ return 0;
++ return powx[powx_inv[a] + powx_inv[b]];
++}
++
++static inline grub_err_t
++recovery (grub_uint8_t *bufs[4], grub_size_t s, const int nbufs,
++ const unsigned *powers,
++ const int *idx)
++{
++ grub_dprintf ("zfs", "recovering %u bufers\n", nbufs);
++ /* Now we have */
++ /* b_i = sum (r_j* (x ** (powers[i] * idx[j])))*/
++ /* Let's invert the matrix in question. */
++ switch (nbufs)
++ {
++ /* Easy: r_0 = bufs[0] / (x << (powers[i] * idx[j])). */
++ case 1:
++ {
++ int add;
++ grub_uint8_t *a;
++ if (powers[0] == 0 || idx[0] == 0)
++ return GRUB_ERR_NONE;
++ add = 255 - ((powers[0] * idx[0]) % 255);
++ for (a = bufs[0]; s--; a++)
++ if (*a)
++ *a = powx[powx_inv[*a] + add];
++ return GRUB_ERR_NONE;
++ }
++ /* Case 2x2: Let's use the determinant formula. */
++ case 2:
++ {
++ grub_uint8_t det, det_inv;
++ grub_uint8_t matrixinv[2][2];
++ unsigned i;
++ /* The determinant is: */
++ det = (powx[(powers[0] * idx[0] + powers[1] * idx[1]) % 255]
++ ^ powx[(powers[0] * idx[1] + powers[1] * idx[0]) % 255]);
++ if (det == 0)
++ return grub_error (GRUB_ERR_BAD_FS, "singular recovery matrix");
++ det_inv = powx[255 - powx_inv[det]];
++ matrixinv[0][0] = gf_mul (powx[(powers[1] * idx[1]) % 255], det_inv);
++ matrixinv[1][1] = gf_mul (powx[(powers[0] * idx[0]) % 255], det_inv);
++ matrixinv[0][1] = gf_mul (powx[(powers[0] * idx[1]) % 255], det_inv);
++ matrixinv[1][0] = gf_mul (powx[(powers[1] * idx[0]) % 255], det_inv);
++ for (i = 0; i < s; i++)
++ {
++ grub_uint8_t b0, b1;
++ b0 = bufs[0][i];
++ b1 = bufs[1][i];
++
++ bufs[0][i] = (gf_mul (b0, matrixinv[0][0])
++ ^ gf_mul (b1, matrixinv[0][1]));
++ bufs[1][i] = (gf_mul (b0, matrixinv[1][0])
++ ^ gf_mul (b1, matrixinv[1][1]));
++ }
++ return GRUB_ERR_NONE;
++ }
++ /* Otherwise use Gauss. */
++ default:
++ {
++ grub_uint8_t matrix1[nbufs][nbufs], matrix2[nbufs][nbufs];
++ int i, j, k;
++
++ for (i = 0; i < nbufs; i++)
++ for (j = 0; j < nbufs; j++)
++ matrix1[i][j] = powx[(powers[i] * idx[j]) % 255];
++ for (i = 0; i < nbufs; i++)
++ for (j = 0; j < nbufs; j++)
++ matrix2[i][j] = 0;
++ for (i = 0; i < nbufs; i++)
++ matrix2[i][i] = 1;
++
++ for (i = 0; i < nbufs; i++)
++ {
++ grub_uint8_t mul;
++ for (j = i; j < nbufs; j++)
++ if (matrix1[i][j])
++ break;
++ if (j == nbufs)
++ return grub_error (GRUB_ERR_BAD_FS, "singular recovery matrix");
++ if (j != i)
++ {
++ int xchng;
++ xchng = j;
++ for (j = 0; j < nbufs; j++)
++ {
++ grub_uint8_t t;
++ t = matrix1[xchng][j];
++ matrix1[xchng][j] = matrix1[i][j];
++ matrix1[i][j] = t;
++ }
++ for (j = 0; j < nbufs; j++)
++ {
++ grub_uint8_t t;
++ t = matrix2[xchng][j];
++ matrix2[xchng][j] = matrix2[i][j];
++ matrix2[i][j] = t;
++ }
++ }
++ mul = powx[255 - powx_inv[matrix1[i][i]]];
++ for (j = 0; j < nbufs; j++)
++ matrix1[i][j] = gf_mul (matrix1[i][j], mul);
++ for (j = 0; j < nbufs; j++)
++ matrix2[i][j] = gf_mul (matrix2[i][j], mul);
++ for (j = i + 1; j < nbufs; j++)
++ {
++ mul = matrix1[j][i];
++ for (k = 0; k < nbufs; k++)
++ matrix1[j][k] ^= gf_mul (matrix1[i][k], mul);
++ for (k = 0; k < nbufs; k++)
++ matrix2[j][k] ^= gf_mul (matrix2[i][k], mul);
++ }
++ }
++ for (i = nbufs - 1; i >= 0; i--)
++ {
++ for (j = 0; j < i; j++)
++ {
++ grub_uint8_t mul;
++ mul = matrix1[j][i];
++ for (k = 0; k < nbufs; k++)
++ matrix1[j][k] ^= gf_mul (matrix1[i][k], mul);
++ for (k = 0; k < nbufs; k++)
++ matrix2[j][k] ^= gf_mul (matrix2[i][k], mul);
++ }
++ }
++
++ for (i = 0; i < (int) s; i++)
++ {
++ grub_uint8_t b[nbufs];
++ for (j = 0; j < nbufs; j++)
++ b[j] = bufs[j][i];
++ for (j = 0; j < nbufs; j++)
++ {
++ bufs[j][i] = 0;
++ for (k = 0; k < nbufs; k++)
++ bufs[j][i] ^= gf_mul (matrix2[j][k], b[k]);
++ }
++ }
++ return GRUB_ERR_NONE;
++ }
++ }
++}
++
++static grub_err_t
++read_device (grub_uint64_t offset, struct grub_zfs_device_desc *desc,
++ grub_size_t len, void *buf)
++{
++ switch (desc->type)
++ {
++ case DEVICE_LEAF:
++ {
++ grub_uint64_t sector;
++ sector = DVA_OFFSET_TO_PHYS_SECTOR (offset);
++ if (!desc->dev)
++ {
++ return grub_error (GRUB_ERR_BAD_FS, "member drive unknown");
++ }
++ /* read in a data block */
++ return grub_disk_read (desc->dev->disk, sector, 0, len, buf);
++ }
++ case DEVICE_MIRROR:
++ {
++ grub_err_t err = GRUB_ERR_NONE;
++ unsigned i;
++ if (desc->n_children <= 0)
++ return grub_error (GRUB_ERR_BAD_FS,
++ "non-positive number of mirror children");
++ for (i = 0; i < desc->n_children; i++)
++ {
++ err = read_device (offset, &desc->children[i],
++ len, buf);
++ if (!err)
++ break;
++ grub_errno = GRUB_ERR_NONE;
++ }
++ return (grub_errno = err);
++ }
++ case DEVICE_RAIDZ:
++ {
++ unsigned c = 0;
++ grub_uint64_t high;
++ grub_uint64_t devn;
++ grub_uint64_t m;
++ grub_uint32_t s, orig_s;
++ void *orig_buf = buf;
++ grub_size_t orig_len = len;
++ grub_uint8_t *recovery_buf[4];
++ grub_size_t recovery_len[4];
++ int recovery_idx[4];
++ unsigned failed_devices = 0;
++ int idx, orig_idx;
++
++ if (desc->nparity < 1 || desc->nparity > 3)
++ return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
++ "raidz%d is not supported", desc->nparity);
++
++ orig_s = (((len + (1 << desc->ashift) - 1) >> desc->ashift)
++ + (desc->n_children - desc->nparity) - 1);
++ s = orig_s;
++
++ high = grub_divmod64_full ((offset >> desc->ashift),
++ desc->n_children, &m);
++ if (desc->nparity == 2)
++ c = 2;
++ if (desc->nparity == 3)
++ c = 3;
++ if (((len + (1 << desc->ashift) - 1) >> desc->ashift)
++ >= (desc->n_children - desc->nparity))
++ idx = (desc->n_children - desc->nparity - 1);
++ else
++ idx = ((len + (1 << desc->ashift) - 1) >> desc->ashift) - 1;
++ orig_idx = idx;
++ while (len > 0)
++ {
++ grub_size_t csize;
++ grub_uint32_t bsize;
++ grub_err_t err;
++ bsize = s / (desc->n_children - desc->nparity);
++
++ if (desc->nparity == 1
++ && ((offset >> (desc->ashift + 11)) & 1) == c)
++ c++;
++
++ high = grub_divmod64_full ((offset >> desc->ashift) + c,
++ desc->n_children, &devn);
++ csize = bsize << desc->ashift;
++ if (csize > len)
++ csize = len;
++
++ grub_dprintf ("zfs", "RAIDZ mapping 0x%" PRIxGRUB_UINT64_T
++ "+%u (%" PRIxGRUB_SIZE ", %" PRIxGRUB_UINT32_T
++ ") -> (0x%" PRIxGRUB_UINT64_T ", 0x%"
++ PRIxGRUB_UINT64_T ")\n",
++ offset >> desc->ashift, c, len, bsize, high,
++ devn);
++ err = read_device ((high << desc->ashift)
++ | (offset & ((1 << desc->ashift) - 1)),
++ &desc->children[devn],
++ csize, buf);
++ if (err && failed_devices < desc->nparity)
++ {
++ recovery_buf[failed_devices] = buf;
++ recovery_len[failed_devices] = csize;
++ recovery_idx[failed_devices] = idx;
++ failed_devices++;
++ grub_errno = err = 0;
++ }
++ if (err)
++ return err;
++
++ c++;
++ idx--;
++ s--;
++ buf = (char *) buf + csize;
++ len -= csize;
++ }
++ if (failed_devices)
++ {
++ unsigned redundancy_pow[4];
++ unsigned cur_redundancy_pow = 0;
++ unsigned n_redundancy = 0;
++ unsigned i, j;
++ grub_err_t err;
++
++ /* Compute mul. x**s has a period of 255. */
++ if (powx[0] == 0)
++ {
++ grub_uint8_t cur = 1;
++ for (i = 0; i < 255; i++)
++ {
++ powx[i] = cur;
++ powx[i + 255] = cur;
++ powx_inv[cur] = i;
++ if (cur & 0x80)
++ cur = (cur << 1) ^ poly;
++ else
++ cur <<= 1;
++ }
++ }
++
++ /* Read redundancy data. */
++ for (n_redundancy = 0, cur_redundancy_pow = 0;
++ n_redundancy < failed_devices;
++ cur_redundancy_pow++)
++ {
++ high = grub_divmod64_full ((offset >> desc->ashift)
++ + cur_redundancy_pow
++ + ((desc->nparity == 1)
++ && ((offset >> (desc->ashift + 11))
++ & 1)),
++ desc->n_children, &devn);
++ err = read_device ((high << desc->ashift)
++ | (offset & ((1 << desc->ashift) - 1)),
++ &desc->children[devn],
++ recovery_len[n_redundancy],
++ recovery_buf[n_redundancy]);
++ /* Ignore error if we may still have enough devices. */
++ if (err && n_redundancy + desc->nparity - cur_redundancy_pow - 1
++ >= failed_devices)
++ {
++ grub_errno = GRUB_ERR_NONE;
++ continue;
++ }
++ if (err)
++ return err;
++ redundancy_pow[n_redundancy] = cur_redundancy_pow;
++ n_redundancy++;
++ }
++ /* Now xor-our the parts we already know. */
++ buf = orig_buf;
++ len = orig_len;
++ s = orig_s;
++ idx = orig_idx;
++
++ while (len > 0)
++ {
++ grub_size_t csize;
++ csize = ((s / (desc->n_children - desc->nparity))
++ << desc->ashift);
++ if (csize > len)
++ csize = len;
++
++ for (j = 0; j < failed_devices; j++)
++ if (buf == recovery_buf[j])
++ break;
++
++ if (j == failed_devices)
++ for (j = 0; j < failed_devices; j++)
++ xor_out (recovery_buf[j], buf,
++ csize < recovery_len[j] ? csize : recovery_len[j],
++ idx, redundancy_pow[j]);
++
++ s--;
++ buf = (char *) buf + csize;
++ len -= csize;
++ idx--;
++ }
++ for (i = 0; i < failed_devices
++ && recovery_len[i] == recovery_len[0];
++ i++);
++ /* Since the chunks have variable length handle the last block
++ separately. */
++ if (i != failed_devices)
++ {
++ grub_uint8_t *tmp_recovery_buf[4];
++ for (j = 0; j < i; j++)
++ tmp_recovery_buf[j] = recovery_buf[j] + recovery_len[j] - 1;
++ err = recovery (tmp_recovery_buf, 1, i, redundancy_pow,
++ recovery_idx);
++ if (err)
++ return err;
++ }
++ err = recovery (recovery_buf, recovery_len[failed_devices - 1],
++ failed_devices, redundancy_pow, recovery_idx);
++ if (err)
++ return err;
++ }
++ return GRUB_ERR_NONE;
++ }
++ }
++ return grub_error (GRUB_ERR_BAD_FS, "unsupported device type");
++}
++
++static grub_err_t
++read_dva (const dva_t *dva,
++ grub_zfs_endian_t endian, struct grub_zfs_data *data,
++ void *buf, grub_size_t len)
++{
++ grub_uint64_t offset;
++ unsigned i;
++ grub_err_t err;
++ int try = 0;
++ offset = dva_get_offset (dva, endian);
++
++ for (try = 0; try < 2; try++)
++ {
++ for (i = 0; i < data->n_devices_attached; i++)
++ if (data->devices_attached[i].id == DVA_GET_VDEV (dva))
++ {
++ err = read_device (offset, &data->devices_attached[i], len, buf);
++ if (!err)
++ return GRUB_ERR_NONE;
++ break;
++ }
++ if (try == 1)
++ break;
++ err = scan_devices (data);
++ if (err)
++ return err;
++ }
++ return err;
++}
+
+ /*
+ * Read a block of data based on the gang block address dva,
+@@ -412,7 +1292,6 @@
+ struct grub_zfs_data *data)
+ {
+ zio_gbh_phys_t *zio_gb;
+- grub_uint64_t offset, sector;
+ unsigned i;
+ grub_err_t err;
+ zio_cksum_t zc;
+@@ -424,13 +1303,8 @@
+ return grub_errno;
+ grub_dprintf ("zfs", endian == LITTLE_ENDIAN ? "little-endian gang\n"
+ :"big-endian gang\n");
+- offset = dva_get_offset (dva, endian);
+- sector = DVA_OFFSET_TO_PHYS_SECTOR (offset);
+- grub_dprintf ("zfs", "offset=%llx\n", (unsigned long long) offset);
+
+- /* read in the gang block header */
+- err = grub_disk_read (data->disk, sector, 0, SPA_GANGBLOCKSIZE,
+- (char *) zio_gb);
++ err = read_dva (dva, endian, data, zio_gb, SPA_GANGBLOCKSIZE);
+ if (err)
+ {
+ grub_free (zio_gb);
+@@ -483,20 +1357,13 @@
+ /* pick a good dva from the block pointer */
+ for (i = 0; i < SPA_DVAS_PER_BP; i++)
+ {
+- grub_uint64_t offset, sector;
+-
+ if (bp->blk_dva[i].dva_word[0] == 0 && bp->blk_dva[i].dva_word[1] == 0)
+ continue;
+
+ if ((grub_zfs_to_cpu64 (bp->blk_dva[i].dva_word[1], endian)>>63) & 1)
+ err = zio_read_gang (bp, endian, &bp->blk_dva[i], buf, data);
+ else
+- {
+- /* read in a data block */
+- offset = dva_get_offset (&bp->blk_dva[i], endian);
+- sector = DVA_OFFSET_TO_PHYS_SECTOR (offset);
+- err = grub_disk_read (data->disk, sector, 0, psize, buf);
+- }
++ err = read_dva (&bp->blk_dva[i], endian, data, buf, psize);
+ if (!err)
+ return GRUB_ERR_NONE;
+ grub_errno = GRUB_ERR_NONE;
+@@ -527,7 +1394,7 @@
+ *buf = NULL;
+
+ checksum = (grub_zfs_to_cpu64((bp)->blk_prop, endian) >> 40) & 0xff;
+- comp = (grub_zfs_to_cpu64((bp)->blk_prop, endian)>>32) & 0x7;
++ comp = (grub_zfs_to_cpu64((bp)->blk_prop, endian)>>32) & 0xff;
+ lsize = (BP_IS_HOLE(bp) ? 0 :
+ (((grub_zfs_to_cpu64 ((bp)->blk_prop, endian) & 0xffff) + 1)
+ << SPA_MINBLOCKSHIFT));
+@@ -602,7 +1469,8 @@
+ dmu_read (dnode_end_t * dn, grub_uint64_t blkid, void **buf,
+ grub_zfs_endian_t *endian_out, struct grub_zfs_data *data)
+ {
+- int idx, level;
++ int level;
++ grub_off_t idx;
+ blkptr_t *bp_array = dn->dn.dn_blkptr;
+ int epbs = dn->dn.dn_indblkshift - SPA_BLKPTRSHIFT;
+ blkptr_t *bp;
+@@ -670,7 +1538,8 @@
+ */
+ static grub_err_t
+ mzap_lookup (mzap_phys_t * zapobj, grub_zfs_endian_t endian,
+- int objsize, char *name, grub_uint64_t * value)
++ int objsize, char *name, grub_uint64_t * value,
++ int case_insensitive)
+ {
+ int i, chunks;
+ mzap_ent_phys_t *mzap_ent = zapobj->mz_chunk;
+@@ -678,7 +1547,8 @@
+ chunks = objsize / MZAP_ENT_LEN - 1;
+ for (i = 0; i < chunks; i++)
+ {
+- if (grub_strcmp (mzap_ent[i].mze_name, name) == 0)
++ if (case_insensitive ? (grub_strcasecmp (mzap_ent[i].mze_name, name) == 0)
++ : (grub_strcmp (mzap_ent[i].mze_name, name) == 0))
+ {
+ *value = grub_zfs_to_cpu64 (mzap_ent[i].mze_value, endian);
+ return GRUB_ERR_NONE;
+@@ -711,7 +1581,8 @@
+ }
+
+ static grub_uint64_t
+-zap_hash (grub_uint64_t salt, const char *name)
++zap_hash (grub_uint64_t salt, const char *name,
++ int case_insensitive)
+ {
+ static grub_uint64_t table[256];
+ const grub_uint8_t *cp;
+@@ -729,8 +1600,12 @@
+ }
+ }
+
+- for (cp = (const grub_uint8_t *) name; (c = *cp) != '\0'; cp++)
+- crc = (crc >> 8) ^ table[(crc ^ c) & 0xFF];
++ if (case_insensitive)
++ for (cp = (const grub_uint8_t *) name; (c = *cp) != '\0'; cp++)
++ crc = (crc >> 8) ^ table[(crc ^ grub_toupper (c)) & 0xFF];
++ else
++ for (cp = (const grub_uint8_t *) name; (c = *cp) != '\0'; cp++)
++ crc = (crc >> 8) ^ table[(crc ^ c) & 0xFF];
+
+ /*
+ * Only use 28 bits, since we need 4 bits in the cookie for the
+@@ -748,10 +1623,34 @@
+ * array_len is actual len in bytes (not encoded le_value_length).
+ * buf is null-terminated.
+ */
++
++static inline int
++name_cmp (const char *s1, const char *s2, grub_size_t n,
++ int case_insensitive)
++{
++ const char *t1 = (const char *) s1;
++ const char *t2 = (const char *) s2;
++
++ if (!case_insensitive)
++ return grub_memcmp (t1, t2, n);
++
++ while (n--)
++ {
++ if (grub_toupper (*t1) != grub_toupper (*t2))
++ return (int) grub_toupper (*t1) - (int) grub_toupper (*t2);
++
++ t1++;
++ t2++;
++ }
++
++ return 0;
++}
++
+ /* XXX */
+ static int
+ zap_leaf_array_equal (zap_leaf_phys_t * l, grub_zfs_endian_t endian,
+- int blksft, int chunk, int array_len, const char *buf)
++ int blksft, int chunk, int array_len, const char *buf,
++ int case_insensitive)
+ {
+ int bseen = 0;
+
+@@ -763,7 +1662,8 @@
+ if (chunk >= ZAP_LEAF_NUMCHUNKS (blksft))
+ return (0);
+
+- if (grub_memcmp (la->la_array, buf + bseen, toread) != 0)
++ if (name_cmp ((char *) la->la_array, buf + bseen, toread,
++ case_insensitive) != 0)
+ break;
+ chunk = grub_zfs_to_cpu16 (la->la_next, endian);
+ bseen += toread;
+@@ -804,7 +1704,8 @@
+ static grub_err_t
+ zap_leaf_lookup (zap_leaf_phys_t * l, grub_zfs_endian_t endian,
+ int blksft, grub_uint64_t h,
+- const char *name, grub_uint64_t * value)
++ const char *name, grub_uint64_t * value,
++ int case_insensitive)
+ {
+ grub_uint16_t chunk;
+ struct zap_leaf_entry *le;
+@@ -816,7 +1717,7 @@
+ return grub_error (GRUB_ERR_BAD_FS, "invalid leaf magic");
+
+ for (chunk = grub_zfs_to_cpu16 (l->l_hash[LEAF_HASH (blksft, h)], endian);
+- chunk != CHAIN_END; chunk = le->le_next)
++ chunk != CHAIN_END; chunk = grub_zfs_to_cpu16 (le->le_next, endian))
+ {
+
+ if (chunk >= ZAP_LEAF_NUMCHUNKS (blksft))
+@@ -836,11 +1737,12 @@
+ if (zap_leaf_array_equal (l, endian, blksft,
+ grub_zfs_to_cpu16 (le->le_name_chunk,endian),
+ grub_zfs_to_cpu16 (le->le_name_length, endian),
+- name))
++ name, case_insensitive))
+ {
+ struct zap_leaf_array *la;
+
+- if (le->le_int_size != 8 || le->le_value_length != 1)
++ if (le->le_int_size != 8 || grub_zfs_to_cpu16 (le->le_value_length,
++ endian) != 1)
+ return grub_error (GRUB_ERR_BAD_FS, "invalid leaf chunk entry");
+
+ /* get the uint64_t property value */
+@@ -858,9 +1760,9 @@
+
+ /* Verify if this is a fat zap header block */
+ static grub_err_t
+-zap_verify (zap_phys_t *zap)
++zap_verify (zap_phys_t *zap, grub_zfs_endian_t endian)
+ {
+- if (zap->zap_magic != (grub_uint64_t) ZAP_MAGIC)
++ if (grub_zfs_to_cpu64 (zap->zap_magic, endian) != (grub_uint64_t) ZAP_MAGIC)
+ return grub_error (GRUB_ERR_BAD_FS, "bad ZAP magic");
+
+ if (zap->zap_flags != 0)
+@@ -879,7 +1781,8 @@
+ /* XXX */
+ static grub_err_t
+ fzap_lookup (dnode_end_t * zap_dnode, zap_phys_t * zap,
+- char *name, grub_uint64_t * value, struct grub_zfs_data *data)
++ char *name, grub_uint64_t * value, struct grub_zfs_data *data,
++ int case_insensitive)
+ {
+ void *l;
+ grub_uint64_t hash, idx, blkid;
+@@ -888,18 +1791,18 @@
+ grub_err_t err;
+ grub_zfs_endian_t leafendian;
+
+- err = zap_verify (zap);
++ err = zap_verify (zap, zap_dnode->endian);
+ if (err)
+ return err;
+
+- hash = zap_hash (zap->zap_salt, name);
++ hash = zap_hash (zap->zap_salt, name, case_insensitive);
+
+ /* get block id from index */
+ if (zap->zap_ptrtbl.zt_numblks != 0)
+ return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
+ "external pointer tables not supported");
+ idx = ZAP_HASH_IDX (hash, zap->zap_ptrtbl.zt_shift);
+- blkid = ((grub_uint64_t *) zap)[idx + (1 << (blksft - 3 - 1))];
++ blkid = grub_zfs_to_cpu64 (((grub_uint64_t *) zap)[idx + (1 << (blksft - 3 - 1))], zap_dnode->endian);
+
+ /* Get the leaf block */
+ if ((1U << blksft) < sizeof (zap_leaf_phys_t))
+@@ -908,7 +1811,8 @@
+ if (err)
+ return err;
+
+- err = zap_leaf_lookup (l, leafendian, blksft, hash, name, value);
++ err = zap_leaf_lookup (l, leafendian, blksft, hash, name, value,
++ case_insensitive);
+ grub_free (l);
+ return err;
+ }
+@@ -922,14 +1826,14 @@
+ {
+ zap_leaf_phys_t *l;
+ void *l_in;
+- grub_uint64_t idx, blkid;
++ grub_uint64_t idx, idx2, blkid;
+ grub_uint16_t chunk;
+ int blksft = zfs_log2 (grub_zfs_to_cpu16 (zap_dnode->dn.dn_datablkszsec,
+ zap_dnode->endian) << DNODE_SHIFT);
+ grub_err_t err;
+ grub_zfs_endian_t endian;
+
+- if (zap_verify (zap))
++ if (zap_verify (zap, zap_dnode->endian))
+ return 0;
+
+ /* get block id from index */
+@@ -945,9 +1849,17 @@
+ grub_error (GRUB_ERR_BAD_FS, "ZAP leaf is too small");
+ return 0;
+ }
+- for (idx = 0; idx < zap->zap_ptrtbl.zt_numblks; idx++)
++ for (idx = 0; idx < (1ULL << zap->zap_ptrtbl.zt_shift); idx++)
+ {
+- blkid = ((grub_uint64_t *) zap)[idx + (1 << (blksft - 3 - 1))];
++ blkid = grub_zfs_to_cpu64 (((grub_uint64_t *) zap)[idx + (1 << (blksft - 3 - 1))],
++ zap_dnode->endian);
++
++ for (idx2 = 0; idx2 < idx; idx2++)
++ if (blkid == grub_zfs_to_cpu64 (((grub_uint64_t *) zap)[idx2 + (1 << (blksft - 3 - 1))],
++ zap_dnode->endian))
++ break;
++ if (idx2 != idx)
++ continue;
+
+ err = dmu_read (zap_dnode, blkid, &l_in, &endian, data);
+ l = l_in;
+@@ -983,8 +1895,11 @@
+
+ buf = grub_malloc (grub_zfs_to_cpu16 (le->le_name_length, endian)
+ + 1);
+- if (zap_leaf_array_get (l, endian, blksft, le->le_name_chunk,
+- le->le_name_length, buf))
++ if (zap_leaf_array_get (l, endian, blksft,
++ grub_zfs_to_cpu16 (le->le_name_chunk,
++ endian),
++ grub_zfs_to_cpu16 (le->le_name_length,
++ endian), buf))
+ {
+ grub_free (buf);
+ continue;
+@@ -996,7 +1911,9 @@
+ continue;
+
+ /* get the uint64_t property value */
+- la = &ZAP_LEAF_CHUNK (l, blksft, le->le_value_chunk).l_array;
++ la = &ZAP_LEAF_CHUNK (l, blksft,
++ grub_zfs_to_cpu16 (le->le_value_chunk,
++ endian)).l_array;
+ val = grub_be_to_cpu64 (la->la_array64);
+ if (hook (buf, val))
+ return 1;
+@@ -1014,7 +1931,7 @@
+ */
+ static grub_err_t
+ zap_lookup (dnode_end_t * zap_dnode, char *name, grub_uint64_t * val,
+- struct grub_zfs_data *data)
++ struct grub_zfs_data *data, int case_insensitive)
+ {
+ grub_uint64_t block_type;
+ int size;
+@@ -1037,7 +1954,8 @@
+ if (block_type == ZBT_MICRO)
+ {
+ grub_dprintf ("zfs", "micro zap\n");
+- err = (mzap_lookup (zapbuf, endian, size, name, val));
++ err = mzap_lookup (zapbuf, endian, size, name, val,
++ case_insensitive);
+ grub_dprintf ("zfs", "returned %d\n", err);
+ grub_free (zapbuf);
+ return err;
+@@ -1046,7 +1964,8 @@
+ {
+ grub_dprintf ("zfs", "fat zap\n");
+ /* this is a fat zap */
+- err = (fzap_lookup (zap_dnode, zapbuf, name, val, data));
++ err = fzap_lookup (zap_dnode, zapbuf, name, val, data,
++ case_insensitive);
+ grub_dprintf ("zfs", "returned %d\n", err);
+ grub_free (zapbuf);
+ return err;
+@@ -1074,7 +1993,7 @@
+ return 0;
+ block_type = grub_zfs_to_cpu64 (*((grub_uint64_t *) zapbuf), endian);
+
+- grub_dprintf ("zfs", "zap read\n");
++ grub_dprintf ("zfs", "zap iterate\n");
+
+ if (block_type == ZBT_MICRO)
+ {
+@@ -1172,9 +2091,9 @@
+ */
+ static grub_err_t
+ dnode_get_path (dnode_end_t * mdn, const char *path_in, dnode_end_t * dn,
+- struct grub_zfs_data *data)
++ struct grub_zfs_data *data, int *case_insensitive)
+ {
+- grub_uint64_t objnum, version;
++ grub_uint64_t objnum, version, insensitivity;
+ char *cname, ch;
+ grub_err_t err = GRUB_ERR_NONE;
+ char *path, *path_buf;
+@@ -1199,19 +2118,31 @@
+ return err;
+ }
+
+- err = zap_lookup (&(dnode_path->dn), ZPL_VERSION_STR, &version, data);
++ err = zap_lookup (&(dnode_path->dn), ZPL_VERSION_STR, &version,
++ data, 0);
+ if (err)
+ {
+ grub_free (dn_new);
+ return err;
+ }
++
+ if (version > ZPL_VERSION)
+ {
+ grub_free (dn_new);
+ return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, "too new ZPL version");
+ }
+-
+- err = zap_lookup (&(dnode_path->dn), ZFS_ROOT_OBJ, &objnum, data);
++
++ err = zap_lookup (&(dnode_path->dn), "casesensitivity", &insensitivity,
++ data, 0);
++ if (err == GRUB_ERR_FILE_NOT_FOUND)
++ {
++ grub_errno = GRUB_ERR_NONE;
++ insensitivity = 0;
++ }
++ if (case_insensitive)
++ *case_insensitive = insensitivity;
++
++ err = zap_lookup (&(dnode_path->dn), ZFS_ROOT_OBJ, &objnum, data, 0);
+ if (err)
+ {
+ grub_free (dn_new);
+@@ -1272,7 +2203,7 @@
+ grub_free (path_buf);
+ return grub_error (GRUB_ERR_BAD_FILE_TYPE, "not a directory");
+ }
+- err = zap_lookup (&(dnode_path->dn), cname, &objnum, data);
++ err = zap_lookup (&(dnode_path->dn), cname, &objnum, data, insensitivity);
+ if (err)
+ break;
+
+@@ -1291,22 +2222,54 @@
+ break;
+
+ *path = ch;
+-#if 0
+- if (((grub_zfs_to_cpu64(((znode_phys_t *) DN_BONUS (&dnode_path->dn.dn))->zp_mode, dnode_path->dn.endian) >> 12) & 0xf) == 0xa && ch)
++ if (dnode_path->dn.dn.dn_bonustype == DMU_OT_ZNODE
++ && ((grub_zfs_to_cpu64(((znode_phys_t *) DN_BONUS (&dnode_path->dn.dn))->zp_mode, dnode_path->dn.endian) >> 12) & 0xf) == 0xa)
+ {
++ char *sym_value;
++ grub_size_t sym_sz;
++ int free_symval = 0;
+ char *oldpath = path, *oldpathbuf = path_buf;
+- path = path_buf
+- = grub_malloc (sizeof (dnode_path->dn.dn.dn_bonus)
+- - sizeof (znode_phys_t) + grub_strlen (oldpath) + 1);
++ sym_value = ((char *) DN_BONUS (&dnode_path->dn.dn) + sizeof (struct znode_phys));
++
++ sym_sz = grub_zfs_to_cpu64 (((znode_phys_t *) DN_BONUS (&dnode_path->dn.dn))->zp_size, dnode_path->dn.endian);
++
++ if (dnode_path->dn.dn.dn_flags & 1)
++ {
++ grub_size_t block;
++ grub_size_t blksz;
++ blksz = (grub_zfs_to_cpu16 (dnode_path->dn.dn.dn_datablkszsec,
++ dnode_path->dn.endian)
++ << SPA_MINBLOCKSHIFT);
++
++ sym_value = grub_malloc (sym_sz);
++ if (!sym_value)
++ return grub_errno;
++ for (block = 0; block < (sym_sz + blksz - 1) / blksz; block++)
++ {
++ void *t;
++ grub_size_t movesize;
++
++ err = dmu_read (&(dnode_path->dn), block, &t, 0, data);
++ if (err)
++ return err;
++
++ movesize = MIN (sym_sz - block * blksz, blksz);
++
++ grub_memcpy (sym_value + block * blksz, t, movesize);
++ grub_free (t);
++ }
++ free_symval = 1;
++ }
++ path = path_buf = grub_malloc (sym_sz + grub_strlen (oldpath) + 1);
+ if (!path_buf)
+ {
+ grub_free (oldpathbuf);
+ return grub_errno;
+ }
+- grub_memcpy (path,
+- (char *) DN_BONUS(&dnode_path->dn.dn) + sizeof (znode_phys_t),
+- sizeof (dnode_path->dn.dn.dn_bonus) - sizeof (znode_phys_t));
+- path [sizeof (dnode_path->dn.dn.dn_bonus) - sizeof (znode_phys_t)] = 0;
++ grub_memcpy (path, sym_value, sym_sz);
++ if (free_symval)
++ grub_free (sym_value);
++ path [sym_sz] = 0;
+ grub_memcpy (path + grub_strlen (path), oldpath,
+ grub_strlen (oldpath) + 1);
+
+@@ -1324,7 +2287,62 @@
+ grub_free (dn_new);
+ }
+ }
+-#endif
++ if (dnode_path->dn.dn.dn_bonustype == DMU_OT_SA)
++ {
++ void *sahdrp;
++ int hdrsize;
++
++ if (dnode_path->dn.dn.dn_bonuslen != 0)
++ {
++ sahdrp = DN_BONUS (&dnode_path->dn.dn);
++ }
++ else if (dnode_path->dn.dn.dn_flags & DNODE_FLAG_SPILL_BLKPTR)
++ {
++ blkptr_t *bp = &dnode_path->dn.dn.dn_spill;
++
++ err = zio_read (bp, dnode_path->dn.endian, &sahdrp, NULL, data);
++ if (err)
++ return err;
++ }
++ else
++ {
++ return grub_error (GRUB_ERR_BAD_FS, "filesystem is corrupt");
++ }
++
++ hdrsize = SA_HDR_SIZE (((sa_hdr_phys_t *) sahdrp));
++
++ if (((grub_zfs_to_cpu64 (*(grub_uint64_t *) ((char *) sahdrp + hdrsize + SA_TYPE_OFFSET), dnode_path->dn.endian) >> 12) & 0xf) == 0xa)
++ {
++ char *sym_value = (char *) sahdrp + hdrsize + SA_SYMLINK_OFFSET;
++ grub_size_t sym_sz =
++ grub_zfs_to_cpu64 (*(grub_uint64_t *) ((char *) sahdrp + hdrsize + SA_SIZE_OFFSET), dnode_path->dn.endian);
++ char *oldpath = path, *oldpathbuf = path_buf;
++ path = path_buf = grub_malloc (sym_sz + grub_strlen (oldpath) + 1);
++ if (!path_buf)
++ {
++ grub_free (oldpathbuf);
++ return grub_errno;
++ }
++ grub_memcpy (path, sym_value, sym_sz);
++ path [sym_sz] = 0;
++ grub_memcpy (path + grub_strlen (path), oldpath,
++ grub_strlen (oldpath) + 1);
++
++ grub_free (oldpathbuf);
++ if (path[0] != '/')
++ {
++ dn_new = dnode_path;
++ dnode_path = dn_new->next;
++ grub_free (dn_new);
++ }
++ else while (dnode_path != root)
++ {
++ dn_new = dnode_path;
++ dnode_path = dn_new->next;
++ grub_free (dn_new);
++ }
++ }
++ }
+ }
+
+ if (!err)
+@@ -1417,7 +2435,7 @@
+
+ grub_dprintf ("zfs", "alive\n");
+
+- err = zap_lookup (mdn, DMU_POOL_ROOT_DATASET, &objnum, data);
++ err = zap_lookup (mdn, DMU_POOL_ROOT_DATASET, &objnum, data, 0);
+ if (err)
+ return err;
+
+@@ -1452,7 +2470,7 @@
+ if (err)
+ return err;
+
+- err = zap_lookup (mdn, cname, &objnum, data);
++ err = zap_lookup (mdn, cname, &objnum, data, 0);
+ if (err)
+ return err;
+
+@@ -1495,7 +2513,7 @@
+ static grub_err_t
+ dnode_get_fullpath (const char *fullpath, dnode_end_t * mdn,
+ grub_uint64_t *mdnobj, dnode_end_t * dn, int *isfs,
+- struct grub_zfs_data *data)
++ struct grub_zfs_data *data, int *case_insensitive)
+ {
+ char *fsname, *snapname;
+ const char *ptr_at, *filename;
+@@ -1573,7 +2591,7 @@
+ err = dnode_get (&(data->mos), snapobj,
+ DMU_OT_DSL_DS_SNAP_MAP, mdn, data);
+ if (!err)
+- err = zap_lookup (mdn, snapname, &headobj, data);
++ err = zap_lookup (mdn, snapname, &headobj, data, 0);
+ if (!err)
+ err = dnode_get (&(data->mos), headobj, DMU_OT_DSL_DATASET, mdn, data);
+ if (err)
+@@ -1597,7 +2615,7 @@
+ grub_free (snapname);
+ return GRUB_ERR_NONE;
+ }
+- err = dnode_get_path (mdn, filename, dn, data);
++ err = dnode_get_path (mdn, filename, dn, data, case_insensitive);
+ grub_free (fsname);
+ grub_free (snapname);
+ return err;
+@@ -1625,11 +2643,12 @@
+ */
+
+ static int
+-nvlist_find_value (char *nvlist, char *name, int valtype, char **val,
++nvlist_find_value (const char *nvlist, const char *name,
++ int valtype, char **val,
+ grub_size_t *size_out, grub_size_t *nelm_out)
+ {
+ int name_len, type, encode_size;
+- char *nvpair, *nvp_name;
++ const char *nvpair, *nvp_name;
+
+ /* Verify if the 1st and 2nd byte in the nvlist are valid. */
+ /* NOTE: independently of what endianness header announces all
+@@ -1671,7 +2690,7 @@
+
+ if ((grub_strncmp (nvp_name, name, name_len) == 0) && type == valtype)
+ {
+- *val = nvpair;
++ *val = (char *) nvpair;
+ *size_out = encode_size;
+ if (nelm_out)
+ *nelm_out = nelm;
+@@ -1684,7 +2703,8 @@
+ }
+
+ int
+-grub_zfs_nvlist_lookup_uint64 (char *nvlist, char *name, grub_uint64_t * out)
++grub_zfs_nvlist_lookup_uint64 (const char *nvlist, const char *name,
++ grub_uint64_t * out)
+ {
+ char *nvpair;
+ grub_size_t size;
+@@ -1704,7 +2724,7 @@
+ }
+
+ char *
+-grub_zfs_nvlist_lookup_string (char *nvlist, char *name)
++grub_zfs_nvlist_lookup_string (const char *nvlist, const char *name)
+ {
+ char *nvpair;
+ char *ret;
+@@ -1732,7 +2752,7 @@
+ }
+
+ char *
+-grub_zfs_nvlist_lookup_nvlist (char *nvlist, char *name)
++grub_zfs_nvlist_lookup_nvlist (const char *nvlist, const char *name)
+ {
+ char *nvpair;
+ char *ret;
+@@ -1753,199 +2773,114 @@
+ }
+
+ int
+-grub_zfs_nvlist_lookup_nvlist_array_get_nelm (char *nvlist, char *name)
+-{
+- char *nvpair;
+- grub_size_t nelm, size;
+- int found;
+-
+- found = nvlist_find_value (nvlist, name, DATA_TYPE_NVLIST, &nvpair,
+- &size, &nelm);
+- if (! found)
+- return -1;
+- return nelm;
+-}
+-
+-char *
+-grub_zfs_nvlist_lookup_nvlist_array (char *nvlist, char *name,
+- grub_size_t index)
+-{
+- char *nvpair, *nvpairptr;
+- int found;
+- char *ret;
+- grub_size_t size;
+- unsigned i;
+- grub_size_t nelm;
+-
+- found = nvlist_find_value (nvlist, name, DATA_TYPE_NVLIST, &nvpair,
+- &size, &nelm);
+- if (!found)
+- return 0;
+- if (index >= nelm)
+- {
+- grub_error (GRUB_ERR_OUT_OF_RANGE, "trying to lookup past nvlist array");
+- return 0;
+- }
+-
+- nvpairptr = nvpair;
+-
+- for (i = 0; i < index; i++)
+- {
+- grub_uint32_t encode_size;
+-
+- /* skip the header, nvl_version, and nvl_nvflag */
+- nvpairptr = nvpairptr + 4 * 2;
+-
+- while (nvpairptr < nvpair + size
+- && (encode_size = grub_be_to_cpu32 (*(grub_uint32_t *) nvpairptr)))
+- nvlist += encode_size; /* goto the next nvpair */
+-
+- nvlist = nvlist + 4 * 2; /* skip the ending 2 zeros - 8 bytes */
+- }
+-
+- if (nvpairptr >= nvpair + size
+- || nvpairptr + grub_be_to_cpu32 (*(grub_uint32_t *) (nvpairptr + 4 * 2))
+- >= nvpair + size)
+- {
+- grub_error (GRUB_ERR_BAD_FS, "incorrect nvlist array");
+- return 0;
+- }
+-
+- ret = grub_zalloc (grub_be_to_cpu32 (*(grub_uint32_t *) (nvpairptr + 4 * 2))
+- + 3 * sizeof (grub_uint32_t));
+- if (!ret)
+- return 0;
+- grub_memcpy (ret, nvlist, sizeof (grub_uint32_t));
+-
+- grub_memcpy (ret + sizeof (grub_uint32_t), nvpairptr, size);
+- return ret;
+-}
+-
+-static grub_err_t
+-zfs_fetch_nvlist (struct grub_zfs_data * data, char **nvlist)
+-{
+- grub_err_t err;
+-
+- *nvlist = grub_malloc (VDEV_PHYS_SIZE);
+- /* Read in the vdev name-value pair list (112K). */
+- err = grub_disk_read (data->disk, data->vdev_phys_sector, 0,
+- VDEV_PHYS_SIZE, *nvlist);
+- if (err)
+- {
+- grub_free (*nvlist);
+- *nvlist = 0;
+- return err;
+- }
+- return GRUB_ERR_NONE;
+-}
+-
+-/*
+- * Check the disk label information and retrieve needed vdev name-value pairs.
+- *
+- */
+-static grub_err_t
+-check_pool_label (struct grub_zfs_data *data)
++grub_zfs_nvlist_lookup_nvlist_array_get_nelm (const char *nvlist,
++ const char *name)
+ {
+- grub_uint64_t pool_state, txg = 0;
+- char *nvlist;
+-#if 0
+- char *nv;
+-#endif
+- grub_uint64_t diskguid;
+- grub_uint64_t version;
++ char *nvpair;
++ grub_size_t nelm, size;
+ int found;
+- grub_err_t err;
+
+- err = zfs_fetch_nvlist (data, &nvlist);
+- if (err)
+- return err;
++ found = nvlist_find_value (nvlist, name, DATA_TYPE_NVLIST_ARRAY, &nvpair,
++ &size, &nelm);
++ if (! found)
++ return -1;
++ return nelm;
++}
+
+- grub_dprintf ("zfs", "check 2 passed\n");
++static int
++get_nvlist_size (const char *beg, const char *limit)
++{
++ const char *ptr;
++ grub_uint32_t encode_size;
++
++ ptr = beg + 8;
+
+- found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_POOL_STATE,
+- &pool_state);
+- if (! found)
+- {
+- grub_free (nvlist);
+- if (! grub_errno)
+- grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_POOL_STATE " not found");
+- return grub_errno;
+- }
+- grub_dprintf ("zfs", "check 3 passed\n");
++ while (ptr < limit
++ && (encode_size = grub_be_to_cpu32 (*(grub_uint32_t *) ptr)))
++ ptr += encode_size; /* goto the next nvpair */
++ ptr += 8;
++ return (ptr > limit) ? -1 : (ptr - beg);
++}
+
+- if (pool_state == POOL_STATE_DESTROYED)
+- {
+- grub_free (nvlist);
+- return grub_error (GRUB_ERR_BAD_FS, "zpool is marked as destroyed");
+- }
+- grub_dprintf ("zfs", "check 4 passed\n");
++char *
++grub_zfs_nvlist_lookup_nvlist_array (const char *nvlist, const char *name,
++ grub_size_t index)
++{
++ char *nvpair, *nvpairptr;
++ int found;
++ char *ret;
++ grub_size_t size;
++ unsigned i;
++ grub_size_t nelm;
++ int elemsize = 0;
+
+- found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_POOL_TXG, &txg);
++ found = nvlist_find_value (nvlist, name, DATA_TYPE_NVLIST_ARRAY, &nvpair,
++ &size, &nelm);
+ if (!found)
++ return 0;
++ if (index >= nelm)
+ {
+- grub_free (nvlist);
+- if (! grub_errno)
+- grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_POOL_TXG " not found");
+- return grub_errno;
++ grub_error (GRUB_ERR_OUT_OF_RANGE, "trying to lookup past nvlist array");
++ return 0;
+ }
+- grub_dprintf ("zfs", "check 6 passed\n");
+
+- /* not an active device */
+- if (txg == 0)
+- {
+- grub_free (nvlist);
+- return grub_error (GRUB_ERR_BAD_FS, "zpool isn't active");
+- }
+- grub_dprintf ("zfs", "check 7 passed\n");
++ nvpairptr = nvpair;
+
+- found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_VERSION,
+- &version);
+- if (! found)
++ for (i = 0; i < index; i++)
+ {
+- grub_free (nvlist);
+- if (! grub_errno)
+- grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_VERSION " not found");
+- return grub_errno;
+- }
+- grub_dprintf ("zfs", "check 8 passed\n");
++ int r;
++ r = get_nvlist_size (nvpairptr, nvpair + size);
+
+- if (version > SPA_VERSION)
+- {
+- grub_free (nvlist);
+- return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
+- "too new version %llu > %llu",
+- (unsigned long long) version,
+- (unsigned long long) SPA_VERSION);
+- }
+- grub_dprintf ("zfs", "check 9 passed\n");
+-#if 0
+- if (nvlist_lookup_value (nvlist, ZPOOL_CONFIG_VDEV_TREE, &nv,
+- DATA_TYPE_NVLIST, NULL))
+- {
+- grub_free (vdev);
+- return (GRUB_ERR_BAD_FS);
++ if (r < 0)
++ {
++ grub_error (GRUB_ERR_BAD_FS, "incorrect nvlist array");
++ return NULL;
++ }
++ nvpairptr += r;
+ }
+- grub_dprintf ("zfs", "check 10 passed\n");
+-#endif
+
+- found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_GUID, &diskguid);
+- if (! found)
++ elemsize = get_nvlist_size (nvpairptr, nvpair + size);
++
++ if (elemsize < 0)
+ {
+- grub_free (nvlist);
+- if (! grub_errno)
+- grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_GUID " not found");
+- return grub_errno;
++ grub_error (GRUB_ERR_BAD_FS, "incorrect nvlist array");
++ return 0;
+ }
+- grub_dprintf ("zfs", "check 11 passed\n");
+
+- grub_free (nvlist);
++ ret = grub_zalloc (elemsize + sizeof (grub_uint32_t));
++ if (!ret)
++ return 0;
++ grub_memcpy (ret, nvlist, sizeof (grub_uint32_t));
+
+- return GRUB_ERR_NONE;
++ grub_memcpy (ret + sizeof (grub_uint32_t), nvpairptr, elemsize);
++ return ret;
++}
++
++static void
++unmount_device (struct grub_zfs_device_desc *desc)
++{
++ unsigned i;
++ switch (desc->type)
++ {
++ case DEVICE_LEAF:
++ if (!desc->original && desc->dev)
++ grub_device_close (desc->dev);
++ return;
++ case DEVICE_RAIDZ:
++ case DEVICE_MIRROR:
++ for (i = 0; i < desc->n_children; i++)
++ unmount_device (&desc->children[i]);
++ return;
++ }
+ }
+
+ static void
+ zfs_unmount (struct grub_zfs_data *data)
+ {
++ unsigned i;
++ for (i = 0; i < data->n_devices_attached; i++)
++ unmount_device (&data->devices_attached[i]);
++ grub_free (data->devices_attached);
+ grub_free (data->dnode_buf);
+ grub_free (data->dnode_mdn);
+ grub_free (data->file_buf);
+@@ -1961,13 +2896,11 @@
+ zfs_mount (grub_device_t dev)
+ {
+ struct grub_zfs_data *data = 0;
+- int label = 0;
+- uberblock_phys_t *ub_array, *ubbest = NULL;
+- vdev_boot_header_t *bh;
+- void *osp = 0;
+- grub_size_t ospsize;
+ grub_err_t err;
+- int vdevnum;
++ objset_phys_t *osp = 0;
++ grub_size_t ospsize;
++ grub_zfs_endian_t ub_endian = UNKNOWN_ENDIAN;
++ uberblock_t *ub;
+
+ if (! dev->disk)
+ {
+@@ -1975,119 +2908,56 @@
+ return 0;
+ }
+
+- data = grub_malloc (sizeof (*data));
++ data = grub_zalloc (sizeof (*data));
+ if (!data)
+ return 0;
+- grub_memset (data, 0, sizeof (*data));
+ #if 0
+ /* if it's our first time here, zero the best uberblock out */
+ if (data->best_drive == 0 && data->best_part == 0 && find_best_root)
+ grub_memset (&current_uberblock, 0, sizeof (uberblock_t));
+ #endif
+
+- data->disk = dev->disk;
+-
+- ub_array = grub_malloc (VDEV_UBERBLOCK_RING);
+- if (!ub_array)
++ data->n_devices_allocated = 16;
++ data->devices_attached = grub_malloc (sizeof (data->devices_attached[0])
++ * data->n_devices_allocated);
++ data->n_devices_attached = 0;
++ err = scan_disk (dev, data, 1);
++ if (err)
+ {
+ zfs_unmount (data);
+- return 0;
++ return NULL;
+ }
+
+- bh = grub_malloc (VDEV_BOOT_HEADER_SIZE);
+- if (!bh)
++ ub = &(data->current_uberblock);
++ ub_endian = (grub_zfs_to_cpu64 (ub->ub_magic,
++ LITTLE_ENDIAN) == UBERBLOCK_MAGIC
++ ? LITTLE_ENDIAN : BIG_ENDIAN);
++
++ err = zio_read (&ub->ub_rootbp, ub_endian,
++ (void **) &osp, &ospsize, data);
++ if (err)
+ {
+ zfs_unmount (data);
+- grub_free (ub_array);
+- return 0;
++ return NULL;
+ }
+
+- vdevnum = VDEV_LABELS;
+-
+- /* Don't check back labels on CDROM. */
+- if (grub_disk_get_size (dev->disk) == GRUB_DISK_SIZE_UNKNOWN)
+- vdevnum = VDEV_LABELS / 2;
+-
+- for (label = 0; ubbest == NULL && label < vdevnum; label++)
++ if (ospsize < OBJSET_PHYS_SIZE_V14)
+ {
+- grub_zfs_endian_t ub_endian = UNKNOWN_ENDIAN;
+- grub_dprintf ("zfs", "label %d\n", label);
+-
+- data->vdev_phys_sector
+- = label * (sizeof (vdev_label_t) >> SPA_MINBLOCKSHIFT)
+- + ((VDEV_SKIP_SIZE + VDEV_BOOT_HEADER_SIZE) >> SPA_MINBLOCKSHIFT)
+- + (label < VDEV_LABELS / 2 ? 0 : grub_disk_get_size (dev->disk)
+- - VDEV_LABELS * (sizeof (vdev_label_t) >> SPA_MINBLOCKSHIFT));
+-
+- /* Read in the uberblock ring (128K). */
+- err = grub_disk_read (data->disk, data->vdev_phys_sector
+- + (VDEV_PHYS_SIZE >> SPA_MINBLOCKSHIFT),
+- 0, VDEV_UBERBLOCK_RING, (char *) ub_array);
+- if (err)
+- {
+- grub_errno = GRUB_ERR_NONE;
+- continue;
+- }
+- grub_dprintf ("zfs", "label ok %d\n", label);
+-
+- ubbest = find_bestub (ub_array, data->vdev_phys_sector);
+- if (!ubbest)
+- {
+- grub_dprintf ("zfs", "No uberblock found\n");
+- grub_errno = GRUB_ERR_NONE;
+- continue;
+- }
+- ub_endian = (grub_zfs_to_cpu64 (ubbest->ubp_uberblock.ub_magic,
+- LITTLE_ENDIAN) == UBERBLOCK_MAGIC
+- ? LITTLE_ENDIAN : BIG_ENDIAN);
+- err = zio_read (&ubbest->ubp_uberblock.ub_rootbp,
+- ub_endian,
+- &osp, &ospsize, data);
+- if (err)
+- {
+- grub_dprintf ("zfs", "couldn't zio_read\n");
+- grub_errno = GRUB_ERR_NONE;
+- continue;
+- }
+-
+- if (ospsize < OBJSET_PHYS_SIZE_V14)
+- {
+- grub_dprintf ("zfs", "osp too small\n");
+- grub_free (osp);
+- continue;
+- }
+- grub_dprintf ("zfs", "ubbest %p\n", ubbest);
+-
+- err = check_pool_label (data);
+- if (err)
+- {
+- grub_errno = GRUB_ERR_NONE;
+- continue;
+- }
+-#if 0
+- if (find_best_root &&
+- vdev_uberblock_compare (&ubbest->ubp_uberblock,
+- &(current_uberblock)) <= 0)
+- continue;
+-#endif
+- /* Got the MOS. Save it at the memory addr MOS. */
+- grub_memmove (&(data->mos.dn), &((objset_phys_t *) osp)->os_meta_dnode,
+- DNODE_SIZE);
+- data->mos.endian = (grub_zfs_to_cpu64 (ubbest->ubp_uberblock.ub_rootbp.blk_prop, ub_endian) >> 63) & 1;
+- grub_memmove (&(data->current_uberblock),
+- &ubbest->ubp_uberblock, sizeof (uberblock_t));
+- grub_free (ub_array);
+- grub_free (bh);
++ grub_error (GRUB_ERR_BAD_FS, "OSP too small");
+ grub_free (osp);
+- return data;
++ zfs_unmount (data);
++ return NULL;
+ }
+- grub_error (GRUB_ERR_BAD_FS, "couldn't find a valid label");
+- zfs_unmount (data);
+- grub_free (ub_array);
+- grub_free (bh);
++
++ /* Got the MOS. Save it at the memory addr MOS. */
++ grub_memmove (&(data->mos.dn), &osp->os_meta_dnode, DNODE_SIZE);
++ data->mos.endian = (grub_zfs_to_cpu64 (ub->ub_rootbp.blk_prop,
++ ub_endian) >> 63) & 1;
+ grub_free (osp);
+
+- return 0;
++ data->mounted = 1;
++
++ return data;
+ }
+
+ grub_err_t
+@@ -2099,7 +2969,7 @@
+ zfs = zfs_mount (dev);
+ if (!zfs)
+ return grub_errno;
+- err = zfs_fetch_nvlist (zfs, nvlist);
++ err = zfs_fetch_nvlist (zfs->device_original, nvlist);
+ zfs_unmount (zfs);
+ return err;
+ }
+@@ -2115,7 +2985,7 @@
+ if (! data)
+ return grub_errno;
+
+- err = zfs_fetch_nvlist (data, &nvlist);
++ err = zfs_fetch_nvlist (data->device_original, &nvlist);
+ if (err)
+ {
+ zfs_unmount (data);
+@@ -2131,11 +3001,7 @@
+ static grub_err_t
+ zfs_uuid (grub_device_t device, char **uuid)
+ {
+- char *nvlist;
+- int found;
+ struct grub_zfs_data *data;
+- grub_uint64_t guid;
+- grub_err_t err;
+
+ *uuid = 0;
+
+@@ -2143,24 +3009,36 @@
+ if (! data)
+ return grub_errno;
+
+- err = zfs_fetch_nvlist (data, &nvlist);
+- if (err)
+- {
+- zfs_unmount (data);
+- return err;
+- }
+-
+- found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_POOL_GUID, &guid);
+- if (! found)
+- return grub_errno;
+- grub_free (nvlist);
+- *uuid = grub_xasprintf ("%016llx", (long long unsigned) guid);
++ *uuid = grub_xasprintf ("%016llx", (long long unsigned) data->guid);
+ zfs_unmount (data);
+ if (! *uuid)
+ return grub_errno;
+ return GRUB_ERR_NONE;
+ }
+
++static grub_err_t
++zfs_mtime (grub_device_t device, grub_int32_t *mt)
++{
++ struct grub_zfs_data *data;
++ grub_zfs_endian_t ub_endian = UNKNOWN_ENDIAN;
++ uberblock_t *ub;
++
++ *mt = 0;
++
++ data = zfs_mount (device);
++ if (! data)
++ return grub_errno;
++
++ ub = &(data->current_uberblock);
++ ub_endian = (grub_zfs_to_cpu64 (ub->ub_magic,
++ LITTLE_ENDIAN) == UBERBLOCK_MAGIC
++ ? LITTLE_ENDIAN : BIG_ENDIAN);
++
++ *mt = grub_zfs_to_cpu64 (ub->ub_timestamp, ub_endian);
++ zfs_unmount (data);
++ return GRUB_ERR_NONE;
++}
++
+ /*
+ * zfs_open() locates a file in the rootpool by following the
+ * MOS and places the dnode of the file in the memory address DNODE.
+@@ -2177,7 +3055,7 @@
+ return grub_errno;
+
+ err = dnode_get_fullpath (fsfilename, &(data->mdn), 0,
+- &(data->dnode), &isfs, data);
++ &(data->dnode), &isfs, data, NULL);
+ if (err)
+ {
+ zfs_unmount (data);
+@@ -2227,12 +3105,14 @@
+ }
+
+ hdrsize = SA_HDR_SIZE (((sa_hdr_phys_t *) sahdrp));
+- file->size = *(grub_uint64_t *) ((char *) sahdrp + hdrsize + SA_SIZE_OFFSET);
++ file->size = grub_zfs_to_cpu64 (*(grub_uint64_t *) ((char *) sahdrp + hdrsize + SA_SIZE_OFFSET), data->dnode.endian);
+ }
+- else
++ else if (data->dnode.dn.dn_bonustype == DMU_OT_ZNODE)
+ {
+ file->size = grub_zfs_to_cpu64 (((znode_phys_t *) DN_BONUS (&data->dnode.dn))->zp_size, data->dnode.endian);
+ }
++ else
++ return grub_error (GRUB_ERR_BAD_FS, "bad bonus type");
+
+ file->data = data;
+ file->offset = 0;
+@@ -2248,7 +3128,7 @@
+ grub_zfs_read (grub_file_t file, char *buf, grub_size_t len)
+ {
+ struct grub_zfs_data *data = (struct grub_zfs_data *) file->data;
+- int blksz, movesize;
++ grub_size_t blksz, movesize;
+ grub_size_t length;
+ grub_size_t read;
+ grub_err_t err;
+@@ -2302,7 +3182,7 @@
+ data->file_start = blkid * blksz;
+ data->file_end = data->file_start + blksz;
+
+- movesize = MIN (length, data->file_end - (int) file->offset - read);
++ movesize = MIN (length, data->file_end - file->offset - read);
+
+ grub_memmove (buf, data->file_buf + file->offset + read
+ - data->file_start, movesize);
+@@ -2339,7 +3219,7 @@
+ return grub_errno;
+
+ err = dnode_get_fullpath (fsfilename, &(data->mdn), mdnobj,
+- &(data->dnode), &isfs, data);
++ &(data->dnode), &isfs, data, NULL);
+ zfs_unmount (data);
+ return err;
+ }
+@@ -2377,7 +3257,7 @@
+ return;
+ }
+
+- err = zap_lookup (&dn, ZFS_ROOT_OBJ, &objnum, data);
++ err = zap_lookup (&dn, ZFS_ROOT_OBJ, &objnum, data, 0);
+ if (err)
+ {
+ grub_dprintf ("zfs", "failed here\n");
+@@ -2391,8 +3271,39 @@
+ return;
+ }
+
+- info->mtimeset = 1;
+- info->mtime = grub_zfs_to_cpu64 (((znode_phys_t *) DN_BONUS (&dn.dn))->zp_mtime[0], dn.endian);
++ if (dn.dn.dn_bonustype == DMU_OT_SA)
++ {
++ void *sahdrp;
++ int hdrsize;
++
++ if (dn.dn.dn_bonuslen != 0)
++ {
++ sahdrp = (sa_hdr_phys_t *) DN_BONUS (&dn.dn);
++ }
++ else if (dn.dn.dn_flags & DNODE_FLAG_SPILL_BLKPTR)
++ {
++ blkptr_t *bp = &dn.dn.dn_spill;
++
++ err = zio_read (bp, dn.endian, &sahdrp, NULL, data);
++ if (err)
++ return;
++ }
++ else
++ {
++ grub_error (GRUB_ERR_BAD_FS, "filesystem is corrupt");
++ return;
++ }
++
++ hdrsize = SA_HDR_SIZE (((sa_hdr_phys_t *) sahdrp));
++ info->mtimeset = 1;
++ info->mtime = grub_zfs_to_cpu64 (*(grub_uint64_t *) ((char *) sahdrp + hdrsize + SA_MTIME_OFFSET), dn.endian);
++ }
++
++ if (dn.dn.dn_bonustype == DMU_OT_ZNODE)
++ {
++ info->mtimeset = 1;
++ info->mtime = grub_zfs_to_cpu64 (((znode_phys_t *) DN_BONUS (&dn.dn))->zp_mtime[0], dn.endian);
++ }
+ return;
+ }
+
+@@ -2403,6 +3314,7 @@
+ struct grub_zfs_data *data;
+ grub_err_t err;
+ int isfs;
++ int case_insensitive = 0;
+ auto int NESTED_FUNC_ATTR iterate_zap (const char *name, grub_uint64_t val);
+ auto int NESTED_FUNC_ATTR iterate_zap_fs (const char *name,
+ grub_uint64_t val);
+@@ -2416,10 +3328,48 @@
+ grub_memset (&info, 0, sizeof (info));
+
+ dnode_get (&(data->mdn), val, 0, &dn, data);
+- info.mtimeset = 1;
+- info.mtime = grub_zfs_to_cpu64 (((znode_phys_t *) DN_BONUS (&dn.dn))->zp_mtime[0], dn.endian);
+- info.dir = (dn.dn.dn_type == DMU_OT_DIRECTORY_CONTENTS);
+- grub_dprintf ("zfs", "type=%d, name=%s\n",
++
++ if (dn.dn.dn_bonustype == DMU_OT_SA)
++ {
++ void *sahdrp;
++ int hdrsize;
++
++ if (dn.dn.dn_bonuslen != 0)
++ {
++ sahdrp = (sa_hdr_phys_t *) DN_BONUS (&data->dnode.dn);
++ }
++ else if (dn.dn.dn_flags & DNODE_FLAG_SPILL_BLKPTR)
++ {
++ blkptr_t *bp = &dn.dn.dn_spill;
++
++ err = zio_read (bp, dn.endian, &sahdrp, NULL, data);
++ if (err)
++ {
++ grub_print_error ();
++ return 0;
++ }
++ }
++ else
++ {
++ grub_error (GRUB_ERR_BAD_FS, "filesystem is corrupt");
++ grub_print_error ();
++ return 0;
++ }
++
++ hdrsize = SA_HDR_SIZE (((sa_hdr_phys_t *) sahdrp));
++ info.mtimeset = 1;
++ info.mtime = grub_zfs_to_cpu64 (*(grub_uint64_t *) ((char *) sahdrp + hdrsize + SA_MTIME_OFFSET), dn.endian);
++ info.case_insensitive = case_insensitive;
++ }
++
++ if (dn.dn.dn_bonustype == DMU_OT_ZNODE)
++ {
++ info.mtimeset = 1;
++ info.mtime = grub_zfs_to_cpu64 (((znode_phys_t *) DN_BONUS (&dn.dn))->zp_mtime[0],
++ dn.endian);
++ }
++ info.dir = (dn.dn.dn_type == DMU_OT_DIRECTORY_CONTENTS);
++ grub_dprintf ("zfs", "type=%d, name=%s\n",
+ (int)dn.dn.dn_type, (char *)name);
+ return hook (name, &info);
+ }
+@@ -2464,7 +3414,8 @@
+ data = zfs_mount (device);
+ if (! data)
+ return grub_errno;
+- err = dnode_get_fullpath (path, &(data->mdn), 0, &(data->dnode), &isfs, data);
++ err = dnode_get_fullpath (path, &(data->mdn), 0, &(data->dnode), &isfs, data,
++ &case_insensitive);
+ if (err)
+ {
+ zfs_unmount (data);
+@@ -2532,12 +3483,13 @@
+ .close = grub_zfs_close,
+ .label = zfs_label,
+ .uuid = zfs_uuid,
+- .mtime = 0,
++ .mtime = zfs_mtime,
+ .next = 0
+ };
+
+ GRUB_MOD_INIT (zfs)
+ {
++ COMPILE_TIME_ASSERT (sizeof (zap_leaf_chunk_t) == ZAP_LEAF_CHUNKSIZE);
+ grub_fs_register (&grub_zfs_fs);
+ #ifndef GRUB_UTIL
+ my_mod = mod;
+--- a/include/grub/zfs/zio.h
++++ b/include/grub/zfs/zio.h
+@@ -77,7 +77,15 @@
+ ZIO_COMPRESS_OFF,
+ ZIO_COMPRESS_LZJB,
+ ZIO_COMPRESS_EMPTY,
+- ZIO_COMPRESS_GZIP,
++ ZIO_COMPRESS_GZIP1,
++ ZIO_COMPRESS_GZIP2,
++ ZIO_COMPRESS_GZIP3,
++ ZIO_COMPRESS_GZIP4,
++ ZIO_COMPRESS_GZIP5,
++ ZIO_COMPRESS_GZIP6,
++ ZIO_COMPRESS_GZIP7,
++ ZIO_COMPRESS_GZIP8,
++ ZIO_COMPRESS_GZIP9,
+ ZIO_COMPRESS_FUNCTIONS
+ };
+
+--- a/grub-core/fs/zfs/zfsinfo.c
++++ b/grub-core/fs/zfs/zfsinfo.c
+@@ -141,7 +141,6 @@
+ }
+ grub_printf ("Mirror VDEV with %d children\n", nelm);
+ print_state (nvlist, tab);
+-
+ for (i = 0; i < nelm; i++)
+ {
+ char *child;
+@@ -161,6 +160,7 @@
+
+ grub_free (child);
+ }
++ return GRUB_ERR_NONE;
+ }
+
+ print_tabs (tab);
+--- a/include/grub/zfs/sa_impl.h
++++ b/include/grub/zfs/sa_impl.h
+@@ -29,6 +29,9 @@
+ } sa_hdr_phys_t;
+
+ #define SA_HDR_SIZE(hdr) BF32_GET_SB(hdr->sa_layout_info, 10, 16, 3, 0)
++#define SA_TYPE_OFFSET 0x0
+ #define SA_SIZE_OFFSET 0x8
++#define SA_MTIME_OFFSET 0x38
++#define SA_SYMLINK_OFFSET 0xa0
+
+ #endif /* _SYS_SA_IMPL_H */
+--- a/include/grub/zfs/zfs.h
++++ b/include/grub/zfs/zfs.h
+@@ -28,7 +28,7 @@
+ /*
+ * On-disk version number.
+ */
+-#define SPA_VERSION 28ULL
++#define SPA_VERSION 33ULL
+
+ /*
+ * The following are configuration names used in the nvlist describing a pool's
+@@ -112,12 +112,14 @@
+ grub_err_t grub_zfs_getmdnobj (grub_device_t dev, const char *fsfilename,
+ grub_uint64_t *mdnobj);
+
+-char *grub_zfs_nvlist_lookup_string (char *nvlist, char *name);
+-char *grub_zfs_nvlist_lookup_nvlist (char *nvlist, char *name);
+-int grub_zfs_nvlist_lookup_uint64 (char *nvlist, char *name,
++char *grub_zfs_nvlist_lookup_string (const char *nvlist, const char *name);
++char *grub_zfs_nvlist_lookup_nvlist (const char *nvlist, const char *name);
++int grub_zfs_nvlist_lookup_uint64 (const char *nvlist, const char *name,
+ grub_uint64_t *out);
+-char *grub_zfs_nvlist_lookup_nvlist_array (char *nvlist, char *name,
++char *grub_zfs_nvlist_lookup_nvlist_array (const char *nvlist,
++ const char *name,
+ grub_size_t index);
+-int grub_zfs_nvlist_lookup_nvlist_array_get_nelm (char *nvlist, char *name);
++int grub_zfs_nvlist_lookup_nvlist_array_get_nelm (const char *nvlist,
++ const char *name);
+
+ #endif /* ! GRUB_ZFS_HEADER */