From 919b97754cedca6f37dd1808b00198dc3cb8bf98 Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers3@gmail.com>
Date: Sun, 3 Aug 2014 18:37:36 -0500
Subject: [PATCH 01/16] xpress.h: Remove ENABLE_XPRESS_DEBUG

Neither XPRESS_DEBUG() nor XPRESS_ASSERT() is used anymore.
---
 include/wimlib/xpress.h | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/include/wimlib/xpress.h b/include/wimlib/xpress.h
index 37f2fdfa..a7113153 100644
--- a/include/wimlib/xpress.h
+++ b/include/wimlib/xpress.h
@@ -4,15 +4,6 @@
 /* Constants for the XPRESS data compression format.  See the comments in
  * xpress-decompress.c for more information about this format.  */
 
-//#define ENABLE_XPRESS_DEBUG
-#ifdef ENABLE_XPRESS_DEBUG
-#	define XPRESS_DEBUG DEBUG
-#	define XPRESS_ASSERT wimlib_assert
-#else
-#	define XPRESS_DEBUG(format, ...)
-#	define XPRESS_ASSERT(...)
-#endif
-
 #define XPRESS_NUM_CHARS	256
 #define XPRESS_NUM_SYMBOLS	512
 #define XPRESS_MAX_CODEWORD_LEN	15
-- 
2.43.0


From 969809ef646ec6ceb9730da2eb21884feaff994d Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers3@gmail.com>
Date: Sun, 3 Aug 2014 18:41:11 -0500
Subject: [PATCH 02/16] win32_common.c:  Remove code for windows version
 detection

This isn't used by anything anymore.
---
 include/wimlib/win32_common.h | 13 -------------
 src/win32_common.c            | 15 ---------------
 2 files changed, 28 deletions(-)

diff --git a/include/wimlib/win32_common.h b/include/wimlib/win32_common.h
index 691af744..8b4a48d4 100644
--- a/include/wimlib/win32_common.h
+++ b/include/wimlib/win32_common.h
@@ -143,19 +143,6 @@ extern NTSTATUS (WINAPI *func_RtlDosPathNameToNtPathName_U_WithStatus)
 extern NTSTATUS (WINAPI *func_RtlCreateSystemVolumeInformationFolder)
 			(PCUNICODE_STRING VolumeRootPath);
 
-
-extern bool
-windows_version_is_at_least(unsigned major, unsigned minor);
-
-#define running_on_windows_xp_or_later() \
-			windows_version_is_at_least(5, 1)
-
-#define running_on_windows_vista_or_later() \
-			windows_version_is_at_least(6, 0)
-
-#define running_on_windows_7_or_later() \
-			windows_version_is_at_least(6, 1)
-
 extern int
 win32_path_to_nt_path(const wchar_t *win32_path, UNICODE_STRING *nt_path);
 
diff --git a/src/win32_common.c b/src/win32_common.c
index 412421ea..48e21468 100644
--- a/src/win32_common.c
+++ b/src/win32_common.c
@@ -484,20 +484,8 @@ NTSTATUS (WINAPI *func_RtlDosPathNameToNtPathName_U_WithStatus)
 NTSTATUS (WINAPI *func_RtlCreateSystemVolumeInformationFolder)
 		(PCUNICODE_STRING VolumeRootPath);
 
-static OSVERSIONINFO windows_version_info = {
-	.dwOSVersionInfoSize = sizeof(OSVERSIONINFO),
-};
-
 static bool acquired_privileges = false;
 
-bool
-windows_version_is_at_least(unsigned major, unsigned minor)
-{
-	return windows_version_info.dwMajorVersion > major ||
-		(windows_version_info.dwMajorVersion == major &&
-		 windows_version_info.dwMinorVersion >= minor);
-}
-
 struct dll_sym {
 	void **func_ptr;
 	const char *name;
@@ -599,9 +587,6 @@ win32_global_init(int init_flags)
 		acquired_privileges = true;
 	}
 
-	/* Get Windows version information.  */
-	GetVersionEx(&windows_version_info);
-
 	ret = init_dll(&ntdll_spec);
 	if (ret)
 		goto out_drop_privs;
-- 
2.43.0


From 471905f062792c0dfdd21aaae1172d94c2e0369c Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers3@gmail.com>
Date: Sun, 3 Aug 2014 18:46:11 -0500
Subject: [PATCH 03/16] wim.h: Delete prototype for nonexistent function
 close_wim()

---
 include/wimlib/wim.h | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/include/wimlib/wim.h b/include/wimlib/wim.h
index c78fe905..587e2f69 100644
--- a/include/wimlib/wim.h
+++ b/include/wimlib/wim.h
@@ -155,9 +155,6 @@ open_wim_as_WIMStruct(const void *wim_filename_or_fd, int open_flags,
 		      WIMStruct **wim_ret,
 		      wimlib_progress_func_t progfunc, void *progctx);
 
-extern int
-close_wim(WIMStruct *wim);
-
 extern int
 can_modify_wim(WIMStruct *wim);
 
-- 
2.43.0


From 105b46dcfa04b92674bf0c18f93f9438d8d9ef9a Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers3@gmail.com>
Date: Mon, 4 Aug 2014 20:46:24 -0500
Subject: [PATCH 04/16] write.c: Fix handling of NULL context in
 stream_filtered()

A NULL filter_context is supposed to be valid and interpreted as "don't
filter anything".  This case can't be triggered by wimlib-imagex, but it
might be possible via custom library calls.
---
 src/write.c | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/write.c b/src/write.c
index 91954f9f..39e8bd0a 100644
--- a/src/write.c
+++ b/src/write.c
@@ -102,12 +102,15 @@ static int
 stream_filtered(const struct wim_lookup_table_entry *lte,
 		const struct filter_context *ctx)
 {
-	int write_flags = ctx->write_flags;
-	WIMStruct *wim = ctx->wim;
+	int write_flags;
+	WIMStruct *wim;
 
 	if (ctx == NULL)
 		return 0;
 
+	write_flags = ctx->write_flags;
+	wim = ctx->wim;
+
 	if (write_flags & WIMLIB_WRITE_FLAG_OVERWRITE &&
 	    lte->resource_location == RESOURCE_IN_WIM &&
 	    lte->rspec->wim == wim)
-- 
2.43.0


From 24f13cb8e265b848c4633e0adb91d4f25a618743 Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers3@gmail.com>
Date: Mon, 4 Aug 2014 20:57:03 -0500
Subject: [PATCH 05/16] extract.c: Fix dereference of NULL in memory exhausted
 path

found_lte can be NULL here if the call to new_lookup_table_entry()
failed.
---
 src/extract.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/extract.c b/src/extract.c
index 40e32964..fb96f13f 100644
--- a/src/extract.c
+++ b/src/extract.c
@@ -269,7 +269,7 @@ load_streams_from_pipe(struct apply_ctx *ctx,
 	}
 	ret = 0;
 out:
-	if (found_lte->resource_location != RESOURCE_IN_WIM)
+	if (found_lte && found_lte->resource_location != RESOURCE_IN_WIM)
 		FREE(rspec);
 	free_lookup_table_entry(found_lte);
 	return ret;
-- 
2.43.0


From 0436be80bd6eea1e80d921d362ae546f17879e40 Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers3@gmail.com>
Date: Mon, 4 Aug 2014 21:02:14 -0500
Subject: [PATCH 06/16] capture_common.c: Add missing breaks in switch stmt in
 do_capture_progress()

No effect because EXCLUDE_VERBOSE is set whenever VERBOSE is, but these
should be there.
---
 src/capture_common.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/capture_common.c b/src/capture_common.c
index ececd29a..def3a13f 100644
--- a/src/capture_common.c
+++ b/src/capture_common.c
@@ -59,12 +59,14 @@ do_capture_progress(struct add_image_params *params, int status,
 	case WIMLIB_SCAN_DENTRY_OK:
 		if (!(params->add_flags & WIMLIB_ADD_FLAG_VERBOSE))
 			return 0;
+		break;
 	case WIMLIB_SCAN_DENTRY_UNSUPPORTED:
 	case WIMLIB_SCAN_DENTRY_EXCLUDED:
 	case WIMLIB_SCAN_DENTRY_FIXED_SYMLINK:
 	case WIMLIB_SCAN_DENTRY_NOT_FIXED_SYMLINK:
 		if (!(params->add_flags & WIMLIB_ADD_FLAG_EXCLUDE_VERBOSE))
 			return 0;
+		break;
 	}
 	params->progress.scan.status = status;
 	if (status == WIMLIB_SCAN_DENTRY_OK && inode->i_nlink == 1) {
-- 
2.43.0


From 4075b6ec704b03f387af8044762f228b60ffb2d6 Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers3@gmail.com>
Date: Mon, 4 Aug 2014 21:07:07 -0500
Subject: [PATCH 07/16] ntfs-3g_capture.c: Remove a never-executed statement

---
 src/ntfs-3g_capture.c | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/ntfs-3g_capture.c b/src/ntfs-3g_capture.c
index af9ebbee..fa5b4690 100644
--- a/src/ntfs-3g_capture.c
+++ b/src/ntfs-3g_capture.c
@@ -789,8 +789,6 @@ out:
 		if (do_ntfs_umount(vol)) {
 			ERROR_WITH_ERRNO("Failed to unmount NTFS volume `%s'",
 					 device);
-			if (ret == 0)
-				ret = WIMLIB_ERR_NTFS_3G;
 		}
 	} else {
 		/* We need to leave the NTFS volume mounted so that we can read
-- 
2.43.0


From 32614c9f026be20f0336df3053b91090dc53297f Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers3@gmail.com>
Date: Mon, 4 Aug 2014 21:16:46 -0500
Subject: [PATCH 08/16] read_wim_header(): Check return value of lseek()

---
 src/header.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/header.c b/src/header.c
index 57cea04f..e223ce9f 100644
--- a/src/header.c
+++ b/src/header.c
@@ -96,7 +96,9 @@ read_wim_header(WIMStruct *wim, struct wim_header *hdr)
 			/* Pipable WIM:  Use header at end instead, unless
 			 * actually reading from a pipe.  */
 			if (!in_fd->is_pipe) {
-				lseek(in_fd->fd, -WIM_HEADER_DISK_SIZE, SEEK_END);
+				ret = WIMLIB_ERR_READ;
+				if (-1 == lseek(in_fd->fd, -WIM_HEADER_DISK_SIZE, SEEK_END))
+					goto read_error;
 				ret = full_read(in_fd, &disk_hdr, sizeof(disk_hdr));
 				if (ret)
 					goto read_error;
-- 
2.43.0


From 3df040b57bf40f45a636fa4a012ba1eeb6157e92 Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers3@gmail.com>
Date: Tue, 5 Aug 2014 21:00:00 -0500
Subject: [PATCH 09/16] mount_image.c: Cleanup

- Improve some comments.
- Don't use the T() macro.  The mount code doesn't run on Windows.
- Make sure we don't accidentally return errno=0.
- Return WIMLIB_ERR_NO_FILENAME if read-write mounting WIM that has no
  backing file.
- inode_resolve_streams() already does nothing if inode->i_resolved
- create_dentry() is never called with NULL 'dentry_ret'
- attr_timeout=0 was in FUSE options two times!
- 'have_progfunc' argument to create_message_queue() was always true; get
  rid of it.
- Use geteuid() rather than getuid() when testing for root
---
 src/mount_image.c | 89 +++++++++++++++++++++++++++++------------------
 1 file changed, 55 insertions(+), 34 deletions(-)

diff --git a/src/mount_image.c b/src/mount_image.c
index b53dfb5c..734afe48 100644
--- a/src/mount_image.c
+++ b/src/mount_image.c
@@ -1,10 +1,10 @@
 /*
  * mount_image.c
  *
- * This file implements mounting of WIM files using FUSE, which stands for
- * Filesystem in Userspace.  FUSE allows a filesystem to be implemented in a
- * userspace process by implementing the filesystem primitives--- read(),
- * write(), readdir(), etc.
+ * This file implements mounting of WIM images using FUSE
+ * (Filesystem in Userspace).  See http://fuse.sourceforge.net/.
+ *
+ * Currently it is only expected to work on Linux.
  */
 
 /*
@@ -389,21 +389,20 @@ wim_pathname_to_stream(const struct wimfs_context *ctx, const char *path,
 		stream_name = path_stream_name(path);
 		if (stream_name) {
 			p = (char *)stream_name - 1;
-			*p = T('\0');
+			*p = '\0';
 		}
 	}
 
 	dentry = get_dentry(wim, path, WIMLIB_CASE_SENSITIVE);
 	if (p)
-		*p = T(':');
+		*p = ':';
 	if (!dentry)
 		return -errno;
 
 	inode = dentry->d_inode;
 
-	if (!inode->i_resolved)
-		if (inode_resolve_streams(inode, wim->lookup_table, false))
-			return -EIO;
+	if (inode_resolve_streams(inode, wim->lookup_table, false))
+		return -EIO;
 
 	if (!(lookup_flags & LOOKUP_FLAG_DIRECTORY_OK)
 	      && inode_is_directory(inode))
@@ -505,8 +504,7 @@ create_dentry(struct fuse_context *fuse_ctx, const char *path,
 
 	dentry_add_child(parent, new_dentry);
 
-	if (dentry_ret)
-		*dentry_ret = new_dentry;
+	*dentry_ret = new_dentry;
 	return 0;
 }
 
@@ -944,7 +942,7 @@ out_restore_wim_filename:
 	return ret;
 }
 
-/* Deletes the staging directory, undoing the effects of a succesful call to
+/* Deletes the staging directory, undoing the effects of a successful call to
  * make_staging_dir().  */
 static void
 delete_staging_dir(struct wimfs_context *ctx)
@@ -966,6 +964,7 @@ delete_staging_dir(struct wimfs_context *ctx)
 	close(ctx->parent_dir_fd);
 }
 
+/* Number the inodes in the mounted image sequentially.  */
 static void
 reassign_inode_numbers(struct wimfs_context *ctx)
 {
@@ -992,6 +991,8 @@ release_extra_refcnts(struct wimfs_context *ctx)
 	}
 }
 
+/* Delete the 'struct wim_lookup_table_entry' for any stream that was modified
+ * or created in the read-write mounted image and had a final size of 0.  */
 static void
 delete_empty_streams(struct wimfs_context *ctx)
 {
@@ -1009,6 +1010,9 @@ delete_empty_streams(struct wimfs_context *ctx)
         }
 }
 
+/* Close all file descriptors open to the specified inode.
+ *
+ * Note: closing the last file descriptor might free the inode.  */
 static void
 inode_close_fds(struct wim_inode *inode)
 {
@@ -1021,6 +1025,7 @@ inode_close_fds(struct wim_inode *inode)
 	}
 }
 
+/* Close all file descriptors open to the mounted image.  */
 static void
 close_all_fds(struct wimfs_context *ctx)
 {
@@ -1069,7 +1074,7 @@ renew_current_image(struct wimfs_context *ctx)
 	if (ret)
 		goto err_free_new_lte;
 
-	ret = xml_add_image(wim, T(""));
+	ret = xml_add_image(wim, "");
 	if (ret)
 		goto err_undo_append;
 
@@ -1128,12 +1133,16 @@ commit_image(struct wimfs_context *ctx, int unmount_flags, mqd_t mq)
 	xml_update_image_info(ctx->wim, ctx->wim->current_image);
 
 	write_flags = 0;
+
 	if (unmount_flags & WIMLIB_UNMOUNT_FLAG_CHECK_INTEGRITY)
 		write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
+
 	if (unmount_flags & WIMLIB_UNMOUNT_FLAG_REBUILD)
 		write_flags |= WIMLIB_WRITE_FLAG_REBUILD;
+
 	if (unmount_flags & WIMLIB_UNMOUNT_FLAG_RECOMPRESS)
 		write_flags |= WIMLIB_WRITE_FLAG_RECOMPRESS;
+
 	return wimlib_overwrite(ctx->wim, write_flags, 0);
 }
 
@@ -1149,6 +1158,7 @@ may_unmount_wimfs(void)
 		fuse_ctx->uid == 0);
 }
 
+/* Unmount the mounted image, called from the daemon process.  */
 static int
 unmount_wimfs(void)
 {
@@ -1172,6 +1182,11 @@ unmount_wimfs(void)
 	}
 
 	if (wimfs_ctx->num_open_fds) {
+
+		/* There are still open file descriptors to the image.  */
+
+		/* With COMMIT, refuse to unmount unless FORCE is also
+		 * specified.  */
 		if ((unmount_flags & (WIMLIB_UNMOUNT_FLAG_COMMIT |
 				      WIMLIB_UNMOUNT_FLAG_FORCE))
 				 == WIMLIB_UNMOUNT_FLAG_COMMIT)
@@ -1179,16 +1194,20 @@ unmount_wimfs(void)
 			ret = WIMLIB_ERR_MOUNTED_IMAGE_IS_BUSY;
 			goto out;
 		}
+
+		/* Force-close all file descriptors.  */
 		close_all_fds(wimfs_ctx);
 	}
 
 	if (unmount_flags & WIMLIB_UNMOUNT_FLAG_COMMIT)
 		ret = commit_image(wimfs_ctx, unmount_flags, mq);
 	else
-		ret = 0;
+		ret = 0;  /* Read-only mount, or discarding changes to
+			     a read-write mount  */
+
 out:
 	/* Leave the image mounted if commit failed, unless this is a
-	 * forced unmount.  The user can retry without commit if they
+	 * forced unmount.  The user can retry without COMMIT if they
 	 * want.  */
 	if (!ret || (unmount_flags & WIMLIB_UNMOUNT_FLAG_FORCE)) {
 		unlock_wim_for_append(wimfs_ctx->wim);
@@ -1298,11 +1317,11 @@ wimfs_getattr(const char *path, struct stat *stbuf)
 static int
 copy_xattr(char *dest, size_t destsize, const void *src, size_t srcsize)
 {
-	if (!destsize)
-		return srcsize;
-	if (destsize < srcsize)
-		return -ERANGE;
-	memcpy(dest, src, srcsize);
+	if (destsize) {
+		if (destsize < srcsize)
+			return -ERANGE;
+		memcpy(dest, src, srcsize);
+	}
 	return srcsize;
 }
 
@@ -1380,11 +1399,11 @@ wimfs_getxattr(const char *path, const char *name, char *value,
 		return -EFBIG;
 
 	if (size) {
-		if (lte->size > size)
+		if (size < lte->size)
 			return -ERANGE;
 
 		if (read_full_stream_into_buf(lte, value))
-			return -errno;
+			return errno ? -errno : -EIO;
 	}
 	return lte->size;
 }
@@ -1659,7 +1678,7 @@ wimfs_read(const char *path, char *buf, size_t size,
 	switch (lte->resource_location) {
 	case RESOURCE_IN_WIM:
 		if (read_partial_wim_stream_into_buf(lte, size, offset, buf))
-			ret = -errno;
+			ret = errno ? -errno : -EIO;
 		else
 			ret = size;
 		break;
@@ -1815,7 +1834,8 @@ wimfs_setxattr(const char *path, const char *name,
 	if (!strncmp(name, "wimfs.", 6)) {
 		/* Handle some magical extended attributes.  These really should
 		 * be ioctls, but directory ioctls aren't supported until
-		 * libfuse 2.9, and even then they are broken.  */
+		 * libfuse 2.9, and even then they are broken.  [Fixed by
+		 * libfuse commit e3b7d4c278a26520be63d99d6ea84b26906fe73d]  */
 		name += 6;
 		if (!strcmp(name, "unmount_info")) {
 			if (!may_unmount_wimfs())
@@ -2080,6 +2100,8 @@ wimlib_mount_image(WIMStruct *wim, int image, const char *dir,
 
 	/* For read-write mount, check for write access to the WIM.  */
 	if (mount_flags & WIMLIB_MOUNT_FLAG_READWRITE) {
+		if (!wim->filename)
+			return WIMLIB_ERR_NO_FILENAME;
 		ret = can_delete_from_wim(wim);
 		if (ret)
 			return ret;
@@ -2234,7 +2256,6 @@ wimlib_mount_image(WIMStruct *wim, int image, const char *dir,
 	char optstring[256] =
 		"use_ino"
 		",subtype=wimfs"
-		",attr_timeout=0"
 		",hard_remove"
 		",default_permissions"
 		",kernel_cache"
@@ -2301,27 +2322,27 @@ generate_message_queue_name(char name[WIMFS_MQUEUE_NAME_LEN + 1])
 }
 
 static mqd_t
-create_message_queue(const char *name, bool have_progfunc)
+create_message_queue(const char *name)
 {
-	bool am_root = (getuid() == 0);
-	mode_t umask_save = 0;
-	mode_t mode = 0600;
+	bool am_root;
+	mode_t umask_save;
+	mode_t mode;
 	struct mq_attr attr;
 	mqd_t mq;
 
 	memset(&attr, 0, sizeof(attr));
 	attr.mq_maxmsg = 8;
-	if (have_progfunc)
-		attr.mq_msgsize = sizeof(struct commit_progress_report);
-	else
-		attr.mq_msgsize = sizeof(int);
+	attr.mq_msgsize = sizeof(struct commit_progress_report);
 
+	am_root = (geteuid() == 0);
 	if (am_root) {
 		/* Filesystem mounted as normal user with --allow-other should
 		 * be able to send messages to root user, if they're doing the
 		 * unmount.  */
 		umask_save = umask(0);
 		mode = 0666;
+	} else {
+		mode = 0600;
 	}
 	mq = mq_open(name, O_RDWR | O_CREAT | O_EXCL, mode, &attr);
 	if (am_root)
@@ -2392,7 +2413,7 @@ do_unmount_commit(const char *dir, int unmount_flags,
 	if (progfunc) {
 		generate_message_queue_name(unmount_info.mq_name);
 
-		mq = create_message_queue(unmount_info.mq_name, progfunc != NULL);
+		mq = create_message_queue(unmount_info.mq_name);
 		if (mq == (mqd_t)-1) {
 			ERROR_WITH_ERRNO("Can't create POSIX message queue");
 			return WIMLIB_ERR_MQUEUE;
-- 
2.43.0


From 56f882a80475fbe170f3d580400eb6f011ec5dfb Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers3@gmail.com>
Date: Tue, 5 Aug 2014 22:26:38 -0500
Subject: [PATCH 10/16] LZX decompression:  Cleanup

No change in behavior.
---
 Makefile.am                        |   1 +
 include/wimlib/decompress_common.h |   2 +-
 include/wimlib/lzx.h               |  94 +---
 include/wimlib/lzx_constants.h     |  78 ++++
 src/lzx-common.c                   |  16 +-
 src/lzx-decompress.c               | 711 ++++++++++++-----------------
 6 files changed, 397 insertions(+), 505 deletions(-)
 create mode 100644 include/wimlib/lzx_constants.h

diff --git a/Makefile.am b/Makefile.am
index 0d3d0f04..c6efa2ce 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -107,6 +107,7 @@ libwim_la_SOURCES =		\
 	include/wimlib/lz_suffix_array_utils.h	\
 	include/wimlib/lzms.h		\
 	include/wimlib/lzx.h		\
+	include/wimlib/lzx_constants.h	\
 	include/wimlib/metadata.h	\
 	include/wimlib/pathlist.h	\
 	include/wimlib/paths.h		\
diff --git a/include/wimlib/decompress_common.h b/include/wimlib/decompress_common.h
index 2b5d4f65..856c6411 100644
--- a/include/wimlib/decompress_common.h
+++ b/include/wimlib/decompress_common.h
@@ -230,7 +230,7 @@ make_huffman_decode_table(u16 decode_table[], unsigned num_syms,
  * This function won't write any data beyond this position.
  */
 static inline void
-lz_copy(u8 *dst, unsigned length, unsigned offset, const u8 *winend)
+lz_copy(u8 *dst, u32 length, u32 offset, const u8 *winend)
 {
 	const u8 *src = dst - offset;
 #if defined(__x86_64__) || defined(__i386__)
diff --git a/include/wimlib/lzx.h b/include/wimlib/lzx.h
index 539edf30..576d8bd5 100644
--- a/include/wimlib/lzx.h
+++ b/include/wimlib/lzx.h
@@ -1,12 +1,15 @@
+/*
+ * lzx.h
+ *
+ * Declarations shared between LZX compression and decompression.
+ */
+
 #ifndef _WIMLIB_LZX_H
 #define _WIMLIB_LZX_H
 
-/* Constants for the LZX data compression format.  See the comments in
- * lzx-compress.c and lzx-decompress.c for more information about this format.
- * */
-
 #include "wimlib/assert.h"
 #include "wimlib/compiler.h"
+#include "wimlib/lzx_constants.h"
 #include "wimlib/util.h"
 #include "wimlib/types.h"
 
@@ -19,77 +22,6 @@
 #	define LZX_ASSERT(...)
 #endif
 
-/* Constants, most of which are defined by the LZX specification: */
-
-/* The smallest and largest allowed match lengths. */
-#define LZX_MIN_MATCH_LEN            2
-#define LZX_MAX_MATCH_LEN            257
-
-/* Number of values an uncompressed literal byte can represent. */
-#define LZX_NUM_CHARS                256
-
-/* Each LZX block begins with 3 bits that determines the block type.  Below are
- * the valid block types.  Values 0, and 4 through 7, are invalid. */
-#define LZX_BLOCKTYPE_VERBATIM       1
-#define LZX_BLOCKTYPE_ALIGNED        2
-#define LZX_BLOCKTYPE_UNCOMPRESSED   3
-
-#define LZX_NUM_PRIMARY_LENS         7
-
-/* The number of position slots varies from 30 to 51 depending on the window
- * size (see comment in lzx-decompress.c).  */
-#define LZX_MAX_POSITION_SLOTS		51
-
-#define LZX_MIN_WINDOW_ORDER	15
-#define LZX_MAX_WINDOW_ORDER	21
-#define LZX_MIN_WINDOW_SIZE	(1U << LZX_MIN_WINDOW_ORDER)  /* 32768   */
-#define LZX_MAX_WINDOW_SIZE	(1U << LZX_MAX_WINDOW_ORDER)  /* 2097152 */
-
-/* Read the LZX specification for information about the Huffman trees used in
- * the LZX compression format.  Basically there are 4 of them: The main tree,
- * the length tree, the pre tree, and the aligned tree.  The main tree and
- * length tree are given at the beginning of VERBATIM and ALIGNED blocks as a
- * list of *_NUM_SYMBOLS code length values.  They are read using the
- * read_code_lens() function and built using the make_decode_table() function.
- * The decode table is not a real tree but rather a table that we can index by
- * some number of bits (*_TABLEBITS) of the input to quickly look up the symbol
- * corresponding to a Huffman code.
- *
- * The ALIGNED tree is only present on ALIGNED blocks.
- *
- * A PRECODE is used to encode the code lengths for the main tree and the length
- * tree.  There is a separate pretree for each half of the main tree.  */
-
-#define LZX_MAINCODE_MAX_NUM_SYMBOLS	(LZX_NUM_CHARS + (LZX_MAX_POSITION_SLOTS << 3))
-#define LZX_MAINCODE_TABLEBITS		11
-
-#define LZX_LENCODE_NUM_SYMBOLS		249
-#define LZX_LENCODE_TABLEBITS		10
-
-#define LZX_PRECODE_NUM_SYMBOLS		20
-#define LZX_PRECODE_TABLEBITS		6
-#define LZX_PRECODE_ELEMENT_SIZE	4
-
-#define LZX_ALIGNEDCODE_NUM_SYMBOLS	8
-#define LZX_ALIGNEDCODE_TABLEBITS	7
-#define LZX_ALIGNEDCODE_ELEMENT_SIZE	3
-
-/* Maximum allowed length of Huffman codewords.  */
-#define LZX_MAX_MAIN_CODEWORD_LEN	16
-#define LZX_MAX_LEN_CODEWORD_LEN	16
-#define LZX_MAX_PRE_CODEWORD_LEN	16
-#define LZX_MAX_ALIGNED_CODEWORD_LEN	8
-
-/* For the LZX-compressed blocks in WIM files, this value is always used as the
- * filesize parameter for the call instruction (0xe8 byte) preprocessing, even
- * though the blocks themselves are not this size, and the size of the actual
- * file resource in the WIM file is very likely to be something entirely
- * different as well.  */
-#define LZX_WIM_MAGIC_FILESIZE		12000000
-
-/* Assumed LZX block size when the encoded block size begins with a 0 bit.  */
-#define LZX_DEFAULT_BLOCK_SIZE		32768
-
 #define USE_LZX_EXTRA_BITS_ARRAY
 
 #ifdef USE_LZX_EXTRA_BITS_ARRAY
@@ -138,8 +70,6 @@ lzx_get_position_slot_raw(u32 formatted_offset)
 extern bool lzx_window_size_valid(size_t window_size);
 extern unsigned lzx_get_num_main_syms(u32 window_size);
 
-#define LZX_NUM_RECENT_OFFSETS	3
-
 /* Least-recently used queue for match offsets.  */
 struct lzx_lru_queue {
 	u32 R[LZX_NUM_RECENT_OFFSETS];
@@ -147,14 +77,10 @@ struct lzx_lru_queue {
 #ifdef __x86_64__
 _aligned_attribute(8)  /* Improves performance of LZX compression by 1% - 2%;
 			  specifically, this speeds up
-			  lzx_choose_near_optimal_match().  */
+			  lzx_choose_near_optimal_item().  */
 #endif
 ;
 
-/* In the LZX format, an offset of n bytes is actually encoded
- * as (n + LZX_OFFSET_OFFSET).  */
-#define LZX_OFFSET_OFFSET	(LZX_NUM_RECENT_OFFSETS - 1)
-
 /* Initialize the LZX least-recently-used match offset queue at the beginning of
  * a new window for either decompression or compression.  */
 static inline void
@@ -165,9 +91,9 @@ lzx_lru_queue_init(struct lzx_lru_queue *queue)
 }
 
 extern void
-lzx_do_e8_preprocessing(u8 *data, s32 size);
+lzx_do_e8_preprocessing(u8 *data, u32 size);
 
 extern void
-lzx_undo_e8_preprocessing(u8 *data, s32 size);
+lzx_undo_e8_preprocessing(u8 *data, u32 size);
 
 #endif /* _WIMLIB_LZX_H */
diff --git a/include/wimlib/lzx_constants.h b/include/wimlib/lzx_constants.h
new file mode 100644
index 00000000..36e812d8
--- /dev/null
+++ b/include/wimlib/lzx_constants.h
@@ -0,0 +1,78 @@
+/*
+ * lzx_constants.h
+ *
+ * Constants for the LZX compression format.
+ */
+
+#ifndef _LZX_CONSTANTS_H
+#define _LZX_CONSTANTS_H
+
+/* The smallest and largest allowed match lengths.  */
+#define LZX_MIN_MATCH_LEN	2
+#define LZX_MAX_MATCH_LEN	257
+
+/* Number of values an uncompressed literal byte can represent.  */
+#define LZX_NUM_CHARS	256
+
+/* Valid values of the 3-bit block type field.  */
+#define LZX_BLOCKTYPE_VERBATIM       1
+#define LZX_BLOCKTYPE_ALIGNED        2
+#define LZX_BLOCKTYPE_UNCOMPRESSED   3
+
+/* Maximum value of the "length header" portion of a main symbol.  If the length
+ * header has this value, then the match length is at least LZX_NUM_PRIMARY_LENS
+ * + LZX_MIN_MATCH_LEN, and a length symbol follows.  */
+#define LZX_NUM_PRIMARY_LENS         7
+
+/* Maximum number of position slots.  The actual number of position slots will
+ * depend on the window size.  */
+#define LZX_MAX_POSITION_SLOTS	51
+
+#define LZX_MIN_WINDOW_ORDER	15
+#define LZX_MAX_WINDOW_ORDER	21
+#define LZX_MIN_WINDOW_SIZE	(1U << LZX_MIN_WINDOW_ORDER)  /* 32768   */
+#define LZX_MAX_WINDOW_SIZE	(1U << LZX_MAX_WINDOW_ORDER)  /* 2097152 */
+
+/* Maximum number of symbols in the main code.  The actual number of symbols in
+ * the main code will depend on the window size.  */
+#define LZX_MAINCODE_MAX_NUM_SYMBOLS	(LZX_NUM_CHARS + (LZX_MAX_POSITION_SLOTS << 3))
+
+/* Number of symbols in the length code.  */
+#define LZX_LENCODE_NUM_SYMBOLS		249
+
+/* Number of symbols in the pre-code.  */
+#define LZX_PRECODE_NUM_SYMBOLS		20
+
+/* Number of bits in which each pre-code codeword length is represented.  */
+#define LZX_PRECODE_ELEMENT_SIZE	4
+
+/* Number of symbols in the aligned offset code.  */
+#define LZX_ALIGNEDCODE_NUM_SYMBOLS	8
+
+/* Number of bits in which each aligned offset codeword length is represented.  */
+#define LZX_ALIGNEDCODE_ELEMENT_SIZE	3
+
+/* Maximum lengths (in bits) for length-limited Huffman code construction.  */
+#define LZX_MAX_MAIN_CODEWORD_LEN	16
+#define LZX_MAX_LEN_CODEWORD_LEN	16
+#define LZX_MAX_PRE_CODEWORD_LEN	16
+#define LZX_MAX_ALIGNED_CODEWORD_LEN	8
+
+/* For LZX-compressed blocks in WIM resources, this value is always used as the
+ * filesize parameter for the call instruction (0xe8 byte) preprocessing, even
+ * though the blocks themselves are not this size, and the size of the actual
+ * file resource in the WIM file is very likely to be something entirely
+ * different as well.  */
+#define LZX_WIM_MAGIC_FILESIZE	12000000
+
+/* Assumed LZX block size when the encoded block size begins with a 0 bit.
+ * This is probably WIM-specific.  */
+#define LZX_DEFAULT_BLOCK_SIZE	32768
+
+/* Number of offsets in the recent (or "repeat") offsets queue.  */
+#define LZX_NUM_RECENT_OFFSETS	3
+
+/* An offset of n bytes is actually encoded as (n + LZX_OFFSET_OFFSET).  */
+#define LZX_OFFSET_OFFSET	(LZX_NUM_RECENT_OFFSETS - 1)
+
+#endif /* _LZX_CONSTANTS_H */
diff --git a/src/lzx-common.c b/src/lzx-common.c
index 24bf9974..e61629e7 100644
--- a/src/lzx-common.c
+++ b/src/lzx-common.c
@@ -33,14 +33,8 @@
 #  include <emmintrin.h>
 #endif
 
-/* LZX uses what it calls 'position slots' to represent match offsets.
- * What this means is that a small 'position slot' number and a small
- * offset from that slot are encoded instead of one large offset for
- * every match.
- * - lzx_position_base is an index to the position slot bases
- * - lzx_extra_bits states how many bits of offset-from-base data is needed.
+/* Mapping: position slot => first match offset that uses that position slot.
  */
-
 const u32 lzx_position_base[LZX_MAX_POSITION_SLOTS] = {
 	0      , 1      , 2      , 3      , 4      ,	/* 0  --- 4  */
 	6      , 8      , 12     , 16     , 24     ,	/* 5  --- 9  */
@@ -55,6 +49,8 @@ const u32 lzx_position_base[LZX_MAX_POSITION_SLOTS] = {
 	2097152						/* 50	     */
 };
 
+/* Mapping: position slot => how many extra bits must be read and added to the
+ * corresponding position base to decode the match offset.  */
 #ifdef USE_LZX_EXTRA_BITS_ARRAY
 const u8 lzx_extra_bits[LZX_MAX_POSITION_SLOTS] = {
 	0 , 0 , 0 , 0 , 1 ,
@@ -193,7 +189,7 @@ inline  /* Although inlining the 'process_target' function still speeds up the
 	   SSE2 case, it bloats the binary more.  */
 #endif
 void
-lzx_e8_filter(u8 *data, s32 size, void (*process_target)(s32 *, s32))
+lzx_e8_filter(u8 *data, u32 size, void (*process_target)(s32 *, s32))
 {
 #ifdef __SSE2__
 	/* SSE2 vectorized implementation for x86_64.  This speeds up LZX
@@ -288,13 +284,13 @@ lzx_e8_filter(u8 *data, s32 size, void (*process_target)(s32 *, s32))
 }
 
 void
-lzx_do_e8_preprocessing(u8 *data, s32 size)
+lzx_do_e8_preprocessing(u8 *data, u32 size)
 {
 	lzx_e8_filter(data, size, do_translate_target);
 }
 
 void
-lzx_undo_e8_preprocessing(u8 *data, s32 size)
+lzx_undo_e8_preprocessing(u8 *data, u32 size)
 {
 	lzx_e8_filter(data, size, undo_translate_target);
 }
diff --git a/src/lzx-decompress.c b/src/lzx-decompress.c
index 16b46cb2..0c95ac03 100644
--- a/src/lzx-decompress.c
+++ b/src/lzx-decompress.c
@@ -1,9 +1,7 @@
 /*
  * lzx-decompress.c
  *
- * LZX decompression routines, originally based on code taken from cabextract
- * v0.5, which was, itself, a modified version of the lzx decompression code
- * from unlzx.
+ * A very fast decompressor for LZX, as used in WIM files.
  */
 
 /*
@@ -27,80 +25,31 @@
 
 /*
  * LZX is an LZ77 and Huffman-code based compression format that has many
- * similarities to the DEFLATE format used in zlib.  The compression ratio is as
- * good or better than DEFLATE.
+ * similarities to DEFLATE (the format used by zlib/gzip).  The compression
+ * ratio is as good or better than DEFLATE.  See lzx-compress.c for a format
+ * overview, and see https://en.wikipedia.org/wiki/LZX_(algorithm) for a
+ * historical overview.  Here I make some pragmatic notes.
  *
- * Some notes on the LZX compression format as used in Windows Imaging (WIM)
- * files:
+ * The old specification for LZX is the document "Microsoft LZX Data Compression
+ * Format" (1997).  It defines the LZX format as used in cabinet files.  Allowed
+ * window sizes are 2^n where 15 <= n <= 21.  However, this document contains
+ * several errors, so don't read too much into it...
  *
- * A compressed WIM resource consists of a table of chunk offsets followed by
- * the compressed chunks themselves.  All compressed chunks except possibly the
- * last decompress to a fixed number of bytes, by default 32768.  This is quite
- * similar to the cabinet (.cab) file format, but they are not the same.
- * According to the cabinet format documentation, the LZX block size is
- * independent from the CFDATA blocks, and an LZX block may span several CFDATA
- * blocks.  However, in WIMs, LZX blocks do not appear to ever span multiple WIM
- * chunks.  Note that this means any WIM chunk may be decompressed or compressed
- * independently from any other chunk, which allows random access.
+ * The new specification for LZX is the document "[MS-PATCH]: LZX DELTA
+ * Compression and Decompression" (2014).  It defines the LZX format as used by
+ * Microsoft's binary patcher.  It corrects several errors in the 1997 document
+ * and extends the format in several ways --- namely, optional reference data,
+ * up to 2^25 byte windows, and longer match lengths.
  *
- * An LZX compressed WIM chunk contains one or more LZX blocks of the aligned,
- * verbatim, or uncompressed block types.  For aligned and verbatim blocks, the
- * size of the block in uncompressed bytes is specified by a bit following the 3
- * bits that specify the block type, possibly followed by an additional 16 bits.
- * '1' means to use the default block size (equal to 32768, the default size of
- * a WIM chunk), while '0' means that the block size is provided by the next 16
- * bits.
+ * WIM files use a more restricted form of LZX.  No LZX DELTA extensions are
+ * present, the window is not "sliding", E8 preprocessing is done
+ * unconditionally with a fixed file size, and the maximum window size is always
+ * 2^15 bytes (equal to the size of each "chunk" in a compressed WIM resource).
+ * This code is primarily intended to implement this form of LZX.  But although
+ * not compatible with WIMGAPI, this code also supports maximum window sizes up
+ * to 2^21 bytes.
  *
- * The cabinet format, as documented, allows for the possibility that a
- * compressed CFDATA chunk is up to 6144 bytes larger than the data it
- * uncompresses to.  However, in the WIM format it appears that every chunk that
- * would be 32768 bytes or more when compressed is actually stored fully
- * uncompressed.
- *
- * The 'e8' preprocessing step that changes x86 call instructions to use
- * absolute offsets instead of relative offsets relies on a filesize parameter.
- * There is no such parameter for this in the WIM files (even though the size of
- * the file resource could be used for this purpose), and instead a magic file
- * size of 12000000 is used.  The 'e8' preprocessing is always done, and there
- * is no bit to indicate whether it is done or not.
- */
-
-/*
- * Some more notes about errors in Microsoft's LZX documentation:
- *
- * Microsoft's LZX document and their implementation of the com.ms.util.cab Java
- * package do not concur.
- *
- * In the LZX document, there is a table showing the correlation between window
- * size and the number of position slots. It states that the 1MB window = 40
- * slots and the 2MB window = 42 slots. In the implementation, 1MB = 42 slots,
- * 2MB = 50 slots. The actual calculation is 'find the first slot whose position
- * base is equal to or more than the required window size'. This would explain
- * why other tables in the document refer to 50 slots rather than 42.
- *
- * The constant NUM_PRIMARY_LENS used in the decompression pseudocode is not
- * defined in the specification.
- *
- * The LZX document states that aligned offset blocks have their aligned offset
- * Huffman tree AFTER the main and length trees. The implementation suggests
- * that the aligned offset tree is BEFORE the main and length trees.
- *
- * The LZX document decoding algorithm states that, in an aligned offset block,
- * if an extra_bits value is 1, 2 or 3, then that number of bits should be read
- * and the result added to the match offset. This is correct for 1 and 2, but
- * not 3, where just a Huffman symbol (using the aligned tree) should be read.
- *
- * Regarding the E8 preprocessing, the LZX document states 'No translation may
- * be performed on the last 6 bytes of the input block'. This is correct.
- * However, the pseudocode provided checks for the *E8 leader* up to the last 6
- * bytes. If the leader appears between -10 and -7 bytes from the end, this
- * would cause the next four bytes to be modified, at least one of which would
- * be in the last 6 bytes, which is not allowed according to the spec.
- *
- * The specification states that the Huffman trees must always contain at least
- * one element. However, many CAB files contain blocks where the length tree is
- * completely empty (because there are no matches), and this is expected to
- * succeed.
+ * TODO: Add support for window sizes up to 2^25 bytes.
  */
 
 #ifdef HAVE_CONFIG_H
@@ -115,165 +64,182 @@
 
 #include <string.h>
 
-/* Huffman decoding tables and maps from symbols to code lengths. */
+/* These values are chosen for fast decompression.  */
+#define LZX_MAINCODE_TABLEBITS		11
+#define LZX_LENCODE_TABLEBITS		10
+#define LZX_PRECODE_TABLEBITS		6
+#define LZX_ALIGNEDCODE_TABLEBITS	7
+
+/* Huffman decoding tables, and arrays that map symbols to codeword lengths.  */
 struct lzx_tables {
 
-	u16 maintree_decode_table[(1 << LZX_MAINCODE_TABLEBITS) +
+	u16 maincode_decode_table[(1 << LZX_MAINCODE_TABLEBITS) +
 					(LZX_MAINCODE_MAX_NUM_SYMBOLS * 2)]
 					_aligned_attribute(DECODE_TABLE_ALIGNMENT);
-	u8 maintree_lens[LZX_MAINCODE_MAX_NUM_SYMBOLS];
+	u8 maincode_lens[LZX_MAINCODE_MAX_NUM_SYMBOLS];
 
 
-	u16 lentree_decode_table[(1 << LZX_LENCODE_TABLEBITS) +
+	u16 lencode_decode_table[(1 << LZX_LENCODE_TABLEBITS) +
 					(LZX_LENCODE_NUM_SYMBOLS * 2)]
 					_aligned_attribute(DECODE_TABLE_ALIGNMENT);
-	u8 lentree_lens[LZX_LENCODE_NUM_SYMBOLS];
+	u8 lencode_lens[LZX_LENCODE_NUM_SYMBOLS];
 
 
-	u16 alignedtree_decode_table[(1 << LZX_ALIGNEDCODE_TABLEBITS) +
+	u16 alignedcode_decode_table[(1 << LZX_ALIGNEDCODE_TABLEBITS) +
 					(LZX_ALIGNEDCODE_NUM_SYMBOLS * 2)]
 					_aligned_attribute(DECODE_TABLE_ALIGNMENT);
-	u8 alignedtree_lens[LZX_ALIGNEDCODE_NUM_SYMBOLS];
+	u8 alignedcode_lens[LZX_ALIGNEDCODE_NUM_SYMBOLS];
 } _aligned_attribute(DECODE_TABLE_ALIGNMENT);
 
+/* The main LZX decompressor structure.
+ *
+ * Note: we keep track of most of the decompression state outside this
+ * structure.  This structure only exists so that (1) we can store
+ * @max_window_size and @num_main_syms for multiple calls to lzx_decompress();
+ * and (2) so that we don't have to allocate the large 'struct lzx_tables' on
+ * the stack.  */
 struct lzx_decompressor {
 	u32 max_window_size;
 	unsigned num_main_syms;
 	struct lzx_tables tables;
 };
 
-/*
- * Reads a Huffman-encoded symbol using the pre-tree.
- */
+/* Read a Huffman-encoded symbol using the precode.  */
 static inline u16
-read_huffsym_using_pretree(struct input_bitstream *istream,
-			   const u16 pretree_decode_table[])
+read_huffsym_using_precode(struct input_bitstream *istream,
+			   const u16 precode_decode_table[])
 {
-	return read_huffsym(istream, pretree_decode_table,
+	return read_huffsym(istream, precode_decode_table,
 			    LZX_PRECODE_TABLEBITS, LZX_MAX_PRE_CODEWORD_LEN);
 }
 
-/* Reads a Huffman-encoded symbol using the main tree. */
+/* Read a Huffman-encoded symbol using the main code.  */
 static inline u16
-read_huffsym_using_maintree(struct input_bitstream *istream,
+read_huffsym_using_maincode(struct input_bitstream *istream,
 			    const struct lzx_tables *tables)
 {
-	return read_huffsym(istream, tables->maintree_decode_table,
+	return read_huffsym(istream, tables->maincode_decode_table,
 			    LZX_MAINCODE_TABLEBITS, LZX_MAX_MAIN_CODEWORD_LEN);
 }
 
-/* Reads a Huffman-encoded symbol using the length tree. */
+/* Read a Huffman-encoded symbol using the length code.  */
 static inline u16
-read_huffsym_using_lentree(struct input_bitstream *istream,
+read_huffsym_using_lencode(struct input_bitstream *istream,
 			   const struct lzx_tables *tables)
 {
-	return read_huffsym(istream, tables->lentree_decode_table,
+	return read_huffsym(istream, tables->lencode_decode_table,
 			    LZX_LENCODE_TABLEBITS, LZX_MAX_LEN_CODEWORD_LEN);
 }
 
-/* Reads a Huffman-encoded symbol using the aligned offset tree. */
+/* Read a Huffman-encoded symbol using the aligned offset code.  */
 static inline u16
-read_huffsym_using_alignedtree(struct input_bitstream *istream,
+read_huffsym_using_alignedcode(struct input_bitstream *istream,
 			       const struct lzx_tables *tables)
 {
-	return read_huffsym(istream, tables->alignedtree_decode_table,
+	return read_huffsym(istream, tables->alignedcode_decode_table,
 			    LZX_ALIGNEDCODE_TABLEBITS, LZX_MAX_ALIGNED_CODEWORD_LEN);
 }
 
 /*
- * Reads the pretree from the input, then uses the pretree to decode @num_lens
- * code length values from the input.
+ * Read the precode from the compressed input bitstream, then use it to decode
+ * @num_lens codeword length values.
  *
- * @istream:	The bit stream for the input.  It is positioned on the beginning
- *			of the pretree for the code length values.
- * @lens:	An array that contains the length values from the previous time
- *			the code lengths for this Huffman tree were read, or all
- *			0's if this is the first time.
- * @num_lens:	Number of length values to decode and return.
+ * @istream:
+ *	The input bitstream.
  *
+ * @lens:
+ *	An array that contains the length values from the previous time the
+ *	codeword lengths for this Huffman code were read, or all 0's if this is
+ *	the first time.
+ *
+ * @num_lens:
+ *	Number of length values to decode.
+ *
+ * Returns 0 on success, or -1 if the data was invalid.
  */
 static int
-lzx_read_code_lens(struct input_bitstream *istream, u8 lens[],
-		   unsigned num_lens)
+lzx_read_codeword_lens(struct input_bitstream *istream, u8 lens[], unsigned num_lens)
 {
-	/* Declare the decoding table and length table for the pretree. */
-	u16 pretree_decode_table[(1 << LZX_PRECODE_TABLEBITS) +
+	/* Declare the decoding table and length table for the precode.  */
+	u16 precode_decode_table[(1 << LZX_PRECODE_TABLEBITS) +
 					(LZX_PRECODE_NUM_SYMBOLS * 2)]
 					_aligned_attribute(DECODE_TABLE_ALIGNMENT);
-	u8 pretree_lens[LZX_PRECODE_NUM_SYMBOLS];
-	unsigned i;
+	u8 precode_lens[LZX_PRECODE_NUM_SYMBOLS];
 	int ret;
 
-	/* Read the code lengths of the pretree codes.  There are 20 lengths of
-	 * 4 bits each. */
-	for (i = 0; i < LZX_PRECODE_NUM_SYMBOLS; i++) {
-		pretree_lens[i] = bitstream_read_bits(istream,
+	/* Read the lengths of the precode codewords.  These are given
+	 * explicitly.  */
+	for (int i = 0; i < LZX_PRECODE_NUM_SYMBOLS; i++) {
+		precode_lens[i] = bitstream_read_bits(istream,
 						      LZX_PRECODE_ELEMENT_SIZE);
 	}
 
-	/* Make the decoding table for the pretree. */
-	ret = make_huffman_decode_table(pretree_decode_table,
+	/* Make the decoding table for the precode.  */
+	ret = make_huffman_decode_table(precode_decode_table,
 					LZX_PRECODE_NUM_SYMBOLS,
 					LZX_PRECODE_TABLEBITS,
-					pretree_lens,
+					precode_lens,
 					LZX_MAX_PRE_CODEWORD_LEN);
 	if (ret)
 		return ret;
 
-	/* Pointer past the last length value that needs to be filled in. */
+	/* Pointer past the last length value that needs to be filled in.  */
 	u8 *lens_end = lens + num_lens;
 
-	while (1) {
-
-		/* Decode a symbol from the input.  If the symbol is between 0
-		 * and 16, it is the difference from the old length.  If it is
-		 * between 17 and 19, it is a special code that indicates that
-		 * some number of the next lengths are all 0, or some number of
-		 * the next lengths are all equal to the next symbol in the
-		 * input. */
-		unsigned tree_code;
-		u32 num_zeroes;
-		unsigned code;
-		u32 num_same;
+	for (;;) {
+
+		unsigned presym;
+		unsigned run_len;
 		signed char value;
 
-		tree_code = read_huffsym_using_pretree(istream,
-						       pretree_decode_table);
-		switch (tree_code) {
-		case 17: /* Run of 0's */
-			num_zeroes = bitstream_read_bits(istream, 4);
-			num_zeroes += 4;
-			while (num_zeroes--) {
+		/* Decode a symbol from the input.
+		 *
+		 * If the symbol is between 0 and 16, it is the difference from
+		 * the old length, modulo 17.
+		 *
+		 * If the symbol is between 17 and 19, it is a special symbol
+		 * that indicates that some number of the next lengths are all
+		 * 0, or that some number of the next lengths are all equal to
+		 * the next symbol.  */
+
+		presym = read_huffsym_using_precode(istream,
+						    precode_decode_table);
+		switch (presym) {
+
+		case 17: /* Run of 0's  */
+			run_len = 4 + bitstream_read_bits(istream, 4);
+			do {
 				*lens = 0;
 				if (++lens == lens_end)
 					return 0;
-			}
+			} while (--run_len);
 			break;
-		case 18: /* Longer run of 0's */
-			num_zeroes = bitstream_read_bits(istream, 5);
-			num_zeroes += 20;
-			while (num_zeroes--) {
+
+		case 18: /* Longer run of 0's  */
+			run_len = 20 + bitstream_read_bits(istream, 5);
+			do {
 				*lens = 0;
 				if (++lens == lens_end)
 					return 0;
-			}
+			} while (--run_len);
 			break;
-		case 19: /* Run of identical lengths */
-			num_same = bitstream_read_bits(istream, 1);
-			num_same += 4;
-			code = read_huffsym_using_pretree(istream,
-							  pretree_decode_table);
-			value = (signed char)*lens - (signed char)code;
+
+		case 19: /* Run of identical lengths  */
+			run_len = 4 + bitstream_read_bits(istream, 1);
+			presym = read_huffsym_using_precode(istream,
+							    precode_decode_table);
+			value = (signed char)*lens - (signed char)presym;
 			if (value < 0)
 				value += 17;
-			while (num_same--) {
+			do {
 				*lens = value;
 				if (++lens == lens_end)
 					return 0;
-			}
+			} while (--run_len);
 			break;
-		default: /* Difference from old length. */
-			value = (signed char)*lens - (signed char)tree_code;
+
+		default: /* Difference from old length  */
+			value = (signed char)*lens - (signed char)presym;
 			if (value < 0)
 				value += 17;
 			*lens = value;
@@ -285,40 +251,37 @@ lzx_read_code_lens(struct input_bitstream *istream, u8 lens[],
 }
 
 /*
- * Reads the header for an LZX-compressed block.
+ * Read the header of an LZX block and save the block type and size in
+ * *block_type_ret and *block_size_ret, respectively.
  *
- * @istream:		The input bitstream.
- * @block_size_ret:	A pointer to an int into which the size of the block,
- *				in bytes, will be returned.
- * @block_type_ret:	A pointer to an int into which the type of the block
- *				(LZX_BLOCKTYPE_*) will be returned.
- * @tables:		A pointer to an lzx_tables structure in which the
- *				main tree, the length tree, and possibly the
- *				aligned offset tree will be constructed.
- * @queue:	A pointer to the least-recently-used queue into which
- *			R0, R1, and R2 will be written (only for uncompressed
- *			blocks, which contain this information in the header)
+ * If the block is compressed, also update the Huffman decode @tables with the
+ * new Huffman codes.
+ *
+ * If the block is uncompressed, also update the match offset @queue with the
+ * new match offsets.
+ *
+ * Return 0 on success, or -1 if the data was invalid.
  */
 static int
 lzx_read_block_header(struct input_bitstream *istream,
 		      unsigned num_main_syms,
-		      unsigned max_window_size,
-		      unsigned *block_size_ret,
-		      unsigned *block_type_ret,
+		      u32 max_window_size,
+		      int *block_type_ret,
+		      u32 *block_size_ret,
 		      struct lzx_tables *tables,
 		      struct lzx_lru_queue *queue)
 {
+	int block_type;
+	u32 block_size;
 	int ret;
-	unsigned block_type;
-	unsigned block_size;
 
 	bitstream_ensure_bits(istream, 4);
 
-	/* The first three bits tell us what kind of block it is, and are one
-	 * of the LZX_BLOCKTYPE_* values.  */
+	/* The first three bits tell us what kind of block it is, and should be
+	 * one of the LZX_BLOCKTYPE_* values.  */
 	block_type = bitstream_pop_bits(istream, 3);
 
-	/* Read the block size.  This mirrors the behavior
+	/* Read the block size.  This mirrors the behavior of
 	 * lzx_write_compressed_block() in lzx-compress.c; see that for more
 	 * details.  */
 	if (bitstream_pop_bits(istream, 1)) {
@@ -341,118 +304,89 @@ lzx_read_block_header(struct input_bitstream *istream,
 	}
 
 	switch (block_type) {
+
 	case LZX_BLOCKTYPE_ALIGNED:
-		/* Read the path lengths for the elements of the aligned tree,
-		 * then build it. */
 
-		for (unsigned i = 0; i < LZX_ALIGNEDCODE_NUM_SYMBOLS; i++) {
-			tables->alignedtree_lens[i] =
+		/* Read the aligned offset code and prepare its decode table.
+		 */
+
+		for (int i = 0; i < LZX_ALIGNEDCODE_NUM_SYMBOLS; i++) {
+			tables->alignedcode_lens[i] =
 				bitstream_read_bits(istream,
 						    LZX_ALIGNEDCODE_ELEMENT_SIZE);
 		}
 
-		LZX_DEBUG("Building the aligned tree.");
-		ret = make_huffman_decode_table(tables->alignedtree_decode_table,
+		ret = make_huffman_decode_table(tables->alignedcode_decode_table,
 						LZX_ALIGNEDCODE_NUM_SYMBOLS,
 						LZX_ALIGNEDCODE_TABLEBITS,
-						tables->alignedtree_lens,
+						tables->alignedcode_lens,
 						LZX_MAX_ALIGNED_CODEWORD_LEN);
-		if (ret) {
-			LZX_DEBUG("Failed to make the decode table for the "
-				  "aligned offset tree");
+		if (ret)
 			return ret;
-		}
 
 		/* Fall though, since the rest of the header for aligned offset
-		 * blocks is the same as that for verbatim blocks */
+		 * blocks is the same as that for verbatim blocks.  */
 
 	case LZX_BLOCKTYPE_VERBATIM:
-		if (block_type == LZX_BLOCKTYPE_VERBATIM)
-			LZX_DEBUG("Found verbatim block.");
-
-		LZX_DEBUG("Reading path lengths for main tree.");
-		/* Read the path lengths for the first 256 elements of the main
-		 * tree. */
-		ret = lzx_read_code_lens(istream, tables->maintree_lens,
-					 LZX_NUM_CHARS);
-		if (ret) {
-			LZX_DEBUG("Failed to read the code lengths for the "
-				  "first 256 elements of the main tree");
-			return ret;
-		}
 
-		/* Read the path lengths for the remaining elements of the main
-		 * tree. */
-		LZX_DEBUG("Reading path lengths for remaining elements of "
-			  "main tree (%d elements).",
-			  num_main_syms - LZX_NUM_CHARS);
-		ret = lzx_read_code_lens(istream,
-					 tables->maintree_lens + LZX_NUM_CHARS,
-					 num_main_syms - LZX_NUM_CHARS);
-		if (ret) {
-			LZX_DEBUG("Failed to read the path lengths for the "
-				  "remaining elements of the main tree");
+		/* Read the main code and prepare its decode table.
+		 *
+		 * Note that the codeword lengths in the main code are encoded
+		 * in two parts: one part for literal symbols, and one part for
+		 * match symbols.  */
+
+		ret = lzx_read_codeword_lens(istream, tables->maincode_lens,
+					     LZX_NUM_CHARS);
+		if (ret)
 			return ret;
-		}
 
-		LZX_DEBUG("Building the Huffman decoding "
-			  "table for the main tree.");
+		ret = lzx_read_codeword_lens(istream,
+					     tables->maincode_lens + LZX_NUM_CHARS,
+					     num_main_syms - LZX_NUM_CHARS);
+		if (ret)
+			return ret;
 
-		ret = make_huffman_decode_table(tables->maintree_decode_table,
+		ret = make_huffman_decode_table(tables->maincode_decode_table,
 						num_main_syms,
 						LZX_MAINCODE_TABLEBITS,
-						tables->maintree_lens,
+						tables->maincode_lens,
 						LZX_MAX_MAIN_CODEWORD_LEN);
-		if (ret) {
-			LZX_DEBUG("Failed to make the decode "
-				  "table for the main tree");
+		if (ret)
 			return ret;
-		}
 
-		LZX_DEBUG("Reading path lengths for the length tree.");
-		ret = lzx_read_code_lens(istream, tables->lentree_lens,
-					 LZX_LENCODE_NUM_SYMBOLS);
-		if (ret) {
-			LZX_DEBUG("Failed to read the path "
-				  "lengths for the length tree");
+		/* Read the length code and prepare its decode table.  */
+
+		ret = lzx_read_codeword_lens(istream, tables->lencode_lens,
+					     LZX_LENCODE_NUM_SYMBOLS);
+		if (ret)
 			return ret;
-		}
 
-		LZX_DEBUG("Building the length tree.");
-		ret = make_huffman_decode_table(tables->lentree_decode_table,
+		ret = make_huffman_decode_table(tables->lencode_decode_table,
 						LZX_LENCODE_NUM_SYMBOLS,
 						LZX_LENCODE_TABLEBITS,
-						tables->lentree_lens,
+						tables->lencode_lens,
 						LZX_MAX_LEN_CODEWORD_LEN);
-		if (ret) {
-			LZX_DEBUG("Failed to build the length Huffman tree");
+		if (ret)
 			return ret;
-		}
-		/* The bitstream of compressed literals and matches for this
-		 * block directly follows and will be read in
-		 * lzx_decompress_block(). */
+
 		break;
+
 	case LZX_BLOCKTYPE_UNCOMPRESSED:
-		LZX_DEBUG("Found uncompressed block.");
+
 		/* Before reading the three LRU match offsets from the
-		 * uncompressed block header, the stream needs to be aligned on
-		 * a 16-bit boundary.  But, unexpectedly, if the stream is
+		 * uncompressed block header, the stream must be aligned on a
+		 * 16-bit boundary.  But, unexpectedly, if the stream is
 		 * *already* aligned, the correct thing to do is to throw away
-		 * the next 16 bits. */
+		 * the next 16 bits.  */
+
 		if (istream->bitsleft == 0) {
-			if (istream->data_bytes_left < 14) {
-				LZX_DEBUG("Insufficient length in "
-					  "uncompressed block");
+			if (istream->data_bytes_left < 14)
 				return -1;
-			}
 			istream->data += 2;
 			istream->data_bytes_left -= 2;
 		} else {
-			if (istream->data_bytes_left < 12) {
-				LZX_DEBUG("Insufficient length in "
-					  "uncompressed block");
+			if (istream->data_bytes_left < 12)
 				return -1;
-			}
 			istream->bitsleft = 0;
 			istream->bitbuf = 0;
 		}
@@ -461,86 +395,56 @@ lzx_read_block_header(struct input_bitstream *istream,
 		queue->R[2] = le32_to_cpu(*(le32*)(istream->data + 8));
 		istream->data += 12;
 		istream->data_bytes_left -= 12;
-		/* The uncompressed data of this block directly follows and will
-		 * be read in lzx_decompress(). */
 		break;
+
 	default:
-		LZX_DEBUG("Found invalid block");
+		/* Unrecognized block type.  */
 		return -1;
 	}
+
 	*block_type_ret = block_type;
 	*block_size_ret = block_size;
 	return 0;
 }
 
 /*
- * Decodes a compressed match from a block of LZX-compressed data.  A match
- * refers to some match_offset to a point earlier in the window as well as some
- * match_len, for which the data is to be copied to the current position in the
- * window.
- *
- * @main_element:	The start of the match data, as decoded using the main
- *			tree.
- *
- * @block_type:		The type of the block (LZX_BLOCKTYPE_ALIGNED or
- *			LZX_BLOCKTYPE_VERBATIM)
- *
- * @bytes_remaining:	The amount of uncompressed data remaining to be
- *			uncompressed in this block.  It is an error if the match
- *			is longer than this number.
- *
- * @window:		A pointer to the window into which the uncompressed
- *			data is being written.
- *
- * @window_pos:		The current byte offset in the window.
- *
- * @tables:		The Huffman decoding tables for this LZX block (main
- *			code, length code, and for LZX_BLOCKTYPE_ALIGNED blocks,
- *			also the aligned offset code).
- *
- * @queue:		The least-recently used queue for match offsets.
+ * Decode a match and copy its bytes into the decompression window.
  *
- * @istream:		The input bitstream.
- *
- * Returns the length of the match, or a negative number on error.  The possible
- * error cases are:
- *	- Match would exceed the amount of data remaining to be uncompressed.
- *	- Match refers to data before the window.
- *	- The input bitstream ended unexpectedly.
+ * Return the length of the match in bytes, or 0 if the match underflowed the
+ * window or overflowed the current block.
  */
-static int
-lzx_decode_match(unsigned main_element, int block_type,
-		 unsigned bytes_remaining, u8 *window,
-		 unsigned window_pos,
+static u32
+lzx_decode_match(unsigned main_symbol, int block_type,
+		 u32 bytes_remaining, u8 *window, u32 window_pos,
 		 const struct lzx_tables *tables,
 		 struct lzx_lru_queue *queue,
 		 struct input_bitstream *istream)
 {
 	unsigned length_header;
 	unsigned position_slot;
-	unsigned match_len;
-	unsigned match_offset;
+	u32 match_len;
+	u32 match_offset;
 	unsigned num_extra_bits;
 	u32 verbatim_bits;
 	u32 aligned_bits;
 
-	/* The main element is offset by 256 because values under 256 indicate a
-	 * literal value. */
-	main_element -= LZX_NUM_CHARS;
+	/* The main symbol is offset by 256 because values under 256 indicate a
+	 * literal value.  */
+	main_symbol -= LZX_NUM_CHARS;
 
 	/* The length header consists of the lower 3 bits of the main element.
 	 * The position slot is the rest of it. */
-	length_header = main_element & LZX_NUM_PRIMARY_LENS;
-	position_slot = main_element >> 3;
+	length_header = main_symbol & LZX_NUM_PRIMARY_LENS;
+	position_slot = main_symbol >> 3;
 
 	/* If the length_header is less than LZX_NUM_PRIMARY_LENS (= 7), it
 	 * gives the match length as the offset from LZX_MIN_MATCH_LEN.
 	 * Otherwise, the length is given by an additional symbol encoded using
-	 * the length tree, offset by 9 (LZX_MIN_MATCH_LEN +
+	 * the length code, offset by 9 (LZX_MIN_MATCH_LEN +
 	 * LZX_NUM_PRIMARY_LENS) */
 	match_len = LZX_MIN_MATCH_LEN + length_header;
 	if (length_header == LZX_NUM_PRIMARY_LENS)
-		match_len += read_huffsym_using_lentree(istream, tables);
+		match_len += read_huffsym_using_lencode(istream, tables);
 
 	/* If the position_slot is 0, 1, or 2, the match offset is retrieved
 	 * from the LRU queue.  Otherwise, the match offset is not in the LRU
@@ -565,8 +469,8 @@ lzx_decode_match(unsigned main_element, int block_type,
 		/* For aligned blocks, if there are at least 3 extra bits, the
 		 * actual number of extra bits is 3 less, and they encode a
 		 * number of 8-byte words that are added to the offset; there
-		 * is then an additional symbol read using the aligned tree that
-		 * specifies the actual byte alignment. */
+		 * is then an additional symbol read using the aligned offset
+		 * code that specifies the actual byte alignment. */
 		if (block_type == LZX_BLOCKTYPE_ALIGNED && num_extra_bits >= 3) {
 
 			/* There is an error in the LZX "specification" at this
@@ -579,7 +483,7 @@ lzx_decode_match(unsigned main_element, int block_type,
 			verbatim_bits = bitstream_read_bits(istream,
 							    num_extra_bits - 3);
 			verbatim_bits <<= 3;
-			aligned_bits = read_huffsym_using_alignedtree(istream,
+			aligned_bits = read_huffsym_using_alignedcode(istream,
 								      tables);
 		} else {
 			/* For non-aligned blocks, or for aligned blocks with
@@ -600,23 +504,13 @@ lzx_decode_match(unsigned main_element, int block_type,
 		queue->R[0] = match_offset;
 	}
 
-	/* Verify that the match is in the bounds of the part of the window
-	 * currently in use, then copy the source of the match to the current
-	 * position. */
+	/* Validate the match, then copy it to the current position.  */
 
-	if (unlikely(match_len > bytes_remaining)) {
-		LZX_DEBUG("Match of length %u bytes overflows "
-			  "uncompressed block size", match_len);
-		return -1;
-	}
+	if (unlikely(match_len > bytes_remaining))
+		return 0;
 
-	if (unlikely(match_offset > window_pos)) {
-		LZX_DEBUG("Match of length %u bytes references "
-			  "data before window (match_offset = %u, "
-			  "window_pos = %u)",
-			  match_len, match_offset, window_pos);
-		return -1;
-	}
+	if (unlikely(match_offset > window_pos))
+		return 0;
 
 	lz_copy(&window[window_pos], match_len, match_offset,
 		&window[window_pos + bytes_remaining]);
@@ -625,50 +519,60 @@ lzx_decode_match(unsigned main_element, int block_type,
 }
 
 /*
- * Decompresses an LZX-compressed block of data from which the header has already
- * been read.
+ * Decompress an LZX-compressed block of data.
+ *
+ * @block_type:
+ *	The type of the block (LZX_BLOCKTYPE_VERBATIM or LZX_BLOCKTYPE_ALIGNED).
+ *
+ * @block_size:
+ *	The size of the block, in bytes.
+ *
+ * @window:
+ *	Pointer to the beginning of the decompression window.
+ *
+ * @window_pos:
+ *	The position in the window at which the block starts.
+ *
+ * @tables:
+ *	The Huffman decoding tables for the block.
  *
- * @block_type:	The type of the block (LZX_BLOCKTYPE_VERBATIM or
- *		LZX_BLOCKTYPE_ALIGNED)
- * @block_size:	The size of the block, in bytes.
- * @window:	Pointer to the decompression window.
- * @window_pos:	The current position in the window.  Will be 0 for the first
- *			block.
- * @tables:	The Huffman decoding tables for the block (main, length, and
- *			aligned offset, the latter only for LZX_BLOCKTYPE_ALIGNED)
- * @queue:	The least-recently-used queue for match offsets.
- * @istream:	The input bitstream for the compressed literals.
+ * @queue:
+ *	The least-recently-used queue for match offsets.
+ *
+ * @istream:
+ *	The input bitstream, positioned at the start of the block data.
+ *
+ * Returns 0 on success, or -1 if the data was invalid.
  */
 static int
-lzx_decompress_block(int block_type, unsigned block_size,
-		     u8 *window,
-		     unsigned window_pos,
+lzx_decompress_block(int block_type, u32 block_size,
+		     u8 *window, u32 window_pos,
 		     const struct lzx_tables *tables,
 		     struct lzx_lru_queue *queue,
 		     struct input_bitstream *istream)
 {
-	unsigned main_element;
-	unsigned end;
-	int match_len;
-
-	end = window_pos + block_size;
-	while (window_pos < end) {
-		main_element = read_huffsym_using_maintree(istream, tables);
-		if (main_element < LZX_NUM_CHARS) {
-			/* literal: 0 to LZX_NUM_CHARS - 1 */
-			window[window_pos++] = main_element;
+	u32 block_end;
+	unsigned main_symbol;
+	u32 match_len;
+
+	block_end = window_pos + block_size;
+	while (window_pos < block_end) {
+		main_symbol = read_huffsym_using_maincode(istream, tables);
+		if (main_symbol < LZX_NUM_CHARS) {
+			/* Literal  */
+			window[window_pos++] = main_symbol;
 		} else {
-			/* match: LZX_NUM_CHARS to num_main_syms - 1 */
-			match_len = lzx_decode_match(main_element,
+			/* Match  */
+			match_len = lzx_decode_match(main_symbol,
 						     block_type,
-						     end - window_pos,
+						     block_end - window_pos,
 						     window,
 						     window_pos,
 						     tables,
 						     queue,
 						     istream);
-			if (unlikely(match_len < 0))
-				return match_len;
+			if (unlikely(match_len == 0))
+				return -1;
 			window_pos += match_len;
 		}
 	}
@@ -678,38 +582,32 @@ lzx_decompress_block(int block_type, unsigned block_size,
 static int
 lzx_decompress(const void *compressed_data, size_t compressed_size,
 	       void *uncompressed_data, size_t uncompressed_size,
-	       void *_ctx)
+	       void *_dec)
 {
-	struct lzx_decompressor *ctx = _ctx;
+	struct lzx_decompressor *dec = _dec;
 	struct input_bitstream istream;
 	struct lzx_lru_queue queue;
-	unsigned window_pos;
-	unsigned block_size;
-	unsigned block_type;
+	u32 window_pos;
+	int block_type;
+	u32 block_size;
+	bool may_have_e8_byte;
 	int ret;
-	bool e8_preprocessing_done;
-
-	LZX_DEBUG("compressed_data = %p, compressed_size = %zu, "
-		  "uncompressed_data = %p, uncompressed_size = %zu, "
-		  "max_window_size=%u).",
-		  compressed_data, compressed_size,
-		  uncompressed_data, uncompressed_size,
-		  ctx->max_window_size);
-
-	if (uncompressed_size > ctx->max_window_size) {
-		LZX_DEBUG("Uncompressed size of %zu exceeds "
-			  "window size of %u!",
-			  uncompressed_size, ctx->max_window_size);
+
+	if (uncompressed_size > dec->max_window_size)
 		return -1;
-	}
 
-	memset(ctx->tables.maintree_lens, 0, sizeof(ctx->tables.maintree_lens));
-	memset(ctx->tables.lentree_lens, 0, sizeof(ctx->tables.lentree_lens));
-	lzx_lru_queue_init(&queue);
 	init_input_bitstream(&istream, compressed_data, compressed_size);
 
-	e8_preprocessing_done = false; /* Set to true if there may be 0xe8 bytes
-					  in the uncompressed data. */
+	/* Initialize the recent offsets queue.  */
+	lzx_lru_queue_init(&queue);
+
+	/* Codeword lengths begin as all 0's for delta encoding purposes.  */
+	memset(dec->tables.maincode_lens, 0, sizeof(dec->tables.maincode_lens));
+	memset(dec->tables.lencode_lens, 0, sizeof(dec->tables.lencode_lens));
+
+	/* Set this to true if there may be 0xe8 bytes in the uncompressed data.
+	 */
+	may_have_e8_byte = false;
 
 	/* The compressed data will consist of one or more blocks.  The
 	 * following loop decompresses one block, and it runs until there all
@@ -720,96 +618,89 @@ lzx_decompress(const void *compressed_data, size_t compressed_size,
 	     window_pos < uncompressed_size;
 	     window_pos += block_size)
 	{
-		LZX_DEBUG("Reading block header.");
-		ret = lzx_read_block_header(&istream, ctx->num_main_syms,
-					    ctx->max_window_size, &block_size,
-					    &block_type, &ctx->tables, &queue);
+		ret = lzx_read_block_header(&istream, dec->num_main_syms,
+					    dec->max_window_size, &block_type,
+					    &block_size, &dec->tables, &queue);
 		if (ret)
 			return ret;
 
-		LZX_DEBUG("block_size = %u, window_pos = %u",
-			  block_size, window_pos);
-
-		if (block_size > uncompressed_size - window_pos) {
-			LZX_DEBUG("Expected a block size of at "
-				  "most %zu bytes (found %u bytes)",
-				  uncompressed_size - window_pos, block_size);
+		if (block_size > uncompressed_size - window_pos)
 			return -1;
-		}
 
-		switch (block_type) {
-		case LZX_BLOCKTYPE_VERBATIM:
-		case LZX_BLOCKTYPE_ALIGNED:
-			if (block_type == LZX_BLOCKTYPE_VERBATIM)
-				LZX_DEBUG("LZX_BLOCKTYPE_VERBATIM");
-			else
-				LZX_DEBUG("LZX_BLOCKTYPE_ALIGNED");
+		if (block_type != LZX_BLOCKTYPE_UNCOMPRESSED) {
+
+			/* Compressed block.  */
+
 			ret = lzx_decompress_block(block_type,
 						   block_size,
 						   uncompressed_data,
 						   window_pos,
-						   &ctx->tables,
+						   &dec->tables,
 						   &queue,
 						   &istream);
 			if (ret)
 				return ret;
 
-			if (ctx->tables.maintree_lens[0xe8] != 0)
-				e8_preprocessing_done = true;
-			break;
-		case LZX_BLOCKTYPE_UNCOMPRESSED:
-			LZX_DEBUG("LZX_BLOCKTYPE_UNCOMPRESSED");
-			if (istream.data_bytes_left < block_size) {
-				LZX_DEBUG("Unexpected end of input when "
-					  "reading %u bytes from LZX bitstream "
-					  "(only have %u bytes left)",
-					  block_size, istream.data_bytes_left);
+			/* If the first 0xe8 byte was in this block, it must
+			 * have been encoded as a literal using mainsym 0xe8. */
+			if (dec->tables.maincode_lens[0xe8] != 0)
+				may_have_e8_byte = true;
+		} else {
+
+			/* Uncompressed block.  */
+
+			if (istream.data_bytes_left < block_size)
 				return -1;
-			}
+
 			memcpy(&((u8*)uncompressed_data)[window_pos], istream.data,
 			       block_size);
 			istream.data += block_size;
 			istream.data_bytes_left -= block_size;
-			/* Re-align bitstream if an odd number of bytes were
+
+			/* Re-align the bitstream if an odd number of bytes was
 			 * read.  */
 			if (istream.data_bytes_left && (block_size & 1)) {
 				istream.data_bytes_left--;
 				istream.data++;
 			}
-			e8_preprocessing_done = true;
-			break;
+			may_have_e8_byte = true;
 		}
 	}
-	if (e8_preprocessing_done)
+
+	/* Postprocess the data unless it cannot possibly contain 0xe8 bytes  */
+	if (may_have_e8_byte)
 		lzx_undo_e8_preprocessing(uncompressed_data, uncompressed_size);
+
 	return 0;
 }
 
 static void
-lzx_free_decompressor(void *_ctx)
+lzx_free_decompressor(void *_dec)
 {
-	struct lzx_decompressor *ctx = _ctx;
+	struct lzx_decompressor *dec = _dec;
 
-	ALIGNED_FREE(ctx);
+	ALIGNED_FREE(dec);
 }
 
 static int
-lzx_create_decompressor(size_t max_window_size, void **ctx_ret)
+lzx_create_decompressor(size_t max_window_size, void **dec_ret)
 {
-	struct lzx_decompressor *ctx;
+	struct lzx_decompressor *dec;
 
 	if (!lzx_window_size_valid(max_window_size))
 		return WIMLIB_ERR_INVALID_PARAM;
 
-	ctx = ALIGNED_MALLOC(sizeof(struct lzx_decompressor),
+	/* The aligned allocation is needed to ensure that the lzx_tables are
+	 * aligned properly.  */
+	dec = ALIGNED_MALLOC(sizeof(struct lzx_decompressor),
 			     DECODE_TABLE_ALIGNMENT);
-	if (ctx == NULL)
+	if (!dec)
 		return WIMLIB_ERR_NOMEM;
 
-	ctx->max_window_size = max_window_size;
-	ctx->num_main_syms = lzx_get_num_main_syms(max_window_size);
+	dec->max_window_size = max_window_size;
+	dec->num_main_syms = lzx_get_num_main_syms(max_window_size);
 
-	*ctx_ret = ctx;
+	*dec_ret = dec;
 	return 0;
 }
 
-- 
2.43.0


From 41fb4d5debd14f3a0e1717bf25e7e145cd42ae1f Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers3@gmail.com>
Date: Wed, 6 Aug 2014 18:58:10 -0500
Subject: [PATCH 11/16] Update README and README.WINDOWS

---
 README         | 59 +++++++++++++++++++++-----------------------------
 README.WINDOWS | 15 ++++++-------
 2 files changed, 32 insertions(+), 42 deletions(-)

diff --git a/README b/README
index 2a171888..9a3f26da 100644
--- a/README
+++ b/README
@@ -2,16 +2,15 @@
 
 This is wimlib version 1.7.1-BETA (June 2014).  wimlib is a C library for
 creating, modifying, extracting, and mounting files in the Windows Imaging
-Format (WIM files).  These files are normally created using the ImageX
-(imagex.exe) or Dism (Dism.exe) utilities on Windows, but wimlib is distributed
-with a free implementation of ImageX called "wimlib-imagex" for both UNIX-like
-systems and Windows.
+Format (WIM files).  wimlib and its command-line frontend 'wimlib-imagex'
+provide a free and cross-platform alternative to Microsoft's WIMGAPI, ImageX,
+and DISM.
 
                                   INSTALLATION
 
-To install wimlib and wimlib-imagex on Windows you simply need to download and
-extract the ZIP file containing the latest binaries from the SourceForge page
-(http://sourceforge.net/projects/wimlib/), which you may have already done.
+To install wimlib and wimlib-imagex on Windows, simply download and extract the
+ZIP file containing the latest binaries from the SourceForge page
+(http://sourceforge.net/projects/wimlib/).  You probably have already done this!
 
 To install wimlib and wimlib-imagex on UNIX-like systems (with Linux being the
 primary supported and tested platform), you must compile the source code, which
@@ -309,47 +308,42 @@ This section documents the most important options that may be passed to the
 
                                   PORTABILITY
 
-wimlib has primarily been tested on Linux and Windows (primarily Windows 7, but
-also Windows XP and Windows 8).
+wimlib works on both UNIX-like systems (Linux, Mac OS X, FreeBSD, etc.) and
+Windows (XP and later).
 
-wimlib may work on FreeBSD and Mac OS X.  However, this is not well tested.  If
-you do not have libntfs-3g 2011-4-12 or later available, you must configure
-wimlib with --without-ntfs-3g.  On FreeBSD, before mounting a WIM you need to
-load the POSIX message queue module (run `kldload mqueuefs').
+On UNIX-like systems other than Linux, you must compile --without-fuse.
+In addition, --without-ntfs-3g and --without-libcrypto are needed if the
+corresponding libraries are not available on your system.
 
-The code has primarily been tested on x86 and x86_64 CPUs, but it's written to
-be portable to other architectures and I've also tested it on ARM.  However,
-although the code is written to correctly deal with endianness, it has not yet
-actually been tested on a big-endian architecture.
+wimlib works on x86 and x86_64, but it should work on any other GCC-supported
+32-bit or 64-bit architecture.
 
                                    REFERENCES
 
 The WIM file format is partially specified in a document that can be found in
 the Microsoft Download Center.  However, this document really only provides an
-overview of the format and is not a formal specification.
+overview of the format and is not a formal specification.  It also does not
+cover later extensions of the format, such as solid blocks.
 
 With regards to the supported compression formats:
 
 - Microsoft has official documentation for XPRESS that is of reasonable quality.
-- Microsoft has official documentation for LZX but it contains errors.
+- Microsoft has official documentation for LZX, but in two different documents,
+  neither of which is completely applicable to its use in the WIM format, and
+  the first of which contains multiple errors.
 - There does not seem to be any official documentation for LZMS, so my comments
   and code in src/lzms-decompress.c may in fact be the best documentation
   available for this particular compression format.
 
+The algorithms used by wimlib's compression and decompression codecs are
+inspired by a variety of sources, including open source projects and computer
+science papers.
+
 The code in ntfs-3g_apply.c and ntfs-3g_capture.c uses the NTFS-3g library,
 which is a library for reading and writing to NTFS filesystems (the filesystem
 used by recent versions of Windows).  See
 http://www.tuxera.com/community/ntfs-3g-download/ for more information.
 
-The LZX decompressor (lzx-decompress.c) was originally based on code from the
-cabextract project (http://www.cabextract.org.uk).  The LZX compressor
-(lzx-compress.c) was originally based on code written by Matthew Russotto
-(www.russotto.net/chm/).  However I have since rewritten and made many
-improvements to both the decompressor and compressor.
-
-lz_binary_trees.c contains LZ77 match-finding code that uses binary trees.  It
-is based on code from liblzma but I have since rewritten it.
-
 A limited number of other free programs can handle some parts of the WIM
 file format:
 
@@ -357,8 +351,9 @@ file format:
     other archive formats).  However, wimlib is designed specifically to handle
     WIM files and provides features previously only available in Microsoft's
     implementation, such as the ability to mount WIMs read-write as well as
-    read-only, the ability to create compressed WIMs, and the correct handling
-    of security descriptors and hard links.
+    read-only, the ability to create compressed WIMs, the correct handling of
+    security descriptors and hard links, support for LZMS compression, and
+    support for solid archives.
   * ImagePyX (https://github.com/maxpat78/ImagePyX) is a Python program that
     provides similar capabilities to wimlib-imagex.  One thing to note, though,
     is that it does not support compression and decompression by itself, but
@@ -386,7 +381,3 @@ functionality.
 
 wimlib comes with no warranty whatsoever.  Please submit a bug report (to
 ebiggers3@gmail.com) if you find a bug in wimlib and/or wimlib-imagex.
-
-Be aware that some parts of the WIM file format are poorly documented or even
-completely undocumented, so I've just had to do the best I can to read and write
-WIMs that appear to be compatible with Microsoft's software.
diff --git a/README.WINDOWS b/README.WINDOWS
index 10406467..775d545d 100644
--- a/README.WINDOWS
+++ b/README.WINDOWS
@@ -12,9 +12,9 @@ you should read too.
 For the convenience of Windows users, the Windows distribution of wimlib is a
 ZIP file containing the following items:
 
-  * wimlib-imagex.exe, a command-line tool to deal with WIM (.wim) and split WIM
-    (.swm) files that is similar to Microsoft's ImageX.  This is a ready-to-run
-    executable and not an installer.
+  * wimlib-imagex.exe, a command-line tool to deal with WIM (.wim), split WIM
+    (.swm), and ESD (.esd) files that is inspired by Microsoft's ImageX and
+    DISM.  This is a ready-to-run executable and not an installer.
 
   * Very short batch scripts (e.g. wimapply.cmd) which are shortcuts to the
     corresponding wimlib-imagex commands (e.g. `wimlib-imagex apply').
@@ -69,8 +69,7 @@ It's recommended to use wimlib-imagex in scripts to avoid having to
 interactively enter commands.  However, note that wimlib-imagex is largely just
 a command-line front-end for wimlib, and it's possible to use wimlib's API in
 other front-ends or applications.  Currently there is no official graphical user
-interface available for wimlib or wimlib-imagex.  An unofficial Windows-only
-graphical user interface that provides a thin wrapper around wimlib-imagex can
-be downloaded at
-http://reboot.pro/files/file/485-wimlib-imagex-command-line-compiler/; however,
-as of 2014-03-23 it is still under development and is only released for testing.
+interface available for wimlib or wimlib-imagex.  However, an unofficial, beta,
+Windows-only graphical user interface that provides a thin wrapper around
+wimlib-imagex can be downloaded at
+http://reboot.pro/files/file/485-wimlib-imagex-command-line-compiler/.
-- 
2.43.0


From f2d4403b993204bffba09dca31b424d158218209 Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers3@gmail.com>
Date: Wed, 6 Aug 2014 21:48:41 -0500
Subject: [PATCH 12/16] Add sparse annotations for endianness checking

---
 include/wimlib/compiler.h   |  8 +++++++
 include/wimlib/endianness.h | 48 ++++++++++++++++++-------------------
 include/wimlib/types.h      | 25 +++++++++----------
 3 files changed, 45 insertions(+), 36 deletions(-)

diff --git a/include/wimlib/compiler.h b/include/wimlib/compiler.h
index fd8942f1..567f07d0 100644
--- a/include/wimlib/compiler.h
+++ b/include/wimlib/compiler.h
@@ -46,4 +46,12 @@
 #	define is_constant(x) (0)
 #endif /* __GNUC__ */
 
+#ifdef __CHECKER__
+#  define _bitwise_attr	__attribute__((bitwise))
+#  define _force_attr	__attribute__((force))
+#else
+#  define _bitwise_attr
+#  define _force_attr
+#endif
+
 #endif /* _WIMLIB_COMPILER_H */
diff --git a/include/wimlib/endianness.h b/include/wimlib/endianness.h
index 25726166..4c1b239f 100644
--- a/include/wimlib/endianness.h
+++ b/include/wimlib/endianness.h
@@ -38,33 +38,33 @@ bswap64(u64 n)
 }
 
 #  ifdef WORDS_BIGENDIAN
-#    define le16_to_cpu(n) bswap16(n)
-#    define le32_to_cpu(n) bswap32(n)
-#    define le64_to_cpu(n) bswap64(n)
-#    define cpu_to_le16(n) bswap16(n)
-#    define cpu_to_le32(n) bswap32(n)
-#    define cpu_to_le64(n) bswap64(n)
+#    define cpu_to_le16(n) ((_force_attr le16)bswap16(n))
+#    define cpu_to_le32(n) ((_force_attr le32)bswap32(n))
+#    define cpu_to_le64(n) ((_force_attr le64)bswap64(n))
+#    define le16_to_cpu(n) bswap16((_force_attr u16)(le16)(n))
+#    define le32_to_cpu(n) bswap32((_force_attr u32)(le32)(n))
+#    define le64_to_cpu(n) bswap64((_force_attr u64)(le64)(n))
 
-#    define cpu_to_be16(n) (n)
-#    define cpu_to_be32(n) (n)
-#    define cpu_to_be64(n) (n)
-#    define be16_to_cpu(n) (n)
-#    define be32_to_cpu(n) (n)
-#    define be64_to_cpu(n) (n)
+#    define cpu_to_be16(n) ((_force_attr be16)(u16)(n))
+#    define cpu_to_be32(n) ((_force_attr be32)(u32)(n))
+#    define cpu_to_be64(n) ((_force_attr be64)(u64)(n))
+#    define be16_to_cpu(n) ((_force_attr u16)(be16)(n))
+#    define be32_to_cpu(n) ((_force_attr u32)(be32)(n))
+#    define be64_to_cpu(n) ((_force_attr u64)(be64)(n))
 #  else
-#    define cpu_to_le16(n) (n)
-#    define cpu_to_le32(n) (n)
-#    define cpu_to_le64(n) (n)
-#    define le16_to_cpu(n) (n)
-#    define le32_to_cpu(n) (n)
-#    define le64_to_cpu(n) (n)
+#    define cpu_to_le16(n) ((_force_attr le16)(u16)(n))
+#    define cpu_to_le32(n) ((_force_attr le32)(u32)(n))
+#    define cpu_to_le64(n) ((_force_attr le64)(u64)(n))
+#    define le16_to_cpu(n) ((_force_attr u16)(le16)(n))
+#    define le32_to_cpu(n) ((_force_attr u32)(le32)(n))
+#    define le64_to_cpu(n) ((_force_attr u64)(le64)(n))
 
-#    define be16_to_cpu(n) bswap16(n)
-#    define be32_to_cpu(n) bswap32(n)
-#    define be64_to_cpu(n) bswap64(n)
-#    define cpu_to_be16(n) bswap16(n)
-#    define cpu_to_be32(n) bswap32(n)
-#    define cpu_to_be64(n) bswap64(n)
+#    define cpu_to_be16(n) ((_force_attr be16)bswap16(n))
+#    define cpu_to_be32(n) ((_force_attr be32)bswap32(n))
+#    define cpu_to_be64(n) ((_force_attr be64)bswap64(n))
+#    define be16_to_cpu(n) bswap16((_force_attr u16)(be16)(n))
+#    define be32_to_cpu(n) bswap32((_force_attr u32)(be32)(n))
+#    define be64_to_cpu(n) bswap64((_force_attr u64)(be64)(n))
 #  endif
 #endif /* _NTFS_ENDIANS_H */
 
diff --git a/include/wimlib/types.h b/include/wimlib/types.h
index 65c14189..0b533767 100644
--- a/include/wimlib/types.h
+++ b/include/wimlib/types.h
@@ -2,6 +2,7 @@
 #define _WIMLIB_TYPES_H
 
 #include "wimlib_tchar.h"
+#include "wimlib/compiler.h"
 
 #include <inttypes.h>
 #include <stdbool.h>
@@ -21,23 +22,23 @@ typedef int32_t s32;
 typedef int64_t s64;
 
 /* Unsigned little endian types of exact size */
-typedef uint8_t  le8;
-typedef uint16_t le16;
-typedef uint32_t le32;
-typedef uint64_t le64;
+typedef uint8_t  _bitwise_attr le8;
+typedef uint16_t _bitwise_attr le16;
+typedef uint32_t _bitwise_attr le32;
+typedef uint64_t _bitwise_attr le64;
 
 /* Signed little endian types of exact size (declare as unsigned to avoid sign
  * extension on big-endian architectures) */
-typedef uint8_t  sle8;
-typedef uint16_t sle16;
-typedef uint32_t sle32;
-typedef uint64_t sle64;
+typedef uint8_t  _bitwise_attr sle8;
+typedef uint16_t _bitwise_attr sle16;
+typedef uint32_t _bitwise_attr sle32;
+typedef uint64_t _bitwise_attr sle64;
 
 /* Unsigned big endian types of exact size */
-typedef uint8_t  be8;
-typedef uint16_t be16;
-typedef uint32_t be32;
-typedef uint64_t be64;
+typedef uint8_t  _bitwise_attr be8;
+typedef uint16_t _bitwise_attr be16;
+typedef uint32_t _bitwise_attr be32;
+typedef uint64_t _bitwise_attr be64;
 
 #endif
 
-- 
2.43.0


From dac0e9d1b28c8c59e6cd1f35dfe71e163dc73bb1 Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers3@gmail.com>
Date: Wed, 6 Aug 2014 21:50:04 -0500
Subject: [PATCH 13/16] Delete useless 1-byte explicit endian types

---
 include/wimlib/types.h | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/include/wimlib/types.h b/include/wimlib/types.h
index 0b533767..ac67cf4a 100644
--- a/include/wimlib/types.h
+++ b/include/wimlib/types.h
@@ -22,20 +22,17 @@ typedef int32_t s32;
 typedef int64_t s64;
 
 /* Unsigned little endian types of exact size */
-typedef uint8_t  _bitwise_attr le8;
 typedef uint16_t _bitwise_attr le16;
 typedef uint32_t _bitwise_attr le32;
 typedef uint64_t _bitwise_attr le64;
 
 /* Signed little endian types of exact size (declare as unsigned to avoid sign
  * extension on big-endian architectures) */
-typedef uint8_t  _bitwise_attr sle8;
 typedef uint16_t _bitwise_attr sle16;
 typedef uint32_t _bitwise_attr sle32;
 typedef uint64_t _bitwise_attr sle64;
 
 /* Unsigned big endian types of exact size */
-typedef uint8_t  _bitwise_attr be8;
 typedef uint16_t _bitwise_attr be16;
 typedef uint32_t _bitwise_attr be32;
 typedef uint64_t _bitwise_attr be64;
-- 
2.43.0


From 522227d4c6cc53ee966162b095ec908bdeb5a023 Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers3@gmail.com>
Date: Wed, 6 Aug 2014 21:50:36 -0500
Subject: [PATCH 14/16] lzx-common.c: Use sle32 for target in e8 translation

---
 src/lzx-common.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/lzx-common.c b/src/lzx-common.c
index e61629e7..b2eeb7d1 100644
--- a/src/lzx-common.c
+++ b/src/lzx-common.c
@@ -115,7 +115,7 @@ lzx_get_num_main_syms(u32 window_size)
 }
 
 static void
-do_translate_target(s32 *target, s32 input_pos)
+do_translate_target(sle32 *target, s32 input_pos)
 {
 	s32 abs_offset, rel_offset;
 
@@ -134,7 +134,7 @@ do_translate_target(s32 *target, s32 input_pos)
 }
 
 static void
-undo_translate_target(s32 *target, s32 input_pos)
+undo_translate_target(sle32 *target, s32 input_pos)
 {
 	s32 abs_offset, rel_offset;
 
@@ -189,7 +189,7 @@ inline  /* Although inlining the 'process_target' function still speeds up the
 	   SSE2 case, it bloats the binary more.  */
 #endif
 void
-lzx_e8_filter(u8 *data, u32 size, void (*process_target)(s32 *, s32))
+lzx_e8_filter(u8 *data, u32 size, void (*process_target)(sle32 *, s32))
 {
 #ifdef __SSE2__
 	/* SSE2 vectorized implementation for x86_64.  This speeds up LZX
@@ -244,7 +244,7 @@ lzx_e8_filter(u8 *data, u32 size, void (*process_target)(s32 *, s32))
 
 					/* Do (or undo) the e8 translation.  */
 					u8 *p8 = (u8 *)p128 + bit;
-					(*process_target)((s32 *)(p8 + 1),
+					(*process_target)((sle32 *)(p8 + 1),
 							  p8 - data);
 
 					/* Don't start an e8 translation in the
@@ -274,7 +274,7 @@ lzx_e8_filter(u8 *data, u32 size, void (*process_target)(s32 *, s32))
 		u8 *p8_end = data + size - 10;
 		do {
 			if (*p8 == 0xe8) {
-				(*process_target)((s32 *)(p8 + 1), p8 - data);
+				(*process_target)((sle32 *)(p8 + 1), p8 - data);
 				p8 += 5;
 			} else {
 				p8++;
-- 
2.43.0


From f5684ebdbc87823cfed7742ac0580af594103278 Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers3@gmail.com>
Date: Wed, 6 Aug 2014 22:13:36 -0500
Subject: [PATCH 15/16] decompress_common.c: Don't include error.h

---
 src/decompress_common.c | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/decompress_common.c b/src/decompress_common.c
index 64e171d9..b56fc3fb 100644
--- a/src/decompress_common.c
+++ b/src/decompress_common.c
@@ -15,7 +15,6 @@
 #endif
 
 #include "wimlib/decompress_common.h"
-#include "wimlib/error.h"
 #include "wimlib/util.h" /* for BUILD_BUG_ON()  */
 
 #include <string.h>
@@ -179,7 +178,6 @@ make_huffman_decode_table(u16 decode_table[const restrict],
 		if (unlikely(left < 0)) {
 			/* The lengths overflow the codespace; that is, the code
 			 * is over-subscribed.  */
-			DEBUG("Invalid prefix code (over-subscribed)");
 			return -1;
 		}
 	}
@@ -201,7 +199,6 @@ make_huffman_decode_table(u16 decode_table[const restrict],
 			       table_num_entries * sizeof(decode_table[0]));
 			return 0;
 		}
-		DEBUG("Invalid prefix code (incomplete set)");
 		return -1;
 	}
 
-- 
2.43.0


From aaa3f0eabacc3f364ee9f83069f5a063ac10d250 Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers3@gmail.com>
Date: Wed, 6 Aug 2014 22:36:38 -0500
Subject: [PATCH 16/16] v1.7.1

---
 NEWS                          | 2 +-
 README                        | 2 +-
 configure.ac                  | 2 +-
 debian/changelog              | 6 ++++++
 doc/man1/imagex-apply.1.in    | 2 +-
 doc/man1/imagex-capture.1.in  | 2 +-
 doc/man1/imagex-delete.1.in   | 2 +-
 doc/man1/imagex-dir.1.in      | 2 +-
 doc/man1/imagex-export.1.in   | 2 +-
 doc/man1/imagex-extract.1.in  | 2 +-
 doc/man1/imagex-info.1.in     | 2 +-
 doc/man1/imagex-join.1.in     | 2 +-
 doc/man1/imagex-mount.1.in    | 2 +-
 doc/man1/imagex-optimize.1.in | 2 +-
 doc/man1/imagex-split.1.in    | 2 +-
 doc/man1/imagex-update.1.in   | 2 +-
 doc/man1/imagex-verify.1.in   | 2 +-
 doc/man1/imagex.1.in          | 2 +-
 doc/man1/mkwinpeimg.1.in      | 2 +-
 update-version                | 2 +-
 20 files changed, 25 insertions(+), 19 deletions(-)

diff --git a/NEWS b/NEWS
index d9296240..19e4b25c 100644
--- a/NEWS
+++ b/NEWS
@@ -1,4 +1,4 @@
-Version 1.7.1-BETA:
+Version 1.7.1:
 	Made more improvements to the XPRESS, LZX, and LZMS compressors.
 
 	The default compression mode for wimcapture is now LZX compression in
diff --git a/README b/README
index 9a3f26da..71c88384 100644
--- a/README
+++ b/README
@@ -1,6 +1,6 @@
                                   INTRODUCTION
 
-This is wimlib version 1.7.1-BETA (June 2014).  wimlib is a C library for
+This is wimlib version 1.7.1 (August 2014).  wimlib is a C library for
 creating, modifying, extracting, and mounting files in the Windows Imaging
 Format (WIM files).  wimlib and its command-line frontend 'wimlib-imagex'
 provide a free and cross-platform alternative to Microsoft's WIMGAPI, ImageX,
diff --git a/configure.ac b/configure.ac
index 4c22938e..78047564 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1,4 +1,4 @@
-AC_INIT([wimlib], [1.7.1-BETA], [ebiggers3@gmail.com])
+AC_INIT([wimlib], [1.7.1], [ebiggers3@gmail.com])
 AC_CONFIG_SRCDIR([src/wim.c])
 AC_CONFIG_MACRO_DIR([m4])
 AC_CONFIG_AUX_DIR([build-aux])
diff --git a/debian/changelog b/debian/changelog
index ab9b0d47..7354e436 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,9 @@
+wimlib (1.7.1-1) unstable; urgency=low
+
+  * Update to v1.7.1
+
+ -- Eric Biggers <ebiggers3@gmail.com>  Wed, 06 Aug 2014 22:34:49 -0500
+
 wimlib (1.7.0-1) unstable; urgency=low
 
   * Update to v1.7.0
diff --git a/doc/man1/imagex-apply.1.in b/doc/man1/imagex-apply.1.in
index 85863455..f818096d 100644
--- a/doc/man1/imagex-apply.1.in
+++ b/doc/man1/imagex-apply.1.in
@@ -1,4 +1,4 @@
-.TH WIMLIB-IMAGEX "1" "June 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
+.TH WIMLIB-IMAGEX "1" "August 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
 .SH NAME
 @IMAGEX_PROGNAME@-apply \- Extract one image, or all images, from a WIM archive
 .SH SYNOPSIS
diff --git a/doc/man1/imagex-capture.1.in b/doc/man1/imagex-capture.1.in
index 6f7116da..0be6e9d0 100644
--- a/doc/man1/imagex-capture.1.in
+++ b/doc/man1/imagex-capture.1.in
@@ -1,4 +1,4 @@
-.TH WIMLIB-IMAGEX "1" "June 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
+.TH WIMLIB-IMAGEX "1" "August 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
 .SH NAME
 @IMAGEX_PROGNAME@-capture, @IMAGEX_PROGNAME@-append \- Create or append a WIM image
 .SH SYNOPSIS
diff --git a/doc/man1/imagex-delete.1.in b/doc/man1/imagex-delete.1.in
index 38335f27..4ff97b85 100644
--- a/doc/man1/imagex-delete.1.in
+++ b/doc/man1/imagex-delete.1.in
@@ -1,4 +1,4 @@
-.TH WIMLIB-IMAGEX "1" "June 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
+.TH WIMLIB-IMAGEX "1" "August 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
 .SH NAME
 @IMAGEX_PROGNAME@-delete \- Delete an image from a WIM archive
 .SH SYNOPSIS
diff --git a/doc/man1/imagex-dir.1.in b/doc/man1/imagex-dir.1.in
index f2c1aebf..31233a61 100644
--- a/doc/man1/imagex-dir.1.in
+++ b/doc/man1/imagex-dir.1.in
@@ -1,4 +1,4 @@
-.TH WIMLIB-IMAGEX "1" "June 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
+.TH WIMLIB-IMAGEX "1" "August 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
 .SH NAME
 @IMAGEX_PROGNAME@-dir \- Show the files contained in a WIM archive
 .SH SYNOPSIS
diff --git a/doc/man1/imagex-export.1.in b/doc/man1/imagex-export.1.in
index 959565de..c380d6e9 100644
--- a/doc/man1/imagex-export.1.in
+++ b/doc/man1/imagex-export.1.in
@@ -1,4 +1,4 @@
-.TH WIMLIB-IMAGEX "1" "June 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
+.TH WIMLIB-IMAGEX "1" "August 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
 .SH NAME
 @IMAGEX_PROGNAME@-export \- Exports an image from a WIM archive to an existing or new WIM archive
 .SH SYNOPSIS
diff --git a/doc/man1/imagex-extract.1.in b/doc/man1/imagex-extract.1.in
index d4560582..74e9d755 100644
--- a/doc/man1/imagex-extract.1.in
+++ b/doc/man1/imagex-extract.1.in
@@ -1,4 +1,4 @@
-.TH WIMLIB-IMAGEX "1" "June 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
+.TH WIMLIB-IMAGEX "1" "August 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
 .SH NAME
 @IMAGEX_PROGNAME@-extract \- Extract files or directories from a WIM image
 .SH SYNOPSIS
diff --git a/doc/man1/imagex-info.1.in b/doc/man1/imagex-info.1.in
index 7b7425f5..088863b5 100644
--- a/doc/man1/imagex-info.1.in
+++ b/doc/man1/imagex-info.1.in
@@ -1,4 +1,4 @@
-.TH WIMLIB-IMAGEX "1" "June 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
+.TH WIMLIB-IMAGEX "1" "August 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
 .SH NAME
 @IMAGEX_PROGNAME@-info \- Display information about a WIM file, or change information about
 an image
diff --git a/doc/man1/imagex-join.1.in b/doc/man1/imagex-join.1.in
index 3949b75f..9f5dde44 100644
--- a/doc/man1/imagex-join.1.in
+++ b/doc/man1/imagex-join.1.in
@@ -1,4 +1,4 @@
-.TH WIMLIB-IMAGEX "1" "June 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
+.TH WIMLIB-IMAGEX "1" "August 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
 .SH NAME
 @IMAGEX_PROGNAME@-join \- Join split WIMs into a standalone one-part WIM
 .SH SYNOPSIS
diff --git a/doc/man1/imagex-mount.1.in b/doc/man1/imagex-mount.1.in
index c38c69c2..b40a33f2 100644
--- a/doc/man1/imagex-mount.1.in
+++ b/doc/man1/imagex-mount.1.in
@@ -1,4 +1,4 @@
-.TH WIMLIB-IMAGEX "1" "June 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
+.TH WIMLIB-IMAGEX "1" "August 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
 .SH NAME
 @IMAGEX_PROGNAME@-mount, @IMAGEX_PROGNAME@-mountrw, @IMAGEX_PROGNAME@-unmount \- Mount and unmount an image from a WIM archive
 .SH SYNOPSIS
diff --git a/doc/man1/imagex-optimize.1.in b/doc/man1/imagex-optimize.1.in
index 2d296c72..5a2b3f2b 100644
--- a/doc/man1/imagex-optimize.1.in
+++ b/doc/man1/imagex-optimize.1.in
@@ -1,4 +1,4 @@
-.TH WIMLIB-IMAGEX "1" "June 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
+.TH WIMLIB-IMAGEX "1" "August 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
 .SH NAME
 @IMAGEX_PROGNAME@-optimize \- Optimize a WIM archive
 .SH SYNOPSIS
diff --git a/doc/man1/imagex-split.1.in b/doc/man1/imagex-split.1.in
index b1e56ff5..431fa7f3 100644
--- a/doc/man1/imagex-split.1.in
+++ b/doc/man1/imagex-split.1.in
@@ -1,4 +1,4 @@
-.TH WIMLIB-IMAGEX "1" "June 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
+.TH WIMLIB-IMAGEX "1" "August 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
 .SH NAME
 @IMAGEX_PROGNAME@-split \- Split a WIM into multiple parts
 .SH SYNOPSIS
diff --git a/doc/man1/imagex-update.1.in b/doc/man1/imagex-update.1.in
index e2f1aab3..079723e6 100644
--- a/doc/man1/imagex-update.1.in
+++ b/doc/man1/imagex-update.1.in
@@ -1,4 +1,4 @@
-.TH WIMLIB-IMAGEX "1" "June 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
+.TH WIMLIB-IMAGEX "1" "August 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
 .SH NAME
 @IMAGEX_PROGNAME@-update \- Update a WIM image
 .SH SYNOPSIS
diff --git a/doc/man1/imagex-verify.1.in b/doc/man1/imagex-verify.1.in
index 5b21cf17..0290e3d3 100644
--- a/doc/man1/imagex-verify.1.in
+++ b/doc/man1/imagex-verify.1.in
@@ -1,4 +1,4 @@
-.TH WIMLIB-IMAGEX "1" "June 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
+.TH WIMLIB-IMAGEX "1" "August 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
 .SH NAME
 @IMAGEX_PROGNAME@-verify \- Verify a WIM file
 .SH SYNOPSIS
diff --git a/doc/man1/imagex.1.in b/doc/man1/imagex.1.in
index 424370b8..3dc30b19 100644
--- a/doc/man1/imagex.1.in
+++ b/doc/man1/imagex.1.in
@@ -1,4 +1,4 @@
-.TH WIMLIB-IMAGEX 1 "June 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
+.TH WIMLIB-IMAGEX 1 "August 2014" "@IMAGEX_PROGNAME@ @VERSION@" "User Commands"
 .SH NAME
 @IMAGEX_PROGNAME@ \- Extract, create, modify, or mount a WIM (Windows Imaging Format) archive
 .SH SYNOPSIS
diff --git a/doc/man1/mkwinpeimg.1.in b/doc/man1/mkwinpeimg.1.in
index 8196ed63..0be637bb 100644
--- a/doc/man1/mkwinpeimg.1.in
+++ b/doc/man1/mkwinpeimg.1.in
@@ -1,4 +1,4 @@
-.TH MKWINPEIMG "1" "June 2014" "mkwinpeimg (wimlib @VERSION@)" "User Commands"
+.TH MKWINPEIMG "1" "August 2014" "mkwinpeimg (wimlib @VERSION@)" "User Commands"
 .SH NAME
 mkwinpeimg \- Make a customized bootable image of Windows PE
 .SH SYNOPSIS
diff --git a/update-version b/update-version
index 0ce1b04c..5e8d3bde 100755
--- a/update-version
+++ b/update-version
@@ -7,7 +7,7 @@ oldyear=2014
 newmajor=1
 newminor=7
 newpatch=1
-newmonth=June
+newmonth=August
 newyear=2014
 
 
-- 
2.43.0