diff -Nru innoextract-1.3/CHANGELOG innoextract-1.4/CHANGELOG
--- innoextract-1.3/CHANGELOG	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/CHANGELOG	2013-03-11 16:24:33.000000000 +0000
@@ -1,18 +1,38 @@
 
-Inno Extract 1.3 (2012-07-03)
- - Respect --quiet and --silent for multi-file installers
- - Compile in C++11 mode if supported
- - Warn about unsupported setup data versions
- - Add support for Inno Setup 5.5.0 installers
+innoextract 1.4 (2013-03-11)
+ - Fixed build on non-Linux platforms with a separate libiconv (Windows™, Mac OS X)
+ - Fixed build on systems with non-standard iconv function prototypes (FreeBSD)
+ - Fixed MSVC build
+ - Fixed build with older glibc versions
+ - Fixed issues with the progress bar in sandbox environments
+ - Fixed string conversion on systems where libiconv defaults to big-endian variants
+ - Fixed extracting very large installers with 32-bit innoextract builds
+ - Improved handling of invalid encoded strings
+ - Improved error messages when input or output files could not be opened
+ - The --list command-line option can now combined with --test or --extract
+ - The --version command-line option can now be modified with --quiet or --silent
+ - Added color output and progress bar support for Windows™
+ - Added support for Unicode filenames under Windows™
+ - Added support for preserving timestamps of extracted files (enabled by default)
+ - Added a --timestamps (-T) command-line options to control or disable file timestamps
+ - Added an --output-dir (-d) command-line option to control where files are extracted
+ - Added various CMake options to fine-tune the build process
+ - Various bug fixes and tweaks
 
-Inno Extract 1.2 (2012-04-01)
- - Fix compile errors with older versions of Boost or GCC.
- - Don't link against libraries that aren't actually needed.
+innoextract 1.3 (2012-07-03)
+ - Fixed --quiet and --silent flags being ignored for some multi-file installers output
+ - Now compiles in C++11 mode if supported
+ - Added a warning when extracting unsupported setup data versions
+ - Added support for Inno Setup 5.5.0 installers
 
-Inno Extract 1.1 (2012-03-19)
- - Support extracting files for a specific language.
- - Fix a bug in the setup header parsing code.
+innoextract 1.2 (2012-04-01)
+ - Fixed compile errors with older versions of Boost or GCC.
+ - Prevented linking against libraries that aren't actually needed.
 
-Inno Extract 1.0 (2012-03-01)
+innoextract 1.1 (2012-03-19)
+ - Added support to extract files for a specific language.
+ - Fixed a bug in the setup header parsing code.
+
+innoextract 1.0 (2012-03-01)
  - Initial release.
  - Can list and extract files but not much more.
diff -Nru innoextract-1.3/CMakeLists.txt innoextract-1.4/CMakeLists.txt
--- innoextract-1.3/CMakeLists.txt	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/CMakeLists.txt	2013-03-11 16:24:33.000000000 +0000
@@ -1,32 +1,94 @@
-project(InnoExtract)
+project(innoextract)
 
 cmake_minimum_required(VERSION 2.8)
 
-# For custom cmake modules.
-set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
+
+# Define configuration options
 
 option(USE_LZMA "Build lzma decompression support." ON)
 option(DEBUG_EXTRA "Expensive debug options" OFF)
+option(SET_WARNING_FLAGS "Adjust compiler warning flags" ON)
+option(SET_OPTIMIZATION_FLAGS "Adjust compiler optimization flags" ON)
+option(USE_CXX11 "Try to use C++11 if available" ON)
+
+set(default_USE_STATIC_LIBS OFF)
+if(WIN32)
+	set(default_USE_STATIC_LIBS ON)
+endif()
+option(USE_STATIC_LIBS       "Statically link libraries" ${default_USE_STATIC_LIBS})
+option(LZMA_USE_STATIC_LIBS  "Statically link liblzma"   ${USE_STATIC_LIBS})
+option(ZLIB_USE_STATIC_LIBS  "Statically link libz"      ${USE_STATIC_LIBS})
+option(BZip2_USE_STATIC_LIBS "Statically link libbz2"    ${USE_STATIC_LIBS})
+option(Boost_USE_STATIC_LIBS "Statically link Boost"     ${USE_STATIC_LIBS})
+option(iconv_USE_STATIC_LIBS "Statically link libiconv"  ${USE_STATIC_LIBS})
+
+
+# Install destinations
+if(CMAKE_VERSION VERSION_LESS 2.8.5)
+	set(CMAKE_INSTALL_DATAROOTDIR "share" CACHE
+			STRING "read-only architecture-independent data root (share) (relative to prefix).")
+	set(CMAKE_INSTALL_BINDIR "bin" CACHE
+			STRING "user executables (bin) (relative to prefix).")
+	set(CMAKE_INSTALL_MANDIR "${CMAKE_INSTALL_DATAROOTDIR}/man" CACHE
+			STRING "man documentation (DATAROOTDIR/man) (relative to prefix).")
+	mark_as_advanced(
+		CMAKE_INSTALL_DATAROOTDIR
+		CMAKE_INSTALL_BINDIR
+		CMAKE_INSTALL_MANDIR
+	)
+else()
+	include(GNUInstallDirs)
+endif()
 
-set(MAN_DIR "share/man" CACHE STRING "Install location for man pages (relative to prefix).")
-mark_as_advanced(MAN_DIR)
 
-include(CompileCheck)
-include(VersionString)
+# Helper scrips
+
 include(CheckSymbolExists)
+
+set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake") # For custom cmake modules
 include(BuildType)
-include(StyleCheck)
+include(CompileCheck)
+include(CXX11Check)
 include(Doxygen)
-include(TestBigEndian)
+include(PrintConfiguration)
+include(StyleCheck)
+include(UseStaticLibs)
+include(VersionString)
+
 
-# Force re-checking libraries if the compiler or compiler flags change.
+# Find required libraries
+
+# Win32 API
+if(WIN32)
+	# Ensure we aren't using functionalities not found under Window XP SP1
+	add_definitions(-D_WIN32_WINNT=0x0502)
+	add_definitions(-DNOMINMAX)
+	add_definitions(-DWIN32_LEAN_AND_MEAN)
+	if(NOT MSVC)
+		 # required for _gmtime64_s on MinGW
+		add_definitions(-DMINGW_HAS_SECURE_API)
+		list(APPEND CMAKE_REQUIRED_DEFINITIONS -DMINGW_HAS_SECURE_API)
+	endif()
+endif()
+
+if(USE_STATIC_LIBS AND NOT MSVC)
+	add_ldflag("-static-libstdc++")
+	add_ldflag("-static-libgcc")
+endif()
+
+# Force re-checking libraries if the compiler or compiler flags change
 if((NOT LAST_CMAKE_CXX_FLAGS STREQUAL CMAKE_CXX_FLAGS)
    OR (NOT LAST_CMAKE_CXX_COMPILER STREQUAL CMAKE_CXX_COMPILER))
 	force_recheck_library(LZMA)
 	force_recheck_library(Boost)
+	force_recheck_library(ZLIB)
+	force_recheck_library(BZip2)
+	force_recheck_library(iconv)
 	unset(Boost_INCLUDE_DIR CACHE)
-	set(LAST_CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" CACHE INTERNAL "The last C++ compiler flags.")
-	set(LAST_CMAKE_CXX_COMPILER "${CMAKE_CXX_COMPILER}" CACHE INTERNAL "The last C++ compiler.")
+	set(LAST_CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" CACHE INTERNAL
+	    "The last C++ compiler flags")
+	set(LAST_CMAKE_CXX_COMPILER "${CMAKE_CXX_COMPILER}" CACHE INTERNAL
+	    "The last C++ compiler")
 endif()
 
 unset(LIBRARIES)
@@ -34,13 +96,14 @@
 if(USE_LZMA)
 	find_package(LZMA REQUIRED)
 	check_link_library(LZMA LZMA_LIBRARIES)
-	list(APPEND LIBRARIES "${LZMA_LIBRARIES}")
-	include_directories(SYSTEM "${LZMA_INCLUDE_DIR}")
-	set(HAVE_LZMA 1)
+	list(APPEND LIBRARIES ${LZMA_LIBRARIES})
+	include_directories(SYSTEM ${LZMA_INCLUDE_DIR})
+	add_definitions(${LZMA_DEFINITIONS})
+	set(INNOEXTRACT_HAVE_LZMA 1)
 else()
 	message(WARNING "\nDisabling LZMA decompression support.\n"
 	                "You won't be able to extract most newer Inno Setup installers.")
-	set(HAVE_LZMA 0)
+	set(INNOEXTRACT_HAVE_LZMA 0)
 endif()
 
 find_package(Boost REQUIRED COMPONENTS
@@ -51,50 +114,102 @@
 	program_options
 )
 check_link_library(Boost Boost_LIBRARIES)
-list(APPEND LIBRARIES "${Boost_LIBRARIES}")
-link_directories("${Boost_LIBRARY_DIRS}")
-include_directories(SYSTEM "${Boost_INCLUDE_DIR}")
-
-add_cxxflag("-std=c++11")
-
-add_cxxflag("-Wall")
-add_cxxflag("-Wextra")
-add_cxxflag("-Wformat=2")
-add_cxxflag("-Wundef")
-add_cxxflag("-Wpointer-arith")
-add_cxxflag("-Wcast-qual")
-add_cxxflag("-Woverloaded-virtual")
-add_cxxflag("-Wlogical-op")
-add_cxxflag("-Wliteral-conversion")
-add_cxxflag("-Wshift-overflow")
-add_cxxflag("-Woverflow")
-add_cxxflag("-Wbool-conversions")
-add_cxxflag("-Wconversion")
-add_cxxflag("-Wsign-conversion")
-add_cxxflag("-Wmissing-declarations")
-add_cxxflag("-Wredundant-decls")
-
-if(DEBUG_EXTRA)
-	add_cxxflag("-ftrapv") # to add checks for (undefined) signed integer overflow
-	add_cxxflag("-fbounds-checking")
-	add_cxxflag("-fcatch-undefined-behavior")
-	add_cxxflag("-Wstrict-aliasing=1")
-else()
-	# -Wuninitialized causes too many false positives - thanks very much, gcc
-	add_cxxflag("-Wno-uninitialized")
-	# (clang only) Conflicts with using const variables for configuration.
-	add_cxxflag("-Wno-constant-logical-operand")
-	add_cxxflag("-Wno-unneeded-internal-declaration")
-	add_cxxflag("-Wno-unused-function")
+list(APPEND LIBRARIES ${Boost_LIBRARIES})
+link_directories(${Boost_LIBRARY_DIRS})
+include_directories(SYSTEM ${Boost_INCLUDE_DIR})
+
+if(Boost_USE_STATIC_LIBS)
+	
+	use_static_libs(ZLIB)
+	find_package(ZLIB REQUIRED)
+	use_static_libs_restore()
+	check_link_library(ZLIB ZLIB_LIBRARIES)
+	list(APPEND LIBRARIES ${ZLIB_LIBRARIES})
+	
+	use_static_libs(BZip2)
+	find_package(BZip2 REQUIRED)
+	use_static_libs_restore()
+	check_link_library(BZip2 BZIP2_LIBRARIES)
+	list(APPEND LIBRARIES ${BZIP2_LIBRARIES})
+	
 endif()
 
-# Because i'm lazy
-add_ldflag("-Wl,--as-needed")
+find_package(iconv REQUIRED)
+check_link_library(iconv iconv_LIBRARIES)
+list(APPEND LIBRARIES ${iconv_LIBRARIES})
+include_directories(SYSTEM ${iconv_INCLUDE_DIR})
+add_definitions(${iconv_DEFINITIONS})
+
+
+# Set compiler flags
+
+if(${Boost_VERSION} LESS 104800)
+	# Older Boost versions don't work with C++11
+elseif(USE_CXX11)
+	enable_cxx11()
+	check_cxx11("alignof" INNOEXTRACT_HAVE_ALIGNOF)
+	if(WIN32)
+		check_cxx11("std::codecvt_utf8_utf16" INNOEXTRACT_HAVE_STD_CODECVT_UTF8_UTF16)
+	endif()
+	check_cxx11("std::unique_ptr" INNOEXTRACT_HAVE_STD_UNIQUE_PTR)
+endif()
 
-check_symbol_exists(isatty "unistd.h" HAVE_ISATTY)
-check_symbol_exists(ioctl "sys/ioctl.h" HAVE_IOCTL)
+# Don't expose internal symbols to the outside world by default
+if(NOT MSVC)
+	add_cxxflag("-fvisibility=hidden")
+	add_cxxflag("-fvisibility-inlines-hidden")
+endif()
 
-test_big_endian(IS_BIG_ENDIAN)
+# Older glibc versions won't provide some useful symbols by default - request them
+# This flag is currently also set by gcc when compiling C++, but not for plain C
+if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+	set(CMAKE_REQUIRED_DEFINITIONS "-D_GNU_SOURCE=1")
+	add_definitions(-D_GNU_SOURCE=1)
+endif()
+
+if(WIN32)
+	# Define this so that we don't accitenally use ANSI functions
+	add_definitions(-D_UNICODE)
+endif()
+
+
+# Check for optional functionality and system configuration
+
+check_symbol_exists(isatty "unistd.h" INNOEXTRACT_HAVE_ISATTY)
+if(NOT INNOEXTRACT_HAVE_ISATTY)
+	check_symbol_exists(_isatty "io.h" INNOEXTRACT_HAVE_MS_ISATTY)
+endif()
+check_symbol_exists(ioctl "sys/ioctl.h" INNOEXTRACT_HAVE_IOCTL)
+check_symbol_exists(_mkgmtime64 "time.h" INNOEXTRACT_HAVE_MKGMTIME64)
+if(NOT INNOEXTRACT_HAVE_MKGMTIME64)
+	check_symbol_exists(timegm "time.h" INNOEXTRACT_HAVE_TIMEGM)
+	if(NOT INNOEXTRACT_HAVE_TIMEGM)
+		check_symbol_exists(_mkgmtime "time.h" INNOEXTRACT_HAVE_MKGMTIME)
+	endif()
+endif()
+check_symbol_exists(_gmtime64_s "time.h" INNOEXTRACT_HAVE_GMTIME64_S)
+if(NOT INNOEXTRACT_HAVE_GMTIME64_S)
+	check_symbol_exists(gmtime_r "time.h" INNOEXTRACT_HAVE_GMTIME_R)
+	if(NOT INNOEXTRACT_HAVE_GMTIME_R)
+		check_symbol_exists(gmtime_s "time.h" INNOEXTRACT_HAVE_GMTIME_S)
+	endif()
+endif()
+if(NOT WIN32)
+	check_symbol_exists(utimensat "sys/stat.h" INNOEXTRACT_HAVE_UTIMENSAT)
+	check_symbol_exists(AT_FDCWD "fcntl.h" INNOEXTRACT_HAVE_AT_FDCWD)
+	if(INNOEXTRACT_HAVE_UTIMENSAT AND INNOEXTRACT_HAVE_AT_FDCWD)
+		set(INNOEXTRACT_HAVE_UTIMENSAT_d 1)
+	else()
+		check_symbol_exists(utimes "sys/time.h" INNOEXTRACT_HAVE_UTIMES)
+	endif()
+endif()
+
+check_symbol_exists(bswap_16 "byteswap.h" INNOEXTRACT_HAVE_BSWAP_16)
+check_symbol_exists(bswap_32 "byteswap.h" INNOEXTRACT_HAVE_BSWAP_32)
+check_symbol_exists(bswap_64 "byteswap.h" INNOEXTRACT_HAVE_BSWAP_64)
+
+
+# All sources:
 
 set(INNOEXTRACT_SOURCES
 	
@@ -140,6 +255,7 @@
 	src/util/console.cpp
 	src/util/load.cpp
 	src/util/log.cpp
+	src/util/time.cpp
 	
 )
 
@@ -151,29 +267,60 @@
 	list(APPEND INNOEXTRACT_SOURCES src/stream/lzma.cpp)
 endif()
 
+if(WIN32)
+	list(APPEND INNOEXTRACT_SOURCES src/util/windows.cpp)
+endif()
+
 file(GLOB_RECURSE ALL_INCLUDES "${CMAKE_SOURCE_DIR}/src/*.hpp")
 
 list(SORT INNOEXTRACT_SOURCES)
 list(SORT ALL_INCLUDES)
 
+list(APPEND CHECKED_SOURCES ${INNOEXTRACT_SOURCES})
+
+
+# Prepare generated files
+
 include_directories(src ${CMAKE_CURRENT_BINARY_DIR})
 
 configure_file("src/configure.hpp.in" "configure.hpp")
 
-file(MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/cli")
-set(VERSION_FILE "${CMAKE_BINARY_DIR}/cli/version.cpp")
-version_file("src/cli/version.cpp.in" "${VERSION_FILE}" "VERSION" ".git")
+set(VERSION_FILE "${CMAKE_BINARY_DIR}/release.cpp")
+set(VERSION_SOURCES VERSION "VERSION" LICENSE "LICENSE")
+version_file("src/release.cpp.in" "${VERSION_FILE}" "${VERSION_SOURCES}" ".git")
 list(APPEND INNOEXTRACT_SOURCES "${VERSION_FILE}")
 
+
+# Main targets
+
 add_executable(innoextract ${INNOEXTRACT_SOURCES} ${ALL_INCLUDES})
 target_link_libraries(innoextract ${LIBRARIES})
 
-install(TARGETS innoextract RUNTIME DESTINATION bin)
+install(TARGETS innoextract RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+
+install(FILES doc/innoextract.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1 OPTIONAL)
 
-install(FILES doc/innoextract.1 DESTINATION ${MAN_DIR}/man1 OPTIONAL)
 
 # Additional targets.
 
-add_style_check_target(style "${INNOEXTRACT_SOURCES}" "${ALL_INCLUDES}")
+add_style_check_target(style "${CHECKED_SOURCES}" "${ALL_INCLUDES}")
 
 add_doxygen_target(doc "doc/Doxyfile.in" "VERSION" ".git" "${CMAKE_BINARY_DIR}/doc")
+
+
+# Print a configuration summary
+
+message("")
+message("Configuration:")
+message(" - Build type: ${CMAKE_BUILD_TYPE}")
+print_configuration("LZMA decompression" FIRST
+	INNOEXTRACT_HAVE_LZMA "enabled"
+	1                     "disabled"
+)
+print_configuration("File time precision" FIRST
+	INNOEXTRACT_HAVE_UTIMENSAT_d "nanoseconds"
+	WIN32                        "100-nanoseconds"
+	INNOEXTRACT_HAVE_UTIMES      "microseconds"
+	1                            "seconds"
+)
+message("")
diff -Nru innoextract-1.3/LICENSE innoextract-1.4/LICENSE
--- innoextract-1.3/LICENSE	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/LICENSE	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 
-Copyright (C) 2011-2012 Daniel Scharrer
+Copyright (C) 2011-2013 Daniel Scharrer <daniel@constexpr.org>
 
 This software is provided 'as-is', without any express or implied
 warranty.  In no event will the author(s) be held liable for any damages
diff -Nru innoextract-1.3/README.md innoextract-1.4/README.md
--- innoextract-1.3/README.md	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/README.md	2013-03-11 16:24:33.000000000 +0000
@@ -1,9 +1,9 @@
 
-# Inno Extract - A tool to unpack installers created by Inno Setup
+# innoextract - A tool to unpack installers created by Inno Setup
 
-[Inno Setup](http://www.jrsoftware.org/isinfo.php) is a tool to create installers for Microsoft Windows applications. Inno Extracts allows to extract such installers under non-windows systems without running the actual installer using wine. Inno Extract currently supports installers created by Inno Setup 1.2.10 to 5.5.0.
+[Inno Setup](http://www.jrsoftware.org/isinfo.php) is a tool to create installers for Microsoft Windows applications. innoextract allows to extract such installers under non-Windows systems without running the actual installer using wine. innoextract currently supports installers created by Inno Setup 1.2.10 to 5.5.3.
 
-Inno Extract is available under the ZLIB license - see the LICENSE file.
+innoextract is available under the ZLIB license - see the LICENSE file.
 
 See the website for [Linux packages](http://constexpr.org/innoextract/#packages).
 
@@ -15,20 +15,21 @@
 
 ## Dependencies
 
-* **Boost 1.37** or newer
+* **[Boost](http://www.boost.org/) 1.37** or newer
 * **liblzma** from [xz-utils](http://tukaani.org/xz/) *(optional)*
+* **iconv** (either as part of the system libc, as is the case with [glibc](http://www.gnu.org/software/libc/) and [uClibc](http://www.uclibc.org/), or as a separate [libiconv](http://www.gnu.org/software/libiconv/))
 
 For Boost you will need the headers as well as the `iostreams`, `filesystem`, `date_time`, `system` and `program_options` libraries. Older Boost version may work but are not actively supported. The boost `iostreams` library needs to be build with zlib and bzip2 support.
 
 While the liblzma dependency is optional, it is highly recommended and you won't be able to extract most installers created by newer Inno Setup versions without it.
 
-To build Inno Extract you will also need **CMake 2.8** and a working C++ compiler, as well as the development headers for liblzma and boost.
+To build innoextract you will also need **[CMake](http://cmake.org/) 2.8** and a working C++ compiler, as well as the development headers for liblzma and boost.
 
-The website might have more [specific instructions for your linux distribution](http://constexpr.org/innoextract/install).
+The website might have more [specific instructions for your Linux distribution](http://constexpr.org/innoextract/install).
 
 ## Compile and install
 
-To compile Inno Extract, run:
+To compile innoextract, run:
 
     $ mkdir -p build && cd build && cmake ..
     $ make
@@ -39,11 +40,31 @@
 
 Build options:
 
-* `USE_LZMA` (default: `ON`): Use *liblzma* if available.
-* `CMAKE_BUILD_TYPE` (default: `Release`): Set to `Debug` to enable debug output.
-* `CMAKE_INSTALL_PREFIX` (default: `/usr/local` on UNIX): Where to install Inno Extract.
-* `DEBUG_EXTRA` (default: `OFF`): Expensive debug options
-* `MAN_DIR` (default: `share/man`): Install location for man pages (relative to prefix).
+| Option                   | Default   | Description |
+|:------------------------ |:---------:|:----------- |
+| `USE_LZMA`               | `ON`      | Use `liblzma` if available.
+| `CMAKE_BUILD_TYPE`       | `Release` | Set to `Debug` to enable debug output.
+| `SET_WARNING_FLAGS`      | `ON`      | Adjust compiler warning flags. This should not affect the produced binaries but is useful to catch potential problems.
+| `SET_OPTIMIZATION_FLAGS` | `ON`      | Adjust compiler optimization flags. For non-debug builds the only thing this does is instruct the linker to only link against libraries that are actually needed.
+| `USE_CXX11`              | `ON`      | Try to compile in C++11 mode if available.
+| `DEBUG_EXTRA`            | `OFF`     | Expensive debug options.
+| `USE_STATIC_LIBS`        | `OFF`^1   | Turns on static linking for all libraries, including `-static-libgcc` and `-static-libstdc++`. You can also use the individual options below:
+| `LZMA_USE_STATIC_LIBS`   | `OFF`^2   | Statically link `liblzma`.
+| `Boost_USE_STATIC_LIBS`  | `OFF`^2   | Statically link Boost. See also `FindBoost.cmake`
+| `ZLIB_USE_STATIC_LIBS`   | `OFF`^2   | Statically link `libz`. (used via Boost)
+| `BZip2_USE_STATIC_LIBS`  | `OFF`^2   | Statically link `libbz2`. (used via Boost)
+| `iconv_USE_STATIC_LIBS`  | `OFF`^2   | Statically link `libiconv`.
+1. Under Windows, the default is `ON`.
+2. Default is `ON` if `USE_STATIC_LIBS` is enabled.
+
+Install options:
+
+| Option                      | Default              | Description |
+|:--------------------------- |:--------------------:|:----------- |
+| `CMAKE_INSTALL_PREFIX`      | `/usr/local`         | Where to install innoextract.
+| `CMAKE_INSTALL_BINDIR`      | `bin`                | Location for binaries (relative to prefix).
+| `CMAKE_INSTALL_DATAROOTDIR` | `share`              | Location for data files (relative to prefix).
+| `CMAKE_INSTALL_MANDIR`      | `${DATAROOTDIR}/man` | Location for man pages (relative to prefix).
 
 Set options by passing `-D<option>=<value>` to cmake.
 
@@ -63,21 +84,21 @@
 
 ## Limitations
 
-* Inno Extract currently only supports extracting all the data. There is no support for extracting individual files or components and limited support for extracting language-specific files.
+* innoextract currently only supports extracting all the data. There is no support for extracting individual files or components and limited support for extracting language-specific files.
 
 * Included scripts and checks are not executed.
 
-* Data is always extracted to the current directory and the mapping from Inno Setup variables like the application directory to subdirectories is hard-coded.
+* The mapping from Inno Setup variables like the application directory to subdirectories is hard-coded.
 
-* Inno Extract does not check if an installer includes multiple files with the same name and will continually overwrite the destination file when extracting.
+* innoextract does not check if an installer includes multiple files with the same name and will continually overwrite the destination file when extracting.
 
-* Names for data files in multi-file installers must follow the standard naming scheme.
+* Names for data slice/disk files in multi-file installers must follow the standard naming scheme.
 
 * Encrypted installers are not supported.
 
 A perhaps more complete, but Windows-only, tool to extract Inno Setup files is [innounp](http://innounp.sourceforge.net/).
 
-Extracting windows installer executables created by programs other than Inno Setup is out of the scope of this project. Some of these can be unpacked by the following programs:
+Extracting Windows installer executables created by programs other than Inno Setup is out of the scope of this project. Some of these can be unpacked by the following programs:
 
 * [cabextract](http://www.cabextract.org.uk/)
 
diff -Nru innoextract-1.3/VERSION innoextract-1.4/VERSION
--- innoextract-1.3/VERSION	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/VERSION	2013-03-11 16:24:33.000000000 +0000
@@ -1,3 +1,2 @@
-Inno Extract 1.3
-Inno Setup 1.2.10 to 5.5.0
-(C) 2011-2012 Daniel Scharrer <daniel@constexpr.org>
+innoextract 1.4
+Inno Setup 1.2.10 to 5.5.3
diff -Nru innoextract-1.3/cmake/BuildType.cmake innoextract-1.4/cmake/BuildType.cmake
--- innoextract-1.3/cmake/BuildType.cmake	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/cmake/BuildType.cmake	2013-03-11 16:24:33.000000000 +0000
@@ -1,23 +1,86 @@
 
 include(CompileCheck)
 
+option(DEBUG_EXTRA "Expensive debug options" OFF)
+option(SET_WARNING_FLAGS "Adjust compiler warning flags" ON)
+option(SET_OPTIMIZATION_FLAGS "Adjust compiler optimization flags" ON)
+
 if(CMAKE_BUILD_TYPE STREQUAL "")
 	set(CMAKE_BUILD_TYPE "Release")
 endif()
-
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-	
 	add_definitions(-DDEBUG)
 	set(DEBUG 1)
+endif()
+
+if(MSVC)
 	
-	check_compiler_flag(RESULT "-g3")
-	if(NOT RESULT STREQUAL "")
-		string(REGEX REPLACE "-g(|[0-9]|gdb)" "" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
-		set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${RESULT}")
+	if(SET_WARNING_FLAGS)
+		add_definitions(/wd4996) # 'unsafe' stdlib functions used by Boost
 	endif()
 	
-	check_compiler_flag(RESULT "-O0")
-	string(REGEX REPLACE "-O[0-9]" "" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
-	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${RESULT}")
+else(MSVC)
 	
-endif()
+	if(SET_WARNING_FLAGS)
+		
+		# GCC (and compatible)
+		add_cxxflag("-Wall")
+		add_cxxflag("-Wextra")
+		add_cxxflag("-Wformat=2")
+		add_cxxflag("-Wundef")
+		add_cxxflag("-Wpointer-arith")
+		add_cxxflag("-Wcast-qual")
+		add_cxxflag("-Woverloaded-virtual")
+		add_cxxflag("-Wlogical-op")
+		add_cxxflag("-Woverflow")
+		add_cxxflag("-Wconversion")
+		add_cxxflag("-Wsign-conversion")
+		add_cxxflag("-Wmissing-declarations")
+		add_cxxflag("-Wredundant-decls")
+		
+		# clang
+		add_cxxflag("-Wliteral-conversion")
+		add_cxxflag("-Wshift-overflow")
+		add_cxxflag("-Wbool-conversions")
+		
+		# icc
+		if(NOT DEBUG_EXTRA)
+			add_cxxflag("-wd1418") # 'external function definition with no prior declaration'
+		endif()
+		
+	endif(SET_WARNING_FLAGS)
+	
+	if(DEBUG_EXTRA)
+		add_cxxflag("-ftrapv") # to add checks for (undefined) signed integer overflow
+		add_cxxflag("-fbounds-checking")
+		add_cxxflag("-fcatch-undefined-behavior")
+		add_cxxflag("-Wstrict-aliasing=1")
+	endif(DEBUG_EXTRA)
+	
+	if(SET_OPTIMIZATION_FLAGS)
+		
+		# Link as few libraries as possible
+		# This is much easier than trying to decide which libraries are needed for each system
+		# Specifically, the need for libboost_system depends on the Boost version
+		add_ldflag("-Wl,--as-needed")
+		
+		if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+			
+			# set debug symbol level to -g3
+			check_compiler_flag(RESULT "-g3")
+			if(NOT RESULT STREQUAL "")
+				string(REGEX REPLACE "-g(|[0-9]|gdb)" "" CMAKE_CXX_FLAGS_DEBUG
+							"${CMAKE_CXX_FLAGS_DEBUG}")
+				set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${RESULT}")
+			endif()
+			
+			# disable optimizations
+			check_compiler_flag(RESULT "-O0")
+			string(REGEX REPLACE "-O[0-9]" "" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
+			set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${RESULT}")
+			
+		endif()
+		
+	endif(SET_OPTIMIZATION_FLAGS)
+	
+endif(MSVC)
diff -Nru innoextract-1.3/cmake/CXX11Check.cmake innoextract-1.4/cmake/CXX11Check.cmake
--- innoextract-1.3/cmake/CXX11Check.cmake	1970-01-01 00:00:00.000000000 +0000
+++ innoextract-1.4/cmake/CXX11Check.cmake	2013-03-11 16:24:33.000000000 +0000
@@ -0,0 +1,50 @@
+
+# Copyright (C) 2013 Daniel Scharrer
+#
+# This software is provided 'as-is', without any express or implied
+# warranty.  In no event will the author(s) be held liable for any damages
+# arising from the use of this software.
+#
+# Permission is granted to anyone to use this software for any purpose,
+# including commercial applications, and to alter it and redistribute it
+# freely, subject to the following restrictions:
+#
+# 1. The origin of this software must not be misrepresented; you must not
+#    claim that you wrote the original software. If you use this software
+#    in a product, an acknowledgment in the product documentation would be
+#    appreciated but is not required.
+# 2. Altered source versions must be plainly marked as such, and must not be
+#    misrepresented as being the original software.
+# 3. This notice may not be removed or altered from any source distribution.
+
+include(CheckCXXSourceCompiles)
+include(CompileCheck)
+
+set(_HAS_CXX11 0)
+
+function(enable_cxx11)
+	if(MSVC)
+		set(_HAS_CXX11 1 PARENT_SCOPE)
+	else()
+		add_cxxflag("-std=c++11")
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" PARENT_SCOPE)
+		if(FLAG_FOUND OR NOT CMAKE_COMPILER_IS_GNUCXX)
+			set(_HAS_CXX11 1 PARENT_SCOPE)
+		endif()
+	endif()
+endfunction(enable_cxx11)
+
+function(check_cxx11 CHECK RESULTVAR)
+	if(${_HAS_CXX11})
+		string(REGEX REPLACE "[^a-zA-Z0-9_][^a-zA-Z0-9_]*" "-" check "${CHECK}")
+		set(file "${CMAKE_MODULE_PATH}/check-cxx11-${check}.cpp")
+		check_compile(result "${file}" "${CHECK}" "C++11 feature")
+		if("${result}" STREQUAL "")
+			set(${RESULTVAR} OFF PARENT_SCOPE)
+		else()
+			set(${RESULTVAR} ON PARENT_SCOPE)
+		endif()
+	else()
+		set(${RESULTVAR} OFF PARENT_SCOPE)
+	endif()
+endfunction()
\ No newline at end of file
diff -Nru innoextract-1.3/cmake/CompileCheck.cmake innoextract-1.4/cmake/CompileCheck.cmake
--- innoextract-1.3/cmake/CompileCheck.cmake	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/cmake/CompileCheck.cmake	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 
-# Copyright (C) 2011-2012 Daniel Scharrer
+# Copyright (C) 2011-2013 Daniel Scharrer
 #
 # This software is provided 'as-is', without any express or implied
 # warranty.  In no event will the author(s) be held liable for any damages
@@ -17,10 +17,13 @@
 #    misrepresented as being the original software.
 # 3. This notice may not be removed or altered from any source distribution.
 
-function(check_compiler_flag RESULT FLAG)
+function(check_compile RESULT FILE FLAG TYPE)
+	
+	string(REGEX REPLACE "[^a-zA-Z0-9_][^a-zA-Z0-9_]*" "-" cachevar "${TYPE}-${FLAG}")
+	set(cahevar "CHECK_COMPILE_${cahevar}")
 	
-	if(DEFINED CHECK_COMPILER_FLAG_${FLAG})
-		if(CHECK_COMPILER_FLAG_${FLAG})
+	if(DEFINED ${cachevar})
+		if(${cachevar})
 			set(${RESULT} "${FLAG}" PARENT_SCOPE)
 		else()
 			set(${RESULT} "" PARENT_SCOPE)
@@ -28,59 +31,154 @@
 		return()
 	endif()
 	
-	set(compile_test_file "${CMAKE_CURRENT_BINARY_DIR}/compile_flag_test.cpp")
-	file(WRITE ${compile_test_file} "__attribute__((const)) int main(){ return 0; }\n")
-	try_compile(CHECK_COMPILER_FLAG ${CMAKE_BINARY_DIR} ${compile_test_file} COMPILE_DEFINITIONS "${FLAG}" OUTPUT_VARIABLE ERRORLOG)
+	# CMake already has a check_cxx_compiler_flag macro in CheckCXXCompilerFlag, but
+	# it prints the result variable in the output (which is ugly!) and also uses it
+	# as a key to cache checks - so it would need to be unique for each flag.
+	# Unfortunately it also naively pastes the variable name inside a regexp so
+	# if we tried to use the flag itself in the variable name it will fail for -std=c++11.
+	# But we can at least use the expressions for warnings from that macro (and more):
+	set(fail_regexps
+		"warning:"                                     # general
+		"unrecognized .*option"                        # GNU
+		"unknown .*option"                             # Clang
+		"ignoring unknown option"                      # MSVC
+		"warning D9002"                                # MSVC, any lang
+		"option.*not supported"                        # Intel
+		"invalid argument .*option"                    # Intel
+		"ignoring option .*argument required"          # Intel
+		"command line warning"                         # Intel
+		"[Uu]nknown option"                            # HP
+		"[Ww]arning: [Oo]ption"                        # SunPro
+		"command option .* is not recognized"          # XL
+		"not supported in this configuration; ignored" # AIX
+		"File with unknown suffix passed to linker"    # PGI
+		"WARNING: unknown flag:"                       # Open64
+	)
+	
+	# Set the flags to check
+	set(old_CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+	set(old_CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}")
+	set(old_CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}")
+	set(old_CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS}")
+	if("${TYPE}" STREQUAL "linker flag")
+		set(CMAKE_EXE_LINKER_FLAGS "${old_CMAKE_EXE_LINKER_FLAGS} ${FLAG}")
+		set(CMAKE_SHARED_LINKER_FLAGS "${old_CMAKE_SHARED_LINKER_FLAGS} ${FLAG}")
+		set(CMAKE_MODULE_LINKER_FLAGS "${old_CMAKE_MODULE_LINKER_FLAGS} ${FLAG}")
+	elseif("${TYPE}" STREQUAL "compiler flag")
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${FLAG}")
+	endif()
+	
+	# Check if we can compile and link a simple file with the new flags
+	try_compile(
+		check_compiler_flag ${CMAKE_BINARY_DIR} ${FILE}
+		CMAKE_FLAGS "-DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}"
+		            "-DCMAKE_EXE_LINKER_FLAGS=${CMAKE_EXE_LINKER_FLAGS}"
+		            "-DCMAKE_SHARED_LINKER_FLAGS=${CMAKE_SHARED_LINKER_FLAGS}"
+		            "-DCMAKE_MODULE_LINKER_FLAGS=${CMAKE_MODULE_LINKER_FLAGS}"
+		OUTPUT_VARIABLE ERRORLOG
+	)
+	
+	# Restore the old flags
+	set(CMAKE_CXX_FLAGS "${old_CMAKE_CXX_FLAGS}")
+	set(CMAKE_EXE_LINKER_FLAGS "${old_CMAKE_EXE_LINKER_FLAGS}")
+	set(CMAKE_SHARED_LINKER_FLAGS "${old_CMAKE_SHARED_LINKER_FLAGS}")
+	set(CMAKE_MODULE_LINKER_FLAGS "${old_CMAKE_MODULE_LINKER_FLAGS}")
 	
-	string(REGEX MATCH "warning:" HAS_WARNING "${ERRORLOG}")
-	
-	if(NOT CHECK_COMPILER_FLAG)
-		message(STATUS "Checking compiler flag: ${FLAG} - unsupported")
-		set(${RESULT} "" PARENT_SCOPE)
-		set("CHECK_COMPILER_FLAG_${FLAG}" 0 CACHE INTERNAL "...")
-	elseif(NOT HAS_WARNING STREQUAL "")
-		message(STATUS "Checking compiler flag: ${FLAG} - unsupported (warning)")
+	if(NOT check_compiler_flag)
+		message(STATUS "Checking ${TYPE}: ${FLAG} - unsupported")
 		set(${RESULT} "" PARENT_SCOPE)
-		set("CHECK_COMPILER_FLAG_${FLAG}" 0 CACHE INTERNAL "...")
+		set("${cachevar}" 0 CACHE INTERNAL "...")
 	else()
-		message(STATUS "Checking compiler flag: ${FLAG}")
-		set(${RESULT} "${FLAG}" PARENT_SCOPE)
-		set("CHECK_COMPILER_FLAG_${FLAG}" 1 CACHE INTERNAL "...")
+		
+		set(has_warning 0)
+		foreach(expr IN LISTS fail_regexps)
+			if("${ERRORLOG}" MATCHES "${expr}")
+				set(has_warning 1)
+			endif()
+		endforeach()
+		
+		if(has_warning)
+			message(STATUS "Checking ${TYPE}: ${FLAG} - unsupported (warning)")
+			set(${RESULT} "" PARENT_SCOPE)
+			set("${cachevar}" 0 CACHE INTERNAL "...")
+		else()
+			message(STATUS "Checking ${TYPE}: ${FLAG}")
+			set(${RESULT} "${FLAG}" PARENT_SCOPE)
+			set("${cachevar}" 1 CACHE INTERNAL "...")
+		endif()
+		
 	endif()
 	
+endfunction(check_compile)
+
+function(check_flag RESULT FLAG TYPE)
+	set(compile_test_file "${CMAKE_CURRENT_BINARY_DIR}/compile_flag_test.cpp")
+	file(WRITE ${compile_test_file} "__attribute__((const)) int main(){ return 0; }\n")
+	check_compile(result "${compile_test_file}" "${FLAG}" "${TYPE} flag")
+	set(${RESULT} "${result}" PARENT_SCOPE)
+endfunction(check_flag)
+
+function(check_compiler_flag RESULT FLAG)
+	check_flag(result "${FLAG}" compiler)
+	set(${RESULT} "${result}" PARENT_SCOPE)
 endfunction(check_compiler_flag)
 
+function(check_linker_flag RESULT FLAG)
+	check_flag(result "${FLAG}" linker)
+	set(${RESULT} "${result}" PARENT_SCOPE)
+endfunction(check_linker_flag)
+
 function(add_cxxflag FLAG)
 	
 	check_compiler_flag(RESULT "${FLAG}")
 	
 	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${RESULT}" PARENT_SCOPE)
 	
+	if("${RESULT}" STREQUAL "")
+		set(FLAG_FOUND 0 PARENT_SCOPE)
+	else()
+		set(FLAG_FOUND 1 PARENT_SCOPE)
+	endif()
+	
 endfunction(add_cxxflag)
 
 function(add_ldflag FLAG)
 	
-	check_compiler_flag(RESULT "${FLAG}")
+	check_linker_flag(RESULT "${FLAG}")
 	
 	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${RESULT}" PARENT_SCOPE)
 	set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${RESULT}" PARENT_SCOPE)
 	set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${RESULT}" PARENT_SCOPE)
 	
+	if("${RESULT}" STREQUAL "")
+		set(FLAG_FOUND 0 PARENT_SCOPE)
+	else()
+		set(FLAG_FOUND 1 PARENT_SCOPE)
+	endif()
+	
 endfunction(add_ldflag)
 
 function(try_link_library LIBRARY_NAME LIBRARY_FILE ERROR_VAR)
-	# See if we can link a simple program with the library using the configured c++ compiler.
+	# See if we can link a simple program with the library using the configured c++ compiler
 	set(link_test_file "${CMAKE_CURRENT_BINARY_DIR}/link_test.cpp")
 	file(WRITE ${link_test_file} "int main(){}\n")
 	if(CMAKE_THREAD_LIBS_INIT)
 		list(APPEND LIBRARY_FILE "${CMAKE_THREAD_LIBS_INIT}")
 	endif()
-	try_compile(CHECK_${LIBRARY_NAME}_LINK "${CMAKE_BINARY_DIR}" "${link_test_file}" CMAKE_FLAGS "-DLINK_LIBRARIES=${LIBRARY_FILE}" OUTPUT_VARIABLE ERRORLOG)
+	try_compile(
+		CHECK_${LIBRARY_NAME}_LINK "${CMAKE_BINARY_DIR}" "${link_test_file}"
+		CMAKE_FLAGS "-DLINK_LIBRARIES=${LIBRARY_FILE}"
+		            "-DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}"
+		            "-DCMAKE_EXE_LINKER_FLAGS=${CMAKE_EXE_LINKER_FLAGS}"
+		            "-DCMAKE_SHARED_LINKER_FLAGS=${CMAKE_SHARED_LINKER_FLAGS}"
+		            "-DCMAKE_MODULE_LINKER_FLAGS=${CMAKE_MODULE_LINKER_FLAGS}"
+		OUTPUT_VARIABLE ERRORLOG
+	)
 	set(${ERROR_VAR} "${ERRORLOG}" PARENT_SCOPE)
 endfunction(try_link_library)
 
 ##############################################################################
-# Check that a a library actually works for the current configuration.
+# Check that a a library actually works for the current configuration
 function(check_link_library LIBRARY_NAME LIBRARY_VARIABLE)
 	
 	set(lib_current "${${LIBRARY_VARIABLE}}")
@@ -102,7 +200,7 @@
 		message(STATUS "Checking ${LIBRARY_NAME}: ${lib_current}")
 	endif()
 	
-	# Check if we can link to the full path found by find_package.
+	# Check if we can link to the full path found by find_package
 	try_link_library(${LIBRARY_NAME} "${lib_current}" ERRORLOG1)
 	
 	if(CHECK_${LIBRARY_NAME}_LINK)
@@ -110,8 +208,9 @@
 		return()
 	endif()
 	
-	# Check if the linker is smarter than cmake and try to link with only the library name.
-	string(REGEX REPLACE "(^|;)[^;]*/lib([^;/]*)\\.so" "\\1-l\\2" LIBRARY_FILE "${lib_current}")
+	# Check if the linker is smarter than cmake and try to link with only the library name
+	string(REGEX REPLACE "(^|;)[^;]*/lib([^;/]*)\\.so" "\\1-l\\2"
+	       LIBRARY_FILE "${lib_current}")
 	
 	if(NOT LIBRARY_FILE STREQUAL lib_current)
 		
@@ -126,11 +225,15 @@
 		
 	endif()
 	
-	# Force cmake to search again, as the cached library doesn't work.
+	# Force cmake to search again, as the cached library doesn't work
 	unset(FIND_PACKAGE_MESSAGE_DETAILS_${ARGV2} CACHE)
 	unset(FIND_PACKAGE_MESSAGE_DETAILS_${LIBRARY_NAME} CACHE)
 	
-	message(FATAL_ERROR "\n${ERRORLOG1}\n\n${ERRORLOG2}\n\n!! No suitable version of ${LIBRARY_NAME} found.\n   Maybe you don't have the right (32 vs.64 bit) architecture installed?\n\n   Tried ${lib_current} and ${LIBRARY_FILE}\n   Using compiler ${CMAKE_CXX_COMPILER} ${CMAKE_CXX_FLAGS}\n\n\n")
+	message(FATAL_ERROR "\n${ERRORLOG1}\n\n${ERRORLOG2}\n\n"
+	        "!! No suitable version of ${LIBRARY_NAME} found.\n"
+	        "   Maybe you don't have the right (32 vs.64 bit) architecture installed?\n\n"
+	        "   Tried ${lib_current} and ${LIBRARY_FILE}\n"
+	        "   Using compiler ${CMAKE_CXX_COMPILER} ${CMAKE_CXX_FLAGS}\n\n\n")
 	
 endfunction(check_link_library)
 
diff -Nru innoextract-1.3/cmake/FindLZMA.cmake innoextract-1.4/cmake/FindLZMA.cmake
--- innoextract-1.3/cmake/FindLZMA.cmake	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/cmake/FindLZMA.cmake	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 
-# Copyright (C) 2011 Daniel Scharrer
+# Copyright (C) 2011-2013 Daniel Scharrer
 #
 # This software is provided 'as-is', without any express or implied
 # warranty.  In no event will the author(s) be held liable for any damages
@@ -21,15 +21,53 @@
 # Once done this will define
 #
 # LZMA_FOUND
-# LZMA_INCLUDE_DIR - where to find lzma.h
-# LZMA_LIBRARIES - liblzma.so
-
-find_path(LZMA_INCLUDE_DIR lzma.h DOC "The directory where lzma.h resides")
-find_library(LZMA_LIBRARY lzma DOC "The LZMA library")
+# LZMA_INCLUDE_DIR   Where to find lzma.h
+# LZMA_LIBRARIES     The liblzma library
+# LZMA_DEFINITIONS   Definitions to use when compiling code that uses liblzma
+#
+# Typical usage could be something like:
+#   find_package(LZMA REQUIRED)
+#   include_directories(SYSTEM ${LZMA_INCLUDE_DIR})
+#   add_definitions(${LZMA_DEFINITIONS})
+#   ...
+#   target_link_libraries(myexe ${LZMA_LIBRARIES})
+#
+# The following additional options can be defined before the find_package() call:
+# LZMA_USE_STATIC_LIBS  Statically link against liblzma (default: OFF)
 
+if(UNIX)
+	find_package(PkgConfig QUIET)
+	pkg_check_modules(_PC_LZMA liblzma)
+endif()
+
+include(UseStaticLibs)
+use_static_libs(LZMA)
+
+find_path(LZMA_INCLUDE_DIR lzma.h
+	HINTS
+		${_PC_LZMA_INCLUDE_DIRS}
+	DOC "The directory where lzma.h resides"
+)
 mark_as_advanced(LZMA_INCLUDE_DIR)
+
+# Prefer libraries in the same prefix as the include files
+string(REGEX REPLACE "(.*)/include/?" "\\1" LZMA_BASE_DIR ${LZMA_INCLUDE_DIR})
+
+find_library(LZMA_LIBRARY lzma liblzma
+	HINTS
+		"${LZMA_BASE_DIR}/lib"
+		${_PC_LZMA_LIBRARY_DIRS}
+	DOC "The LZMA library"
+)
 mark_as_advanced(LZMA_LIBRARY)
 
+use_static_libs_restore()
+
+set(LZMA_DEFINITIONS)
+if(WIN32 AND LZMA_USE_STATIC_LIBS)
+	set(LZMA_DEFINITIONS -DLZMA_API_STATIC)
+endif()
+
 # handle the QUIETLY and REQUIRED arguments and set LZMA_FOUND to TRUE if 
 # all listed variables are TRUE
 include(FindPackageHandleStandardArgs)
diff -Nru innoextract-1.3/cmake/Findiconv.cmake innoextract-1.4/cmake/Findiconv.cmake
--- innoextract-1.3/cmake/Findiconv.cmake	1970-01-01 00:00:00.000000000 +0000
+++ innoextract-1.4/cmake/Findiconv.cmake	2013-03-11 16:24:33.000000000 +0000
@@ -0,0 +1,89 @@
+
+# Copyright (C) 2012-2013 Daniel Scharrer
+#
+# This software is provided 'as-is', without any express or implied
+# warranty.  In no event will the author(s) be held liable for any damages
+# arising from the use of this software.
+#
+# Permission is granted to anyone to use this software for any purpose,
+# including commercial applications, and to alter it and redistribute it
+# freely, subject to the following restrictions:
+#
+# 1. The origin of this software must not be misrepresented; you must not
+#    claim that you wrote the original software. If you use this software
+#    in a product, an acknowledgment in the product documentation would be
+#    appreciated but is not required.
+# 2. Altered source versions must be plainly marked as such, and must not be
+#    misrepresented as being the original software.
+# 3. This notice may not be removed or altered from any source distribution.
+
+# Try to find the iconv library and include path for iconv.h.
+# Once done this will define
+#
+# ICONV_FOUND
+# iconv_INCLUDE_DIR   Where to find iconv.h
+# iconv_LIBRARIES     The libiconv library or empty if none was found
+# iconv_DEFINITIONS   Definitions to use when compiling code that uses iconv
+#
+# An empty iconv_LIBRARIES is not an error as iconv is often included in the system libc.
+#
+# Typical usage could be something like:
+#   find_package(iconv REQUIRED)
+#   include_directories(SYSTEM ${iconv_INCLUDE_DIR})
+#   add_definitions(${iconv_DEFINITIONS})
+#   ...
+#   target_link_libraries(myexe ${iconv_LIBRARIES})
+#
+# The following additional options can be defined before the find_package() call:
+# iconv_USE_STATIC_LIBS  Statically link against libiconv (default: OFF)
+
+include(UseStaticLibs)
+use_static_libs(iconv)
+
+if(APPLE)
+	# Prefer local iconv.h location over the system iconv.h location as /opt/local/include
+	# may be added to the include path by other libraries, resulting in the #include
+	# statements finding the local copy while we will link agains the system lib.
+	# This way we always find both include file and library in /opt/local/ if there is one.
+	find_path(iconv_INCLUDE_DIR iconv.h
+		PATHS /opt/local/include
+		DOC "The directory where iconv.h resides"
+		NO_CMAKE_SYSTEM_PATH
+	)
+endif(APPLE)
+
+find_path(iconv_INCLUDE_DIR iconv.h
+	PATHS /opt/local/include
+	DOC "The directory where iconv.h resides"
+)
+mark_as_advanced(iconv_INCLUDE_DIR)
+
+# Prefer libraries in the same prefix as the include files
+string(REGEX REPLACE "(.*)/include/?" "\\1" iconv_BASE_DIR ${iconv_INCLUDE_DIR})
+
+find_library(iconv_LIBRARY iconv libiconv
+	HINTS "${iconv_BASE_DIR}/lib"
+	PATHS /opt/local/lib
+	DOC "The iconv library"
+)
+mark_as_advanced(iconv_LIBRARY)
+
+use_static_libs_restore()
+
+set(iconv_DEFINITIONS)
+if(WIN32 AND iconv_USE_STATIC_LIBS)
+	set(iconv_DEFINITIONS -DLIBICONV_STATIC)
+endif()
+
+# handle the QUIETLY and REQUIRED arguments and set iconv_FOUND to TRUE if 
+# all listed variables are TRUE
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(iconv DEFAULT_MSG iconv_INCLUDE_DIR)
+
+# For some reason, find_package_... uppercases it's first argument. Nice!
+if(ICONV_FOUND)
+	set(iconv_LIBRARIES)
+	if(iconv_LIBRARY)
+		list(APPEND iconv_LIBRARIES ${iconv_LIBRARY})
+	endif()
+endif(ICONV_FOUND)
diff -Nru innoextract-1.3/cmake/PrintConfiguration.cmake innoextract-1.4/cmake/PrintConfiguration.cmake
--- innoextract-1.3/cmake/PrintConfiguration.cmake	1970-01-01 00:00:00.000000000 +0000
+++ innoextract-1.4/cmake/PrintConfiguration.cmake	2013-03-11 16:24:33.000000000 +0000
@@ -0,0 +1,72 @@
+
+# Copyright (C) 2013 Daniel Scharrer
+#
+# This software is provided 'as-is', without any express or implied
+# warranty.  In no event will the author(s) be held liable for any damages
+# arising from the use of this software.
+#
+# Permission is granted to anyone to use this software for any purpose,
+# including commercial applications, and to alter it and redistribute it
+# freely, subject to the following restrictions:
+#
+# 1. The origin of this software must not be misrepresented; you must not
+#    claim that you wrote the original software. If you use this software
+#    in a product, an acknowledgment in the product documentation would be
+#    appreciated but is not required.
+# 2. Altered source versions must be plainly marked as such, and must not be
+#    misrepresented as being the original software.
+# 3. This notice may not be removed or altered from any source distribution.
+
+function(print_configuration TITLE)
+	
+	set(str "")
+	
+	set(print_first 0)
+	
+	set(mode 0)
+	
+	foreach(arg IN LISTS ARGN)
+		
+		if(arg STREQUAL "FIRST")
+			set(print_first 1)
+		else()
+			
+			if(mode EQUAL 0)
+				
+				if(${arg})
+					set(mode 1)
+				else()
+					set(mode 2)
+				endif()
+				
+			else()
+				
+				if(mode EQUAL 1 AND NOT arg STREQUAL "")
+					
+					if(str STREQUAL "")
+						set(str "${arg}")
+					else()
+						set(str "${str}, ${arg}")
+					endif()
+					
+					if(print_first)
+						break()
+					endif()
+					
+				endif()
+				
+				set(mode 0)
+				
+			endif()
+			
+		endif()
+		
+	endforeach()
+	
+	if(str STREQUAL "")
+		set(str "(none)")
+	endif()
+	
+	message(" - ${TITLE}: ${str}")
+	
+endfunction()
diff -Nru innoextract-1.3/cmake/StyleCheck.cmake innoextract-1.4/cmake/StyleCheck.cmake
--- innoextract-1.3/cmake/StyleCheck.cmake	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/cmake/StyleCheck.cmake	2013-03-11 16:24:33.000000000 +0000
@@ -1,4 +1,22 @@
 
+# Copyright (C) 2013 Daniel Scharrer
+#
+# This software is provided 'as-is', without any express or implied
+# warranty.  In no event will the author(s) be held liable for any damages
+# arising from the use of this software.
+#
+# Permission is granted to anyone to use this software for any purpose,
+# including commercial applications, and to alter it and redistribute it
+# freely, subject to the following restrictions:
+#
+# 1. The origin of this software must not be misrepresented; you must not
+#    claim that you wrote the original software. If you use this software
+#    in a product, an acknowledgment in the product documentation would be
+#    appreciated but is not required.
+# 2. Altered source versions must be plainly marked as such, and must not be
+#    misrepresented as being the original software.
+# 3. This notice may not be removed or altered from any source distribution.
+
 find_package(PythonInterp)
 
 unset(STYLE_FILTER)
@@ -48,13 +66,15 @@
 	endif()
 	
 	add_custom_target(${TARGET_NAME}
-		COMMAND cmake -E chdir
+		COMMAND "${CMAKE_COMMAND}" -E chdir
 			"${CMAKE_SOURCE_DIR}"
 			"${PYTHON_EXECUTABLE}"
 			"${CMAKE_MODULE_PATH}/cpplint.py"
 			"--filter=${STYLE_FILTER}"
 			${SOURCES_LIST} ${INCLUDES_LIST}
-		DEPENDS ${SOURCES_LIST} ${INCLUDES_LIST} VERBATIM
+		DEPENDS ${SOURCES_LIST} ${INCLUDES_LIST}
+		COMMENT "Checking code style."
+		VERBATIM
 	)
 	
 endfunction(add_style_check_target)
diff -Nru innoextract-1.3/cmake/UseStaticLibs.cmake innoextract-1.4/cmake/UseStaticLibs.cmake
--- innoextract-1.3/cmake/UseStaticLibs.cmake	1970-01-01 00:00:00.000000000 +0000
+++ innoextract-1.4/cmake/UseStaticLibs.cmake	2013-03-11 16:24:33.000000000 +0000
@@ -0,0 +1,36 @@
+
+# Copyright (C) 2013 Daniel Scharrer
+#
+# This software is provided 'as-is', without any express or implied
+# warranty.  In no event will the author(s) be held liable for any damages
+# arising from the use of this software.
+#
+# Permission is granted to anyone to use this software for any purpose,
+# including commercial applications, and to alter it and redistribute it
+# freely, subject to the following restrictions:
+#
+# 1. The origin of this software must not be misrepresented; you must not
+#    claim that you wrote the original software. If you use this software
+#    in a product, an acknowledgment in the product documentation would be
+#    appreciated but is not required.
+# 2. Altered source versions must be plainly marked as such, and must not be
+#    misrepresented as being the original software.
+# 3. This notice may not be removed or altered from any source distribution.
+
+macro(use_static_libs ID)
+	if(${ID}_USE_STATIC_LIBS)
+		set(_UseStaticLibs_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
+		if(WIN32)
+			set(CMAKE_FIND_LIBRARY_SUFFIXES _a.lib .lib .a ${CMAKE_FIND_LIBRARY_SUFFIXES})
+		else()
+			set(CMAKE_FIND_LIBRARY_SUFFIXES .a)
+		endif()
+	endif()
+endmacro()
+
+macro(use_static_libs_restore)
+	if(DEFINED _UseStaticLibs_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES)
+		set(CMAKE_FIND_LIBRARY_SUFFIXES ${_UseStaticLibs_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES})
+		unset(_UseStaticLibs_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES)
+	endif()
+endmacro()
diff -Nru innoextract-1.3/cmake/VersionScript.cmake innoextract-1.4/cmake/VersionScript.cmake
--- innoextract-1.3/cmake/VersionScript.cmake	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/cmake/VersionScript.cmake	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 
-# Copyright (C) 2011-2012 Daniel Scharrer
+# Copyright (C) 2011-2013 Daniel Scharrer
 #
 # This software is provided 'as-is', without any express or implied
 # warranty.  In no event will the author(s) be held liable for any damages
@@ -22,45 +22,83 @@
 # CMake script that reads a VERSION file and the current git history and the calls configure_file().
 # This is used by version_file() in VersionString.cmake
 
-if((NOT DEFINED INPUT) OR (NOT DEFINED OUTPUT) OR (NOT DEFINED VERSION_FILE) OR (NOT DEFINED GIT_DIR))
+if((NOT DEFINED INPUT) OR (NOT DEFINED OUTPUT) OR (NOT DEFINED VERSION_SOURCES) OR (NOT DEFINED GIT_DIR))
 	message(SEND_ERROR "Invalid arguments.")
 endif()
 
-file(READ "${VERSION_FILE}" BASE_VERSION)
-string(STRIP "${BASE_VERSION}" BASE_VERSION)
-
-# Split the version file into lines.
-string(REGEX MATCHALL "[^\r\n]+" version_lines "${BASE_VERSION}")
-set(BASE_VERSION_COUNT 0)
-foreach(version_line IN LISTS version_lines)
-	
-	set(BASE_VERSION_${BASE_VERSION_COUNT} "${version_line}")
-	
-	# Find the last space
-	string(STRIP "${version_line}" version_line)
-	string(LENGTH "${version_line}" version_line_length)
-	set(version_line_split ${version_line_length})
-	foreach(i RANGE ${version_line_length})
-		if(${i} LESS ${version_line_length})
-			string(SUBSTRING "${version_line}" ${i} 1 version_line_char)
-			if(version_line_char STREQUAL " ")
-				set(version_line_split ${i})
-			endif()
-		endif()
-	endforeach()
+set(var "")
+foreach(arg IN LISTS VERSION_SOURCES)
 	
-	# Get everything before the last space
-	string(SUBSTRING "${version_line}" 0 ${version_line_split} version_line_name)
-	string(STRIP "${version_line_name}" BASE_NAME_${BASE_VERSION_COUNT})
-	
-	# Get everything after the last space
-	if(${version_line_split} LESS ${version_line_length})
-		math(EXPR num_length "${version_line_length} - ${version_line_split}")
-		string(SUBSTRING "${version_line}" ${version_line_split} ${num_length} version_line_num)
-		string(STRIP "${version_line_num}" BASE_NUMBER_${BASE_VERSION_COUNT})
+	if(var STREQUAL "")
+		set(var ${arg})
+	else()
+		
+		file(READ "${arg}" ${var})
+		string(STRIP "${${var}}" ${var})
+		string(REGEX REPLACE "\r\n" "\n" ${var} "${${var}}")
+		string(REGEX REPLACE "\r" "\n" ${var} "${${var}}")
+		
+		# Split the version file into lines.
+		string(REGEX MATCHALL "[^\r\n]+" lines "${${var}}")
+		set(${var}_COUNT 0)
+		foreach(line IN LISTS lines)
+			
+			set(${var}_${${var}_COUNT} "${line}")
+			
+			# Find the first and last spaces
+			string(STRIP "${line}" line)
+			string(LENGTH "${line}" line_length)
+			set(first_space -1)
+			set(last_space ${line_length})
+			foreach(i RANGE ${line_length})
+				if(${i} LESS ${line_length})
+					string(SUBSTRING "${line}" ${i} 1 line_char)
+					if(line_char STREQUAL " ")
+						set(last_space ${i})
+						if(first_space EQUAL -1)
+							set(first_space ${i})
+						endif()
+					endif()
+				endif()
+			endforeach()
+			
+			# Get everything before the first space
+			if(${first_space} GREATER -1)
+				string(SUBSTRING "${line}" 0 ${first_space} line_name)
+				string(STRIP "${line_name}" ${var}_${${var}_COUNT}_SHORTNAME)
+			endif()
+			
+			# Get everything after the first space
+			math(EXPR num_length "${line_length} - ${first_space}")
+			string(SUBSTRING "${line}" ${first_space} ${num_length} line_num)
+			string(STRIP "${line_num}" ${var}_${${var}_COUNT}_STRING)
+			
+			# Get everything before the last space
+			string(SUBSTRING "${line}" 0 ${last_space} line_name)
+			string(STRIP "${line_name}" ${var}_${${var}_COUNT}_NAME)
+			
+			# Get everything after the last space
+			if(${last_space} LESS ${line_length})
+				math(EXPR num_length "${line_length} - ${last_space}")
+				string(SUBSTRING "${line}" ${last_space} ${num_length} line_num)
+				string(STRIP "${line_num}" ${var}_${${var}_COUNT}_NUMBER)
+			endif()
+			
+			math(EXPR ${var}_COUNT "${${var}_COUNT} + 1")
+		endforeach()
+		
+		string(REGEX REPLACE "\n\n.*$" "" ${var}_HEAD "${${var}}")
+		string(STRIP "${${var}_HEAD}" ${var}_HEAD)
+		string(REGEX MATCH "\n\n.*" ${var}_TAIL "${${var}}")
+		string(STRIP "${${var}_TAIL}" ${var}_TAIL)
+		
+		string(REGEX REPLACE "\n" "\\\\n" ${var} "${${var}}")
+		string(REGEX REPLACE "\n" "\\\\n" ${var}_HEAD "${${var}_HEAD}")
+		string(REGEX REPLACE "\n" "\\\\n" ${var}_TAIL "${${var}_TAIL}")
+		
+		set(var "")
 	endif()
 	
-	math(EXPR BASE_VERSION_COUNT "${BASE_VERSION_COUNT} + 1")
 endforeach()
 
 # Check for a git directory and fill in the git commit hash if one exists.
diff -Nru innoextract-1.3/cmake/VersionString.cmake innoextract-1.4/cmake/VersionString.cmake
--- innoextract-1.3/cmake/VersionString.cmake	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/cmake/VersionString.cmake	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 
-# Copyright (C) 2011-2012 Daniel Scharrer
+# Copyright (C) 2011-2013 Daniel Scharrer
 #
 # This software is provided 'as-is', without any express or implied
 # warranty.  In no event will the author(s) be held liable for any damages
@@ -24,20 +24,47 @@
 # SRC is processed using the configure_file() cmake command
 # at build to produce DST with the following variable available:
 #
-# - BASE_VERSION: The contents of the file specified by VERSION_FILE
-# - BASE_VERSION_COUNT: Number of lines in the VERSION file
-# - BASE_VERSION_i: The i-th line of the VERSION file
-# - BASE_NAME_i: Everything except the last component of the i-th line of the VERSION file
-# - BASE_NUMBER_i: The last component of the i-th line of the VERSION file
+# VERSION_SOURCES:
+#  List of (${var} ${file}) pairs.
+#
+# for each variable ${var}
+# - ${var}: The contents of the associated file
+# - ${var}_COUNT: Number of lines in the associated file
+# - ${var}_${i}: The ${i}-th line of the associated file
+# - ${var}_${i}_SHORTNAME: The first component of the ${i}-th line of the associated file
+# - ${var}_${i}_STRING: Everything except the first component of the ${i}-th line of the associated file
+# - ${var}_${i}_NAME: Everything except the last component of the ${i}-th line of the associated file
+# - ${var}_${i}_NUMBER: The last component of the ${i}-th line of the associated file
+# - ${var}_HEAD: The first paragraph of the associated file
+# - ${var}_TAIL: The remaining paragraphs of the associated file
+#
 # - GIT_COMMIT: The current git commit. (not defined if there is no GIT_DIR directory)
-# - GIT_COMMIT_PREFIX_i: The first i characters of GIT_COMMIT (i=0..39)
+# - GIT_COMMIT_PREFIX_${i}: The first ${i} characters of GIT_COMMIT (i=0..39)
 # For the exact syntax of SRC see the documentation of the configure_file() cmake command.
 # The version file is regenerated whenever VERSION_FILE or the current commit changes.
-function(version_file SRC DST VERSION_FILE GIT_DIR)
+function(version_file SRC DST VERSION_SOURCES GIT_DIR)
+	
+	set(mode "variable")
+	
+	set(args)
+	set(dependencies "${CMAKE_MODULE_PATH}/VersionScript.cmake")
+	
+	foreach(arg IN LISTS VERSION_SOURCES)
+		
+		if(mode STREQUAL "variable")
+			set(mode "file")
+		else()
+			get_filename_component(arg "${arg}" ABSOLUTE)
+			list(APPEND dependencies ${abs_file})
+			set(mode "variable")
+		endif()
+		
+		list(APPEND args ${arg})
+		
+	endforeach()
 	
 	get_filename_component(abs_src "${SRC}" ABSOLUTE)
 	get_filename_component(abs_dst "${DST}" ABSOLUTE)
-	get_filename_component(abs_version_file "${VERSION_FILE}" ABSOLUTE)
 	get_filename_component(abs_git_dir "${GIT_DIR}" ABSOLUTE)
 	
 	set(defines)
@@ -45,8 +72,6 @@
 		set(defines ${ARGV4})
 	endif()
 	
-	set(dependencies "${abs_version_file}" "${CMAKE_MODULE_PATH}/VersionScript.cmake")
-	
 	if(EXISTS "${abs_git_dir}/HEAD")
 		list(APPEND dependencies "${abs_git_dir}/HEAD")
 	endif()
@@ -62,7 +87,7 @@
 			${CMAKE_COMMAND}
 			"-DINPUT=${abs_src}"
 			"-DOUTPUT=${abs_dst}"
-			"-DVERSION_FILE=${abs_version_file}"
+			"-DVERSION_SOURCES=${args}"
 			"-DGIT_DIR=${abs_git_dir}"
 			${defines}
 			-P "${CMAKE_MODULE_PATH}/VersionScript.cmake"
diff -Nru innoextract-1.3/cmake/check-cxx11-alignof.cpp innoextract-1.4/cmake/check-cxx11-alignof.cpp
--- innoextract-1.3/cmake/check-cxx11-alignof.cpp	1970-01-01 00:00:00.000000000 +0000
+++ innoextract-1.4/cmake/check-cxx11-alignof.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -0,0 +1,3 @@
+int main() {
+	return alignof(int) != 1;
+}
\ No newline at end of file
diff -Nru innoextract-1.3/cmake/check-cxx11-std-codecvt_utf8_utf16.cpp innoextract-1.4/cmake/check-cxx11-std-codecvt_utf8_utf16.cpp
--- innoextract-1.3/cmake/check-cxx11-std-codecvt_utf8_utf16.cpp	1970-01-01 00:00:00.000000000 +0000
+++ innoextract-1.4/cmake/check-cxx11-std-codecvt_utf8_utf16.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -0,0 +1,6 @@
+#include <codecvt>
+
+int main() {
+	std::codecvt_utf8_utf16<wchar_t> codecvt;
+	return 0;
+}
\ No newline at end of file
diff -Nru innoextract-1.3/cmake/check-cxx11-std-unique_ptr.cpp innoextract-1.4/cmake/check-cxx11-std-unique_ptr.cpp
--- innoextract-1.3/cmake/check-cxx11-std-unique_ptr.cpp	1970-01-01 00:00:00.000000000 +0000
+++ innoextract-1.4/cmake/check-cxx11-std-unique_ptr.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -0,0 +1,6 @@
+#include <memory>
+
+int main() {
+	std::unique_ptr<char> ptr(new char);
+	return !ptr;
+}
\ No newline at end of file
diff -Nru innoextract-1.3/cmake/cpplint.py innoextract-1.4/cmake/cpplint.py
--- innoextract-1.3/cmake/cpplint.py	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/cmake/cpplint.py	2013-03-11 16:24:33.000000000 +0000
@@ -1,6 +1,6 @@
 #!/usr/bin/python2.4
 #
-# Note: this file has been adjusted to fit InnoExtract:
+# Note: this file has been adjusted to fit innoextract:
 #  - adjusted include guard style
 #  - hacked so that build/include doesn't complain about #include "Configure.h" lines
 #  - Allow lines that are only whitespace.
@@ -10,6 +10,7 @@
 #  - Don't require two spaces between code and comments
 #  - Warn if spaces are used for identation.
 #  - Allow //! comments
+#  - Allo struct name { typedef a type; }; one-liners
 #
 # Copyright (c) 2009 Google Inc. All rights reserved.
 #
@@ -1196,7 +1197,6 @@
     ('getlogin(', 'getlogin_r('),
     ('getpwnam(', 'getpwnam_r('),
     ('getpwuid(', 'getpwuid_r('),
-    ('gmtime(', 'gmtime_r('),
     ('localtime(', 'localtime_r('),
     ('rand(', 'rand_r('),
     ('readdir(', 'readdir_r('),
@@ -2157,6 +2157,10 @@
             'Lines should very rarely be longer than 100 characters')
 
   if (cleansed_line.count(';') > 1 and
+      # allow one-line definitions for small structs or classes
+      not ((cleansed_line.find('struct ') != -1 or
+            cleansed_line.find('class ') != -1) and
+           cleansed_line.find('};') != -1) and
       # for loops are allowed two ;'s (and may run over two lines).
       cleansed_line.find('for') == -1 and
       (GetPreviousNonBlankLine(clean_lines, linenum)[0].find('for') == -1 or
diff -Nru innoextract-1.3/debian/changelog innoextract-1.4/debian/changelog
--- innoextract-1.3/debian/changelog	2013-04-26 18:18:41.000000000 +0000
+++ innoextract-1.4/debian/changelog	2013-05-23 12:39:47.000000000 +0000
@@ -1,24 +1,46 @@
-innoextract (1.3-1build1) saucy; urgency=low
+innoextract (1.4-0ppa1~saucy) saucy; urgency=low
 
-  * No change rebuild for Boost 1.53 transition.
+  * Bump version to 1.4 (new upstream release):
+  * Fixed issues with the progress bar in sandbox environments
+  * Fixed extracting very large installers with 32-bit innoextract builds
+  * Improved handling
+  * The --list command-line option can now combined with --test or --extract
+  * The --version command-line option can now be modified with --quiet
+    or --silent
+  * Added support for preserving timestamps of extracted files
+    (enabled by default)
+  * Added a --timestamps (-T) command-line options to control or disable
+    file timestamps
+  * Added an --output-dir (-d) command-line option to control where files
+    are extracted
+  * Various bug fixes and tweaks
 
- -- Dmitrijs Ledkovs <dmitrij.ledkov@ubuntu.com>  Fri, 26 Apr 2013 19:18:41 +0100
+ -- Daniel Scharrer <daniel@constexpr.org>  Mon, 11 Mar 2013 17:19:38 +0100
 
-innoextract (1.3-1) unstable; urgency=low
+innoextract (1.3-0ppa1~saucy) saucy; urgency=low
 
-  * New upstream release
-  * Update Debian Standards Version to 3.9.4
+  * New upstream release 1.3:
+  * Respect --quiet and --silent for multi-file installers
+  * Compile in C++11 mode if supported
+  * Warn about unsupported setup data versions
+  * Add support for Inno Setup 5.5.0 installers
 
- -- Lennart Weller <lhw@ring0.de>  Thu, 25 Oct 2012 23:01:31 +0200
+ -- Daniel Scharrer <daniel@constexpr.org>  Tue, 03 Jul 2012 18:19:42 +0200
 
-innoextract (1.2+git20120504-2) unstable; urgency=low
+innoextract (1.2-0ppa2~saucy) saucy; urgency=low
 
-  * introduced hardening to the binary to solve all warnings
+  * Install the upstream changelog file with the correct name.
 
- -- Lennart Weller <lhw@ring0.de>  Thu, 04 Oct 2012 23:05:27 +0200
+ -- Daniel Scharrer <daniel@constexpr.org>  Tue, 03 Apr 2012 21:17:42 +0200
 
-innoextract (1.2+git20120504-1) unstable; urgency=low
+innoextract (1.2-0ppa1~saucy) saucy; urgency=low
 
-  * Initial release. (Closes: #678294)
+  * New upstream release: fix compile errors on older systems and remove unused dependency.
 
- -- Lennart Weller <lhw@ring0.de>  Wed, 20 Jun 2012 18:12:47 +0200
+ -- Daniel Scharrer <daniel@constexpr.org>  Sun, 01 Apr 2012 02:26:24 +0200
+
+innoextract (1.1-0ppa1~saucy) saucy; urgency=low
+
+  * Initial release
+
+ -- Daniel Scharrer <daniel@constexpr.org>  Sun, 25 Mar 2012 08:01:24 +0200
diff -Nru innoextract-1.3/debian/compat innoextract-1.4/debian/compat
--- innoextract-1.3/debian/compat	2013-04-26 18:18:28.000000000 +0000
+++ innoextract-1.4/debian/compat	2012-03-30 22:53:29.000000000 +0000
@@ -1 +1 @@
-9
+7
diff -Nru innoextract-1.3/debian/control innoextract-1.4/debian/control
--- innoextract-1.3/debian/control	2013-04-26 18:18:43.000000000 +0000
+++ innoextract-1.4/debian/control	2013-03-10 23:04:42.000000000 +0000
@@ -1,30 +1,17 @@
 Source: innoextract
 Section: utils
 Priority: extra
-Maintainer: Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
-XSBC-Original-Maintainer: Lennart Weller <lhw@ring0.de>
-Uploaders: Sebastian Reichel <sre@debian.org>
-Standards-Version: 3.9.4
-Vcs-git: git://anonscm.debian.org/collab-maint/innoextract.git
-Vcs-Browser: http://anonscm.debian.org/gitweb/?p=collab-maint/innoextract.git
-Homepage: https://github.com/dscharrer/InnoExtract
-Build-Depends: cmake,
-               debhelper (>= 9),
-               dpkg-dev (>= 1.16.1~),
-               libboost-iostreams-dev,
-               libboost-filesystem-dev,
-               libboost-date-time-dev,
-               libboost-system-dev,
-               libboost-program-options-dev,
-               liblzma-dev
+Maintainer: Daniel Scharrer <daniel@constexpr.org>
+Build-Depends: debhelper (>= 7.0.50), cmake (>= 2.8), libboost-dev, libboost-iostreams-dev , libboost-filesystem-dev, libboost-date-time-dev, libboost-system-dev, libboost-program-options-dev, liblzma-dev
+Standards-Version: 3.9.2
+Homepage: http://constexpr.org/innoextract/
+Vcs-Git: git://github.com/dscharrer/innoextract.git
+Vcs-Browser: https://github.com/dscharrer/innoextract
 
 Package: innoextract
 Architecture: any
-Multi-Arch: foreign
-Depends: ${misc:Depends},
-         ${shlibs:Depends}
-Description: Tool for extracting data from an Inno Setup installer
+Depends: ${shlibs:Depends}, ${misc:Depends}
+Description: Tool to extract installers created by Inno Setup
  Inno Setup is a tool to create installers for Microsoft Windows applications.
- Inno Extracts allows one to extract such installers under non-windows systems
- without running the actual installer using wine. Inno Extract currently
- supports installers created by Inno Setup 1.2.10 to 5.4.3.
+ innoextract allows one to extract such installers under non-windows systems
+ without running the actual installer using wine.
diff -Nru innoextract-1.3/debian/copyright innoextract-1.4/debian/copyright
--- innoextract-1.3/debian/copyright	2013-04-26 18:18:28.000000000 +0000
+++ innoextract-1.4/debian/copyright	2013-03-11 16:22:07.000000000 +0000
@@ -1,57 +1,22 @@
-Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
-Upstream-Name: InnoExtract
-Source: https://github.com/dscharrer/InnoExtract 
+Format: http://dep.debian.net/deps/dep5
+Upstream-Name: innoextract
+Source: http://constexpr.org/innoextract/
 
 Files: *
-Copyright: Copyright 2011-2012 Daniel Scharrer <daniel@constexpr.org>
-License: Zlib
-
-Files: cmake/cpplint.py
-Copyright: 2009 Google Inc.
-License: BSD-3-clause
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions
- are met:
- 1. Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright
-    notice, this list of conditions and the following disclaimer in the
-    documentation and/or other materials provided with the distribution.
- 3. Neither the name of the copyright holder nor the names of contributors
-    may be used to endorse or promote products derived from this software
-    without specific prior written permission.
- .
- THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE
- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- SUCH DAMAGE.
-
-Files: debian/*
-Copyright: Copyright 2012 Lennart Weller <lhw@ring0.de>
-License: Zlib
-
-License: Zlib
- This software is provided 'as-is', without any express or implied warranty. In
- no event will the authors be held liable for any damages arising from the use
- of this software.
- .
- Permission is granted to anyone to use this software for any purpose, including
- commercial applications, and to alter it and redistribute it freely, subject to
- the following restrictions:
+Copyright: 2011-2013 Daniel Scharrer <daniel@constexpr.org>
+License: ZLIB
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the author(s) be held liable for any damages
+ arising from the use of this software.
  .
- 1. The origin of this software must not be misrepresented; you must not claim
- that you wrote the original software. If you use this software in a product, an
- acknowledgment in the product documentation would be appreciated but is not
- required.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
  .
+ 1. The origin of this software must not be misrepresented; you must not
+    claim that you wrote the original software. If you use this software
+    in a product, an acknowledgment in the product documentation would be
+    appreciated but is not required.
  2. Altered source versions must be plainly marked as such, and must not be
- misrepresented as being the original software.
- .
+    misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution.
diff -Nru innoextract-1.3/debian/docs innoextract-1.4/debian/docs
--- innoextract-1.3/debian/docs	1970-01-01 00:00:00.000000000 +0000
+++ innoextract-1.4/debian/docs	2012-04-03 19:10:49.000000000 +0000
@@ -0,0 +1 @@
+README.md
diff -Nru innoextract-1.3/debian/rules innoextract-1.4/debian/rules
--- innoextract-1.3/debian/rules	2013-04-26 18:18:28.000000000 +0000
+++ innoextract-1.4/debian/rules	2012-04-03 19:12:50.000000000 +0000
@@ -1,12 +1,12 @@
 #!/usr/bin/make -f
+# -*- makefile -*-
+# We don't need any custom rules as debhelper is able to fugure out everything.
 
-DPKG_EXPORT_BUILDFLAGS = 1
-include /usr/share/dpkg/buildflags.mk
-CFLAGS+=$(CPPFLAGS)
-CXXFLAGS+=$(CPPFLAGS)
+# Uncomment this to turn on verbose mode.
+#export DH_VERBOSE=1
+
+override_dh_installchangelogs:
+	dh_installchangelogs CHANGELOG
 
 %:
 	dh $@
-
-override_dh_auto_configure:
-	cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr
diff -Nru innoextract-1.3/debian/watch innoextract-1.4/debian/watch
--- innoextract-1.3/debian/watch	2013-04-26 18:18:28.000000000 +0000
+++ innoextract-1.4/debian/watch	1970-01-01 00:00:00.000000000 +0000
@@ -1,3 +0,0 @@
-version=3
-opts="uversionmangle=s/^v//" \
-http://githubredir.debian.net/github/dscharrer/InnoExtract/(.+)\.tar\.gz
diff -Nru innoextract-1.3/doc/Doxyfile.in innoextract-1.4/doc/Doxyfile.in
--- innoextract-1.3/doc/Doxyfile.in	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/doc/Doxyfile.in	2013-03-11 16:24:33.000000000 +0000
@@ -1551,7 +1551,7 @@
 # undefined via #undef or recursively expanded use the := operator
 # instead of the = operator.
 
-PREDEFINED             = HAVE_LZMA
+PREDEFINED             = INNOEXTRACT_HAVE_LZMA
 
 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
 # this tag can be used to specify a list of macro names that should be expanded.
diff -Nru innoextract-1.3/doc/innoextract.1 innoextract-1.4/doc/innoextract.1
--- innoextract-1.3/doc/innoextract.1	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/doc/innoextract.1	2013-03-11 16:24:33.000000000 +0000
@@ -1,121 +1,160 @@
 .\" Manpage for innoextract.
 .\" Contact daniel@constexpr.org to correct errors or typos.
-.TH innoextract 1 "2012-07-02" "1.3"
+.TH innoextract 1 "2013-03-11" "1.4"
 .SH NAME
 innoextract \- tool to extract installers created by Inno Setup
 .SH SYNOPSIS
 .B innoextract
-.RB [ -behlLqstv ]
-.RB [ -c color ]
-.RB [ -p progress ]
-.I installers ...
+.RB [ --extract ]
+.RB [ --lowercase ]
+[options] \fIinstallers\fP ...
+
+\fBinnoextract --list\fP [options] \fIinstallers\fP ...
+
+\fBinnoextract --test\fP [options] \fIinstallers\fP ...
 .SH DESCRIPTION
-.B innoextract
-is a tool that can extract installer executables created by Inno Setup.
+\fBinnoextract\fP is a tool that can extract installer executables created by Inno Setup.
 .PP
-.B innoextract
-will extract files from a installers specified on the command line.
+\fBinnoextract\fP will extract files from installers specified on the command line.
 .PP
-To extract a multi-part installer with external data files, only the executable (.exe) file needs to be given as an argument to
-.B innoextract.
+To extract a multi-part installer with external data files, only the executable (.exe) file needs to be given as an argument to \fBinnoextract\fP.
+.SH OPTIONS SUMMARY
+.PP
+Here is a short summary of the options available in innoextract. Please refer to the detailed  documentation below for a complete description.
+.TP
+.B Generic options:
+.nf
+ \-h \-\-help               Show supported options
+ \-v \-\-version            Print version information
+    \-\-license            Show license information
+.fi
+.TP
+.B Actions:
+.nf
+ \-t \-\-test               Only verify checksums, don't write anything
+ \-e \-\-extract            Extract files (default action)
+ \-l \-\-list               Only list files, don't write anything
+.fi
+.TP
+.B Modifiers:
+.nf
+    \-\-dump               Dump contents without converting filenames
+ \-L \-\-lowercase          Convert extracted filenames to lower-case
+    \-\-language \fILANG\fP      Extract files for the given language
+ \-T \-\-timestamps \fITZ\fP      Timezone for file times or "local" or "none"
+ \-d \-\-output-dir \fIDIR\fP     Extract files into the given directory
+.fi
+.TP
+.B Display options:
+.nf
+ \-q \-\-quiet              Output less information
+ \-s \-\-silent             Output only error/warning information
+ \-c \-\-color[=\fIENABLE\fP]     Enable/disable color output
+ \-p \-\-progress[=\fIENABLE\fP]  Enable/disable the progress bar
+.fi
 .SH OPTIONS
 .TP
-.B \-c --color [enable]
+\fB-c\fP, \fB--color\fP[=\fIENABLE\fP]
 By default
 .B innoextract
-will try to detect if the terminal supports shell escape codes and enable or disable color output accordingly. Pass
-.B 1
-or
-.B true
-to
-.B --color
-to force color output. Pass
-.B 0
-or
-.B false
-to never output color codes.
+will try to detect if the terminal supports shell escape codes and enable or disable color output accordingly. Pass \fB1\fP or \fBtrue\fP to \fB--color\fP to force color output. Pass \fB0\fP or \fBfalse\fP to never output color codes.
 .TP
-.B --dump
+\fB--dump\fP
 Don't convert Windows paths to UNIX paths and don't substitute variables in paths.
 .TP
-.B \-e --extract
-Extract all files to the current directory. This is the default action. You may only specify one of
-.B --extract
-,
-.B --list
-and
-.B --test
+\fB-e\fP, \fB--extract\fP
+Extract all files to the current directory. This action is enabled by default, unless either \fB--list\fP or \fB--extract\fP is specified. You may only specify one of \fB--extract\fP and \fB--test\fP.
 .TP
-.B \-h --help
+\fB-h\fP, \fB--help\fP
 Show a list of the supported options.
 .TP
-.B \--language [lang]
+\fB--language\fP \fILANG\fP
 Extract only language-independent files and files for the given language. By default all files are extracted.
 .TP
-.B \--license
+\fB--license\fP
 Show license information.
 .TP
-.B \-l --list
-List files contained in the installer but don't extract anything. You may only specify one of
-.B --extract
-,
-.B --list
-and
-.B --test
+\fB-l\fP, \fB--list\fP
+List files contained in the installer but don't extract anything.
+
+This option can be combined with \fB--silent\fP to print only the names of the contained files (one per line) without additional syntax that would make consumption by other scripts harder.
+
+The \fB--list\fP option can be combined with \fB--test\fP or \fB--extract\fP to display the names of the files as they are extracted even with \fB--silent\fP.
 .TP
-.B \-L --lowercase
+\fB-L\fP, \fB--lowercase\fP
 Convert filenames stored in the installer to lower-case before extracting.
 .TP
-.B \-p --progress [enable]
-By default
-.B innoextract
-will try to detect if the terminal supports shell escape codes and enable or disable progress bar output accordingly. Pass
-.B 1
-or
-.B true
-to
-.B --progress
-to force progress bar output. Pass
-.B 0
-or
-.B false
-to never show a progress bar.
+\fB-d\fP, \fB--output-dir\fP \fIDIR\fP
+Extract all files into the given directory. By default, \fBinnoextract\fP will extract all files to the current directory.
+
+If the specified directory does not exist, it will be created. However, the parent directory must exist or extracting will fail.
+.TP
+\fB-p\fP, \fB--progress\fP[=\fIENABLE\fP]
+By default \fBinnoextract\fP will try to detect if the terminal supports shell escape codes and enable or disable progress bar output accordingly. Pass \fB1\fP or \fBtrue\fP to \fB--progress\fP to force progress bar output. Pass \fB0\fP or \fBfalse\fP to never show a progress bar.
 .TP
-.B \-q --quiet
+\fB-q\fP, \fB--quiet\fP
 Less verbose output.
 .TP
-.B \-s --silent
-Don't output anything except errors and warnings.
+\fB-s\fP, \fB--silent\fP
+Don't output anything except errors and warnings unless explicitely requested.
+
+This option can be combined with \fB--list\fP to print only the names of the contained files (one per line) without additional syntax that would make consumption by other scripts harder.
 .TP
-.B \-t --test
-Test archive integrity but don't write any output files. You may only specify one of
-.B --extract
-,
-.B --list
-and
-.B --test
+\fB-t\fP, \fB--test\fP
+Test archive integrity but don't write any output files. You may only specify one of \fB--extract\fP and \fB--test\fP.
 .TP
-.B \-v --version
-Show the
-.B innoextract
-version number and supported Inno Setup versions.
+\fB-T\fP, \fB--timestamps\fP \fITZ\fP
+Inno Setup installers can contain timestamps in both UTC and 'local' timezones.
+
+The \fB--timestamps\fP option specifies what timezone should be used to adjust these 'local' file times.
+
+Valid values are those accepted by \fBtzset\fP in the \fBTZ\fP environment variable, except with the direction of the time offset reversed: both \fB-T CET\fP and \fB-T GMT+1\fP will (when DST is in effect) give the same result.
+
+Besides timezones, two special values are accepted:
+
+  "\fBnone\fP"    Don't preserve file times for extracted files, both for UTC and 'local' timestamps. The file times wil be left the way the OS set them when creating the output files.
+
+  "\fBlocal\fP"  Use the system timezone for 'local' timestamps. This is the normal Inno Setup behavior, and can be used together with the \fBTZ\fP environment variable.
+
+The default value for this option is \fBUTC\fP, causing innoextract to not adjust 'local' file times. File times marked as UTC in the Inno Setup file will never be adjusted no matter what \fB--timestamps\fP is set to.
+.TP
+\fB-v\fP, \fB--version\fP
+Print the \fBinnoextract\fP version number and supported Inno Setup versions.
+
+If combined with the \fB--silent\fP option, only the version \fInumber\fP is printed. Otherwise, the output will contain the name (innoextract) followed by the version number on the first line, and, unless the \fB--quiet\fP options is specified, the range of suuported Inno Setup installer versions on the second line.
+.SH EXIT VALUES
+.PP
+.IP \fB0\fP
+Success
+.IP \fB1\fP
+Syntax or usage error
+.IP \fB2+\fP
+Broken or unsupported setup file, or input/output error
 .SH LIMITATIONS
-.B innoextract
-currently only supports extracting all the data. There is no support for extracting individual files or components and limited support for extracting language-specific files.
+\fBinnoextract\fP currently only supports extracting all the data. There is no support for extracting individual files or components and limited support for extracting language-specific files.
 
 Included scripts and checks are not executed.
 
-Data is always extracted to the current directory and the mapping from Inno Setup variables like the application directory to subdirectories is hard-coded.
+The mapping from Inno Setup variables like the application directory to subdirectories is hard-coded.
 
-.B innoextract
-does not check if an installer includes multiple files with the same name and will continually overwrite the destination file when extracting.
+\fBinnoextract\fP does not check if an installer includes multiple files with the same name and will continually overwrite the destination file when extracting.
 
-Names for data files in multi-file installers must follow the standard naming scheme.
+Names for data slice/disk files in multi-file installers must follow the standard naming scheme.
 
 Encrypted installers are not supported.
 .SH SEE ALSO
-cabextract(1), unshield(1)
+\fBcabextract\fP(1), \fBunshield\fP(1), \fBtzset\fP(3)
 .SH BUGS
+.PP
 No known bugs.
+.PP
+Please report bugs to http://innoextract.constexpr.org/issues.
+.SH CREDITS
+.PP
+\fBinnoextract\fP is distributed under the zlib/libpng license.  See the LICENSE file for details.
+.PP
+A website is available at http://constexpr.org/innoextract/.
+.PP
+This program uses the excellent lzma/xz decompression library written by Lasse Collin.
 .SH AUTHOR
 Daniel Scharrer (daniel@constexpr.org)
diff -Nru innoextract-1.3/src/cli/debug.cpp innoextract-1.4/src/cli/debug.cpp
--- innoextract-1.3/src/cli/debug.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/cli/debug.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -21,6 +21,7 @@
 #include "cli/debug.hpp"
 
 #include <ctime>
+#include <iostream>
 
 #include <boost/foreach.hpp>
 
@@ -47,27 +48,28 @@
 #include "util/load.hpp"
 #include "util/log.hpp"
 #include "util/output.hpp"
+#include "util/time.hpp"
 #include "util/util.hpp"
 
-using std::cout;
-
 void print_offsets(const loader::offsets & offsets) {
 	
-	cout << "loaded offsets:" << '\n';
+	std::cout << "loaded offsets:" << '\n';
 	if(offsets.exe_offset) {
-		cout << "- exe: @ " << color::cyan << print_hex(offsets.exe_offset) << color::reset;
+		std::cout << "- exe: @ " << color::cyan << print_hex(offsets.exe_offset)
+		          << color::reset;
 		if(offsets.exe_compressed_size) {
-			cout << "  compressed: " << color::cyan << print_hex(offsets.exe_compressed_size)
-			     << color::reset;
+			std::cout << "  compressed: " << color::cyan
+			          << print_hex(offsets.exe_compressed_size) << color::reset;
 		}
-		cout << "  uncompressed: " << color::cyan << print_bytes(offsets.exe_uncompressed_size)
-		     << color::reset << '\n';
-		cout << "- exe checksum: " << color::cyan << offsets.exe_checksum  << color::reset << '\n';
-	}
-	cout << if_not_zero("- message offset", print_hex(offsets.message_offset));
-	cout << "- header offset: " << color::cyan << print_hex(offsets.header_offset)
-	     << color::reset << '\n';
-	cout << if_not_zero("- data offset", print_hex(offsets.data_offset));
+		std::cout << "  uncompressed: " << color::cyan
+		          << print_bytes(offsets.exe_uncompressed_size) << color::reset << '\n';
+		std::cout << "- exe checksum: " << color::cyan << offsets.exe_checksum
+		          << color::reset << '\n';
+	}
+	std::cout << if_not_zero("- message offset", print_hex(offsets.message_offset));
+	std::cout << "- header offset: " << color::cyan << print_hex(offsets.header_offset)
+	          << color::reset << '\n';
+	std::cout << if_not_zero("- data offset", print_hex(offsets.data_offset));
 }
 
 static void print(std::ostream & os, const setup::windows_version_range & winver,
@@ -92,45 +94,48 @@
 	print(os, item.winver, header);
 }
 
-static void print_entry(const setup::info & info, size_t i, const setup::language_entry & entry) {
+static void print_entry(const setup::info & info, size_t i,
+                        const setup::language_entry & entry) {
 	
 	(void)info, (void)i;
 	
-	cout << " - " << quoted(entry.name) << ':' << '\n';
-	cout << if_not_empty("  Language name", entry.language_name);
-	cout << if_not_empty("  Dialog font", entry.dialog_font);
-	cout << if_not_empty("  Title font", entry.title_font);
-	cout << if_not_empty("  Welcome font", entry.welcome_font);
-	cout << if_not_empty("  Copyright font", entry.copyright_font);
-	cout << if_not_empty("  Data", entry.data);
-	cout << if_not_empty("  License", entry.license_text);
-	cout << if_not_empty("  Info before text", entry.info_before);
-	cout << if_not_empty("  Info after text", entry.info_after);
-	
-	cout << "  Language id: " << color::cyan << std::hex << entry.language_id << std::dec
-	     << color::reset << '\n';
-	
-	cout << if_not_zero("  Codepage", entry.codepage);
-	cout << if_not_zero("  Dialog font size", entry.dialog_font_size);
-	cout << if_not_zero("  Dialog font standard height", entry.dialog_font_standard_height);
-	cout << if_not_zero("  Title font size", entry.title_font_size);
-	cout << if_not_zero("  Welcome font size", entry.welcome_font_size);
-	cout << if_not_zero("  Copyright font size", entry.copyright_font_size);
-	cout << if_not_equal("  Right to left", entry.right_to_left, false);
+	std::cout << " - " << quoted(entry.name) << ':' << '\n';
+	std::cout << if_not_empty("  Language name", entry.language_name);
+	std::cout << if_not_empty("  Dialog font", entry.dialog_font);
+	std::cout << if_not_empty("  Title font", entry.title_font);
+	std::cout << if_not_empty("  Welcome font", entry.welcome_font);
+	std::cout << if_not_empty("  Copyright font", entry.copyright_font);
+	std::cout << if_not_empty("  Data", entry.data);
+	std::cout << if_not_empty("  License", entry.license_text);
+	std::cout << if_not_empty("  Info before text", entry.info_before);
+	std::cout << if_not_empty("  Info after text", entry.info_after);
+	
+	std::cout << "  Language id: " << color::cyan << std::hex << entry.language_id
+	          << std::dec << color::reset << '\n';
+	
+	std::cout << if_not_zero("  Codepage", entry.codepage);
+	std::cout << if_not_zero("  Dialog font size", entry.dialog_font_size);
+	std::cout << if_not_zero("  Dialog font standard height",
+	                         entry.dialog_font_standard_height);
+	std::cout << if_not_zero("  Title font size", entry.title_font_size);
+	std::cout << if_not_zero("  Welcome font size", entry.welcome_font_size);
+	std::cout << if_not_zero("  Copyright font size", entry.copyright_font_size);
+	std::cout << if_not_equal("  Right to left", entry.right_to_left, false);
 }
 
-static void print_entry(const setup::info & info, size_t i, const setup::message_entry & entry) {
+static void print_entry(const setup::info & info, size_t i,
+                        const setup::message_entry & entry) {
 	
 	(void)i;
 	
-	cout << " - " << quoted(entry.name);
+	std::cout << " - " << quoted(entry.name);
 	if(entry.language < 0) {
-		cout << " (default) = ";
+		std::cout << " (default) = ";
 	} else {
-		cout << " (" << color::cyan << info.languages[size_t(entry.language)].name
-		     << color::reset << ") = ";
+		std::cout << " (" << color::cyan << info.languages[size_t(entry.language)].name
+		          << color::reset << ") = ";
 	}
-	cout << quoted(entry.value) << '\n';
+	std::cout << quoted(entry.value) << '\n';
 }
 
 static void print_entry(const setup::info & info, size_t i,
@@ -138,233 +143,244 @@
 	
 	(void)info, (void)i;
 	
-	cout << " - " << print_bytes(entry.permissions.length()) << '\n';
+	std::cout << " - " << print_bytes(entry.permissions.length()) << '\n';
 }
 
-static void print_entry(const setup::info & info, size_t i, const setup::type_entry & entry) {
+static void print_entry(const setup::info & info, size_t i,
+                        const setup::type_entry & entry) {
 	
 	(void)i;
 	
-	cout << " - " << quoted(entry.name) << ':' << '\n';
-	cout << if_not_empty("  Description", entry.description);
-	cout << if_not_empty("  Languages", entry.languages);
-	cout << if_not_empty("  Check", entry.check);
-	
-	print(cout, entry.winver, info.header);
-	
-	cout << if_not_equal("  Custom setup type", entry.custom_type, false);
-	cout << if_not_equal("  Type", entry.type, setup::type_entry::User);
-	cout << if_not_zero("  Size", entry.size);
+	std::cout << " - " << quoted(entry.name) << ':' << '\n';
+	std::cout << if_not_empty("  Description", entry.description);
+	std::cout << if_not_empty("  Languages", entry.languages);
+	std::cout << if_not_empty("  Check", entry.check);
+	
+	print(std::cout, entry.winver, info.header);
+	
+	std::cout << if_not_equal("  Custom setup type", entry.custom_type, false);
+	std::cout << if_not_equal("  Type", entry.type, setup::type_entry::User);
+	std::cout << if_not_zero("  Size", entry.size);
 }
 
-static void print_entry(const setup::info & info, size_t i, const setup::component_entry & entry) {
+static void print_entry(const setup::info & info, size_t i,
+                        const setup::component_entry & entry) {
 	
 	(void)i;
 	
-	cout << " - " << quoted(entry.name) << ':' << '\n';
-	cout << if_not_empty("  Types", entry.types);
-	cout << if_not_empty("  Description", entry.description);
-	cout << if_not_empty("  Languages", entry.languages);
-	cout << if_not_empty("  Check", entry.check);
-	cout << if_not_zero("  Extra disk space required", entry.extra_disk_pace_required);
-	cout << if_not_zero("  Level", entry.level);
-	cout << if_not_equal("  Used", entry.used, true);
+	std::cout << " - " << quoted(entry.name) << ':' << '\n';
+	std::cout << if_not_empty("  Types", entry.types);
+	std::cout << if_not_empty("  Description", entry.description);
+	std::cout << if_not_empty("  Languages", entry.languages);
+	std::cout << if_not_empty("  Check", entry.check);
+	std::cout << if_not_zero("  Extra disk space required", entry.extra_disk_pace_required);
+	std::cout << if_not_zero("  Level", entry.level);
+	std::cout << if_not_equal("  Used", entry.used, true);
 	
-	print(cout, entry.winver, info.header);
+	print(std::cout, entry.winver, info.header);
 	
-	cout << if_not_zero("  Options", entry.options);
-	cout << if_not_zero("  Size", entry.size);
+	std::cout << if_not_zero("  Options", entry.options);
+	std::cout << if_not_zero("  Size", entry.size);
 }
 
-static void print_entry(const setup::info & info, size_t i, const setup::task_entry & entry) {
+static void print_entry(const setup::info & info, size_t i,
+                        const setup::task_entry & entry) {
 	
 	(void)i;
 	
-	cout << " - " << quoted(entry.name) << ':' << '\n';
-	cout << if_not_empty("  Description", entry.description);
-	cout << if_not_empty("  Group description", entry.group_description);
-	cout << if_not_empty("  Components", entry.components);
-	cout << if_not_empty("  Languages", entry.languages);
-	cout << if_not_empty("  Check", entry.check);
-	cout << if_not_zero("  Level", entry.level);
-	cout << if_not_equal("  Used", entry.used, true);
+	std::cout << " - " << quoted(entry.name) << ':' << '\n';
+	std::cout << if_not_empty("  Description", entry.description);
+	std::cout << if_not_empty("  Group description", entry.group_description);
+	std::cout << if_not_empty("  Components", entry.components);
+	std::cout << if_not_empty("  Languages", entry.languages);
+	std::cout << if_not_empty("  Check", entry.check);
+	std::cout << if_not_zero("  Level", entry.level);
+	std::cout << if_not_equal("  Used", entry.used, true);
 	
-	print(cout, entry.winver, info.header);
+	print(std::cout, entry.winver, info.header);
 	
-	cout << if_not_zero("  Options", entry.options);
+	std::cout << if_not_zero("  Options", entry.options);
 }
 
-static void print_entry(const setup::info & info, size_t i, const setup::directory_entry & entry) {
+static void print_entry(const setup::info & info, size_t i,
+                        const setup::directory_entry & entry) {
 	
 	(void)i;
 	
-	cout << " - " << quoted(entry.name) << ':' << '\n';
+	std::cout << " - " << quoted(entry.name) << ':' << '\n';
 	
-	print(cout, entry, info.header);
+	print(std::cout, entry, info.header);
 	
 	if(!entry.permissions.empty()) {
-		cout << "  Permissions: " << entry.permissions.length() << " bytes";
+		std::cout << "  Permissions: " << entry.permissions.length() << " bytes";
 	}
 	
-	cout << if_not_zero("  Attributes", entry.attributes);
-	cout << if_not_equal("  Permission entry", entry.permission, -1);
-	cout << if_not_zero("  Options", entry.options);
+	std::cout << if_not_zero("  Attributes", entry.attributes);
+	std::cout << if_not_equal("  Permission entry", entry.permission, -1);
+	std::cout << if_not_zero("  Options", entry.options);
 }
 
-static void print_entry(const setup::info & info, size_t i, const setup::file_entry & entry) {
+static void print_entry(const setup::info & info, size_t i,
+                        const setup::file_entry & entry) {
 	
 	if(entry.destination.empty()) {
-		cout << " - File #" << i;
+		std::cout << " - File #" << i;
 	} else {
-		cout << " - " << quoted(entry.destination);
+		std::cout << " - " << quoted(entry.destination);
 	}
-	if(entry.location != uint32_t(-1)) {
-		cout << " (location: " << color::cyan << entry.location << color::reset << ')';
+	if(entry.location != boost::uint32_t(-1)) {
+		std::cout << " (location: " << color::cyan << entry.location << color::reset << ')';
 	}
-	cout  << '\n';
+	std::cout  << '\n';
 	
-	cout << if_not_empty("  Source", entry.source);
-	cout << if_not_empty("  Install font name", entry.install_font_name);
-	cout << if_not_empty("  Strong assembly name", entry.strong_assembly_name);
+	std::cout << if_not_empty("  Source", entry.source);
+	std::cout << if_not_empty("  Install font name", entry.install_font_name);
+	std::cout << if_not_empty("  Strong assembly name", entry.strong_assembly_name);
 	
-	print(cout, entry, info.header);
+	print(std::cout, entry, info.header);
 	
-	cout << if_not_zero("  Attributes", entry.attributes);
-	cout << if_not_zero("  Size", entry.external_size);
-	cout << if_not_equal("  Permission entry", entry.permission, -1);
-	cout << if_not_zero("  Options", entry.options);
-	cout << if_not_equal("  Type", entry.type, setup::file_entry::UserFile);
+	std::cout << if_not_zero("  Attributes", entry.attributes);
+	std::cout << if_not_zero("  Size", entry.external_size);
+	std::cout << if_not_equal("  Permission entry", entry.permission, -1);
+	std::cout << if_not_zero("  Options", entry.options);
+	std::cout << if_not_equal("  Type", entry.type, setup::file_entry::UserFile);
 }
 
-static void print_entry(const setup::info & info, size_t i, const setup::icon_entry & entry) {
+static void print_entry(const setup::info & info, size_t i,
+                        const setup::icon_entry & entry) {
 	
 	(void)i;
 	
-	cout << " - " << quoted(entry.name) << " -> " << quoted(entry.filename) << '\n';
-	cout << if_not_empty("  Parameters", entry.parameters);
-	cout << if_not_empty("  Working directory", entry.working_dir);
-	cout << if_not_empty("  Icon file", entry.icon_file);
-	cout << if_not_empty("  Comment", entry.comment);
-	cout << if_not_empty("  App user model id", entry.app_user_model_id);
-	
-	print(cout, entry, info.header);
-	
-	cout << if_not_zero("  Icon index", entry.icon_index);
-	cout << if_not_equal("  Show command", entry.show_command, 1);
-	cout << if_not_equal("  Close on exit", entry.close_on_exit, setup::icon_entry::NoSetting);
-	cout << if_not_zero("  Hotkey", entry.hotkey);
-	cout << if_not_zero("  Options", entry.options);
+	std::cout << " - " << quoted(entry.name) << " -> " << quoted(entry.filename) << '\n';
+	std::cout << if_not_empty("  Parameters", entry.parameters);
+	std::cout << if_not_empty("  Working directory", entry.working_dir);
+	std::cout << if_not_empty("  Icon file", entry.icon_file);
+	std::cout << if_not_empty("  Comment", entry.comment);
+	std::cout << if_not_empty("  App user model id", entry.app_user_model_id);
+	
+	print(std::cout, entry, info.header);
+	
+	std::cout << if_not_zero("  Icon index", entry.icon_index);
+	std::cout << if_not_equal("  Show command", entry.show_command, 1);
+	std::cout << if_not_equal("  Close on exit", entry.close_on_exit,
+	                          setup::icon_entry::NoSetting);
+	std::cout << if_not_zero("  Hotkey", entry.hotkey);
+	std::cout << if_not_zero("  Options", entry.options);
 }
 
-static void print_entry(const setup::info & info, size_t i, const setup::ini_entry & entry) {
+static void print_entry(const setup::info & info, size_t i,
+                        const setup::ini_entry & entry) {
 	
 	(void)i;
 	
-	cout << " - in " << quoted(entry.inifile);
-	cout << " set [" << quoted(entry.section) << "] ";
-	cout << quoted(entry.key) << " = " << quoted(entry.value) << '\n';
+	std::cout << " - in " << quoted(entry.inifile);
+	std::cout << " set [" << quoted(entry.section) << "] ";
+	std::cout << quoted(entry.key) << " = " << quoted(entry.value) << '\n';
 	
-	print(cout, entry, info.header);
+	print(std::cout, entry, info.header);
 	
-	cout << if_not_zero("  Options", entry.options);
+	std::cout << if_not_zero("  Options", entry.options);
 }
 
-static void print_entry(const setup::info & info, size_t i, const setup::registry_entry & entry) {
+static void print_entry(const setup::info & info, size_t i,
+                        const setup::registry_entry & entry) {
 	
 	(void)i;
 	
-	cout << " - ";
+	std::cout << " - ";
 	if(entry.hive != setup::registry_entry::Unset) {
-		cout << entry.hive << '\\';
+		std::cout << entry.hive << '\\';
 	}
-	cout << quoted(entry.key);
-	cout << '\n' << "  ";
+	std::cout << quoted(entry.key);
+	std::cout << '\n' << "  ";
 	if(entry.name.empty()) {
-		cout << "(default)";
+		std::cout << "(default)";
 	} else {
-		cout << quoted(entry.name);
+		std::cout << quoted(entry.name);
 	}
 	if(!entry.value.empty()) {
-		cout << " = " << quoted(entry.value);
+		std::cout << " = " << quoted(entry.value);
 	}
 	if(entry.type != setup::registry_entry::None) {
-		cout << " (" << color::cyan << entry.type << color::reset << ')';
+		std::cout << " (" << color::cyan << entry.type << color::reset << ')';
 	}
-	cout << '\n';
+	std::cout << '\n';
 	
-	print(cout, entry, info.header);
+	print(std::cout, entry, info.header);
 	
 	if(!entry.permissions.empty()) {
-		cout << "  Permissions: " << entry.permissions.length() << " bytes";
+		std::cout << "  Permissions: " << entry.permissions.length() << " bytes";
 	}
-	cout << if_not_equal("  Permission entry", entry.permission, -1);
-	cout << if_not_zero("  Options", entry.options);
+	std::cout << if_not_equal("  Permission entry", entry.permission, -1);
+	std::cout << if_not_zero("  Options", entry.options);
 }
 
-static void print_entry(const setup::info & info, size_t i, const setup::delete_entry & entry) {
+static void print_entry(const setup::info & info, size_t i,
+                        const setup::delete_entry & entry) {
 	
 	(void)i;
 	
-	cout << " - " << quoted(entry.name)
+	std::cout << " - " << quoted(entry.name)
 	     << " (" << color::cyan << entry.type << color::reset << ')' << '\n';
 	
-	print(cout, entry, info.header);
+	print(std::cout, entry, info.header);
 }
 
-static void print_entry(const setup::info & info, size_t i, const setup::run_entry & entry) {
+static void print_entry(const setup::info & info, size_t i,
+                        const setup::run_entry & entry) {
 	
 	(void)i;
 	
-	cout << " - " << quoted(entry.name) << ':' << '\n';
-	cout << if_not_empty("  Parameters", entry.parameters);
-	cout << if_not_empty("  Working directory", entry.working_dir);
-	cout << if_not_empty("  Run once id", entry.run_once_id);
-	cout << if_not_empty("  Status message", entry.status_message);
-	cout << if_not_empty("  Verb", entry.verb);
-	cout << if_not_empty("  Description", entry.verb);
-	
-	print(cout, entry, info.header);
-	
-	cout << if_not_equal("  Show command", entry.show_command, 1);
-	cout << if_not_equal("  Wait", entry.wait, setup::run_entry::WaitUntilTerminated);
-	cout << if_not_zero("  Options", entry.options);
+	std::cout << " - " << quoted(entry.name) << ':' << '\n';
+	std::cout << if_not_empty("  Parameters", entry.parameters);
+	std::cout << if_not_empty("  Working directory", entry.working_dir);
+	std::cout << if_not_empty("  Run once id", entry.run_once_id);
+	std::cout << if_not_empty("  Status message", entry.status_message);
+	std::cout << if_not_empty("  Verb", entry.verb);
+	std::cout << if_not_empty("  Description", entry.verb);
+	
+	print(std::cout, entry, info.header);
+	
+	std::cout << if_not_equal("  Show command", entry.show_command, 1);
+	std::cout << if_not_equal("  Wait", entry.wait, setup::run_entry::WaitUntilTerminated);
+	std::cout << if_not_zero("  Options", entry.options);
 }
 
-static void print_entry(const setup::info & info, size_t i, const setup::data_entry & entry) {
+static void print_entry(const setup::info & info, size_t i,
+                        const setup::data_entry & entry) {
 	
 	(void)info;
 	
-	cout << " - " << "File location #" << i << ':' << '\n';
-	cout << if_not_zero("  First slice", entry.chunk.first_slice);
-	cout << if_not_equal("  Last slice", entry.chunk.last_slice, entry.chunk.first_slice);
-	cout << "  Chunk: offset " << color::cyan << print_hex(entry.chunk.offset)
-	     << color::reset << " size " << color::cyan << print_hex(entry.chunk.size)
-	     << color::reset << '\n';
-	cout << if_not_zero("  File offset", print_hex(entry.file.offset));
-	cout << if_not_zero("  File size", print_bytes(entry.file.size));
-	
-	cout << "  Checksum: " << entry.file.checksum << '\n';
-	
-	std::tm t;
-	if(entry.options & setup::data_entry::TimeStampInUTC) {
-		gmtime_r(&entry.timestamp.tv_sec, &t);
-	} else {
-		localtime_r(&entry.timestamp.tv_sec, &t);
-	}
-	
-	cout << "  Timestamp: " << color::cyan << (t.tm_year + 1900)
-	     << '-' << std::setfill('0') << std::setw(2) << (t.tm_mon + 1)
-	     << '-' << std::setfill('0') << std::setw(2) << t.tm_mday
-	     << ' ' << std::setfill(' ') << std::setw(2) << t.tm_hour
-	     << ':' << std::setfill('0') << std::setw(2) << t.tm_min
-	     << ':' << std::setfill('0') << std::setw(2) << t.tm_sec
-	     << color::reset << " +" << entry.timestamp.tv_nsec << '\n';
+	std::cout << " - " << "File location #" << i << ':' << '\n';
+	std::cout << if_not_zero("  First slice", entry.chunk.first_slice);
+	std::cout << if_not_equal("  Last slice", entry.chunk.last_slice,
+	                          entry.chunk.first_slice);
+	std::cout << "  Chunk: offset " << color::cyan << print_hex(entry.chunk.offset)
+	          << color::reset << " size " << color::cyan << print_hex(entry.chunk.size)
+	          << color::reset << '\n';
+	std::cout << if_not_zero("  File offset", print_hex(entry.file.offset));
+	std::cout << if_not_zero("  File size", print_bytes(entry.file.size));
+	
+	std::cout << "  Checksum: " << entry.file.checksum << '\n';
+	
+	std::tm t = util::format_time(entry.timestamp);
+	
+	bool isUTC = ((entry.options & setup::data_entry::TimeStampInUTC) != 0);
+	std::cout << "  Timestamp: " << color::cyan << (t.tm_year + 1900)
+	          << '-' << std::setfill('0') << std::setw(2) << (t.tm_mon + 1)
+	          << '-' << std::setfill('0') << std::setw(2) << t.tm_mday
+	          << ' ' << std::setfill(' ') << std::setw(2) << t.tm_hour
+	          << ':' << std::setfill('0') << std::setw(2) << t.tm_min
+	          << ':' << std::setfill('0') << std::setw(2) << t.tm_sec
+	          << color::reset << " +" << entry.timestamp_nsec
+	          << (isUTC ? " (UTC)" : " (local)")
+	          << '\n';
 	
-	cout << if_not_zero("  Options", entry.options);
+	std::cout << if_not_zero("  Options", entry.options);
 	
 	if(entry.options & setup::data_entry::VersionInfoValid) {
-		cout << if_not_zero("  File version LS", entry.file_version_ls);
-		cout << if_not_zero("  File version MS", entry.file_version_ms);
+		std::cout << if_not_zero("  File version LS", entry.file_version_ls);
+		std::cout << if_not_zero("  File version MS", entry.file_version_ms);
 	}
 }
 
@@ -376,7 +392,7 @@
 		return;
 	}
 	
-	cout << '\n' << name << ":\n";
+	std::cout << '\n' << name << ":\n";
 	for(size_t i = 0; i < entries.size(); i++) {
 		print_entry(info, i, entries[i]);
 	}
@@ -384,107 +400,116 @@
 
 static void print_header(const setup::header & header) {
 	
-	cout << if_not_empty("App name", header.app_name);
-	cout << if_not_empty("App ver name", header.app_versioned_name);
-	cout << if_not_empty("App id", header.app_id);
-	cout << if_not_empty("Copyright", header.app_copyright);
-	cout << if_not_empty("Publisher", header.app_publisher);
-	cout << if_not_empty("Publisher URL", header.app_publisher_url);
-	cout << if_not_empty("Support phone", header.app_support_phone);
-	cout << if_not_empty("Support URL", header.app_support_url);
-	cout << if_not_empty("Updates URL", header.app_updates_url);
-	cout << if_not_empty("Version", header.app_version);
-	cout << if_not_empty("Default dir name", header.default_dir_name);
-	cout << if_not_empty("Default group name", header.default_group_name);
-	cout << if_not_empty("Uninstall icon name", header.uninstall_icon_name);
-	cout << if_not_empty("Base filename", header.base_filename);
-	cout << if_not_empty("Uninstall files dir", header.uninstall_files_dir);
-	cout << if_not_empty("Uninstall display name", header.uninstall_name);
-	cout << if_not_empty("Uninstall display icon", header.uninstall_icon);
-	cout << if_not_empty("App mutex", header.app_mutex);
-	cout << if_not_empty("Default user name", header.default_user_name);
-	cout << if_not_empty("Default user org", header.default_user_organisation);
-	cout << if_not_empty("Default user serial", header.default_serial);
-	cout << if_not_empty("Readme", header.app_readme_file);
-	cout << if_not_empty("Contact", header.app_contact);
-	cout << if_not_empty("Comments", header.app_comments);
-	cout << if_not_empty("Modify path", header.app_modify_path);
-	cout << if_not_empty("Uninstall reg key", header.create_uninstall_registry_key);
-	cout << if_not_empty("Uninstallable", header.uninstallable);
-	cout << if_not_empty("License", header.license_text);
-	cout << if_not_empty("Info before text", header.info_before);
-	cout << if_not_empty("Info after text", header.info_after);
-	cout << if_not_empty("Uninstaller signature", header.uninstaller_signature);
-	cout << if_not_empty("Compiled code", header.compiled_code);
-	
-	cout << if_not_zero("Lead bytes", header.lead_bytes);
-	
-	cout << if_not_zero("Language entries", header.language_count);
-	cout << if_not_zero("Custom message entries", header.message_count);
-	cout << if_not_zero("Permission entries", header.permission_count);
-	cout << if_not_zero("Type entries", header.type_count);
-	cout << if_not_zero("Component entries", header.component_count);
-	cout << if_not_zero("Task entries", header.task_count);
-	cout << if_not_zero("Dir entries", header.directory_count);
-	cout << if_not_zero("File entries", header.file_count);
-	cout << if_not_zero("File location entries", header.data_entry_count);
-	cout << if_not_zero("Icon entries", header.icon_count);
-	cout << if_not_zero("Ini entries", header.ini_entry_count);
-	cout << if_not_zero("Registry entries", header.registry_entry_count);
-	cout << if_not_zero("Delete entries", header.delete_entry_count);
-	cout << if_not_zero("Uninstall delete entries", header.uninstall_delete_entry_count);
-	cout << if_not_zero("Run entries", header.run_entry_count);
-	cout << if_not_zero("Uninstall run entries", header.uninstall_run_entry_count);
-	
-	cout << if_not_equal("Min version", header.winver.begin, setup::windows_version::none);
-	cout << if_not_equal("Only below version", header.winver.end, setup::windows_version::none);
-	
-	cout << std::hex;
-	cout << if_not_zero("Back color", header.back_color);
-	cout << if_not_zero("Back color2", header.back_color2);
-	cout << if_not_zero("Wizard image back color", header.image_back_color);
-	cout << if_not_zero("Wizard small image back color", header.small_image_back_color);
-	cout << std::dec;
+	std::cout << if_not_empty("App name", header.app_name);
+	std::cout << if_not_empty("App ver name", header.app_versioned_name);
+	std::cout << if_not_empty("App id", header.app_id);
+	std::cout << if_not_empty("Copyright", header.app_copyright);
+	std::cout << if_not_empty("Publisher", header.app_publisher);
+	std::cout << if_not_empty("Publisher URL", header.app_publisher_url);
+	std::cout << if_not_empty("Support phone", header.app_support_phone);
+	std::cout << if_not_empty("Support URL", header.app_support_url);
+	std::cout << if_not_empty("Updates URL", header.app_updates_url);
+	std::cout << if_not_empty("Version", header.app_version);
+	std::cout << if_not_empty("Default dir name", header.default_dir_name);
+	std::cout << if_not_empty("Default group name", header.default_group_name);
+	std::cout << if_not_empty("Uninstall icon name", header.uninstall_icon_name);
+	std::cout << if_not_empty("Base filename", header.base_filename);
+	std::cout << if_not_empty("Uninstall files dir", header.uninstall_files_dir);
+	std::cout << if_not_empty("Uninstall display name", header.uninstall_name);
+	std::cout << if_not_empty("Uninstall display icon", header.uninstall_icon);
+	std::cout << if_not_empty("App mutex", header.app_mutex);
+	std::cout << if_not_empty("Default user name", header.default_user_name);
+	std::cout << if_not_empty("Default user org", header.default_user_organisation);
+	std::cout << if_not_empty("Default user serial", header.default_serial);
+	std::cout << if_not_empty("Readme", header.app_readme_file);
+	std::cout << if_not_empty("Contact", header.app_contact);
+	std::cout << if_not_empty("Comments", header.app_comments);
+	std::cout << if_not_empty("Modify path", header.app_modify_path);
+	std::cout << if_not_empty("Uninstall reg key", header.create_uninstall_registry_key);
+	std::cout << if_not_empty("Uninstallable", header.uninstallable);
+	std::cout << if_not_empty("License", header.license_text);
+	std::cout << if_not_empty("Info before text", header.info_before);
+	std::cout << if_not_empty("Info after text", header.info_after);
+	std::cout << if_not_empty("Uninstaller signature", header.uninstaller_signature);
+	std::cout << if_not_empty("Compiled code", header.compiled_code);
+	
+	std::cout << if_not_zero("Lead bytes", header.lead_bytes);
+	
+	std::cout << if_not_zero("Language entries", header.language_count);
+	std::cout << if_not_zero("Custom message entries", header.message_count);
+	std::cout << if_not_zero("Permission entries", header.permission_count);
+	std::cout << if_not_zero("Type entries", header.type_count);
+	std::cout << if_not_zero("Component entries", header.component_count);
+	std::cout << if_not_zero("Task entries", header.task_count);
+	std::cout << if_not_zero("Dir entries", header.directory_count);
+	std::cout << if_not_zero("File entries", header.file_count);
+	std::cout << if_not_zero("File location entries", header.data_entry_count);
+	std::cout << if_not_zero("Icon entries", header.icon_count);
+	std::cout << if_not_zero("Ini entries", header.ini_entry_count);
+	std::cout << if_not_zero("Registry entries", header.registry_entry_count);
+	std::cout << if_not_zero("Delete entries", header.delete_entry_count);
+	std::cout << if_not_zero("Uninstall delete entries", header.uninstall_delete_entry_count);
+	std::cout << if_not_zero("Run entries", header.run_entry_count);
+	std::cout << if_not_zero("Uninstall run entries", header.uninstall_run_entry_count);
+	
+	std::cout << if_not_equal("Min version", header.winver.begin,
+	                          setup::windows_version::none);
+	std::cout << if_not_equal("Only below version", header.winver.end,
+	                          setup::windows_version::none);
+	
+	std::cout << std::hex;
+	std::cout << if_not_zero("Back color", header.back_color);
+	std::cout << if_not_zero("Back color2", header.back_color2);
+	std::cout << if_not_zero("Wizard image back color", header.image_back_color);
+	std::cout << if_not_zero("Wizard small image back color",
+	                         header.small_image_back_color);
+	std::cout << std::dec;
 	
 	if(header.options & (setup::header::Password | setup::header::EncryptionUsed)) {
-		cout << "Password: " << color::cyan << header.password << color::reset << '\n';
+		std::cout << "Password: " << color::cyan << header.password << color::reset << '\n';
 	}
 	
-	cout << if_not_zero("Extra disk space required", header.extra_disk_space_required);
-	cout << if_not_zero("Slices per disk", header.slices_per_disk);
+	std::cout << if_not_zero("Extra disk space required", header.extra_disk_space_required);
+	std::cout << if_not_zero("Slices per disk", header.slices_per_disk);
 	
-	cout << if_not_equal("Install mode", header.install_mode, setup::header::NormalInstallMode);
-	cout << "Uninstall log mode: " << color::cyan << header.uninstall_log_mode
-	     << color::reset << '\n';
-	cout << "Uninstall style: " << color::cyan << header.uninstall_style << color::reset << '\n';
-	cout << "Dir exists warning: " << color::cyan << header.dir_exists_warning
-	     << color::reset << '\n';
-	cout << if_not_equal("Privileges required", header.privileges_required,
-	                                            setup::header::NoPrivileges);
-	cout << "Show language dialog: " << color::cyan << header.show_language_dialog
-	     << color::reset << '\n';
-	cout << if_not_equal("Danguage detection", header.language_detection,
-	              setup::header::NoLanguageDetection);
-	cout << "Compression: " << color::cyan << header.compression << color::reset << '\n';
-	cout << "Architectures allowed: " << color::cyan << header.architectures_allowed
-	     << color::reset << '\n';
-	cout << "Architectures installed in 64-bit mode: " << color::cyan
-	     << header.architectures_installed_in_64bit_mode << color::reset << '\n';
+	std::cout << if_not_equal("Install mode", header.install_mode,
+	                          setup::header::NormalInstallMode);
+	std::cout << "Uninstall log mode: " << color::cyan << header.uninstall_log_mode
+	          << color::reset << '\n';
+	std::cout << "Uninstall style: " << color::cyan << header.uninstall_style
+	          << color::reset << '\n';
+	std::cout << "Dir exists warning: " << color::cyan << header.dir_exists_warning
+	          << color::reset << '\n';
+	std::cout << if_not_equal("Privileges required", header.privileges_required,
+	                                                 setup::header::NoPrivileges);
+	std::cout << "Show language dialog: " << color::cyan << header.show_language_dialog
+	          << color::reset << '\n';
+	std::cout << if_not_equal("Danguage detection", header.language_detection,
+	                          setup::header::NoLanguageDetection);
+	std::cout << "Compression: " << color::cyan << header.compression
+	          << color::reset << '\n';
+	std::cout << "Architectures allowed: " << color::cyan << header.architectures_allowed
+	          << color::reset << '\n';
+	std::cout << "Architectures installed in 64-bit mode: " << color::cyan
+	          << header.architectures_installed_in_64bit_mode << color::reset << '\n';
 	
 	if(header.options & setup::header::SignedUninstaller) {
-		cout << if_not_zero("Size before signing uninstaller", header.signed_uninstaller_original_size);
-		cout << if_not_zero("Uninstaller header checksum", header.signed_uninstaller_header_checksum);
+		std::cout << if_not_zero("Size before signing uninstaller",
+		                         header.signed_uninstaller_original_size);
+		std::cout << if_not_zero("Uninstaller header checksum",
+		                         header.signed_uninstaller_header_checksum);
 	}
 	
-	cout << "Disable dir page: " << color::cyan << header.disable_dir_page << color::reset << '\n';
-	cout << "Disable program group page: " << color::cyan << header.disable_program_group_page
-	     << color::reset << '\n';
+	std::cout << "Disable dir page: " << color::cyan << header.disable_dir_page
+	          << color::reset << '\n';
+	std::cout << "Disable program group page: " << color::cyan
+	          << header.disable_program_group_page << color::reset << '\n';
 	
-	cout << if_not_zero("Uninstall display size", header.uninstall_display_size);
+	std::cout << if_not_zero("Uninstall display size", header.uninstall_display_size);
 	
-	cout << "Options: " << color::green << header.options << color::reset << '\n';
+	std::cout << "Options: " << color::green << header.options << color::reset << '\n';
 	
-	cout << color::reset;
+	std::cout << color::reset;
 }
 
 static const char * magic_numbers[][2] = {
@@ -518,21 +543,21 @@
 		return;
 	}
 	
-	cout << '\n';
+	std::cout << '\n';
 	
 	if(!info.wizard_image.empty()) {
-		cout << "Wizard image: " << print_bytes(info.wizard_image.length()) << " ("
-		     << guess_extension(info.wizard_image) << ")\n";
+		std::cout << "Wizard image: " << print_bytes(info.wizard_image.length())
+		          << " (" << guess_extension(info.wizard_image) << ")\n";
 	}
 	
 	if(!info.wizard_image_small.empty()) {
-		cout << "Wizard small image: " << print_bytes(info.wizard_image_small.length()) << " ("
-		     << guess_extension(info.wizard_image_small) << ")\n";
+		std::cout << "Wizard small image: " << print_bytes(info.wizard_image_small.length())
+		          << " (" << guess_extension(info.wizard_image_small) << ")\n";
 	}
 	
 	if(!info.decompressor_dll.empty()) {
-		cout << "Decompressor dll: " << print_bytes(info.decompressor_dll.length()) << " ("
-		     << guess_extension(info.decompressor_dll) << ")\n";
+		std::cout << "Decompressor dll: " << print_bytes(info.decompressor_dll.length())
+		          << " (" << guess_extension(info.decompressor_dll) << ")\n";
 	}
 	
 }
diff -Nru innoextract-1.3/src/cli/main.cpp innoextract-1.4/src/cli/main.cpp
--- innoextract-1.3/src/cli/main.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/cli/main.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -18,27 +18,28 @@
  * 3. This notice may not be removed or altered from any source distribution.
  */
 
-#include <fstream>
-#include <iostream>
-#include <iomanip>
-#include <string>
 #include <algorithm>
+#include <cctype>
 #include <cstring>
-#include <vector>
+#include <cstdlib>
+#include <iomanip>
+#include <iostream>
 #include <map>
-#include <cctype>
+#include <string>
+#include <vector>
 
+#include <boost/algorithm/string/predicate.hpp>
 #include <boost/foreach.hpp>
 #include <boost/make_shared.hpp>
 #include <boost/program_options.hpp>
 #include <boost/scoped_ptr.hpp>
 #include <boost/ptr_container/ptr_vector.hpp>
 #include <boost/filesystem/path.hpp>
-#include <boost/filesystem/fstream.hpp>
 #include <boost/filesystem/operations.hpp>
 
+#include "release.hpp"
+
 #include "cli/debug.hpp"
-#include "cli/version.hpp"
 
 #include "loader/offsets.hpp"
 
@@ -55,30 +56,90 @@
 
 #include "util/boostfs_compat.hpp"
 #include "util/console.hpp"
+#include "util/fstream.hpp"
 #include "util/load.hpp"
 #include "util/log.hpp"
 #include "util/output.hpp"
+#include "util/time.hpp"
+#include "util/windows.hpp"
 
-using std::cout;
-using std::string;
-using std::endl;
-using std::setw;
-using std::setfill;
-
-namespace io = boost::iostreams;
 namespace fs = boost::filesystem;
 namespace po = boost::program_options;
 
-static void print_version() {
-	std::cout << color::white << innoextract_version << color::reset
+
+enum ExitValues {
+	ExitSuccess = 0,
+	ExitUserError = 1,
+	ExitDataError = 2
+};
+
+
+static const char * get_command(const char * argv0) {
+	
+	if(!argv0) {
+		argv0 = innoextract_name;
+	}
+	std::string var = argv0;
+	
+#ifdef _WIN32
+	size_t pos = var.find_last_of("/\\");
+#else
+	size_t pos = var.find_last_of('/');
+#endif
+	if(pos != std::string::npos) {
+		var = var.substr(pos + 1);
+	}
+	
+	var += "_COMMAND";
+	
+	const char * env = std::getenv(var.c_str());
+	if(env) {
+		return env;
+	} else {
+		return argv0;
+	}
+}
+
+
+struct options {
+	
+	bool quiet;
+	bool silent;
+	
+	bool list; // The --list action has been explicitely specified
+	bool test; // The --test action has been explicit specified
+	bool extract; // The --extract action has been specified or automatically enabled
+	
+	bool preserve_file_times;
+	bool local_timestamps;
+	
+	std::string language;
+	
+	setup::filename_map filenames;
+	
+	fs::path output_dir;
+	
+};
+
+
+static void print_version(const options & o) {
+	if(o.silent) {
+		std::cout << innoextract_version << '\n';
+		return;
+	}
+	std::cout << color::white << innoextract_name
+	          << ' ' << innoextract_version << color::reset
 #ifdef DEBUG
 	          << " (with debug output)"
 #endif
 	          << '\n';
-	std::cout << "Extracts installers created by " << color::cyan
-	          << innosetup_versions << color::reset << '\n';
+	if(!o.quiet) {
+		std::cout << "Extracts installers created by " << color::cyan
+		          << innosetup_versions << color::reset << '\n';
+	}
 }
 
+
 static void print_help(const char * name, const po::options_description & visible) {
 	std::cout << color::white << "Usage: " << name << " [options] <setup file(s)>\n\n"
 	          << color::reset;
@@ -88,51 +149,58 @@
 	std::cout << "Extracts installers created by " << color::cyan
 	          << innosetup_versions << color::reset << '\n';
 	std::cout << '\n';
-	std::cout << color::white << innoextract_version << color::reset
+	std::cout << color::white << innoextract_name
+	          << ' ' << innoextract_version << color::reset
 	          << ' ' << innoextract_copyright << '\n';
 	std::cout << "This is free software with absolutely no warranty.\n";
 }
 
+
 static void print_license() {
 	
-	std::cout << color::white << innoextract_version << color::reset
+	std::cout << color::white << innoextract_name
+	          << ' ' << innoextract_version << color::reset
 	          << ' ' << innoextract_copyright << '\n';
-	std::cout << '\n';
-	std::cout << "This software is provided 'as-is', without any express or implied\n"
-	             "warranty.  In no event will the author(s) be held liable for any damages\n"
-	             "arising from the use of this software.\n"
-	             "\n"
-	             "Permission is granted to anyone to use this software for any purpose,\n"
-	             "including commercial applications, and to alter it and redistribute it\n"
-	             "freely, subject to the following restrictions:\n"
-	             "\n"
-	             "1. The origin of this software must not be misrepresented; you must not\n"
-	             "   claim that you wrote the original software. If you use this software\n"
-	             "   in a product, an acknowledgment in the product documentation would be\n"
-	             "   appreciated but is not required.\n"
-	             "2. Altered source versions must be plainly marked as such, and must not be\n"
-	             "   misrepresented as being the original software.\n"
-	             "3. This notice may not be removed or altered from any source distribution.\n"
+	std::cout << '\n'<< innoextract_license << '\n';
 	;
 }
 
-struct options {
-	
-	bool silent;
+
+struct file_output {
 	
-	bool dump;
-	bool list;
-	bool test;
+	fs::path name;
+	util::ofstream stream;
 	
-	std::string language;
-	
-	setup::filename_map filenames;
+	explicit file_output(const fs::path & file) : name(file) {
+		try {
+			fs::create_directories(name.parent_path());
+		} catch(...) {
+			throw std::runtime_error("error creating directories for \""
+			                         + name.string() + '"');
+		}
+		stream.open(name, std::ios_base::out | std::ios_base::binary | std::ios_base::trunc);
+		if(!stream.is_open()) {
+			throw std::runtime_error("error opening output file \"" + name.string() + '"');
+		}
+	}
 	
 };
 
+
 static void process_file(const fs::path & file, const options & o) {
 	
-	fs::ifstream ifs(file, std::ios_base::in | std::ios_base::binary | std::ios_base::ate);
+	bool is_directory;
+	try {
+		is_directory = fs::is_directory(file);
+	} catch(...) {
+		throw std::runtime_error("error opening file \"" + file.string()
+		                         + "\": access denied");
+	}
+	if(is_directory) {
+		throw std::runtime_error("input file \"" + file.string() + "\" is a directory");
+	}
+	
+	util::ifstream ifs(file, std::ios_base::in | std::ios_base::binary);
 	if(!ifs.is_open()) {
 		throw std::runtime_error("error opening file \"" + file.string() + '"');
 	}
@@ -140,37 +208,44 @@
 	loader::offsets offsets;
 	offsets.load(ifs);
 	
-	cout << std::boolalpha;
+	std::cout << std::boolalpha;
 	
 #ifdef DEBUG
 	if(logger::debug) {
 		print_offsets(offsets);
-		cout << '\n';
+		std::cout << '\n';
+	}
+#endif
+	
+	setup::info::entry_types entries = setup::info::DataEntries | setup::info::Files;
+#ifdef DEBUG
+	if(logger::debug) {
+		entries = setup::info::entry_types::all();
 	}
 #endif
 	
 	ifs.seekg(offsets.header_offset);
 	setup::info info;
-	info.load(ifs);
+	info.load(ifs, entries);
 	
-	if(!logger::quiet) {
+	if(!o.quiet) {
 		const std::string & name = info.header.app_versioned_name.empty()
 		                           ? info.header.app_name : info.header.app_versioned_name;
-		cout << (o.list ? "Listing" : o.test ? "Testing" : "Extracting")
-		     << " \"" << color::green << name << color::reset
-		     << "\" - setup data version " << color::white << info.version << color::reset
-		     << std::endl;
+		std::cout << (o.extract ? "Extracting" : o.test ? "Testing" : "Listing")
+		          << " \"" << color::green << name << color::reset
+		          << "\" - setup data version " << color::white << info.version << color::reset
+		          << std::endl;
 	}
 	
 #ifdef DEBUG
 	if(logger::debug) {
-		cout << '\n';
+		std::cout << '\n';
 		print_info(info);
-		cout << '\n';
+		std::cout << '\n';
 	}
 #endif
 	
-	uint64_t total_size = 0;
+	boost::uint64_t total_size = 0;
 	
 	std::vector< std::vector<size_t> > files_for_location;
 	files_for_location.resize(info.data_entries.size());
@@ -193,9 +268,9 @@
 	}
 	
 	boost::scoped_ptr<stream::slice_reader> slice_reader;
-	if(!o.list) {
+	if(o.extract || o.test) {
 		if(offsets.data_offset) {
-			slice_reader.reset(new stream::slice_reader(file, offsets.data_offset));
+			slice_reader.reset(new stream::slice_reader(&ifs, offsets.data_offset));
 		} else {
 			slice_reader.reset(new stream::slice_reader(file.parent_path(), file.stem(),
 			                                            info.header.slices_per_disk));
@@ -206,22 +281,26 @@
 	
 	BOOST_FOREACH(const Chunks::value_type & chunk, chunks) {
 		
-		debug("[starting " << chunk.first.compression << " chunk @ " << chunk.first.first_slice
+		debug("[starting " << chunk.first.compression << " chunk @ slice " << chunk.first.first_slice
 		      << " + " << print_hex(offsets.data_offset) << " + " << print_hex(chunk.first.offset)
 		      << ']');
 		
+		if(chunk.first.encrypted) {
+			log_warning << "skipping encrypted chunk (unsupported)";
+			continue;
+		}
+		
 		stream::chunk_reader::pointer chunk_source;
-		if(!o.list) {
+		if(o.extract || o.test) {
 			chunk_source = stream::chunk_reader::get(*slice_reader, chunk.first);
 		}
-		
-		uint64_t offset = 0;
+		boost::uint64_t offset = 0;
 		
 		BOOST_FOREACH(const Files::value_type & location, chunk.second) {
 			const stream::file & file = location.first;
 			
 			// Convert output filenames
-			typedef std::pair<fs::path, size_t> file_t;
+			typedef std::pair<std::string, size_t> file_t;
 			std::vector<file_t> output_names;
 			for(size_t i = 0; i < files_for_location[location.second].size(); i++) {
 				
@@ -234,16 +313,7 @@
 				}
 				
 				if(!info.files[file_i].destination.empty()) {
-					fs::path path;
-					if(o.dump) {
-						std::string file = info.files[file_i].destination;
-						if(o.filenames.lowercase) {
-							std::transform(file.begin(), file.end(), file.begin(), ::tolower);
-						}
-						path = file;
-					} else {
-						path = o.filenames.convert(info.files[file_i].destination);
-					}
+					std::string path = o.filenames.convert(info.files[file_i].destination);
 					if(!path.empty()) {
 						output_names.push_back(std::make_pair(path, file_i));
 					}
@@ -258,7 +328,7 @@
 			// Print filename and size
 			if(!o.silent) {
 				
-				progress::clear();
+				extract_progress.clear();
 				
 				std::cout << " - ";
 				bool named = false;
@@ -266,7 +336,7 @@
 					if(named) {
 						std::cout << ", ";
 					}
-					std::cout << '"' << color::white << path.first.string() << color::reset << '"';
+					std::cout << '"' << color::white << path.first << color::reset << '"';
 					if(!info.files[path.second].languages.empty()) {
 						std::cout << " [" << color::green << info.files[path.second].languages
 						          << color::reset << "]";
@@ -276,21 +346,32 @@
 				if(!named) {
 					std::cout << color::white << "unnamed file" << color::reset;
 				}
-				if(!logger::quiet) {
-				#ifdef DEBUG
-					std::cout << " @ " << print_hex(file.offset);
-				#endif
-				std::cout << " (" << color::dim_cyan << print_bytes(file.size)
-				          << color::reset << ")";
+				if(!o.quiet) {
+					if(logger::debug) {
+						std::cout << " @ " << print_hex(file.offset);
+					}
+					std::cout << " (" << color::dim_cyan << print_bytes(file.size)
+					          << color::reset << ")";
 				}
 				std::cout << '\n';
+				if(o.extract || o.test) {
+					std::cout.flush();
+				}
+				
+				extract_progress.update(0, true);
 				
-				if(!o.list) {
-					extract_progress.update(0, true);
+			} else if(o.list) {
+				extract_progress.clear();
+				BOOST_FOREACH(const file_t & path, output_names) {
+					std::cout << color::white << path.first << color::reset << '\n';
+				}
+				if(o.extract || o.test) {
+					std::cout.flush();
 				}
+				extract_progress.update(0, true);
 			}
 			
-			if(o.list) {
+			if(!o.extract && !o.test) {
 				continue;
 			}
 			
@@ -301,7 +382,7 @@
 			}
 			if(file.offset > offset) {
 				debug("discarding " << print_bytes(file.offset - offset));
-				discard(*chunk_source, file.offset - offset);
+				util::discard(*chunk_source, file.offset - offset);
 			}
 			offset = file.offset + file.size;
 			
@@ -312,44 +393,53 @@
 			file_source = stream::file_reader::get(*chunk_source, file, &checksum);
 			
 			// Open output files
-			boost::ptr_vector<fs::ofstream> output;
+			boost::ptr_vector<file_output> output;
 			if(!o.test) {
 				output.reserve(output_names.size());
 				BOOST_FOREACH(const file_t & path, output_names) {
-					try {
-						fs::create_directories(path.first.parent_path());
-					} catch(...) {
-						throw std::runtime_error("error creating directories for \""
-						                         + path.first.string() + '"');
-					}
-					output.push_back(new fs::ofstream(path.first));
-					if(!output.back().is_open()) {
-						throw std::runtime_error("error opening output file \""
-						                        + path.first.string() + '"');
-					}
+					output.push_back(new file_output(o.output_dir / path.first));
 				}
 			}
 			
 			// Copy data
 			while(!file_source->eof()) {
 				char buffer[8192 * 10];
-				std::streamsize n = file_source->read(buffer, ARRAY_SIZE(buffer)).gcount();
+				std::streamsize buffer_size = std::streamsize(ARRAY_SIZE(buffer));
+				std::streamsize n = file_source->read(buffer, buffer_size).gcount();
 				if(n > 0) {
-					
-					BOOST_FOREACH(fs::ofstream & ofs, output) {
-						ofs.write(buffer, n);
+					BOOST_FOREACH(file_output & out, output) {
+						out.stream.write(buffer, n);
+						if(out.stream.fail()) {
+							throw std::runtime_error("error writing file \""
+							                         + out.name.string() + '"');
+						}
 					}
-					
-					extract_progress.update(uint64_t(n));
+					extract_progress.update(boost::uint64_t(n));
 				}
 			}
 			
+			// Adjust file timestamps
+			if(o.preserve_file_times) {
+				const setup::data_entry & data = info.data_entries[location.second];
+				util::time filetime = data.timestamp;
+				if(o.local_timestamps && !(data.options & data.TimeStampInUTC)) {
+					filetime = util::to_local_time(filetime);
+				}
+				BOOST_FOREACH(file_output & out, output) {
+					out.stream.close();
+					if(!util::set_file_time(out.name, filetime, data.timestamp_nsec)) {
+						log_warning << "error setting timestamp on file " << out.name;
+					}
+				}
+			}
+			
+			// Verify checksums
 			if(checksum != file.checksum) {
 				log_warning << "checksum mismatch:\n"
 				            << "actual:   " << checksum << '\n'
 				            << "expected: " << file.checksum;
 				if(o.test) {
-					throw new std::runtime_error("integrity test failed");
+					throw std::runtime_error("integrity test failed");
 				}
 			}
 		}
@@ -358,6 +448,7 @@
 	extract_progress.clear();
 }
 
+
 int main(int argc, char * argv[]) {
 	
 	::options o;
@@ -365,7 +456,7 @@
 	po::options_description generic("Generic options");
 	generic.add_options()
 		("help,h", "Show supported options")
-		("version,v", "Print the version information")
+		("version,v", "Print version information")
 		("license", "Show license information")
 	;
 	
@@ -376,14 +467,16 @@
 		("list,l", "Only list files, don't write anything")
 	;
 	
-	po::options_description filter("Filters");
+	po::options_description filter("Modifiers");
 	filter.add_options()
 		("dump", "Dump contents without converting filenames")
 		("lowercase,L", "Convert extracted filenames to lower-case")
 		("language", po::value<std::string>(), "Extract files for the given language")
+		("timestamps,T", po::value<std::string>(), "Timezone for file times or \"local\" or \"none\"")
+		("output-dir,d", po::value<fs::path>(), "Extract files into the given directory")
 	;
 	
-	po::options_description io("I/O options");
+	po::options_description io("Display options");
 	io.add_options()
 		("quiet,q", "Output less information")
 		("silent,s", "Output only error/warning information")
@@ -396,7 +489,7 @@
 	
 	po::options_description hidden("Hidden options");
 	hidden.add_options()
-		("setup-files", po::value< std::vector<string> >(), "Setup files to be extracted")
+		("setup-files", po::value< std::vector<std::string> >(), "Setup files to be extracted")
 		/**/;
 	
 	po::options_description options_desc;
@@ -417,13 +510,14 @@
 		po::notify(options);
 	} catch(po::error & e) {
 		std::cerr << "Error parsing command-line: " << e.what() << "\n\n";
-		print_help(argv[0], visible);
-		return 1;
+		print_help(get_command(argv[0]), visible);
+		return ExitUserError;
 	}
 	
 	// Verbosity settings.
-	o.silent = options.count("silent");
-	logger::quiet = o.silent || options.count("quiet");
+	o.silent = (options.count("silent") != 0);
+	o.quiet = o.silent || options.count("quiet");
+	logger::quiet = o.quiet;
 #ifdef DEBUG
 	if(options.count("debug")) {
 		logger::debug = true;
@@ -448,55 +542,94 @@
 	color::init(color_e, progress_e);
 	
 	// Help output.
-	if(options.count("help")) {
-		print_help(argv[0], visible);
-		return 0;
+	if(options.count("help") != 0) {
+		print_help(get_command(argv[0]), visible);
+		return ExitSuccess;
 	}
 	
 	// License output
-	if(options.count("license")) {
+	if(options.count("license") != 0) {
 		print_license();
-		return 0;
+		return ExitSuccess;
 	}
 	
 	// Main action.
-	o.list = options.count("list");
-	bool extract = options.count("extract");
-	o.test = options.count("test");
-	bool explicit_action = o.list || extract || o.test;
+	o.list = (options.count("list") != 0);
+	o.extract = (options.count("extract") != 0);
+	o.test = (options.count("test") != 0);
+	bool explicit_action = o.list || o.test || o.extract;
 	if(!explicit_action) {
-		extract = true;
+		o.extract = true;
 	}
-	if(o.list + extract + o.test > 1) {
+	if(o.extract + o.test > 1) {
 		log_error << "cannot specify multiple actions";
-		return 0;
+		return ExitUserError;
+	}
+	if(!o.extract && !o.test) {
+		progress::set_enabled(false);
 	}
 	
 	// Additional actions.
-	o.dump = options.count("dump");
-	o.filenames.set_lowercase(options.count("lowercase"));
+	o.filenames.set_expand(options.count("dump") == 0);
+	o.filenames.set_lowercase(options.count("lowercase") != 0);
+	
+	// File timestamps
+	{
+		o.preserve_file_times = true, o.local_timestamps = false;
+		po::variables_map::const_iterator i = options.find("timestamps");
+		if(i != options.end()) {
+			std::string timezone = i->second.as<std::string>();
+			if(boost::iequals(timezone, "none")) {
+				o.preserve_file_times = false;
+			} else if(!boost::iequals(timezone, "UTC")) {
+				o.local_timestamps = true;
+				if(!boost::iequals(timezone, "local")) {
+					util::set_local_timezone(timezone);
+				}
+			}
+		}
+	}
 	
 	// List version.
-	if(options.count("version")) {
-		print_version();
+	if(options.count("version") != 0) {
+		print_version(o);
 		if(!explicit_action) {
-			return 0;
+			return ExitSuccess;
 		}
 	}
 	
-	po::variables_map::const_iterator i = options.find("language");
-	if(i != options.end()) {
-		o.language = i->second.as<std::string>();
+	{
+		po::variables_map::const_iterator i = options.find("language");
+		if(i != options.end()) {
+			o.language = i->second.as<std::string>();
+		}
 	}
 	
-	if(!options.count("setup-files")) {
+	if(!options.count("setup-files") != 0) {
 		if(!o.silent) {
-			std::cout << "no input files specified\n";
+			std::cout << get_command(argv[0]) << ": no input files specified\n";
+			std::cout << "Try the --help (-h) option for usage information.\n";
+		}
+		return ExitSuccess;
+	}
+	
+	{
+		po::variables_map::const_iterator i = options.find("output-dir");
+		if(i != options.end()) {
+			o.output_dir = i->second.as<fs::path>();
+			try {
+				if(!fs::exists(o.output_dir)) {
+					fs::create_directory(o.output_dir);
+				}
+			} catch(...) {
+				log_error << "could not create output directory " << o.output_dir;
+				return ExitDataError;
+			}
 		}
-		return 0;
 	}
 	
-	const std::vector<string> & files = options["setup-files"].as< std::vector<string> >();
+	const std::vector<std::string> & files = options["setup-files"]
+	                                         .as< std::vector<std::string> >();
 	
 	try {
 		BOOST_FOREACH(const std::string & file, files) {
@@ -532,5 +665,5 @@
 		std::cout << '.' << std::endl;
 	}
 	
-	return logger::total_errors == 0 ? 0 : 1;
+	return logger::total_errors == 0 ? ExitSuccess : ExitDataError;
 }
diff -Nru innoextract-1.3/src/cli/version.cpp.in innoextract-1.4/src/cli/version.cpp.in
--- innoextract-1.3/src/cli/version.cpp.in	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/cli/version.cpp.in	1970-01-01 00:00:00.000000000 +0000
@@ -1,37 +0,0 @@
-/*
- * Copyright (C) 2011-2012 Daniel Scharrer
- *
- * This software is provided 'as-is', without any express or implied
- * warranty.  In no event will the author(s) be held liable for any damages
- * arising from the use of this software.
- *
- * Permission is granted to anyone to use this software for any purpose,
- * including commercial applications, and to alter it and redistribute it
- * freely, subject to the following restrictions:
- *
- * 1. The origin of this software must not be misrepresented; you must not
- *    claim that you wrote the original software. If you use this software
- *    in a product, an acknowledgment in the product documentation would be
- *    appreciated but is not required.
- * 2. Altered source versions must be plainly marked as such, and must not be
- *    misrepresented as being the original software.
- * 3. This notice may not be removed or altered from any source distribution.
- */
-
-#include "cli/version.hpp"
-
-/*
- * This file is automatically processed by cmake if the version or commit id changes.
- * For the exact syntax see the documentation of the configure_file() cmake command.
- * For available variables see cmake/VersionString.cmake.
- */
-
-#if ${BASE_VERSION_COUNT} != 3
-#error "Configure error - the VERSION file should specify exactly two lines!"
-#endif
-
-const std::string innoextract_version = "${BASE_VERSION_0}${GIT_SUFFIX_5}";
-
-const std::string innosetup_versions = "${BASE_VERSION_1}";
-
-const std::string innoextract_copyright = "${BASE_VERSION_2}";
diff -Nru innoextract-1.3/src/cli/version.hpp innoextract-1.4/src/cli/version.hpp
--- innoextract-1.3/src/cli/version.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/cli/version.hpp	1970-01-01 00:00:00.000000000 +0000
@@ -1,35 +0,0 @@
-/*
- * Copyright (C) 2011 Daniel Scharrer
- *
- * This software is provided 'as-is', without any express or implied
- * warranty.  In no event will the author(s) be held liable for any damages
- * arising from the use of this software.
- *
- * Permission is granted to anyone to use this software for any purpose,
- * including commercial applications, and to alter it and redistribute it
- * freely, subject to the following restrictions:
- *
- * 1. The origin of this software must not be misrepresented; you must not
- *    claim that you wrote the original software. If you use this software
- *    in a product, an acknowledgment in the product documentation would be
- *    appreciated but is not required.
- * 2. Altered source versions must be plainly marked as such, and must not be
- *    misrepresented as being the original software.
- * 3. This notice may not be removed or altered from any source distribution.
- */
-
-#ifndef INNOEXTRACT_VERSION_HPP
-#define INNOEXTRACT_VERSION_HPP
-
-#include <string>
-
-//! Name + version of the program being built
-extern const std::string innoextract_version;
-
-//! Range of supported Inno Setup versions
-extern const std::string innosetup_versions;
-
-//! Copyright line for the current program
-extern const std::string innoextract_copyright;
-
-#endif // INNOEXTRACT_VERSION_HPP
diff -Nru innoextract-1.3/src/configure.hpp.in innoextract-1.4/src/configure.hpp.in
--- innoextract-1.3/src/configure.hpp.in	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/configure.hpp.in	2013-03-11 16:24:33.000000000 +0000
@@ -2,9 +2,35 @@
 #ifndef INNOEXTRACT_CONFIGURE_HPP
 #define INNOEXTRACT_CONFIGURE_HPP
 
-#cmakedefine HAVE_ISATTY
-#cmakedefine HAVE_IOCTL
-#cmakedefine HAVE_LZMA
-#cmakedefine IS_BIG_ENDIAN
+// Console functions
+#cmakedefine01 INNOEXTRACT_HAVE_ISATTY
+#cmakedefine01 INNOEXTRACT_HAVE_MS_ISATTY
+#cmakedefine01 INNOEXTRACT_HAVE_IOCTL
+
+// Time functions
+#cmakedefine01 INNOEXTRACT_HAVE_MKGMTIME64
+#cmakedefine01 INNOEXTRACT_HAVE_TIMEGM
+#cmakedefine01 INNOEXTRACT_HAVE_MKGMTIME
+#cmakedefine01 INNOEXTRACT_HAVE_GMTIME64_S
+#cmakedefine01 INNOEXTRACT_HAVE_GMTIME_R
+#cmakedefine01 INNOEXTRACT_HAVE_GMTIME_S
+
+// File functions
+#cmakedefine01 INNOEXTRACT_HAVE_UTIMENSAT
+#cmakedefine01 INNOEXTRACT_HAVE_AT_FDCWD
+#cmakedefine01 INNOEXTRACT_HAVE_UTIMES
+
+// Endianness
+#cmakedefine01 INNOEXTRACT_HAVE_BSWAP_16
+#cmakedefine01 INNOEXTRACT_HAVE_BSWAP_32
+#cmakedefine01 INNOEXTRACT_HAVE_BSWAP_64
+
+// C++11 functionality
+#cmakedefine01 INNOEXTRACT_HAVE_ALIGNOF
+#cmakedefine01 INNOEXTRACT_HAVE_STD_CODECVT_UTF8_UTF16
+#cmakedefine01 INNOEXTRACT_HAVE_STD_UNIQUE_PTR
+
+// Optional dependencies
+#cmakedefine01 INNOEXTRACT_HAVE_LZMA
 
 #endif // INNOEXTRACT_CONFIGURE_HPP
diff -Nru innoextract-1.3/src/crypto/adler32.cpp innoextract-1.4/src/crypto/adler32.cpp
--- innoextract-1.3/src/crypto/adler32.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/crypto/adler32.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -27,15 +27,15 @@
 
 void adler32::update(const char * input, size_t length) {
 	
-	const uint_fast32_t base = 65521;
+	const boost::uint_fast32_t base = 65521;
 	
-	uint_fast32_t s1 = this->s1;
-	uint_fast32_t s2 = this->s2;
+	boost::uint_fast32_t s1 = this->s1;
+	boost::uint_fast32_t s2 = this->s2;
 	
 	if(length % 8 != 0) {
 		
 		do {
-			s1 += uint8_t(*input++);
+			s1 += boost::uint8_t(*input++);
 			s2 += s1;
 			length--;
 		} while(length % 8 != 0);
@@ -49,14 +49,14 @@
 	
 	while(length > 0) {
 		
-		s1 += uint8_t(input[0]), s2 += s1;
-		s1 += uint8_t(input[1]), s2 += s1;
-		s1 += uint8_t(input[2]), s2 += s1;
-		s1 += uint8_t(input[3]), s2 += s1;
-		s1 += uint8_t(input[4]), s2 += s1;
-		s1 += uint8_t(input[5]), s2 += s1;
-		s1 += uint8_t(input[6]), s2 += s1;
-		s1 += uint8_t(input[7]), s2 += s1;
+		s1 += boost::uint8_t(input[0]), s2 += s1;
+		s1 += boost::uint8_t(input[1]), s2 += s1;
+		s1 += boost::uint8_t(input[2]), s2 += s1;
+		s1 += boost::uint8_t(input[3]), s2 += s1;
+		s1 += boost::uint8_t(input[4]), s2 += s1;
+		s1 += boost::uint8_t(input[5]), s2 += s1;
+		s1 += boost::uint8_t(input[6]), s2 += s1;
+		s1 += boost::uint8_t(input[7]), s2 += s1;
 		
 		length -= 8;
 		input += 8;
@@ -70,8 +70,8 @@
 		}
 	}
 	
-	this->s1 = uint16_t(s1);
-	this->s2 = uint16_t(s2);
+	this->s1 = boost::uint16_t(s1);
+	this->s2 = boost::uint16_t(s2);
 }
 
 } // namespace crypto
diff -Nru innoextract-1.3/src/crypto/adler32.hpp innoextract-1.4/src/crypto/adler32.hpp
--- innoextract-1.3/src/crypto/adler32.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/crypto/adler32.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -22,7 +22,8 @@
 #define INNOEXTRACT_CRYPTO_ADLER32_HPP
 
 #include <stddef.h>
-#include <stdint.h>
+
+#include <boost/cstdint.hpp>
 
 #include "crypto/checksum.hpp"
 
@@ -35,11 +36,11 @@
 	
 	void update(const char * data, size_t length);
 	
-	inline uint32_t finalize() const { return (uint32_t(s2) << 16) | s1; }
+	boost::uint32_t finalize() const { return (boost::uint32_t(s2) << 16) | s1; }
 	
 private:
 	
-	uint16_t s1, s2;
+	boost::uint16_t s1, s2;
 };
 
 } // namespace crypto
diff -Nru innoextract-1.3/src/crypto/checksum.cpp innoextract-1.4/src/crypto/checksum.cpp
--- innoextract-1.3/src/crypto/checksum.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/crypto/checksum.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -68,13 +68,13 @@
 		}
 		case crypto::MD5: {
 			for(size_t i = 0; i < ARRAY_SIZE(checksum.md5); i++) {
-				os << std::setfill('0') << std::hex << std::setw(2) << int(uint8_t(checksum.md5[i]));
+				os << std::setfill('0') << std::hex << std::setw(2) << int(boost::uint8_t(checksum.md5[i]));
 			}
 			break;
 		}
 		case crypto::SHA1: {
 			for(size_t i = 0; i < ARRAY_SIZE(checksum.sha1); i++) {
-				os << std::setfill('0') << std::hex << std::setw(2) << int(uint8_t(checksum.sha1[i]));
+				os << std::setfill('0') << std::hex << std::setw(2) << int(boost::uint8_t(checksum.sha1[i]));
 			}
 			break;
 		}
diff -Nru innoextract-1.3/src/crypto/checksum.hpp innoextract-1.4/src/crypto/checksum.hpp
--- innoextract-1.3/src/crypto/checksum.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/crypto/checksum.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -21,11 +21,12 @@
 #ifndef INNOEXTRACT_CRYPTO_CHECKSUM_HPP
 #define INNOEXTRACT_CRYPTO_CHECKSUM_HPP
 
-#include <stdint.h>
 #include <cstring>
 #include <iosfwd>
 #include <istream>
 
+#include <boost/cstdint.hpp>
+
 #include "util/endian.hpp"
 #include "util/enum.hpp"
 #include "util/types.hpp"
@@ -42,8 +43,8 @@
 struct checksum {
 	
 	union {
-		uint32_t adler32;
-		uint32_t crc32;
+		boost::uint32_t adler32;
+		boost::uint32_t crc32;
 		char md5[16];
 		char sha1[20];
 	};
@@ -51,12 +52,12 @@
 	checksum_type type;
 	
 	bool operator==(const checksum & other) const;
-	inline bool operator!=(const checksum & other) const { return !(*this == other); }
+	bool operator!=(const checksum & other) const { return !(*this == other); }
 	
 };
 
 template <class Impl>
-class checksum_base : public static_polymorphic<Impl> {
+class checksum_base : public util::static_polymorphic<Impl> {
 	
 public:
 	
@@ -65,13 +66,11 @@
 	 * Data is processed as-is and then converted according to Endianness.
 	 */
 	template <class T, class Endianness>
-	inline T load_number(std::istream & is) {
-		T result;
-		char buf[sizeof(result)];
-		is.read(buf, sizeof(buf));
-		this->impl().update(buf, sizeof(buf));
-		std::memcpy(&result, buf, sizeof(result));
-		return little_endian::byteswap_if_alien(result);
+	T load(std::istream & is) {
+		char buffer[sizeof(T)];
+		is.read(buffer, std::streamsize(sizeof(buffer)));
+		this->impl().update(buffer, sizeof(buffer));
+		return Endianness::template load<T>(buffer);
 	}
 	
 	/*!
@@ -79,8 +78,8 @@
 	 * Data is processed as-is and then converted if the host endianness is not little_endian.
 	 */
 	template <class T>
-	inline T load_number(std::istream & is) {
-		return load_number<T, little_endian>(is);
+	T load(std::istream & is) {
+		return load<T, util::little_endian>(is);
 	}
 	
 };
diff -Nru innoextract-1.3/src/crypto/crc32.cpp innoextract-1.4/src/crypto/crc32.cpp
--- innoextract-1.3/src/crypto/crc32.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/crypto/crc32.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -27,19 +27,8 @@
 
 namespace crypto {
 
-#if ENDIANNESS == LITTLE_ENDIAN
-#define CRC32_INDEX(c) (c & 0xff)
-#define CRC32_SHIFTED(c) (c >> 8)
-#elif ENDIANNESS == BIG_ENDIAN
-#define CRC32_INDEX(c) (c >> 24)
-#define CRC32_SHIFTED(c) (c << 8)
-#else
-#error "Unsupported host endianness."
-#endif
-
 /* Table of CRC-32's of all single byte values (made by makecrc.c) */
-const uint32_t crc32::table[] = {
-#if ENDIANNESS == LITTLE_ENDIAN
+static const boost::uint32_t crc32_table[] = {
 	0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
 	0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
 	0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
@@ -92,84 +81,35 @@
 	0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
 	0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
 	0x2d02ef8dL
-#else
-	0x00000000L, 0x96300777L, 0x2c610eeeL, 0xba510999L, 0x19c46d07L,
-	0x8ff46a70L, 0x35a563e9L, 0xa395649eL, 0x3288db0eL, 0xa4b8dc79L,
-	0x1ee9d5e0L, 0x88d9d297L, 0x2b4cb609L, 0xbd7cb17eL, 0x072db8e7L,
-	0x911dbf90L, 0x6410b71dL, 0xf220b06aL, 0x4871b9f3L, 0xde41be84L,
-	0x7dd4da1aL, 0xebe4dd6dL, 0x51b5d4f4L, 0xc785d383L, 0x56986c13L,
-	0xc0a86b64L, 0x7af962fdL, 0xecc9658aL, 0x4f5c0114L, 0xd96c0663L,
-	0x633d0ffaL, 0xf50d088dL, 0xc8206e3bL, 0x5e10694cL, 0xe44160d5L,
-	0x727167a2L, 0xd1e4033cL, 0x47d4044bL, 0xfd850dd2L, 0x6bb50aa5L,
-	0xfaa8b535L, 0x6c98b242L, 0xd6c9bbdbL, 0x40f9bcacL, 0xe36cd832L,
-	0x755cdf45L, 0xcf0dd6dcL, 0x593dd1abL, 0xac30d926L, 0x3a00de51L,
-	0x8051d7c8L, 0x1661d0bfL, 0xb5f4b421L, 0x23c4b356L, 0x9995bacfL,
-	0x0fa5bdb8L, 0x9eb80228L, 0x0888055fL, 0xb2d90cc6L, 0x24e90bb1L,
-	0x877c6f2fL, 0x114c6858L, 0xab1d61c1L, 0x3d2d66b6L, 0x9041dc76L,
-	0x0671db01L, 0xbc20d298L, 0x2a10d5efL, 0x8985b171L, 0x1fb5b606L,
-	0xa5e4bf9fL, 0x33d4b8e8L, 0xa2c90778L, 0x34f9000fL, 0x8ea80996L,
-	0x18980ee1L, 0xbb0d6a7fL, 0x2d3d6d08L, 0x976c6491L, 0x015c63e6L,
-	0xf4516b6bL, 0x62616c1cL, 0xd8306585L, 0x4e0062f2L, 0xed95066cL,
-	0x7ba5011bL, 0xc1f40882L, 0x57c40ff5L, 0xc6d9b065L, 0x50e9b712L,
-	0xeab8be8bL, 0x7c88b9fcL, 0xdf1ddd62L, 0x492dda15L, 0xf37cd38cL,
-	0x654cd4fbL, 0x5861b24dL, 0xce51b53aL, 0x7400bca3L, 0xe230bbd4L,
-	0x41a5df4aL, 0xd795d83dL, 0x6dc4d1a4L, 0xfbf4d6d3L, 0x6ae96943L,
-	0xfcd96e34L, 0x468867adL, 0xd0b860daL, 0x732d0444L, 0xe51d0333L,
-	0x5f4c0aaaL, 0xc97c0dddL, 0x3c710550L, 0xaa410227L, 0x10100bbeL,
-	0x86200cc9L, 0x25b56857L, 0xb3856f20L, 0x09d466b9L, 0x9fe461ceL,
-	0x0ef9de5eL, 0x98c9d929L, 0x2298d0b0L, 0xb4a8d7c7L, 0x173db359L,
-	0x810db42eL, 0x3b5cbdb7L, 0xad6cbac0L, 0x2083b8edL, 0xb6b3bf9aL,
-	0x0ce2b603L, 0x9ad2b174L, 0x3947d5eaL, 0xaf77d29dL, 0x1526db04L,
-	0x8316dc73L, 0x120b63e3L, 0x843b6494L, 0x3e6a6d0dL, 0xa85a6a7aL,
-	0x0bcf0ee4L, 0x9dff0993L, 0x27ae000aL, 0xb19e077dL, 0x44930ff0L,
-	0xd2a30887L, 0x68f2011eL, 0xfec20669L, 0x5d5762f7L, 0xcb676580L,
-	0x71366c19L, 0xe7066b6eL, 0x761bd4feL, 0xe02bd389L, 0x5a7ada10L,
-	0xcc4add67L, 0x6fdfb9f9L, 0xf9efbe8eL, 0x43beb717L, 0xd58eb060L,
-	0xe8a3d6d6L, 0x7e93d1a1L, 0xc4c2d838L, 0x52f2df4fL, 0xf167bbd1L,
-	0x6757bca6L, 0xdd06b53fL, 0x4b36b248L, 0xda2b0dd8L, 0x4c1b0aafL,
-	0xf64a0336L, 0x607a0441L, 0xc3ef60dfL, 0x55df67a8L, 0xef8e6e31L,
-	0x79be6946L, 0x8cb361cbL, 0x1a8366bcL, 0xa0d26f25L, 0x36e26852L,
-	0x95770cccL, 0x03470bbbL, 0xb9160222L, 0x2f260555L, 0xbe3bbac5L,
-	0x280bbdb2L, 0x925ab42bL, 0x046ab35cL, 0xa7ffd7c2L, 0x31cfd0b5L,
-	0x8b9ed92cL, 0x1daede5bL, 0xb0c2649bL, 0x26f263ecL, 0x9ca36a75L,
-	0x0a936d02L, 0xa906099cL, 0x3f360eebL, 0x85670772L, 0x13570005L,
-	0x824abf95L, 0x147ab8e2L, 0xae2bb17bL, 0x381bb60cL, 0x9b8ed292L,
-	0x0dbed5e5L, 0xb7efdc7cL, 0x21dfdb0bL, 0xd4d2d386L, 0x42e2d4f1L,
-	0xf8b3dd68L, 0x6e83da1fL, 0xcd16be81L, 0x5b26b9f6L, 0xe177b06fL,
-	0x7747b718L, 0xe65a0888L, 0x706a0fffL, 0xca3b0666L, 0x5c0b0111L,
-	0xff9e658fL, 0x69ae62f8L, 0xd3ff6b61L, 0x45cf6c16L, 0x78e20aa0L,
-	0xeed20dd7L, 0x5483044eL, 0xc2b30339L, 0x612667a7L, 0xf71660d0L,
-	0x4d476949L, 0xdb776e3eL, 0x4a6ad1aeL, 0xdc5ad6d9L, 0x660bdf40L,
-	0xf03bd837L, 0x53aebca9L, 0xc59ebbdeL, 0x7fcfb247L, 0xe9ffb530L,
-	0x1cf2bdbdL, 0x8ac2bacaL, 0x3093b353L, 0xa6a3b424L, 0x0536d0baL,
-	0x9306d7cdL, 0x2957de54L, 0xbf67d923L, 0x2e7a66b3L, 0xb84a61c4L,
-	0x021b685dL, 0x942b6f2aL, 0x37be0bb4L, 0xa18e0cc3L, 0x1bdf055aL,
-	0x8def022dL
-#endif
 };
 
+static boost::uint8_t crc32_index(boost::uint32_t crc) {
+	return boost::uint8_t(crc & 0xff);
+}
+
+static boost::uint32_t crc32_shifted(boost::uint32_t crc) {
+	return crc >> 8;
+}
+
 void crc32::update(const char * s, size_t n) {
 	
 	for(; (size_t(s) % 4 != 0) && n > 0; n--) {
-		crc = table[CRC32_INDEX(crc) ^ uint8_t(*s++)] ^ CRC32_SHIFTED(crc);
+		crc = crc32_table[crc32_index(crc) ^ boost::uint8_t(*s++)] ^ crc32_shifted(crc);
 	}
 	
 	while(n >= 4) {
-		crc ^= *reinterpret_cast<const uint32_t *>(s);
-		crc = table[CRC32_INDEX(crc)] ^ CRC32_SHIFTED(crc);
-		crc = table[CRC32_INDEX(crc)] ^ CRC32_SHIFTED(crc);
-		crc = table[CRC32_INDEX(crc)] ^ CRC32_SHIFTED(crc);
-		crc = table[CRC32_INDEX(crc)] ^ CRC32_SHIFTED(crc);
+		crc ^= util::little_endian::load<boost::uint32_t>(s);
+		crc = crc32_table[crc32_index(crc)] ^ crc32_shifted(crc);
+		crc = crc32_table[crc32_index(crc)] ^ crc32_shifted(crc);
+		crc = crc32_table[crc32_index(crc)] ^ crc32_shifted(crc);
+		crc = crc32_table[crc32_index(crc)] ^ crc32_shifted(crc);
 		n -= 4;
 		s += 4;
 	}
 	
 	while(n--) {
-		crc = table[CRC32_INDEX(crc) ^ uint8_t(*s++)] ^ CRC32_SHIFTED(crc);
+		crc = crc32_table[crc32_index(crc) ^ boost::uint8_t(*s++)] ^ crc32_shifted(crc);
 	}
 }
 
-#undef CRC32_INDEX
-#undef CRC32_SHIFTED
-
 } // namespace crypto
diff -Nru innoextract-1.3/src/crypto/crc32.hpp innoextract-1.4/src/crypto/crc32.hpp
--- innoextract-1.3/src/crypto/crc32.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/crypto/crc32.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -21,7 +21,7 @@
 #ifndef INNOEXTRACT_CRYPTO_CRC32_HPP
 #define INNOEXTRACT_CRYPTO_CRC32_HPP
 
-#include <stdint.h>
+#include <boost/cstdint.hpp>
 
 #include "crypto/checksum.hpp"
 
@@ -30,18 +30,17 @@
 //! CRC32 checksum calculation
 struct crc32 : public checksum_base<crc32> {
 	
-	inline void init() { crc = CRC32_NEGL; }
+	void init() { crc = CRC32_NEGL; }
 	
 	void update(const char * data, size_t length);
 	
-	inline uint32_t finalize() const { return crc ^ CRC32_NEGL; }
+	boost::uint32_t finalize() const { return crc ^ CRC32_NEGL; }
 	
 private:
 	
-	static const uint32_t CRC32_NEGL = 0xffffffffl;
+	static const boost::uint32_t CRC32_NEGL = 0xffffffffl;
 	
-	static const uint32_t table[256];
-	uint32_t crc;
+	boost::uint32_t crc;
 };
 
 } // namespace crypto
diff -Nru innoextract-1.3/src/crypto/hasher.hpp innoextract-1.4/src/crypto/hasher.hpp
--- innoextract-1.3/src/crypto/hasher.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/crypto/hasher.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -36,8 +36,8 @@
 	
 public:
 	
-	inline hasher() { }
-	inline hasher(checksum_type type) { init(type); }
+	hasher() { }
+	explicit hasher(checksum_type type) { init(type); }
 	hasher(const hasher & o);
 	
 	void init(checksum_type type);
diff -Nru innoextract-1.3/src/crypto/iteratedhash.hpp innoextract-1.4/src/crypto/iteratedhash.hpp
--- innoextract-1.3/src/crypto/iteratedhash.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/crypto/iteratedhash.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -23,8 +23,10 @@
 
 // Taken from Crypto++ and modified to fit the project.
 
-#include <stdint.h>
 #include <cstring>
+
+#include <boost/cstdint.hpp>
+
 #include "crypto/checksum.hpp"
 #include "util/endian.hpp"
 #include "util/types.hpp"
@@ -41,9 +43,9 @@
 	typedef typename transform::hash_word hash_word;
 	typedef typename transform::byte_order byte_order;
 	static const size_t block_size = transform::block_size;
-	static const size_t hash_size = transform::hash_size;
+	static const size_t hash_size = transform::hash_size / sizeof(hash_word);
 	
-	inline void init() { count_lo = count_hi = 0; transform::init(state); }
+	void init() { count_lo = count_hi = 0; transform::init(state); }
 	
 	void update(const char * data, size_t length);
 	
@@ -51,16 +53,16 @@
 	
 private:
 
-	size_t hash(const hash_word * input, size_t length);
-	void pad(unsigned int last_block_size, uint8_t pad_first = 0x80);
+	size_t hash(const char * input, size_t length);
+	void pad(size_t last_block_size, char pad_first = '\x80');
 	
-	inline hash_word bit_count_hi() const {
+	hash_word bit_count_hi() const {
 		return (count_lo >> (8 * sizeof(hash_word) - 3)) + (count_hi << 3);
 	}
-	inline hash_word bit_count_lo() const { return count_lo << 3; }
+	hash_word bit_count_lo() const { return count_lo << 3; }
 	
-	hash_word data[block_size / sizeof(hash_word)];
-	hash_word state[hash_size / sizeof(hash_word)];
+	char data[block_size];
+	hash_word state[hash_size];
 	
 	hash_word count_lo, count_hi;
 	
@@ -75,103 +77,97 @@
 		count_hi++; // carry from low to high
 	}
 	
-	count_hi += hash_word(safe_right_shift<8 * sizeof(hash_word)>(len));
+	count_hi += hash_word(util::safe_right_shift<8 * sizeof(hash_word)>(len));
 	
-	size_t num = mod_power_of_2(old_count_lo, size_t(block_size));
-	uint8_t * d = reinterpret_cast<uint8_t *>(data);
+	size_t num = util::mod_power_of_2(old_count_lo, size_t(block_size));
 	
 	if(num != 0) { // process left over data
 		if(num + len >= block_size) {
-			std::memcpy(d + num, input, block_size-num);
+			std::memcpy(data + num, input, block_size-num);
 			hash(data, block_size);
 			input += (block_size - num);
 			len -= (block_size - num);
-			num = 0;
 			// drop through and do the rest
 		} else {
-			std::memcpy(d + num, input, len);
+			std::memcpy(data + num, input, len);
 			return;
 		}
 	}
 	
 	// now process the input data in blocks of BlockSize bytes and save the leftovers to m_data
 	if(len >= block_size) {
-		
-		if(is_aligned<T>(input)) {
-			size_t leftOver = hash(reinterpret_cast<const hash_word *>(input), len);
-			input += (len - leftOver);
-			len = leftOver;
-			
-		} else {
-			do { // copy input first if it's not aligned correctly
-				std::memcpy(d, input, block_size);
-				hash(data, block_size);
-				input += block_size;
-				len -= block_size;
-			} while(len >= block_size);
-		}
+		size_t leftOver = hash(input, len);
+		input += (len - leftOver);
+		len = leftOver;
 	}
-
+	
 	if(len) {
-		memcpy(d, input, len);
+		memcpy(data, input, len);
 	}
 }
 
 template <class T>
-size_t iterated_hash<T>::hash(const hash_word * input, size_t length) {
+size_t iterated_hash<T>::hash(const char * input, size_t length) {
 	
-	do {
+	if(byte_order::native() && util::is_aligned<T>(input)) {
 		
-		if(byte_order::native) {
-			transform::transform(state, input);
-		} else {
-			byteswap(data, input, block_size);
-			transform::transform(state, data);
-		}
+		do {
+			
+			transform::transform(state, reinterpret_cast<const hash_word *>(input));
+			
+			input += block_size;
+			length -= block_size;
+			
+		} while(length >= block_size);
 		
-		input += block_size / sizeof(hash_word);
-		length -= block_size;
+	} else {
 		
-	} while(length >= block_size);
+		do {
+			
+			hash_word buffer[block_size / sizeof(hash_word)];
+			byte_order::load(input, buffer, ARRAY_SIZE(buffer));
+			
+			transform::transform(state, buffer);
+			
+			input += block_size;
+			length -= block_size;
+			
+		} while(length >= block_size);
+		
+	}
 	
 	return length;
 }
 
 template <class T>
-void iterated_hash<T>::pad(unsigned int last_block_size, uint8_t pad_first) {
-	
-	size_t num = mod_power_of_2(count_lo, size_t(block_size));
+void iterated_hash<T>::pad(size_t last_block_size, char pad_first) {
 	
-	uint8_t * d = reinterpret_cast<uint8_t *>(data);
+	size_t num = util::mod_power_of_2(count_lo, size_t(block_size));
 	
-	d[num++] = pad_first;
+	data[num++] = pad_first;
 	
 	if(num <= last_block_size) {
-		memset(d + num, 0, last_block_size - num);
+		memset(data + num, 0, last_block_size - num);
 	} else {
-		memset(d + num, 0, block_size - num);
+		memset(data + num, 0, block_size - num);
 		hash(data, block_size);
-		memset(d, 0, last_block_size);
+		memset(data, 0, last_block_size);
 	}
 }
 
 template <class T>
 void iterated_hash<T>::finalize(char * digest) {
 	
-	size_t order = byte_order::offset;
+	size_t order = transform::offset * sizeof(hash_word);
 	
-	pad(block_size - 2 * sizeof(hash_word));
-	data[block_size / sizeof(hash_word) - 2 + order] = byte_order::byteswap_if_alien(bit_count_lo());
-	data[block_size / sizeof(hash_word) - 1 - order] = byte_order::byteswap_if_alien(bit_count_hi());
+	size_t size = block_size - 2 * sizeof(hash_word);
+	pad(size);
+	byte_order::store(bit_count_lo(), data + size + order);
+	byte_order::store(bit_count_hi(), data + size + sizeof(hash_word) - order);
 	
 	hash(data, block_size);
 	
-	if(is_aligned<hash_word>(digest) && hash_size % sizeof(hash_word) == 0) {
-		byte_order::byteswap_if_alien(state, reinterpret_cast<hash_word *>(digest), hash_size);
-	} else {
-		byte_order::byteswap_if_alien(state, state, hash_size);
-		memcpy(digest, state, hash_size);
-	}
+	byte_order::store(state, hash_size, digest);
 	
 }
 
diff -Nru innoextract-1.3/src/crypto/md5.cpp innoextract-1.4/src/crypto/md5.cpp
--- innoextract-1.3/src/crypto/md5.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/crypto/md5.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -43,7 +43,7 @@
 #define F4(x, y, z) (y ^ (x | ~z))
 	
 #define MD5STEP(f, w, x, y, z, data, s) \
-	w = rotl_fixed(w + f(x, y, z) + data, s) + x
+	w = util::rotl_fixed(w + f(x, y, z) + data, s) + x
 	
 	hash_word a, b, c, d;
 	
diff -Nru innoextract-1.3/src/crypto/md5.hpp innoextract-1.4/src/crypto/md5.hpp
--- innoextract-1.3/src/crypto/md5.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/crypto/md5.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -21,7 +21,7 @@
 #ifndef INNOEXTRACT_CRYPTO_MD5_HPP
 #define INNOEXTRACT_CRYPTO_MD5_HPP
 
-#include <stdint.h>
+#include <boost/cstdint.hpp>
 
 #include "crypto/iteratedhash.hpp"
 #include "util/endian.hpp"
@@ -32,8 +32,9 @@
 	
 public:
 	
-	typedef uint32_t hash_word;
-	typedef little_endian byte_order;
+	typedef boost::uint32_t hash_word;
+	typedef util::little_endian byte_order;
+	static const size_t offset = 0;
 	static const size_t block_size = 64;
 	static const size_t hash_size = 16;
 	
diff -Nru innoextract-1.3/src/crypto/sha1.cpp innoextract-1.4/src/crypto/sha1.cpp
--- innoextract-1.3/src/crypto/sha1.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/crypto/sha1.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -38,8 +38,8 @@
 void sha1_transform::transform(hash_word * state, const hash_word * data) {
 	
 #define blk0(i) (W[i] = data[i])
-#define blk1(i) (W[i & 15] = rotl_fixed(W[(i + 13) & 15] ^ W[(i + 8) & 15] \
-                                       ^ W[(i + 2) & 15] ^ W[i & 15], 1))
+#define blk1(i) (W[i & 15] = util::rotl_fixed(W[(i + 13) & 15] ^ W[(i + 8) & 15] \
+                                              ^ W[(i + 2) & 15] ^ W[i & 15], 1))
 	
 #define f1(x, y, z) (z ^ (x & (y ^ z)))
 #define f2(x, y, z) (x ^ y ^ z)
@@ -47,16 +47,21 @@
 #define f4(x, y, z) (x ^ y ^ z)
 	
 /* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
-#define R0(v, w, x, y, z, i) z += f1(w, x, y) + blk0(i) + 0x5A827999 + rotl_fixed(v, 5); \
-                             w = rotl_fixed(w, 30);
-#define R1(v, w, x, y, z, i) z += f1(w, x, y) + blk1(i) + 0x5A827999 + rotl_fixed(v, 5); \
-                             w = rotl_fixed(w, 30);
-#define R2(v, w, x, y, z, i) z += f2(w, x, y) + blk1(i) + 0x6ED9EBA1 + rotl_fixed(v, 5); \
-                             w = rotl_fixed(w, 30);
-#define R3(v, w, x, y, z, i) z += f3(w, x, y) + blk1(i) + 0x8F1BBCDC + rotl_fixed(v, 5); \
-                             w = rotl_fixed(w, 30);
-#define R4(v, w, x, y, z, i) z += f4(w, x, y) + blk1(i) + 0xCA62C1D6 + rotl_fixed(v, 5); \
-                             w = rotl_fixed(w, 30);
+#define R0(v, w, x, y, z, i) \
+	z += f1(w, x, y) + blk0(i) + 0x5A827999 + util::rotl_fixed(v, 5); \
+	w = util::rotl_fixed(w, 30);
+#define R1(v, w, x, y, z, i) \
+	z += f1(w, x, y) + blk1(i) + 0x5A827999 + util::rotl_fixed(v, 5); \
+	w = util::rotl_fixed(w, 30);
+#define R2(v, w, x, y, z, i) \
+	z += f2(w, x, y) + blk1(i) + 0x6ED9EBA1 + util::rotl_fixed(v, 5); \
+	w = util::rotl_fixed(w, 30);
+#define R3(v, w, x, y, z, i) \
+	z += f3(w, x, y) + blk1(i) + 0x8F1BBCDC + util::rotl_fixed(v, 5); \
+	w = util::rotl_fixed(w, 30);
+#define R4(v, w, x, y, z, i) \
+	z += f4(w, x, y) + blk1(i) + 0xCA62C1D6 + util::rotl_fixed(v, 5); \
+	w = util::rotl_fixed(w, 30);
 	
 	hash_word W[16];
 	
diff -Nru innoextract-1.3/src/crypto/sha1.hpp innoextract-1.4/src/crypto/sha1.hpp
--- innoextract-1.3/src/crypto/sha1.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/crypto/sha1.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -21,7 +21,7 @@
 #ifndef INNOEXTRACT_CRYPTO_SHA1_HPP
 #define INNOEXTRACT_CRYPTO_SHA1_HPP
 
-#include <stdint.h>
+#include <boost/cstdint.hpp>
 
 #include "crypto/iteratedhash.hpp"
 #include "util/endian.hpp"
@@ -32,8 +32,9 @@
 	
 public:
 	
-	typedef uint32_t hash_word;
-	typedef big_endian byte_order;
+	typedef boost::uint32_t hash_word;
+	typedef util::big_endian byte_order;
+	static const size_t offset = 1;
 	static const size_t block_size = 64;
 	static const size_t hash_size = 20;
 	
diff -Nru innoextract-1.3/src/loader/exereader.cpp innoextract-1.4/src/loader/exereader.cpp
--- innoextract-1.3/src/loader/exereader.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/loader/exereader.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -20,13 +20,14 @@
 
 #include "loader/exereader.hpp"
 
-#include <stdint.h>
-#include <iostream>
+#include <istream>
 #include <iomanip>
 #include <algorithm>
 #include <cstring>
 #include <vector>
 
+#include <boost/cstdint.hpp>
+
 #include "util/load.hpp"
 
 namespace loader {
@@ -38,22 +39,22 @@
 	struct header {
 		
 		//! Number of CoffSection structures following this header after optionalHeaderSize bytes
-		uint16_t nsections;
+		boost::uint16_t nsections;
 		
 		//! Offset of the section table in the file
-		uint32_t section_table_offset;
+		boost::uint32_t section_table_offset;
 		
 		//! Virtual memory address of the resource root table
-		uint32_t resource_table_address;
+		boost::uint32_t resource_table_address;
 		
 	};
 	
 	struct section {
 		
-		uint32_t virtual_size; //!< Section size in virtual memory
-		uint32_t virtual_address; //!< Base virtual memory address
+		boost::uint32_t virtual_size; //!< Section size in virtual memory
+		boost::uint32_t virtual_address; //!< Base virtual memory address
 		
-		uint32_t raw_address; //!< Base file offset
+		boost::uint32_t raw_address; //!< Base file offset
 		
 	};
 	
@@ -70,7 +71,7 @@
 	 *   Remaining 31 bits: Offset to the resource table / leaf relative to
 	 *                      the directory start.
 	 */
-	static uint32_t find_resource_entry(std::istream & is, uint32_t id);
+	static boost::uint32_t find_resource_entry(std::istream & is, boost::uint32_t id);
 	
 	static bool load_header(std::istream & is, header & coff);
 	
@@ -79,25 +80,26 @@
 	/*!
 	 * Convert a memory address to a file offset according to the given section list.
 	 */
-	static uint32_t to_file_offset(const section_list & sections, uint32_t address);
+	static boost::uint32_t to_file_offset(const section_list & sections, boost::uint32_t address);
 	
-	static resource find_resource(std::istream & is, uint32_t name, uint32_t type = TypeData,
-	                              uint32_t language = LanguageDefault);
+	static resource find_resource(std::istream & is, boost::uint32_t name,
+	                              boost::uint32_t type = TypeData,
+	                              boost::uint32_t language = LanguageDefault);
 	
 };
 
 static const char PE_MAGIC[] = { 'P', 'E', 0, 0 };
 
-inline bool get_resource_table(uint32_t & entry, uint32_t resource_offset) {
+bool get_resource_table(boost::uint32_t & entry, boost::uint32_t resource_offset) {
 	
-	bool is_table = (entry & (uint32_t(1) << 31));
+	bool is_table = ((entry & (boost::uint32_t(1) << 31)) != 0);
 	
 	entry &= ~(1 << 31), entry += resource_offset;
 	
 	return is_table;
 }
 
-uint32_t exe_reader_impl::find_resource_entry(std::istream & is, uint32_t needle) {
+boost::uint32_t exe_reader_impl::find_resource_entry(std::istream & is, boost::uint32_t needle) {
 	
 	// skip: characteristics + timestamp + major version + minor version
 	if(is.seekg(4 + 4 + 2 + 2, std::ios_base::cur).fail()) {
@@ -105,22 +107,22 @@
 	}
 	
 	// Number of named resource entries.
-	uint16_t nbnames = load_number<uint16_t>(is);
+	boost::uint16_t nbnames = util::load<boost::uint16_t>(is);
 	
 	// Number of id resource entries.
-	uint16_t nbids = load_number<uint16_t>(is);
+	boost::uint16_t nbids = util::load<boost::uint16_t>(is);
 	
 	
 	// Ignore named resource entries.
-	const uint32_t entry_size = 4 + 4; // id / string address + offset
+	const boost::uint32_t entry_size = 4 + 4; // id / string address + offset
 	if(is.seekg(nbnames * entry_size, std::ios_base::cur).fail()) {
 		return 0;
 	}
 	
 	for(size_t i = 0; i < nbids; i++) {
 		
-		uint32_t id = load_number<uint32_t>(is);
-		uint32_t offset = load_number<uint32_t>(is);
+		boost::uint32_t id = util::load<boost::uint32_t>(is);
+		boost::uint32_t offset = util::load<boost::uint32_t>(is);
 		if(is.fail()) {
 			return 0;
 		}
@@ -136,13 +138,13 @@
 bool exe_reader_impl::load_header(std::istream & is, header & coff) {
 	
 	// Skip the DOS stub.
-	uint16_t peOffset = load_number<uint16_t>(is.seekg(0x3c));
+	boost::uint16_t peOffset = util::load<boost::uint16_t>(is.seekg(0x3c));
 	if(is.fail()) {
 		return false;
 	}
 	
 	char magic[sizeof(PE_MAGIC)];
-	if(is.seekg(peOffset).read(magic, sizeof(magic)).fail()) {
+	if(is.seekg(peOffset).read(magic, std::streamsize(sizeof(magic))).fail()) {
 		return false;
 	}
 	if(std::memcmp(magic, PE_MAGIC, sizeof(PE_MAGIC))) {
@@ -150,15 +152,15 @@
 	}
 	
 	is.seekg(2, std::ios_base::cur); // machine
-	coff.nsections = load_number<uint16_t>(is);
+	coff.nsections = util::load<boost::uint16_t>(is);
 	is.seekg(4 + 4 + 4, std::ios_base::cur); // creation time + symbol table offset + nbsymbols
-	uint16_t optional_header_size = load_number<uint16_t>(is);
+	boost::uint16_t optional_header_size = util::load<boost::uint16_t>(is);
 	is.seekg(2, std::ios_base::cur); // characteristics
 	
-	coff.section_table_offset = uint32_t(is.tellg()) + optional_header_size;
+	coff.section_table_offset = boost::uint32_t(is.tellg()) + optional_header_size;
 	
 	// Skip the optional header.
-	uint16_t optionalHeaderMagic = load_number<uint16_t>(is);
+	boost::uint16_t optionalHeaderMagic = util::load<boost::uint16_t>(is);
 	if(is.fail()) {
 		return false;
 	}
@@ -168,16 +170,16 @@
 		is.seekg(90, std::ios_base::cur);
 	}
 	
-	uint32_t ndirectories = load_number<uint32_t>(is);
+	boost::uint32_t ndirectories = util::load<boost::uint32_t>(is);
 	if(is.fail() || ndirectories < 3) {
 		return false;
 	}
-	const uint32_t directory_header_size = 4 + 4; // address + size
+	const boost::uint32_t directory_header_size = 4 + 4; // address + size
 	is.seekg(2 * directory_header_size, std::ios_base::cur);
 	
 	// Virtual memory address and size of the start of resource directory.
-	coff.resource_table_address = load_number<uint32_t>(is);
-	uint32_t resource_size = load_number<uint32_t>(is);
+	coff.resource_table_address = util::load<boost::uint32_t>(is);
+	boost::uint32_t resource_size = util::load<boost::uint32_t>(is);
 	if(is.fail() || !coff.resource_table_address || !resource_size) {
 		return false;
 	}
@@ -196,11 +198,11 @@
 		
 		is.seekg(8, std::ios_base::cur); // name
 		
-		section.virtual_size = load_number<uint32_t>(is);
-		section.virtual_address = load_number<uint32_t>(is);
+		section.virtual_size = util::load<boost::uint32_t>(is);
+		section.virtual_address = util::load<boost::uint32_t>(is);
 		
 		is.seekg(4, std::ios_base::cur); // raw size
-		section.raw_address = load_number<uint32_t>(is);
+		section.raw_address = util::load<boost::uint32_t>(is);
 		
 		// relocation addr + line number addr + relocation count
 		// + line number count + characteristics
@@ -211,7 +213,8 @@
 	return !is.fail();
 }
 
-uint32_t exe_reader_impl::to_file_offset(const section_list & sections, uint32_t memory) {
+boost::uint32_t exe_reader_impl::to_file_offset(const section_list & sections,
+                                                boost::uint32_t memory) {
 	
 	for(section_list::const_iterator i = sections.begin(); i != sections.end(); ++i) {
 		const section & s = *i;
@@ -223,8 +226,10 @@
 	return 0;
 }
 
-exe_reader_impl::resource exe_reader_impl::find_resource(std::istream & is, uint32_t name,
-                                                         uint32_t type, uint32_t language) {
+exe_reader_impl::resource exe_reader_impl::find_resource(std::istream & is,
+                                                         boost::uint32_t name,
+                                                         boost::uint32_t type,
+                                                         boost::uint32_t language) {
 	
 	is.seekg(0);
 	
@@ -241,39 +246,39 @@
 		return result;
 	}
 	
-	uint32_t resource_offset = to_file_offset(sections, coff.resource_table_address);
+	boost::uint32_t resource_offset = to_file_offset(sections, coff.resource_table_address);
 	if(!resource_offset) {
 		return result;
 	}
 	
 	is.seekg(resource_offset);
-	uint32_t type_offset = find_resource_entry(is, type);
+	boost::uint32_t type_offset = find_resource_entry(is, type);
 	if(!get_resource_table(type_offset, resource_offset)) {
 		return result;
 	}
 	
 	is.seekg(type_offset);
-	uint32_t name_offset = find_resource_entry(is, name);
+	boost::uint32_t name_offset = find_resource_entry(is, name);
 	if(!get_resource_table(name_offset, resource_offset)) {
 		return result;
 	}
 	
 	is.seekg(name_offset);
-	uint32_t leaf_offset = find_resource_entry(is, language);
+	boost::uint32_t leaf_offset = find_resource_entry(is, language);
 	if(!leaf_offset || get_resource_table(leaf_offset, resource_offset)) {
 		return result;
 	}
 	
 	// Virtual memory address and size of the resource data.
 	is.seekg(leaf_offset);
-	uint32_t data_address = load_number<uint32_t>(is);
-	uint32_t data_size = load_number<uint32_t>(is);
+	boost::uint32_t data_address = util::load<boost::uint32_t>(is);
+	boost::uint32_t data_size = util::load<boost::uint32_t>(is);
 	// ignore codepage and reserved word
 	if(is.fail()) {
 		return result;
 	}
 	
-	uint32_t data_offset = to_file_offset(sections, data_address);
+	boost::uint32_t data_offset = to_file_offset(sections, data_address);
 	if(!data_offset) {
 		return result;
 	}
@@ -286,8 +291,8 @@
 
 } // anonymous namespace
 
-exe_reader::resource exe_reader::find_resource(std::istream & is, uint32_t name,
-                                               uint32_t type, uint32_t language) {
+exe_reader::resource exe_reader::find_resource(std::istream & is, boost::uint32_t name,
+                                               boost::uint32_t type, boost::uint32_t language) {
 	return exe_reader_impl::find_resource(is, name, type, language);
 }
 
diff -Nru innoextract-1.3/src/loader/exereader.hpp innoextract-1.4/src/loader/exereader.hpp
--- innoextract-1.3/src/loader/exereader.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/loader/exereader.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -21,9 +21,10 @@
 #ifndef INNOEXTRACT_LOADER_EXEREADER_HPP
 #define INNOEXTRACT_LOADER_EXEREADER_HPP
 
-#include <stdint.h>
 #include <istream>
 
+#include <boost/cstdint.hpp>
+
 namespace loader {
 
 /*!
@@ -38,9 +39,9 @@
 	//! Position and size of a resource entry
 	struct resource {
 		
-		uint32_t offset; //!< File offset of the resource data in bytes
+		boost::uint32_t offset; //!< File offset of the resource data in bytes
 		
-		uint32_t size; //!< Size of the resource data in bytes
+		boost::uint32_t size; //!< Size of the resource data in bytes
 		
 	};
 	
@@ -61,8 +62,9 @@
 	 *
 	 * \return the location of the resource or `(0, 0)` if the requested resource does not exist.
 	 */
-	static resource find_resource(std::istream & is, uint32_t name, uint32_t type = TypeData,
-	                              uint32_t language = LanguageDefault);
+	static resource find_resource(std::istream & is, boost::uint32_t name,
+	                              boost::uint32_t type = TypeData,
+	                              boost::uint32_t language = LanguageDefault);
 	
 };
 
diff -Nru innoextract-1.3/src/loader/offsets.cpp innoextract-1.4/src/loader/offsets.cpp
--- innoextract-1.3/src/loader/offsets.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/loader/offsets.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -20,9 +20,9 @@
 
 #include "loader/offsets.hpp"
 
-#include <stdint.h>
 #include <cstring>
 
+#include <boost/cstdint.hpp>
 #include <boost/static_assert.hpp>
 
 #include <stddef.h>
@@ -57,8 +57,8 @@
 
 const int ResourceNameInstaller = 11111;
 
-const uint32_t SetupLoaderHeaderOffset = 0x30;
-const uint32_t SetupLoaderHeaderMagic = 0x6f6e6e49;
+const boost::uint32_t SetupLoaderHeaderOffset = 0x30;
+const boost::uint32_t SetupLoaderHeaderMagic = 0x6f6e6e49;
 
 } // anonymous namespace
 
@@ -66,14 +66,14 @@
 	
 	is.seekg(SetupLoaderHeaderOffset);
 	
-	uint32_t magic = load_number<uint32_t>(is);
+	boost::uint32_t magic = util::load<boost::uint32_t>(is);
 	if(is.fail() || magic != SetupLoaderHeaderMagic) {
 		is.clear();
 		return false;
 	}
 	
-	uint32_t offset_table_offset = load_number<uint32_t>(is);
-	uint32_t not_offset_table_offset = load_number<uint32_t>(is);
+	boost::uint32_t offset_table_offset = util::load<boost::uint32_t>(is);
+	boost::uint32_t not_offset_table_offset = util::load<boost::uint32_t>(is);
 	if(is.fail() || offset_table_offset != ~not_offset_table_offset) {
 		is.clear();
 		return false;
@@ -93,7 +93,7 @@
 	return load_offsets_at(is, resource.offset);
 }
 
-bool offsets::load_offsets_at(std::istream & is, uint32_t pos) {
+bool offsets::load_offsets_at(std::istream & is, boost::uint32_t pos) {
 	
 	if(is.seekg(pos).fail()) {
 		is.clear();
@@ -101,14 +101,15 @@
 	}
 	
 	char magic[12];
-	if(is.read(magic, ARRAY_SIZE(magic)).fail()) {
+	if(is.read(magic, std::streamsize(ARRAY_SIZE(magic))).fail()) {
 		is.clear();
 		return false;
 	}
 	
 	setup::version_constant version = 0;
 	for(size_t i = 0; i < ARRAY_SIZE(known_setup_loader_versions); i++) {
-		BOOST_STATIC_ASSERT(ARRAY_SIZE(known_setup_loader_versions[i].magic) == ARRAY_SIZE(magic));
+		BOOST_STATIC_ASSERT(ARRAY_SIZE(known_setup_loader_versions[i].magic)
+		                    == ARRAY_SIZE(magic));
 		if(!memcmp(magic, known_setup_loader_versions[i].magic, ARRAY_SIZE(magic))) {
 			version = known_setup_loader_versions[i].version;
 			break;
@@ -123,40 +124,40 @@
 	checksum.update(magic, ARRAY_SIZE(magic));
 	
 	if(version >= INNO_VERSION(5, 1,  5)) {
-		uint32_t revision = checksum.load_number<uint32_t>(is);
+		boost::uint32_t revision = checksum.load<boost::uint32_t>(is);
 		if(is.fail() || revision != 1) {
 			is.clear();
 			return false;
 		}
 	}
 	
-	(void)checksum.load_number<uint32_t>(is);
-	exe_offset = checksum.load_number<uint32_t>(is);
+	(void)checksum.load<boost::uint32_t>(is);
+	exe_offset = checksum.load<boost::uint32_t>(is);
 	
 	if(version >= INNO_VERSION(4, 1, 6)) {
 		exe_compressed_size = 0;
 	} else {
-		exe_compressed_size = checksum.load_number<uint32_t>(is);
+		exe_compressed_size = checksum.load<boost::uint32_t>(is);
 	}
 	
-	exe_uncompressed_size = checksum.load_number<uint32_t>(is);
+	exe_uncompressed_size = checksum.load<boost::uint32_t>(is);
 	
 	if(version >= INNO_VERSION(4, 0, 3)) {
 		exe_checksum.type = crypto::CRC32;
-		exe_checksum.crc32 = checksum.load_number<uint32_t>(is);
+		exe_checksum.crc32 = checksum.load<boost::uint32_t>(is);
 	} else {
 		exe_checksum.type = crypto::Adler32;
-		exe_checksum.adler32 = checksum.load_number<uint32_t>(is);
+		exe_checksum.adler32 = checksum.load<boost::uint32_t>(is);
 	}
 	
 	if(version >= INNO_VERSION(4, 0, 0)) {
 		message_offset = 0;
 	} else {
-		message_offset = load_number<uint32_t>(is);
+		message_offset = util::load<boost::uint32_t>(is);
 	}
 	
-	header_offset = checksum.load_number<uint32_t>(is);
-	data_offset = checksum.load_number<uint32_t>(is);
+	header_offset = checksum.load<boost::uint32_t>(is);
+	data_offset = checksum.load<boost::uint32_t>(is);
 	
 	if(is.fail()) {
 		is.clear();
@@ -164,7 +165,7 @@
 	}
 	
 	if(version >= INNO_VERSION(4, 0, 10)) {
-		uint32_t expected = load_number<uint32_t>(is);
+		boost::uint32_t expected = util::load<boost::uint32_t>(is);
 		if(is.fail()) {
 			is.clear();
 			return false;
diff -Nru innoextract-1.3/src/loader/offsets.hpp innoextract-1.4/src/loader/offsets.hpp
--- innoextract-1.3/src/loader/offsets.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/loader/offsets.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -21,9 +21,10 @@
 #ifndef INNOEXTRACT_LOADER_OFFSETS_HPP
 #define INNOEXTRACT_LOADER_OFFSETS_HPP
 
-#include <stdint.h>
 #include <iosfwd>
 
+#include <boost/cstdint.hpp>
+
 #include "crypto/checksum.hpp"
 
 namespace loader {
@@ -49,17 +50,17 @@
 	 *
 	 * A value of \c 0 means there is no setup.e32 embedded in this file
 	 */
-	uint32_t exe_offset;
+	boost::uint32_t exe_offset;
 	
 	/*!
 	 * Size of `setup.e32` after compression, in bytes
 	 *
 	 * A value of \c 0 means the executable size is not known
 	 */
-	uint32_t exe_compressed_size;
+	boost::uint32_t exe_compressed_size;
 	
 	//! Size of `setup.e32` before compression, in bytes
-	uint32_t exe_uncompressed_size;
+	boost::uint32_t exe_uncompressed_size;
 	
 	/*!
 	 * Checksum of `setup.e32` before compression
@@ -69,7 +70,7 @@
 	crypto::checksum exe_checksum;
 	
 	//! Offset of embedded setup messages
-	uint32_t message_offset;
+	boost::uint32_t message_offset;
 	
 	/*!
 	 * Offset of embedded `setup-0.bin` data (the setup headers)
@@ -82,7 +83,7 @@
 	 *
 	 * Loading the version and headers is done in \ref setup::info.
 	 */
-	uint32_t header_offset;
+	boost::uint32_t header_offset;
 	
 	/*!
 	 * Offset of embedded `setup-1.bin` data
@@ -98,7 +99,7 @@
 	 * The layout of the chunks and files is stored in the \ref setup::data_entry headers
 	 * while the \ref setup::file_entry headers provide the filenames and meta information.
 	 */
-	uint32_t data_offset;
+	boost::uint32_t data_offset;
 	
 	/*!
 	 * \brief Find the setup loader offsets in a file
@@ -117,7 +118,7 @@
 	
 	bool load_from_exe_resource(std::istream & is);
 	
-	bool load_offsets_at(std::istream & is, uint32_t pos);
+	bool load_offsets_at(std::istream & is, boost::uint32_t pos);
 	
 };
 
diff -Nru innoextract-1.3/src/release.cpp.in innoextract-1.4/src/release.cpp.in
--- innoextract-1.3/src/release.cpp.in	1970-01-01 00:00:00.000000000 +0000
+++ innoextract-1.4/src/release.cpp.in	2013-03-11 16:24:33.000000000 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2011-2013 Daniel Scharrer
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the author(s) be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#include "release.hpp"
+
+/*
+ * This file is automatically processed by cmake if the version or commit id changes.
+ * For the exact syntax see the documentation of the configure_file() cmake command.
+ * For available variables see cmake/VersionString.cmake.
+ */
+
+#if ${VERSION_COUNT} != 2
+#error "Configure error - the VERSION file should specify exactly two lines!"
+#endif
+
+#if ${LICENSE_COUNT} < 3
+#error "Configure error - the LICENSE file should specify at least three lines!"
+#endif
+
+const char innoextract_name[] = "${VERSION_0_NAME}";
+
+const char innoextract_version[] = "${VERSION_0_NUMBER}${GIT_SUFFIX_5}";
+
+const char innosetup_versions[] = "${VERSION_1}";
+
+const char innoextract_copyright[] = "${LICENSE_0_STRING}";
+
+const char innoextract_license[] = "${LICENSE_TAIL}";
diff -Nru innoextract-1.3/src/release.hpp innoextract-1.4/src/release.hpp
--- innoextract-1.3/src/release.hpp	1970-01-01 00:00:00.000000000 +0000
+++ innoextract-1.4/src/release.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2011-2013 Daniel Scharrer
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the author(s) be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef INNOEXTRACT_VERSION_HPP
+#define INNOEXTRACT_VERSION_HPP
+
+//! Name of the program being built
+extern const char innoextract_name[];
+
+//! Name + version of the program being built
+extern const char innoextract_version[];
+
+//! Range of supported Inno Setup versions
+extern const char innosetup_versions[];
+
+//! Copyright line for the current program
+extern const char innoextract_copyright[];
+
+//! License text for the current program
+extern const char innoextract_license[];
+
+#endif // INNOEXTRACT_VERSION_HPP
diff -Nru innoextract-1.3/src/setup/component.cpp innoextract-1.4/src/setup/component.cpp
--- innoextract-1.3/src/setup/component.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/component.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -55,29 +55,29 @@
 
 void component_entry::load(std::istream & is, const version & version) {
 	
-	is >> encoded_string(name, version.codepage());
-	is >> encoded_string(description, version.codepage());
-	is >> encoded_string(types, version.codepage());
+	is >> util::encoded_string(name, version.codepage());
+	is >> util::encoded_string(description, version.codepage());
+	is >> util::encoded_string(types, version.codepage());
 	if(version >= INNO_VERSION(4, 0, 1)) {
-		is >> encoded_string(languages, version.codepage());
+		is >> util::encoded_string(languages, version.codepage());
 	} else {
 		languages.clear();
 	}
 	if(version >= INNO_VERSION_EXT(3, 0, 6, 1)) {
-		is >> encoded_string(check, version.codepage());
+		is >> util::encoded_string(check, version.codepage());
 	} else {
 		check.clear();
 	}
 	
 	if(version >= INNO_VERSION(4, 0, 0)) {
-		extra_disk_pace_required = load_number<uint64_t>(is);
+		extra_disk_pace_required = util::load<boost::uint64_t>(is);
 	} else {
-		extra_disk_pace_required = load_number<uint32_t>(is);
+		extra_disk_pace_required = util::load<boost::uint32_t>(is);
 	}
 	
 	if(version >= INNO_VERSION_EXT(3, 0, 6, 1)) {
-		level = load_number<int32_t>(is);
-		used = load_number<uint8_t>(is);
+		level = util::load<boost::int32_t>(is);
+		used = util::load_bool(is);
 	} else {
 		level = 0, used = true;
 	}
@@ -92,7 +92,11 @@
 		options = stored_flags<stored_component_flags_0>(is).get();
 	}
 	
-	size = (version >= INNO_VERSION(4, 0, 0)) ? load_number<uint64_t>(is) : load_number<uint32_t>(is);
+	if(version >= INNO_VERSION(4, 0, 0)) {
+		size = util::load<boost::uint64_t>(is);
+	} else {
+		size = util::load<boost::uint32_t>(is);
+	}
 }
 
 } // namespace setup
diff -Nru innoextract-1.3/src/setup/component.hpp innoextract-1.4/src/setup/component.hpp
--- innoextract-1.3/src/setup/component.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/component.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -21,10 +21,11 @@
 #ifndef INNOEXTRACT_SETUP_COMPONENT_HPP
 #define INNOEXTRACT_SETUP_COMPONENT_HPP
 
-#include <stdint.h>
 #include <string>
 #include <iosfwd>
 
+#include <boost/cstdint.hpp>
+
 #include "setup/windows.hpp"
 #include "util/enum.hpp"
 #include "util/flags.hpp"
@@ -51,7 +52,7 @@
 	std::string languages;
 	std::string check;
 	
-	uint64_t extra_disk_pace_required;
+	boost::uint64_t extra_disk_pace_required;
 	
 	int level;
 	bool used;
@@ -60,7 +61,7 @@
 	
 	flags options;
 	
-	uint64_t size;
+	boost::uint64_t size;
 	
 	void load(std::istream & is, const version & version);
 	
diff -Nru innoextract-1.3/src/setup/data.cpp innoextract-1.4/src/setup/data.cpp
--- innoextract-1.3/src/setup/data.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/data.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -23,118 +23,139 @@
 #include "setup/version.hpp"
 #include "util/load.hpp"
 #include "util/log.hpp"
+#include "util/output.hpp"
 #include "util/storedenum.hpp"
+#include "util/time.hpp"
 
 namespace setup {
 
 void data_entry::load(std::istream & is, const version & version) {
 	
-	chunk.first_slice = load_number<uint32_t>(is, version.bits);
-	chunk.last_slice = load_number<uint32_t>(is, version.bits);
+	chunk.first_slice = util::load<boost::uint32_t>(is, version.bits);
+	chunk.last_slice = util::load<boost::uint32_t>(is, version.bits);
 	if(version < INNO_VERSION(4, 0, 0)) {
 		if(chunk.first_slice < 1 || chunk.last_slice < 1) {
-			log_warning << "[file location] unexpected disk number: " << chunk.first_slice << " / "
-			            << chunk.last_slice;
+			log_warning << "[file location] unexpected disk number: " << chunk.first_slice
+			            << " / " << chunk.last_slice;
 		} else {
 			chunk.first_slice--, chunk.last_slice--;
 		}
 	}
 	
-	chunk.offset = load_number<uint32_t>(is);
+	chunk.offset = util::load<boost::uint32_t>(is);
 	
 	if(version >= INNO_VERSION(4, 0, 1)) {
-		file.offset = load_number<uint64_t>(is);
+		file.offset = util::load<boost::uint64_t>(is);
 	} else {
 		file.offset = 0;
 	}
 	
 	if(version >= INNO_VERSION(4, 0, 0)) {
-		file.size = load_number<uint64_t>(is);
-		chunk.size = load_number<uint64_t>(is);
+		file.size = util::load<boost::uint64_t>(is);
+		chunk.size = util::load<boost::uint64_t>(is);
 	} else {
-		file.size = load_number<uint32_t>(is);
-		chunk.size = load_number<uint32_t>(is);
+		file.size = util::load<boost::uint32_t>(is);
+		chunk.size = util::load<boost::uint32_t>(is);
 	}
 	
 	if(version >= INNO_VERSION(5, 3, 9)) {
-		is.read(file.checksum.sha1, sizeof(file.checksum.sha1)), file.checksum.type = crypto::SHA1;
+		is.read(file.checksum.sha1, std::streamsize(sizeof(file.checksum.sha1)));
+		file.checksum.type = crypto::SHA1;
 	} else if(version >= INNO_VERSION(4, 2, 0)) {
-		is.read(file.checksum.md5, sizeof(file.checksum.md5)), file.checksum.type = crypto::MD5;
+		is.read(file.checksum.md5, std::streamsize(sizeof(file.checksum.md5)));
+		file.checksum.type = crypto::MD5;
 	} else if(version >= INNO_VERSION(4, 0, 1)) {
-		file.checksum.crc32 = load_number<uint32_t>(is), file.checksum.type = crypto::CRC32;
+		file.checksum.crc32 = util::load<boost::uint32_t>(is);
+		file.checksum.type = crypto::CRC32;
 	} else {
-		file.checksum.adler32 = load_number<uint32_t>(is), file.checksum.type = crypto::Adler32;
+		file.checksum.adler32 = util::load<boost::uint32_t>(is);
+		file.checksum.type = crypto::Adler32;
 	}
 	
 	if(version.bits == 16) {
 		
-		int32_t date = load_number<int32_t>(is); // milliseconds?
+		// 16-bit installers use the FAT filetime format
 		
-		// TODO this seems to be off by a few years:
-		// expected ~ 2000-04-18, got 1991-07-28
+		boost::uint16_t time = util::load<boost::uint16_t>(is);
+		boost::uint16_t date = util::load<boost::uint16_t>(is);
 		
-		timestamp.tv_sec = date;
-		timestamp.tv_nsec = 0;
+		struct tm t;
+		t.tm_sec  = util::get_bits(time,  0,  4) * 2;           // [0, 58]
+		t.tm_min  = util::get_bits(time,  5, 10);               // [0, 59]
+		t.tm_hour = util::get_bits(time, 11, 15);               // [0, 23]
+		t.tm_mday = util::get_bits(date,  0,  4);               // [1, 31]
+		t.tm_mon  = util::get_bits(date,  5,  8) - 1;           // [0, 11]
+		t.tm_year = util::get_bits(date,  9, 15) + 1980 - 1900; // [80, 199]
+		
+		timestamp = util::parse_time(t);
+		timestamp_nsec = 0;
 		
 	} else {
 		
-		int64_t filetime = load_number<int64_t>(is);
+		// 32-bit installers use the Win32 FILETIME format
+		
+		boost::int64_t filetime = util::load<boost::int64_t>(is);
 		
-		static const int64_t FILETIME_OFFSET = 0x19DB1DED53E8000ll;
-		if(filetime < FILETIME_OFFSET) {
+		static const boost::int64_t FiletimeOffset = 0x19DB1DED53E8000ll;
+		if(filetime < FiletimeOffset) {
 			log_warning << "[file location] unexpected filetime: " << filetime;
 		}
-		filetime -= FILETIME_OFFSET;
+		filetime -= FiletimeOffset;
+		
+		timestamp = filetime / 10000000;
+		timestamp_nsec = boost::uint32_t(filetime % 10000000) * 100;
 		
-		timestamp.tv_sec = std::time_t(filetime / 10000000);
-		timestamp.tv_nsec = int32_t(filetime % 10000000) * 100;
 	}
 	
-	file_version_ms = load_number<uint32_t>(is);
-	file_version_ls = load_number<uint32_t>(is);
+	file_version_ms = util::load<boost::uint32_t>(is);
+	file_version_ls = util::load<boost::uint32_t>(is);
 	
 	options = 0;
 	
-	stored_flag_reader<flags> flags(is, version.bits);
+	stored_flag_reader<flags> flagreader(is, version.bits);
 	
-	flags.add(VersionInfoValid);
-	flags.add(VersionInfoNotValid);
+	flagreader.add(VersionInfoValid);
+	flagreader.add(VersionInfoNotValid);
 	if(version >= INNO_VERSION(2, 0, 17) && version < INNO_VERSION(4, 0, 1)) {
-		flags.add(BZipped);
+		flagreader.add(BZipped);
 	}
 	if(version >= INNO_VERSION(4, 0, 10)) {
-		flags.add(TimeStampInUTC);
+		flagreader.add(TimeStampInUTC);
 	}
 	if(version >= INNO_VERSION(4, 1, 0)) {
-		flags.add(IsUninstallerExe);
+		flagreader.add(IsUninstallerExe);
 	}
 	if(version >= INNO_VERSION(4, 1, 8)) {
-		flags.add(CallInstructionOptimized);
+		flagreader.add(CallInstructionOptimized);
 	}
 	if(version >= INNO_VERSION(4, 2, 0)) {
-		flags.add(Touch);
+		flagreader.add(Touch);
 	}
 	if(version >= INNO_VERSION(4, 2, 2)) {
-		flags.add(ChunkEncrypted);
+		flagreader.add(ChunkEncrypted);
 	}
 	if(version >= INNO_VERSION(4, 2, 5)) {
-		flags.add(ChunkCompressed);
+		flagreader.add(ChunkCompressed);
 	} else {
 		options |= ChunkCompressed;
 	}
 	if(version >= INNO_VERSION(5, 1, 13)) {
-		flags.add(SolidBreak);
+		flagreader.add(SolidBreak);
 	}
 	
-	options |= flags;
+	options |= flagreader;
 	
-	chunk.compression = (options & ChunkCompressed) ? stream::UnknownCompression : stream::Stored;
+	if(options & ChunkCompressed) {
+		chunk.compression = stream::UnknownCompression;
+	} else {
+		chunk.compression = stream::Stored;
+	}
 	if(options & BZipped) {
 		options |= ChunkCompressed;
 		chunk.compression = stream::BZip2;
 	}
 	
-	chunk.encrypted = (options & ChunkEncrypted);
+	chunk.encrypted = ((options & ChunkEncrypted) != 0);
 	
 	if(options & CallInstructionOptimized) {
 		if(version < INNO_VERSION(5, 2, 0)) {
diff -Nru innoextract-1.3/src/setup/data.hpp innoextract-1.4/src/setup/data.hpp
--- innoextract-1.3/src/setup/data.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/data.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -22,10 +22,10 @@
 #define INNOEXTRACT_SETUP_DATA_HPP
 
 #include <stddef.h>
-#include <stdint.h>
-#include <ctime>
 #include <iosfwd>
 
+#include <boost/cstdint.hpp>
+
 #include "crypto/checksum.hpp"
 #include "stream/chunk.hpp"
 #include "stream/file.hpp"
@@ -58,10 +58,11 @@
 	
 	stream::file file;
 	
-	timespec timestamp;
+	boost::int64_t timestamp;
+	boost::uint32_t timestamp_nsec;
 	
-	uint32_t file_version_ms;
-	uint32_t file_version_ls;
+	boost::uint32_t file_version_ms;
+	boost::uint32_t file_version_ls;
 	
 	flags options;
 	
diff -Nru innoextract-1.3/src/setup/delete.cpp innoextract-1.4/src/setup/delete.cpp
--- innoextract-1.3/src/setup/delete.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/delete.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -39,10 +39,10 @@
 void delete_entry::load(std::istream & is, const version & version) {
 	
 	if(version < INNO_VERSION(1, 3, 21)) {
-		::load<uint32_t>(is); // uncompressed size of the directory entry structure
+		(void)util::load<boost::uint32_t>(is); // uncompressed size of the entry
 	}
 	
-	is >> encoded_string(name, version.codepage());
+	is >> util::encoded_string(name, version.codepage());
 	
 	load_condition_data(is, version);
 	
diff -Nru innoextract-1.3/src/setup/directory.cpp innoextract-1.4/src/setup/directory.cpp
--- innoextract-1.3/src/setup/directory.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/directory.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -48,21 +48,21 @@
 void directory_entry::load(std::istream & is, const version & version) {
 	
 	if(version < INNO_VERSION(1, 3, 21)) {
-		::load<uint32_t>(is); // uncompressed size of the directory entry structure
+		(void)util::load<boost::uint32_t>(is); // uncompressed size of the entry
 	}
 	
-	is >> encoded_string(name, version.codepage());
+	is >> util::encoded_string(name, version.codepage());
 	
 	load_condition_data(is, version);
 	
 	if(version >= INNO_VERSION(4, 0, 11) && version < INNO_VERSION(4, 1, 0)) {
-		is >> encoded_string(permissions, version.codepage());
+		is >> util::encoded_string(permissions, version.codepage());
 	} else {
 		permissions.clear();
 	}
 	
 	if(version >= INNO_VERSION(2, 0, 11)) {
-		attributes = load_number<uint32_t>(is);
+		attributes = util::load<boost::uint32_t>(is);
 	} else {
 		attributes = 0;
 	}
@@ -70,7 +70,7 @@
 	load_version_data(is, version);
 	
 	if(version >= INNO_VERSION(4, 1, 0)) {
-		permission = load_number<int16_t>(is);
+		permission = util::load<boost::int16_t>(is);
 	} else {
 		permission = -1;
 	}
diff -Nru innoextract-1.3/src/setup/directory.hpp innoextract-1.4/src/setup/directory.hpp
--- innoextract-1.3/src/setup/directory.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/directory.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -21,10 +21,11 @@
 #ifndef INNOEXTRACT_SETUP_DIRECTORY_HPP
 #define INNOEXTRACT_SETUP_DIRECTORY_HPP
 
-#include <stdint.h>
 #include <string>
 #include <iosfwd>
 
+#include <boost/cstdint.hpp>
+
 #include "setup/item.hpp"
 #include "util/enum.hpp"
 #include "util/flags.hpp"
@@ -46,7 +47,7 @@
 	std::string name;
 	std::string permissions;
 	
-	uint32_t attributes;
+	boost::uint32_t attributes;
 	
 	int permission; //!< index into the permission entry list
 	
diff -Nru innoextract-1.3/src/setup/file.cpp innoextract-1.4/src/setup/file.cpp
--- innoextract-1.3/src/setup/file.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/file.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -72,19 +72,19 @@
 
 void file_entry::load(std::istream & is, const version & version) {
 	
-	(void)enum_names<file_copy_mode>::names;
+	USE_ENUM_NAMES(file_copy_mode)
 	
 	options = 0;
 	
 	if(version < INNO_VERSION(1, 3, 21)) {
-		::load<uint32_t>(is); // uncompressed size of the file entry structure
+		(void)util::load<boost::uint32_t>(is); // uncompressed size of the entry
 	}
 	
-	is >> encoded_string(source, version.codepage());
-	is >> encoded_string(destination, version.codepage());
-	is >> encoded_string(install_font_name, version.codepage());
+	is >> util::encoded_string(source, version.codepage());
+	is >> util::encoded_string(destination, version.codepage());
+	is >> util::encoded_string(install_font_name, version.codepage());
 	if(version >= INNO_VERSION(5, 2, 5)) {
-		is >> encoded_string(strong_assembly_name, version.codepage());
+		is >> util::encoded_string(strong_assembly_name, version.codepage());
 	} else {
 		strong_assembly_name.clear();
 	}
@@ -93,10 +93,10 @@
 	
 	load_version_data(is, version);
 	
-	location = load_number<uint32_t>(is, version.bits);
-	attributes = load_number<uint32_t>(is, version.bits);
-	external_size = (version >= INNO_VERSION(4, 0, 0)) ? load_number<uint64_t>(is)
-	                                                  : load_number<uint32_t>(is);
+	location = util::load<boost::uint32_t>(is, version.bits);
+	attributes = util::load<boost::uint32_t>(is, version.bits);
+	external_size = (version >= INNO_VERSION(4, 0, 0)) ? util::load<boost::uint64_t>(is)
+	                                                   : util::load<boost::uint32_t>(is);
 	
 	if(version < INNO_VERSION(3, 0, 5)) {
 		file_copy_mode copyMode = stored_enum<stored_file_copy_mode>(is).get();
@@ -109,82 +109,82 @@
 	}
 	
 	if(version >= INNO_VERSION(4, 1, 0)) {
-		permission = load_number<int16_t>(is);
+		permission = util::load<boost::int16_t>(is);
 	} else {
 		permission = -1;
 	}
 	
-	stored_flag_reader<flags> flags(is, version.bits);
+	stored_flag_reader<flags> flagreader(is, version.bits);
 	
-	flags.add(ConfirmOverwrite);
-	flags.add(NeverUninstall);
-	flags.add(RestartReplace);
-	flags.add(DeleteAfterInstall);
+	flagreader.add(ConfirmOverwrite);
+	flagreader.add(NeverUninstall);
+	flagreader.add(RestartReplace);
+	flagreader.add(DeleteAfterInstall);
 	if(version.bits != 16) {
-		flags.add(RegisterServer);
-		flags.add(RegisterTypeLib);
-		flags.add(SharedFile);
+		flagreader.add(RegisterServer);
+		flagreader.add(RegisterTypeLib);
+		flagreader.add(SharedFile);
 	}
 	if(version < INNO_VERSION(2, 0, 0)) {
-		flags.add(IsReadmeFile);
+		flagreader.add(IsReadmeFile);
 	}
-	flags.add(CompareTimeStamp);
-	flags.add(FontIsNotTrueType);
-	flags.add(SkipIfSourceDoesntExist);
-	flags.add(OverwriteReadOnly);
+	flagreader.add(CompareTimeStamp);
+	flagreader.add(FontIsNotTrueType);
+	flagreader.add(SkipIfSourceDoesntExist);
+	flagreader.add(OverwriteReadOnly);
 	if(version >= INNO_VERSION(1, 3, 21)) {
-		flags.add(OverwriteSameVersion);
-		flags.add(CustomDestName);
+		flagreader.add(OverwriteSameVersion);
+		flagreader.add(CustomDestName);
 	}
 	if(version >= INNO_VERSION(1, 3, 25)) {
-		flags.add(OnlyIfDestFileExists);
+		flagreader.add(OnlyIfDestFileExists);
 	}
 	if(version >= INNO_VERSION(2, 0, 5)) {
-		flags.add(NoRegError);
+		flagreader.add(NoRegError);
 	}
 	if(version >= INNO_VERSION(3, 0, 1)) {
-		flags.add(UninsRestartDelete);
+		flagreader.add(UninsRestartDelete);
 	}
 	if(version >= INNO_VERSION(3, 0, 5)) {
-		flags.add(OnlyIfDoesntExist);
-		flags.add(IgnoreVersion);
-		flags.add(PromptIfOlder);
+		flagreader.add(OnlyIfDoesntExist);
+		flagreader.add(IgnoreVersion);
+		flagreader.add(PromptIfOlder);
 	}
 	if(version >= INNO_VERSION_EXT(3, 0, 6, 1)) {
-		flags.add(DontCopy);
+		flagreader.add(DontCopy);
 	}
 	if(version >= INNO_VERSION(4, 0, 5)) {
-		flags.add(UninsRemoveReadOnly);
+		flagreader.add(UninsRemoveReadOnly);
 	}
 	if(version >= INNO_VERSION(4, 1, 8)) {
-		flags.add(RecurseSubDirsExternal);
+		flagreader.add(RecurseSubDirsExternal);
 	}
 	if(version >= INNO_VERSION(4, 2, 1)) {
-		flags.add(ReplaceSameVersionIfContentsDiffer);
+		flagreader.add(ReplaceSameVersionIfContentsDiffer);
 	}
 	if(version >= INNO_VERSION(4, 2, 5)) {
-		flags.add(DontVerifyChecksum);
+		flagreader.add(DontVerifyChecksum);
 	}
 	if(version >= INNO_VERSION(5, 0, 3)) {
-		flags.add(UninsNoSharedFilePrompt);
+		flagreader.add(UninsNoSharedFilePrompt);
 	}
 	if(version >= INNO_VERSION(5, 1, 0)) {
-		flags.add(CreateAllSubDirs);
+		flagreader.add(CreateAllSubDirs);
 	}
 	if(version >= INNO_VERSION(5, 1, 2)) {
-		flags.add(Bits32);
-		flags.add(Bits64);
+		flagreader.add(Bits32);
+		flagreader.add(Bits64);
 	}
 	if(version >= INNO_VERSION(5, 2, 0)) {
-		flags.add(ExternalSizePreset);
-		flags.add(SetNtfsCompression);
-		flags.add(UnsetNtfsCompression);
+		flagreader.add(ExternalSizePreset);
+		flagreader.add(SetNtfsCompression);
+		flagreader.add(UnsetNtfsCompression);
 	}
 	if(version >= INNO_VERSION(5, 2, 5)) {
-		flags.add(GacInstall);
+		flagreader.add(GacInstall);
 	}
 	
-	options |= flags;
+	options |= flagreader;
 	
 	if(version.bits == 16 || version >= INNO_VERSION(5, 0, 0)) {
 		type = stored_enum<stored_file_type_0>(is).get();
diff -Nru innoextract-1.3/src/setup/file.hpp innoextract-1.4/src/setup/file.hpp
--- innoextract-1.3/src/setup/file.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/file.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -21,10 +21,11 @@
 #ifndef INNOEXTRACT_SETUP_FILE_HPP
 #define INNOEXTRACT_SETUP_FILE_HPP
 
-#include <stdint.h>
 #include <string>
 #include <iosfwd>
 
+#include <boost/cstdint.hpp>
+
 #include "setup/item.hpp"
 #include "util/enum.hpp"
 #include "util/flags.hpp"
@@ -85,9 +86,9 @@
 	std::string install_font_name;
 	std::string strong_assembly_name;
 	
-	uint32_t location; //!< index into the data entry list
-	uint32_t attributes;
-	uint64_t external_size;
+	boost::uint32_t location; //!< index into the data entry list
+	boost::uint32_t attributes;
+	boost::uint64_t external_size;
 	
 	int permission; //!< index into the permission entry list
 	
diff -Nru innoextract-1.3/src/setup/filename.cpp innoextract-1.4/src/setup/filename.cpp
--- innoextract-1.3/src/setup/filename.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/filename.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012 Daniel Scharrer
+ * Copyright (C) 2012-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -20,94 +20,132 @@
 
 #include "setup/filename.hpp"
 
+#include <stddef.h>
 #include <algorithm>
 #include <cctype>
 
-#include "util/log.hpp"
-
-using std::string;
-namespace fs = boost::filesystem;
-
 namespace setup {
 
-const string & filename_map::lookup(const string & key) const {
-	std::map<string, string>::const_iterator i = find(key);
+#if defined(_WIN32)
+static const char path_sep = '\\';
+#else
+static const char path_sep = '/';
+#endif
+
+const std::string & filename_map::lookup(const std::string & key) const {
+	std::map<std::string, std::string>::const_iterator i = find(key);
 	return (i == end()) ? key : i->second;
 }
 
-fs::path filename_map::convert(const string & name) const {
+std::string filename_map::expand_variables(it & begin, it end, bool close) const {
 	
-	size_t start = 0;
-	string buffer;
-	fs::path result;
-	
-	while(true) {
-		
-		size_t pos = name.find_first_of("{\\", start);
-		
-		if(pos == string::npos || name[pos] == '\\') {
-			
-			// Directory segment without constant
-			
-			size_t n = (pos == string::npos) ? string::npos : pos - start;
-			string segment = name.substr(start, n);
-			
-			if(lowercase) {
-				std::transform(segment.begin(), segment.end(), segment.begin(), ::tolower);
-			}
-			
-			if(buffer.empty()) {
-				result /= segment;
-			} else {
-				result /= buffer + segment;
-				buffer.clear();
-			}
-			
-			if(pos == string::npos) {
-				return result;
-			}
-			
-			start = pos + 1;
-			
-		} else {
-			
-			// Constant or escape sequence
-			
-			string segment = name.substr(start, pos - start);
-			if(lowercase) {
-				std::transform(segment.begin(), segment.end(), segment.begin(), ::tolower);
-			}
-			buffer += segment;
-			
-			if(pos + 1 < name.length() && name[pos + 1] == '{') {
-				
-				// Handle '{{' escape sequence
-				buffer += '{';
-				start = pos + 2;
-				
-			} else {
-				
-				// Handle nested constants.
-				size_t count = 1;
-				size_t end = pos;
-				do {
-					end = name.find_first_of("}{", end + 1);
-					(name[end] == '}') ? count-- : count++;
-				} while(count > 0 && end != string::npos);
-				
-				if(end == string::npos) {
-					start = pos + 1;
-				} else {
-					string key = name.substr(pos + 1, end - pos - 1);
-					std::transform(key.begin(), key.end(), key.begin(), ::tolower);
-					buffer += lookup(key);
-					start = end + 1;
-				}
-				
+	std::string result;
+	result.reserve(size_t(end - begin));
+	
+	while(begin != end) {
+		
+		// Flush everything before the next bracket
+		it pos = begin;
+		while(pos != end && *pos != '{' && *pos != '}') {
+			pos++;
+		}
+		result.append(begin, pos);
+		begin = pos;
+		
+		if(pos == end) {
+			// No more variables or escape sequences
+			break;
+		}
+		
+		begin++;
+		
+		if(close && *pos == '}') {
+			// Current context closed
+			break;
+		}
+		
+		if(!close && *pos == '}') {
+			// literal '}' character
+			result.push_back('}');
+			continue;
+		}
+		
+		// '{{' escape sequence
+		if(begin != end && *begin == '{') {
+			result.push_back('{');
+			begin++;
+			continue;
+		}
+		
+		// Recursively expand variables until we reach the end of this context
+		result.append(lookup(expand_variables(begin, end, true)));
+	}
+	
+	return result;
+}
+
+std::string filename_map::shorten_path(const std::string & path) const {
+	
+	std::string result;
+	result.reserve(path.size());
+	
+	it begin = path.begin();
+	it end = path.end();
+	while(begin != end) {
+		
+		it s_begin = begin;
+		it s_end = std::find(begin, end, '\\');
+		begin = (s_end == end) ? end : (s_end + 1);
+		
+		size_t segment_length = size_t(s_end - s_begin);
+		
+		// Empty segment - ignore
+		if(segment_length == 0) {
+			continue;
+		}
+		
+		// '.' segment - ignore
+		if(segment_length == 1 && *s_begin == '.') {
+			continue;
+		}
+		
+		// '..' segment - backtrace in result path
+		if(segment_length == 2 && *s_begin == '.' && *(s_begin + 1) == '.') {
+			size_t last_sep = result.find_last_of(path_sep);
+			if(last_sep == std::string::npos) {
+				last_sep = 0;
 			}
+			result.resize(last_sep);
+			continue;
 		}
 		
+		// Normal segment - append to the result path
+		if(!result.empty()) {
+			result.push_back(path_sep);
+		}
+		result.append(s_begin, s_end);
+		
 	}
+	
+	return result;
+}
+
+std::string filename_map::convert(std::string input) const {
+	
+	// Convert paths to lower-case if requested
+	if(lowercase) {
+		std::transform(input.begin(), input.end(), input.begin(), ::tolower);
+	}
+	
+	// Don't expand variables if requested
+	if(!expand) {
+		return input;
+	}
+	
+	it begin = input.begin();
+	std::string expanded = expand_variables(begin, input.end());
+	
+	return shorten_path(expanded);
 }
 
 } // namespace setup
diff -Nru innoextract-1.3/src/setup/filename.hpp innoextract-1.4/src/setup/filename.hpp
--- innoextract-1.3/src/setup/filename.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/filename.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012 Daniel Scharrer
+ * Copyright (C) 2012-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -18,29 +18,45 @@
  * 3. This notice may not be removed or altered from any source distribution.
  */
 
+/*!
+ * Map for converting between stored filenames and output filenames.
+ */
 #ifndef INNOEXTRACT_SETUP_FILENAME_MAP_HPP
 #define INNOEXTRACT_SETUP_FILENAME_MAP_HPP
 
 #include <string>
 #include <map>
-#include <boost/filesystem/path.hpp>
 
 namespace setup {
 
+/*!
+ * Map to convert between raw windows file paths stored in the setup file (which can
+ * contain variables) and output filenames.
+ */
 class filename_map : public std::map<std::string, std::string> {
 	
 	const std::string & lookup(const std::string & key) const;
 	
-public:
-	
 	bool lowercase;
+	bool expand;
 	
-	filename_map() : lowercase(false) { }
+	typedef std::string::const_iterator it;
 	
-	boost::filesystem::path convert(const std::string & name) const;
+	std::string expand_variables(it & begin, it end, bool close = false) const;
+	std::string shorten_path(const std::string & path) const;
 	
+public:
+	
+	filename_map() : lowercase(false), expand(false) { }
+	
+	std::string convert(std::string path) const;
+	
+	//! Set if paths should be converted to lower-case.
 	void set_lowercase(bool enable) { lowercase = enable; }
 	
+	//! Set if variables should be expanded and path separators converted.
+	void set_expand(bool enable) { expand = enable; }
+	
 };
 
 } // namespace setup
diff -Nru innoextract-1.3/src/setup/header.cpp innoextract-1.4/src/setup/header.cpp
--- innoextract-1.3/src/setup/header.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/header.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -128,106 +128,106 @@
 	options = 0;
 	
 	if(version < INNO_VERSION(1, 3, 21)) {
-		::load<uint32_t>(is); // uncompressed size of the setup header structure
+		(void)util::load<boost::uint32_t>(is); // uncompressed size of the setup header
 	}
 	
-	is >> encoded_string(app_name, version.codepage());
-	is >> encoded_string(app_versioned_name, version.codepage());
+	is >> util::encoded_string(app_name, version.codepage());
+	is >> util::encoded_string(app_versioned_name, version.codepage());
 	if(version >= INNO_VERSION(1, 3, 21)) {
-		is >> encoded_string(app_id, version.codepage());
+		is >> util::encoded_string(app_id, version.codepage());
 	}
-	is >> encoded_string(app_copyright, version.codepage());
+	is >> util::encoded_string(app_copyright, version.codepage());
 	if(version >= INNO_VERSION(1, 3, 21)) {
-		is >> encoded_string(app_publisher, version.codepage());
-		is >> encoded_string(app_publisher_url, version.codepage());
+		is >> util::encoded_string(app_publisher, version.codepage());
+		is >> util::encoded_string(app_publisher_url, version.codepage());
 	} else {
 		app_publisher.clear(), app_publisher_url.clear();
 	}
 	if(version >= INNO_VERSION(5, 1, 13)) {
-		is >> encoded_string(app_support_phone, version.codepage());
+		is >> util::encoded_string(app_support_phone, version.codepage());
 	} else {
 		app_support_phone.clear();
 	}
 	if(version >= INNO_VERSION(1, 3, 21)) {
-		is >> encoded_string(app_support_url, version.codepage());
-		is >> encoded_string(app_updates_url, version.codepage());
-		is >> encoded_string(app_version, version.codepage());
+		is >> util::encoded_string(app_support_url, version.codepage());
+		is >> util::encoded_string(app_updates_url, version.codepage());
+		is >> util::encoded_string(app_version, version.codepage());
 	} else {
 		app_support_url.clear(), app_updates_url.clear(), app_version.clear();
 	}
-	is >> encoded_string(default_dir_name, version.codepage());
-	is >> encoded_string(default_group_name, version.codepage());
+	is >> util::encoded_string(default_dir_name, version.codepage());
+	is >> util::encoded_string(default_group_name, version.codepage());
 	if(version < INNO_VERSION(3, 0, 0)) {
-		is >> ansi_string(uninstall_icon_name);
+		is >> util::ansi_string(uninstall_icon_name);
 	} else {
 		uninstall_icon_name.clear();
 	}
-	is >> encoded_string(base_filename, version.codepage());
+	is >> util::encoded_string(base_filename, version.codepage());
 	if(version >= INNO_VERSION(1, 3, 21)) {
 		if(version < INNO_VERSION(5, 2, 5)) {
-			is >> ansi_string(license_text);
-			is >> ansi_string(info_before);
-			is >> ansi_string(info_after);
+			is >> util::ansi_string(license_text);
+			is >> util::ansi_string(info_before);
+			is >> util::ansi_string(info_after);
 		}
-		is >> encoded_string(uninstall_files_dir, version.codepage());
-		is >> encoded_string(uninstall_name, version.codepage());
-		is >> encoded_string(uninstall_icon, version.codepage());
-		is >> encoded_string(app_mutex, version.codepage());
+		is >> util::encoded_string(uninstall_files_dir, version.codepage());
+		is >> util::encoded_string(uninstall_name, version.codepage());
+		is >> util::encoded_string(uninstall_icon, version.codepage());
+		is >> util::encoded_string(app_mutex, version.codepage());
 	} else {
 		license_text.clear(), info_before.clear(), info_after.clear();
 		uninstall_files_dir.clear(), uninstall_name.clear();
 		uninstall_icon.clear(), app_mutex.clear();
 	}
 	if(version >= INNO_VERSION(3, 0, 0)) {
-		is >> encoded_string(default_user_name, version.codepage());
-		is >> encoded_string(default_user_organisation, version.codepage());
+		is >> util::encoded_string(default_user_name, version.codepage());
+		is >> util::encoded_string(default_user_organisation, version.codepage());
 	} else {
 		default_user_name.clear(), default_user_organisation.clear();
 	}
 	if(version >= INNO_VERSION_EXT(3, 0, 6, 1)) {
-		is >> encoded_string(default_serial, version.codepage());
+		is >> util::encoded_string(default_serial, version.codepage());
 		if(version < INNO_VERSION(5, 2, 5)) {
-			is >> binary_string(compiled_code);
+			is >> util::binary_string(compiled_code);
 		}
 	} else {
 		default_serial.clear(), compiled_code.clear();
 	}
 	if(version >= INNO_VERSION(4, 2, 4)) {
-		is >> encoded_string(app_readme_file, version.codepage());
-		is >> encoded_string(app_contact, version.codepage());
-		is >> encoded_string(app_comments, version.codepage());
-		is >> encoded_string(app_modify_path, version.codepage());
+		is >> util::encoded_string(app_readme_file, version.codepage());
+		is >> util::encoded_string(app_contact, version.codepage());
+		is >> util::encoded_string(app_comments, version.codepage());
+		is >> util::encoded_string(app_modify_path, version.codepage());
 	} else {
 		app_readme_file.clear(), app_contact.clear();
 		app_comments.clear(), app_modify_path.clear();
 	}
 	if(version >= INNO_VERSION(5, 3, 8)) {
-		is >> encoded_string(create_uninstall_registry_key, version.codepage());
+		is >> util::encoded_string(create_uninstall_registry_key, version.codepage());
 	} else {
 		create_uninstall_registry_key.clear();
 	}
 	if(version >= INNO_VERSION(5, 3, 10)) {
-		is >> encoded_string(uninstallable, version.codepage());
+		is >> util::encoded_string(uninstallable, version.codepage());
 	} else {
 		uninstallable.clear();
 	}
 	if(version >= INNO_VERSION(5, 5, 0)) {
-		is >> encoded_string(close_applications_filter, version.codepage());
+		is >> util::encoded_string(close_applications_filter, version.codepage());
 	} else {
 		close_applications_filter.clear();
 	}
 	if(version >= INNO_VERSION(5, 2, 5)) {
-		is >> ansi_string(license_text);
-		is >> ansi_string(info_before);
-		is >> ansi_string(info_after);
+		is >> util::ansi_string(license_text);
+		is >> util::ansi_string(info_before);
+		is >> util::ansi_string(info_after);
 	}
 	if(version >= INNO_VERSION(5, 2, 1) && version < INNO_VERSION(5, 3, 10)) {
-		is >> binary_string(uninstaller_signature);
+		is >> util::binary_string(uninstaller_signature);
 	} else {
 		uninstaller_signature.clear();
 	}
 	if(version >= INNO_VERSION(5, 2, 5)) {
-		is >> binary_string(compiled_code);
+		is >> util::binary_string(compiled_code);
 	}
 	
 	if(version >= INNO_VERSION(2, 0, 6) && !version.unicode) {
@@ -237,7 +237,7 @@
 	}
 	
 	if(version >= INNO_VERSION(4, 0, 0)) {
-		language_count = load_number<uint32_t>(is);
+		language_count = util::load<boost::uint32_t>(is);
 	} else if(version >= INNO_VERSION(2, 0, 1)) {
 		language_count = 1;
 	} else {
@@ -245,78 +245,81 @@
 	}
 	
 	if(version >= INNO_VERSION(4, 2, 1)) {
-		message_count = load_number<uint32_t>(is);
+		message_count = util::load<boost::uint32_t>(is);
 	} else {
 		message_count = 0;
 	}
 	
 	if(version >= INNO_VERSION(4, 1, 0)) {
-		permission_count = load_number<uint32_t>(is);
+		permission_count = util::load<boost::uint32_t>(is);
 	} else {
 		permission_count = 0;
 	}
 	
 	if(version >= INNO_VERSION(2, 0, 0)) {
-		type_count = load_number<uint32_t>(is);
-		component_count = load_number<uint32_t>(is);
-		task_count = load_number<uint32_t>(is);
+		type_count = util::load<boost::uint32_t>(is);
+		component_count = util::load<boost::uint32_t>(is);
+		task_count = util::load<boost::uint32_t>(is);
 	} else {
 		type_count = 0, component_count = 0, task_count = 0;
 	}
 	
-	directory_count = load_number<uint32_t>(is, version.bits);
-	file_count = load_number<uint32_t>(is, version.bits);
-	data_entry_count = load_number<uint32_t>(is, version.bits);
-	icon_count = load_number<uint32_t>(is, version.bits);
-	ini_entry_count = load_number<uint32_t>(is, version.bits);
-	registry_entry_count = load_number<uint32_t>(is, version.bits);
-	delete_entry_count = load_number<uint32_t>(is, version.bits);
-	uninstall_delete_entry_count = load_number<uint32_t>(is, version.bits);
-	run_entry_count = load_number<uint32_t>(is, version.bits);
-	uninstall_run_entry_count = load_number<uint32_t>(is, version.bits);
-	
-	int32_t license_size = 0;
-	int32_t info_before_size = 0;
-	int32_t info_after_size = 0;
+	directory_count = util::load<boost::uint32_t>(is, version.bits);
+	file_count = util::load<boost::uint32_t>(is, version.bits);
+	data_entry_count = util::load<boost::uint32_t>(is, version.bits);
+	icon_count = util::load<boost::uint32_t>(is, version.bits);
+	ini_entry_count = util::load<boost::uint32_t>(is, version.bits);
+	registry_entry_count = util::load<boost::uint32_t>(is, version.bits);
+	delete_entry_count = util::load<boost::uint32_t>(is, version.bits);
+	uninstall_delete_entry_count = util::load<boost::uint32_t>(is, version.bits);
+	run_entry_count = util::load<boost::uint32_t>(is, version.bits);
+	uninstall_run_entry_count = util::load<boost::uint32_t>(is, version.bits);
+	
+	boost::int32_t license_size = 0;
+	boost::int32_t info_before_size = 0;
+	boost::int32_t info_after_size = 0;
 	if(version < INNO_VERSION(1, 3, 21)) {
-		license_size = load_number<int32_t>(is, version.bits);
-		info_before_size = load_number<int32_t>(is, version.bits);
-		info_after_size = load_number<int32_t>(is, version.bits);
+		license_size = util::load<boost::int32_t>(is, version.bits);
+		info_before_size = util::load<boost::int32_t>(is, version.bits);
+		info_after_size = util::load<boost::int32_t>(is, version.bits);
 	}
 	
 	winver.load(is, version);
 	
-	back_color = load_number<uint32_t>(is);
+	back_color = util::load<boost::uint32_t>(is);
 	if(version >= INNO_VERSION(1, 3, 21)) {
-		back_color2 = load_number<uint32_t>(is);
+		back_color2 = util::load<boost::uint32_t>(is);
 	} else {
 		back_color2 = 0;
 	}
-	image_back_color = load_number<uint32_t>(is);
+	image_back_color = util::load<boost::uint32_t>(is);
 	if(version >= INNO_VERSION(2, 0, 0) && version < INNO_VERSION(5, 0, 4)) {
-		small_image_back_color = load_number<uint32_t>(is);
+		small_image_back_color = util::load<boost::uint32_t>(is);
 	} else {
 		small_image_back_color = 0;
 	}
 	
 	if(version < INNO_VERSION(4, 2, 0)) {
-		password.crc32 = load_number<uint32_t>(is), password.type = crypto::CRC32;
+		password.crc32 = util::load<boost::uint32_t>(is);
+		password.type = crypto::CRC32;
 	} else if(version < INNO_VERSION(5, 3, 9)) {
-		is.read(password.md5, sizeof(password.md5)), password.type = crypto::MD5;
+		is.read(password.md5, std::streamsize(sizeof(password.md5)));
+		password.type = crypto::MD5;
 	} else {
-		is.read(password.sha1, sizeof(password.sha1)), password.type = crypto::SHA1;
+		is.read(password.sha1, std::streamsize(sizeof(password.sha1)));
+		password.type = crypto::SHA1;
 	}
 	if(version >= INNO_VERSION(4, 2, 2)) {
-		is.read(password_salt, sizeof(password_salt));
+		is.read(password_salt, std::streamsize(sizeof(password_salt)));
 	} else {
 		memset(password_salt, 0, sizeof(password_salt));
 	}
 	
 	if(version >= INNO_VERSION(4, 0, 0)) {
-		extra_disk_space_required = load_number<int64_t>(is);
-		slices_per_disk = load_number<uint32_t>(is);
+		extra_disk_space_required = util::load<boost::int64_t>(is);
+		slices_per_disk = util::load<boost::uint32_t>(is);
 	} else {
-		extra_disk_space_required = load_number<int32_t>(is);
+		extra_disk_space_required = util::load<boost::int32_t>(is);
 		slices_per_disk = 1;
 	}
 	
@@ -383,8 +386,8 @@
 	}
 	
 	if(version >= INNO_VERSION(5, 2, 1) && version < INNO_VERSION(5, 3, 10)) {
-		signed_uninstaller_original_size = load_number<uint32_t>(is);
-		signed_uninstaller_header_checksum = load_number<uint32_t>(is);
+		signed_uninstaller_original_size = util::load<boost::uint32_t>(is);
+		signed_uninstaller_header_checksum = util::load<boost::uint32_t>(is);
 	} else {
 		signed_uninstaller_original_size = signed_uninstaller_header_checksum = 0;
 	}
@@ -395,150 +398,150 @@
 	}
 	
 	if(version >= INNO_VERSION(5, 5, 0)) {
-		uninstall_display_size = load_number<uint64_t>(is);
+		uninstall_display_size = util::load<boost::uint64_t>(is);
 	} else if(version >= INNO_VERSION(5, 3, 6)) {
-		uninstall_display_size = load_number<uint32_t>(is);
+		uninstall_display_size = util::load<boost::uint32_t>(is);
 	} else {
 		uninstall_display_size = 0;
 	}
 	
 	
-	stored_flag_reader<flags> flags(is, version.bits);
+	stored_flag_reader<flags> flagreader(is, version.bits);
 	
-	flags.add(DisableStartupPrompt);
+	flagreader.add(DisableStartupPrompt);
 	if(version < INNO_VERSION(5, 3, 10)) {
-		flags.add(Uninstallable);
+		flagreader.add(Uninstallable);
 	}
-	flags.add(CreateAppDir);
+	flagreader.add(CreateAppDir);
 	if(version < INNO_VERSION(5, 3, 3)) {
-		flags.add(DisableDirPage);
+		flagreader.add(DisableDirPage);
 	}
 	if(version < INNO_VERSION(1, 3, 21)) {
-		flags.add(DisableDirExistsWarning);
+		flagreader.add(DisableDirExistsWarning);
 	}
 	if(version < INNO_VERSION(5, 3, 3)) {
-		flags.add(DisableProgramGroupPage);
+		flagreader.add(DisableProgramGroupPage);
 	}
-	flags.add(AllowNoIcons);
+	flagreader.add(AllowNoIcons);
 	if(version < INNO_VERSION(3, 0, 0) || version >= INNO_VERSION(3, 0, 3)) {
-		flags.add(AlwaysRestart);
+		flagreader.add(AlwaysRestart);
 	}
 	if(version < INNO_VERSION(1, 3, 21)) {
-		flags.add(BackSolid);
+		flagreader.add(BackSolid);
 	}
-	flags.add(AlwaysUsePersonalGroup);
-	flags.add(WindowVisible);
-	flags.add(WindowShowCaption);
-	flags.add(WindowResizable);
-	flags.add(WindowStartMaximized);
-	flags.add(EnableDirDoesntExistWarning);
+	flagreader.add(AlwaysUsePersonalGroup);
+	flagreader.add(WindowVisible);
+	flagreader.add(WindowShowCaption);
+	flagreader.add(WindowResizable);
+	flagreader.add(WindowStartMaximized);
+	flagreader.add(EnableDirDoesntExistWarning);
 	if(version < INNO_VERSION(4, 1, 2)) {
-		flags.add(DisableAppendDir);
+		flagreader.add(DisableAppendDir);
 	}
-	flags.add(Password);
-	flags.add(AllowRootDirectory);
-	flags.add(DisableFinishedPage);
+	flagreader.add(Password);
+	flagreader.add(AllowRootDirectory);
+	flagreader.add(DisableFinishedPage);
 	if(version.bits != 16) {
 		if(version < INNO_VERSION(3, 0, 4)) {
-			flags.add(AdminPrivilegesRequired);
+			flagreader.add(AdminPrivilegesRequired);
 		}
 		if(version < INNO_VERSION(3, 0, 0)) {
-			flags.add(AlwaysCreateUninstallIcon);
+			flagreader.add(AlwaysCreateUninstallIcon);
 		}
 		if(version < INNO_VERSION(1, 3, 21)) {
-			flags.add(OverwriteUninstRegEntries);
+			flagreader.add(OverwriteUninstRegEntries);
 		}
-		flags.add(ChangesAssociations);
+		flagreader.add(ChangesAssociations);
 	}
 	if(version >= INNO_VERSION(1, 3, 21)) {
 		if(version < INNO_VERSION(5, 3, 8)) {
-			flags.add(CreateUninstallRegKey);
+			flagreader.add(CreateUninstallRegKey);
 		}
-		flags.add(UsePreviousAppDir);
-		flags.add(BackColorHorizontal);
-		flags.add(UsePreviousGroup);
-		flags.add(UpdateUninstallLogAppName);
+		flagreader.add(UsePreviousAppDir);
+		flagreader.add(BackColorHorizontal);
+		flagreader.add(UsePreviousGroup);
+		flagreader.add(UpdateUninstallLogAppName);
 	}
 	if(version >= INNO_VERSION(2, 0, 0)) {
-		flags.add(UsePreviousSetupType);
-		flags.add(DisableReadyMemo);
-		flags.add(AlwaysShowComponentsList);
-		flags.add(FlatComponentsList);
-		flags.add(ShowComponentSizes);
-		flags.add(UsePreviousTasks);
-		flags.add(DisableReadyPage);
+		flagreader.add(UsePreviousSetupType);
+		flagreader.add(DisableReadyMemo);
+		flagreader.add(AlwaysShowComponentsList);
+		flagreader.add(FlatComponentsList);
+		flagreader.add(ShowComponentSizes);
+		flagreader.add(UsePreviousTasks);
+		flagreader.add(DisableReadyPage);
 	}
 	if(version >= INNO_VERSION(2, 0, 7)) {
-		flags.add(AlwaysShowDirOnReadyPage);
-		flags.add(AlwaysShowGroupOnReadyPage);
+		flagreader.add(AlwaysShowDirOnReadyPage);
+		flagreader.add(AlwaysShowGroupOnReadyPage);
 	}
 	if(version >= INNO_VERSION(2, 0, 17) && version < INNO_VERSION(4, 1, 5)) {
-		flags.add(BzipUsed);
+		flagreader.add(BzipUsed);
 	}
 	if(version >= INNO_VERSION(2, 0, 18)) {
-		flags.add(AllowUNCPath);
+		flagreader.add(AllowUNCPath);
 	}
 	if(version >= INNO_VERSION(3, 0, 0)) {
-		flags.add(UserInfoPage);
-		flags.add(UsePreviousUserInfo);
+		flagreader.add(UserInfoPage);
+		flagreader.add(UsePreviousUserInfo);
 	}
 	if(version >= INNO_VERSION(3, 0, 1)) {
-		flags.add(UninstallRestartComputer);
+		flagreader.add(UninstallRestartComputer);
 	}
 	if(version >= INNO_VERSION(3, 0, 3)) {
-		flags.add(RestartIfNeededByRun);
+		flagreader.add(RestartIfNeededByRun);
 	}
 	if(version >= INNO_VERSION_EXT(3, 0, 6, 1)) {
-		flags.add(ShowTasksTreeLines);
+		flagreader.add(ShowTasksTreeLines);
 	}
 	if(version >= INNO_VERSION(4, 0, 0) && version < INNO_VERSION(4, 0, 10)) {
-		flags.add(ShowLanguageDialog);
+		flagreader.add(ShowLanguageDialog);
 	}
 	if(version >= INNO_VERSION(4, 0, 1) && version < INNO_VERSION(4, 0, 10)) {
-		flags.add(DetectLanguageUsingLocale);
+		flagreader.add(DetectLanguageUsingLocale);
 	}
 	if(version >= INNO_VERSION(4, 0, 9)) {
-		flags.add(AllowCancelDuringInstall);
+		flagreader.add(AllowCancelDuringInstall);
 	} else {
 		options |= AllowCancelDuringInstall;
 	}
 	if(version >= INNO_VERSION(4, 1, 3)) {
-		flags.add(WizardImageStretch);
+		flagreader.add(WizardImageStretch);
 	}
 	if(version >= INNO_VERSION(4, 1, 8)) {
-		flags.add(AppendDefaultDirName);
-		flags.add(AppendDefaultGroupName);
+		flagreader.add(AppendDefaultDirName);
+		flagreader.add(AppendDefaultGroupName);
 	}
 	if(version >= INNO_VERSION(4, 2, 2)) {
-		flags.add(EncryptionUsed);
+		flagreader.add(EncryptionUsed);
 	}
 	if(version >= INNO_VERSION(5, 0, 4)) {
-		flags.add(ChangesEnvironment);
+		flagreader.add(ChangesEnvironment);
 	}
 	if(version >= INNO_VERSION(5, 1, 7) && !version.unicode) {
-		flags.add(ShowUndisplayableLanguages);
+		flagreader.add(ShowUndisplayableLanguages);
 	}
 	if(version >= INNO_VERSION(5, 1, 13)) {
-		flags.add(SetupLogging);
+		flagreader.add(SetupLogging);
 	}
 	if(version >= INNO_VERSION(5, 2, 1)) {
-		flags.add(SignedUninstaller);
+		flagreader.add(SignedUninstaller);
 	}
 	if(version >= INNO_VERSION(5, 3, 8)) {
-		flags.add(UsePreviousLanguage);
+		flagreader.add(UsePreviousLanguage);
 	}
 	if(version >= INNO_VERSION(5, 3, 9)) {
-		flags.add(DisableWelcomePage);
+		flagreader.add(DisableWelcomePage);
 	}
 	if(version >= INNO_VERSION(5, 5, 0)) {
-		flags.add(CloseApplications);
-		flags.add(RestartApplications);
-		flags.add(AllowNetworkDrive);
+		flagreader.add(CloseApplications);
+		flagreader.add(RestartApplications);
+		flagreader.add(AllowNetworkDrive);
 	} else {
 		options |= AllowNetworkDrive;
 	}
 	
-	options |= flags;
+	options |= flagreader;
 	
 	if(version < INNO_VERSION(3, 0, 4)) {
 		privileges_required = (options & AdminPrivilegesRequired) ? AdminPriviliges : NoPrivileges;
@@ -563,19 +566,19 @@
 			std::string temp;
 			temp.resize(size_t(license_size));
 			is.read(&temp[0], license_size);
-			to_utf8(temp, license_text);
+			util::to_utf8(temp, license_text);
 		}
 		if(info_before_size > 0) {
 			std::string temp;
 			temp.resize(size_t(info_before_size));
 			is.read(&temp[0], info_before_size);
-			to_utf8(temp, info_before);
+			util::to_utf8(temp, info_before);
 		}
 		if(info_after_size > 0) {
 			std::string temp;
 			temp.resize(size_t(info_after_size));
 			is.read(&temp[0], info_after_size);
-			to_utf8(temp, info_after);
+			util::to_utf8(temp, info_after);
 		}
 	}
 	
diff -Nru innoextract-1.3/src/setup/header.hpp innoextract-1.4/src/setup/header.hpp
--- innoextract-1.3/src/setup/header.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/header.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -21,12 +21,13 @@
 #ifndef INNOEXTRACT_SETUP_HEADER_HPP
 #define INNOEXTRACT_SETUP_HEADER_HPP
 
-#include <stdint.h>
 #include <stddef.h>
 #include <bitset>
 #include <string>
 #include <iosfwd>
 
+#include <boost/cstdint.hpp>
+
 #include "crypto/checksum.hpp"
 #include "setup/windows.hpp"
 #include "stream/chunk.hpp"
@@ -171,7 +172,7 @@
 	
 	windows_version_range winver;
 	
-	typedef uint32_t Color;
+	typedef boost::uint32_t Color;
 	Color back_color;
 	Color back_color2;
 	Color image_back_color;
@@ -180,7 +181,7 @@
 	crypto::checksum password;
 	salt password_salt;
 	
-	int64_t extra_disk_space_required;
+	boost::int64_t extra_disk_space_required;
 	size_t slices_per_disk;
 	
 	enum install_verbosity {
@@ -233,13 +234,13 @@
 	architecture_types architectures_allowed;
 	architecture_types architectures_installed_in_64bit_mode;
 	
-	uint32_t signed_uninstaller_original_size;
-	uint32_t signed_uninstaller_header_checksum;
+	boost::uint32_t signed_uninstaller_original_size;
+	boost::uint32_t signed_uninstaller_header_checksum;
 	
 	auto_bool disable_dir_page;
 	auto_bool disable_program_group_page;
 	
-	uint64_t uninstall_display_size;
+	boost::uint64_t uninstall_display_size;
 	
 	flags options;
 	
diff -Nru innoextract-1.3/src/setup/icon.cpp innoextract-1.4/src/setup/icon.cpp
--- innoextract-1.3/src/setup/icon.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/icon.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -39,62 +39,62 @@
 void icon_entry::load(std::istream & is, const version & version) {
 	
 	if(version < INNO_VERSION(1, 3, 21)) {
-		::load<uint32_t>(is); // uncompressed size of the icon entry structure
+		(void)util::load<boost::uint32_t>(is); // uncompressed size of the entry
 	}
 	
-	is >> encoded_string(name, version.codepage());
-	is >> encoded_string(filename, version.codepage());
-	is >> encoded_string(parameters, version.codepage());
-	is >> encoded_string(working_dir, version.codepage());
-	is >> encoded_string(icon_file, version.codepage());
-	is >> encoded_string(comment, version.codepage());
+	is >> util::encoded_string(name, version.codepage());
+	is >> util::encoded_string(filename, version.codepage());
+	is >> util::encoded_string(parameters, version.codepage());
+	is >> util::encoded_string(working_dir, version.codepage());
+	is >> util::encoded_string(icon_file, version.codepage());
+	is >> util::encoded_string(comment, version.codepage());
 	
 	load_condition_data(is, version);
 	
 	if(version >= INNO_VERSION(5, 3, 5)) {
-		is >> encoded_string(app_user_model_id, version.codepage());
+		is >> util::encoded_string(app_user_model_id, version.codepage());
 	} else {
 		app_user_model_id.clear();
 	}
 	
 	load_version_data(is, version);
 	
-	icon_index = load_number<int32_t>(is, version.bits);
+	icon_index = util::load<boost::int32_t>(is, version.bits);
 	
 	if(version >= INNO_VERSION(1, 3, 21)) {
-		show_command = load_number<int32_t>(is);
+		show_command = util::load<boost::int32_t>(is);
 		close_on_exit = stored_enum<stored_close_setting>(is).get();
 	} else {
 		show_command = 1, close_on_exit = NoSetting;
 	}
 	
 	if(version >= INNO_VERSION(2, 0, 7)) {
-		hotkey = load_number<uint16_t>(is);
+		hotkey = util::load<boost::uint16_t>(is);
 	} else {
 		hotkey = 0;
 	}
 	
-	stored_flag_reader<flags> flags(is, version.bits);
+	stored_flag_reader<flags> flagreader(is, version.bits);
 	
-	flags.add(NeverUninstall);
+	flagreader.add(NeverUninstall);
 	if(version >= INNO_VERSION(1, 3, 21)) {
-		flags.add(RunMinimized);
+		flagreader.add(RunMinimized);
 	}
-	flags.add(CreateOnlyIfFileExists);
+	flagreader.add(CreateOnlyIfFileExists);
 	if(version.bits != 16) {
-		flags.add(UseAppPaths);
+		flagreader.add(UseAppPaths);
 	}
 	if(version >= INNO_VERSION(5, 0, 3)) {
-		flags.add(FolderShortcut);
+		flagreader.add(FolderShortcut);
 	}
 	if(version >= INNO_VERSION(5, 4, 2)) {
-		flags.add(ExcludeFromShowInNewInstall);
+		flagreader.add(ExcludeFromShowInNewInstall);
 	}
 	if(version >= INNO_VERSION(5, 5, 0)) {
-		flags.add(PreventPinning);
+		flagreader.add(PreventPinning);
 	}
 	
-	options = flags;
+	options = flagreader;
 }
 
 } // namespace setup
diff -Nru innoextract-1.3/src/setup/icon.hpp innoextract-1.4/src/setup/icon.hpp
--- innoextract-1.3/src/setup/icon.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/icon.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -21,10 +21,11 @@
 #ifndef INNOEXTRACT_SETUP_ICON_HPP
 #define INNOEXTRACT_SETUP_ICON_HPP
 
-#include <stdint.h>
 #include <string>
 #include <iosfwd>
 
+#include <boost/cstdint.hpp>
+
 #include "setup/item.hpp"
 #include "util/enum.hpp"
 #include "util/flags.hpp"
@@ -66,7 +67,7 @@
 	
 	close_setting close_on_exit;
 	
-	uint16_t hotkey;
+	boost::uint16_t hotkey;
 	
 	flags options;
 	
diff -Nru innoextract-1.3/src/setup/info.cpp innoextract-1.4/src/setup/info.cpp
--- innoextract-1.3/src/setup/info.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/info.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -48,52 +48,98 @@
 
 namespace {
 
+struct no_arg { };
+
+template <class Entry, class Arg>
+static void load_entry(std::istream & is, const setup::version & version,
+                       Entry & entity, Arg arg) {
+	entity.load(is, version, arg);
+}
 template <class Entry>
+static void load_entry(std::istream & is, const setup::version & version,
+                                    Entry & entity, no_arg arg) {
+	(void)arg;
+	entity.load(is, version);
+}
+
+template <class Entry, class Arg>
 static void load_entries(std::istream & is, const setup::version & version,
                   info::entry_types entry_types, size_t count,
-                  std::vector<Entry> & entries, info::entry_types::enum_type entry_type) {
+                  std::vector<Entry> & entries, info::entry_types::enum_type entry_type,
+                  Arg arg = Arg()) {
 	
+	entries.clear();
 	if(entry_types & entry_type) {
 		entries.resize(count);
 		for(size_t i = 0; i < count; i++) {
 			Entry & entry = entries[i];
-			entry.load(is, version);
+			load_entry(is, version, entry, arg);
 		}
 	} else {
 		for(size_t i = 0; i < count; i++) {
 			Entry entry;
-			entry.load(is, version);
+			load_entry(is, version, entry, arg);
 		}
 	}
 }
 
+template <class Entry>
+static void load_entries(std::istream & is, const setup::version & version,
+                  info::entry_types entry_types, size_t count,
+                  std::vector<Entry> & entries, info::entry_types::enum_type entry_type) {
+	load_entries<Entry, no_arg>(is, version, entry_types, count, entries, entry_type);
+}
+
 static void load_wizard_and_decompressor(std::istream & is, const setup::version & version,
                                         const setup::header & header,
                                         setup::info & info, info::entry_types entries) {
 	
 	(void)entries;
 	
-	is >> binary_string(info.wizard_image);
-	
-	if(version >= INNO_VERSION(2, 0, 0)) {
-		is >> binary_string(info.wizard_image_small);
+	if(entries & (info::WizardImages | info::NoSkip)) {
+		is >> util::binary_string(info.wizard_image);
+		if(version >= INNO_VERSION(2, 0, 0)) {
+			is >> util::binary_string(info.wizard_image_small);
+		}
+	} else {
+		info.wizard_image.clear();
+		util::binary_string::skip(is);
+		info.wizard_image_small.clear();
+		if(version >= INNO_VERSION(2, 0, 0)) {
+			util::binary_string::skip(is);
+		}
 	}
 	
+	info.decompressor_dll.clear();
 	if(header.compression == stream::BZip2
 	   || (header.compression == stream::LZMA1 && version == INNO_VERSION(4, 1, 5))
 	   || (header.compression == stream::Zlib && version >= INNO_VERSION(4, 2, 6))) {
-		
-		is >> binary_string(info.decompressor_dll);
+		if(entries & (info::DecompressorDll | info::NoSkip)) {
+			is >> util::binary_string(info.decompressor_dll);
+		} else {
+			// decompressor dll - we don't need this
+			util::binary_string::skip(is);
+		}
 	}
 }
 
 } // anonymous namespace
 
+static void check_is_end(stream::block_reader::pointer & is) {
+	is->exceptions(std::ios_base::goodbit);
+	char dummy;
+	if(!is->get(dummy).eof()) {
+		throw std::ios_base::failure("expected end of stream");
+	}
+}
+
 void info::load(std::istream & ifs, entry_types e, const setup::version & v) {
 	
+	if(e & (Messages|NoSkip)) {
+		e |= Languages;
+	}
+	
 	stream::block_reader::pointer is = stream::block_reader::get(ifs, v);
-	assert(is);
-	is->exceptions(std::ios_base::badbit | std::ios_base::failbit);
 	
 	header.load(*is, v);
 	
@@ -103,7 +149,7 @@
 		load_wizard_and_decompressor(*is, v, header, *this, e);
 	}
 	
-	load_entries(*is, v, e, header.message_count, messages, Messages);
+	load_entries(*is, v, e, header.message_count, messages, Messages, languages);
 	load_entries(*is, v, e, header.permission_count, permissions, Permissions);
 	load_entries(*is, v, e, header.type_count, types, Types);
 	load_entries(*is, v, e, header.component_count, components, Components);
@@ -124,42 +170,14 @@
 		load_wizard_and_decompressor(*is, v, header, *this, e);
 	}
 	
-	is->exceptions(std::ios_base::goodbit);
-	char dummy;
-	if(!is->get(dummy).eof()) {
-		throw std::ios_base::failure("expected end of stream");
-	}
-	
+	// restart the compression stream
+	check_is_end(is);
 	is = stream::block_reader::get(ifs, v);
-	assert(is);
-	is->exceptions(std::ios_base::badbit | std::ios_base::failbit);
 	
 	load_entries(*is, v, e, header.data_entry_count, data_entries, DataEntries);
 	
 	is->exceptions(std::ios_base::goodbit);
-	if(!is->get(dummy).eof()) {
-		throw std::ios_base::failure("expected end of stream");
-	}
-	
-	BOOST_FOREACH(setup::message_entry & entry, messages) {
-		
-		if(entry.language >= 0 ? size_t(entry.language) >= languages.size()
-		                       : entry.language != -1) {
-			log_warning << "unexpected language index: " << entry.language;
-			continue;
-		}
-		
-		uint32_t codepage;
-		if(entry.language < 0) {
-			codepage = v.codepage();
-		} else {
-			codepage = languages[size_t(entry.language)].codepage;
-		}
-		
-		std::string decoded;
-		to_utf8(entry.value, decoded, codepage);
-		entry.value = decoded;
-	}
+	check_is_end(is);
 }
 
 void info::load(std::istream & is, entry_types entries) {
@@ -171,11 +189,13 @@
 		            << color::white << version << color::reset;
 	}
 	
+	// Some setup versions didn't increment the data version number when they should have.
+	// To work around this, we try to parse the headers for both data versions.
 	bool ambiguous = version.is_ambiguous();
 	if(ambiguous) {
+		// Force parsing all headers so that we don't miss any errors.
 		entries |= NoSkip;
 	}
-	
 	if(!version.known || ambiguous) {
 		std::ios_base::streampos start = is.tellg();
 		try {
@@ -186,6 +206,7 @@
 			if(!version) {
 				throw;
 			}
+			is.clear();
 			is.seekg(start);
 		}
 	}
diff -Nru innoextract-1.3/src/setup/info.hpp innoextract-1.4/src/setup/info.hpp
--- innoextract-1.3/src/setup/info.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/info.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -18,6 +18,9 @@
  * 3. This notice may not be removed or altered from any source distribution.
  */
 
+/*!
+ * Central point to load all the different headers in the correct order.
+ */
 #ifndef INNOEXTRACT_SETUP_INFO_HPP
 #define INNOEXTRACT_SETUP_INFO_HPP
 
@@ -45,6 +48,9 @@
 struct task_entry;
 struct type_entry;
 
+/*!
+ * Class used to hold and load the various \ref setup headers.
+ */
 struct info {
 	
 	info();
@@ -76,30 +82,56 @@
 	
 	setup::header header;
 	
-	std::vector<component_entry> components;
-	std::vector<data_entry> data_entries;
-	std::vector<delete_entry> delete_entries;
-	std::vector<delete_entry> uninstall_delete_entries;
-	std::vector<directory_entry> directories;
-	std::vector<file_entry> files;
-	std::vector<icon_entry> icons;
-	std::vector<ini_entry> ini_entries;
-	std::vector<language_entry> languages;
-	std::vector<message_entry> messages;
-	std::vector<permission_entry> permissions;
-	std::vector<registry_entry> registry_entries;
-	std::vector<run_entry> run_entries;
-	std::vector<run_entry> uninstall_run_entries;
-	std::vector<task_entry> tasks;
-	std::vector<type_entry> types;
+	std::vector<component_entry>  components;               //! \c Components
+	std::vector<data_entry>       data_entries;             //! \c DataEntries
+	std::vector<delete_entry>     delete_entries;           //! \c DeleteEntries
+	std::vector<delete_entry>     uninstall_delete_entries; //! \c UninstallDeleteEntries
+	std::vector<directory_entry>  directories;              //! \c Directories
+	std::vector<file_entry>       files;                    //! \c Files
+	std::vector<icon_entry>       icons;                    //! \c Icons
+	std::vector<ini_entry>        ini_entries;              //! \c IniEntries
+	std::vector<language_entry>   languages;                //! \c Languages
+	std::vector<message_entry>    messages;                 //! \c Messages
+	std::vector<permission_entry> permissions;              //! \c Permissions
+	std::vector<registry_entry>   registry_entries;         //! \c RegistryEntries
+	std::vector<run_entry>        run_entries;              //! \c RunEntries
+	std::vector<run_entry>        uninstall_run_entries;    //! \c UninstallRunEntries
+	std::vector<task_entry>       tasks;                    //! \c Tasks
+	std::vector<type_entry>       types;                    //! \c Types
 	
+	//! Images displayed in the installer UI.
+	//! Loading enabled by \c WizardImages
 	std::string wizard_image;
 	std::string wizard_image_small;
 	
+	//! Contents of the helper DLL used to decompress setup data in some versions.
+	//! Loading enabled by \c DecompressorDll
 	std::string decompressor_dll;
 	
-	void load(std::istream & is, entry_types entries = setup::info::entry_types::all());
-	
+	/*!
+	 * Load setup headers.
+	 *
+	 * \param is      The input stream to load the setup headers from.
+	 *                It must already be positioned at start of \ref setup::version
+	 *                identifier whose position is given by
+	 *                \ref loader::offsets::header_offset.
+	 * \param entries What kinds of entries to load.
+	 */
+	void load(std::istream & is, entry_types entries);
+	
+	/*!
+	 * Load setup headers for a specific version.
+	 *
+	 * \param is      The input stream to load the setup headers from.
+	 *                It must already be positioned at start of the compressed headers.
+	 *                The compressed headers start directly after the \ref setup::version
+	 *                identifier whose position is given by
+	 *                \ref loader::offsets::header_offset.
+	 * \param entries What kinds of entries to load.
+	 * \param version The setup data version of the headers.
+	 *
+	 * This function does not set the \ref version member.
+	 */
 	void load(std::istream & is, entry_types entries, const setup::version & version);
 	
 };
diff -Nru innoextract-1.3/src/setup/ini.cpp innoextract-1.4/src/setup/ini.cpp
--- innoextract-1.3/src/setup/ini.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/ini.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -20,7 +20,7 @@
 
 #include "setup/ini.hpp"
 
-#include <stdint.h>
+#include <boost/cstdint.hpp>
 
 #include "setup/version.hpp"
 #include "util/load.hpp"
@@ -43,16 +43,16 @@
 void ini_entry::load(std::istream & is, const version & version) {
 	
 	if(version < INNO_VERSION(1, 3, 21)) {
-		::load<uint32_t>(is); // uncompressed size of the ini entry structure
+		(void)util::load<boost::uint32_t>(is); // uncompressed size of the entry
 	}
 	
-	is >> encoded_string(inifile, version.codepage());
+	is >> util::encoded_string(inifile, version.codepage());
 	if(inifile.empty()) {
 		inifile = "{windows}/WIN.INI";
 	}
-	is >> encoded_string(section, version.codepage());
-	is >> encoded_string(key, version.codepage());
-	is >> encoded_string(value, version.codepage());
+	is >> util::encoded_string(section, version.codepage());
+	is >> util::encoded_string(key, version.codepage());
+	is >> util::encoded_string(value, version.codepage());
 	
 	load_condition_data(is, version);
 	
diff -Nru innoextract-1.3/src/setup/item.cpp innoextract-1.4/src/setup/item.cpp
--- innoextract-1.3/src/setup/item.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/item.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -28,25 +28,25 @@
 void item::load_condition_data(std::istream & is, const version & version) {
 	
 	if(version >= INNO_VERSION(2, 0, 0)) {
-		is >> encoded_string(components, version.codepage());
-		is >> encoded_string(tasks, version.codepage());
+		is >> util::encoded_string(components, version.codepage());
+		is >> util::encoded_string(tasks, version.codepage());
 	} else {
 		components.clear(), tasks.clear();
 	}
 	if(version >= INNO_VERSION(4, 0, 1)) {
-		is >> encoded_string(languages, version.codepage());
+		is >> util::encoded_string(languages, version.codepage());
 	} else {
 		languages.clear();
 	}
 	if(version >= INNO_VERSION_EXT(3, 0, 6, 1)) {
-		is >> encoded_string(check, version.codepage());
+		is >> util::encoded_string(check, version.codepage());
 	} else {
 		check.clear();
 	}
 	
 	if(version >= INNO_VERSION(4, 1, 0)) {
-		is >> encoded_string(after_install, version.codepage());
-		is >> encoded_string(before_install, version.codepage());
+		is >> util::encoded_string(after_install, version.codepage());
+		is >> util::encoded_string(before_install, version.codepage());
 	} else {
 		after_install.clear(), before_install.clear();
 	}
diff -Nru innoextract-1.3/src/setup/item.hpp innoextract-1.4/src/setup/item.hpp
--- innoextract-1.3/src/setup/item.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/item.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -46,7 +46,7 @@
 	
 	void load_condition_data(std::istream & is, const version & version);
 	
-	inline void load_version_data(std::istream & is, const version & version) {
+	void load_version_data(std::istream & is, const version & version) {
 		winver.load(is, version);
 	}
 	
diff -Nru innoextract-1.3/src/setup/language.cpp innoextract-1.4/src/setup/language.cpp
--- innoextract-1.3/src/setup/language.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/language.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -28,34 +28,34 @@
 void language_entry::load(std::istream & is, const version & version) {
 	
 	if(version >= INNO_VERSION(4, 0, 0)) {
-		is >> encoded_string(name, version.codepage());
+		is >> util::encoded_string(name, version.codepage());
 	} else {
 		name = "default";
 	}
 	
-	is >> encoded_string(language_name, (version >= INNO_VERSION(4, 2, 2)) ? 1200u : 1252u);
+	is >> util::encoded_string(language_name, (version >= INNO_VERSION(4, 2, 2)) ? 1200u : 1252u);
 	
-	is >> encoded_string(dialog_font, version.codepage());
-	is >> encoded_string(title_font, version.codepage());
-	is >> encoded_string(welcome_font, version.codepage());
-	is >> encoded_string(copyright_font, version.codepage());
+	is >> util::encoded_string(dialog_font, version.codepage());
+	is >> util::encoded_string(title_font, version.codepage());
+	is >> util::encoded_string(welcome_font, version.codepage());
+	is >> util::encoded_string(copyright_font, version.codepage());
 	
 	if(version >= INNO_VERSION(4, 0, 0)) {
-		is >> binary_string(data);
+		is >> util::binary_string(data);
 	}
 	
 	if(version >= INNO_VERSION(4, 0, 1)) {
-		is >> ansi_string(license_text);
-		is >> ansi_string(info_before);
-		is >> ansi_string(info_after);
+		is >> util::ansi_string(license_text);
+		is >> util::ansi_string(info_before);
+		is >> util::ansi_string(info_after);
 	} else {
 		license_text.clear(), info_before.clear(), info_after.clear();
 	}
 	
-	language_id = load_number<uint32_t>(is);
+	language_id = util::load<boost::uint32_t>(is);
 	
 	if(version >= INNO_VERSION(4, 2, 2) && (version < INNO_VERSION(5, 3, 0) || !version.unicode)) {
-		codepage = load_number<uint32_t>(is);
+		codepage = util::load<boost::uint32_t>(is);
 	} else {
 		codepage = 0;
 	}
@@ -63,20 +63,20 @@
 		codepage = version.codepage();
 	}
 	
-	dialog_font_size = load_number<uint32_t>(is);
+	dialog_font_size = util::load<boost::uint32_t>(is);
 	
 	if(version < INNO_VERSION(4, 1, 0)) {
-		dialog_font_standard_height = load_number<uint32_t>(is);
+		dialog_font_standard_height = util::load<boost::uint32_t>(is);
 	} else {
 		dialog_font_standard_height = 0;
 	}
 	
-	title_font_size = load_number<uint32_t>(is);
-	welcome_font_size = load_number<uint32_t>(is);
-	copyright_font_size = load_number<uint32_t>(is);
+	title_font_size = util::load<boost::uint32_t>(is);
+	welcome_font_size = util::load<boost::uint32_t>(is);
+	copyright_font_size = util::load<boost::uint32_t>(is);
 	
 	if(version >= INNO_VERSION(5, 2, 3)) {
-		right_to_left = ::load<uint8_t>(is);
+		right_to_left = util::load_bool(is);
 	} else {
 		right_to_left = false;
 	}
diff -Nru innoextract-1.3/src/setup/language.hpp innoextract-1.4/src/setup/language.hpp
--- innoextract-1.3/src/setup/language.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/language.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -21,10 +21,11 @@
 #ifndef INNOEXTRACT_SETUP_LANGUAGE_HPP
 #define INNOEXTRACT_SETUP_LANGUAGE_HPP
 
-#include <stdint.h>
 #include <string>
 #include <iosfwd>
 
+#include <boost/cstdint.hpp>
+
 namespace setup {
 
 struct version;
@@ -44,8 +45,8 @@
 	std::string info_before;
 	std::string info_after;
 	
-	uint32_t language_id;
-	uint32_t codepage;
+	boost::uint32_t language_id;
+	boost::uint32_t codepage;
 	size_t dialog_font_size;
 	size_t dialog_font_standard_height;
 	size_t title_font_size;
diff -Nru innoextract-1.3/src/setup/message.cpp innoextract-1.4/src/setup/message.cpp
--- innoextract-1.3/src/setup/message.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/message.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -20,20 +20,33 @@
 
 #include "setup/message.hpp"
 
-#include <stdint.h>
+#include <boost/cstdint.hpp>
 
+#include "setup/language.hpp"
 #include "setup/version.hpp"
 #include "util/load.hpp"
 
 namespace setup {
 
-void message_entry::load(std::istream & is, const version & version) {
+void message_entry::load(std::istream & is, const version & version,
+                         const std::vector<language_entry> & languages) {
 	
-	is >> encoded_string(name, version.codepage());
-	is >> binary_string(value); // encoding depends on the codepage in the LanguageEntry
+	is >> util::encoded_string(name, version.codepage());
+	std::string raw_value = util::binary_string::load(is);
 	
-	language = load_number<int32_t>(is);
+	language = util::load<boost::int32_t>(is);
 	
+	boost::uint32_t codepage;
+	if(language < 0) {
+		codepage = version.codepage();
+	} else if(language < 0 || size_t(language) >= languages.size()) {
+		value.clear();
+		return;
+	} else {
+		codepage = languages[size_t(language)].codepage;
+	}
+	
+	util::to_utf8(raw_value, value, codepage);
 }
 
 } // namespace setup
diff -Nru innoextract-1.3/src/setup/message.hpp innoextract-1.4/src/setup/message.hpp
--- innoextract-1.3/src/setup/message.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/message.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -23,10 +23,12 @@
 
 #include <string>
 #include <iosfwd>
+#include <vector>
 
 namespace setup {
 
 struct version;
+struct language_entry;
 
 struct message_entry {
 	
@@ -41,7 +43,8 @@
 	// Index into the default language entry list or -1.
 	int language;
 	
-	void load(std::istream & is, const version & version);
+	void load(std::istream & is, const version & version,
+	          const std::vector<language_entry> & languages);
 	
 };
 
diff -Nru innoextract-1.3/src/setup/permission.cpp innoextract-1.4/src/setup/permission.cpp
--- innoextract-1.3/src/setup/permission.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/permission.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -20,15 +20,16 @@
 
 #include "setup/permission.hpp"
 
+#include "setup/version.hpp"
 #include "util/load.hpp"
 
 namespace setup {
 
-void permission_entry::load(std::istream & is, const version & version) {
+void permission_entry::load(std::istream & is, const version & v) {
 	
-	(void)version;
+	(void)v;
 	
-	is >> binary_string(permissions); // an array of TGrantPermissionEntry's
+	is >> util::binary_string(permissions); // an array of TGrantPermissionEntry's
 	
 }
 
diff -Nru innoextract-1.3/src/setup/registry.cpp innoextract-1.4/src/setup/registry.cpp
--- innoextract-1.3/src/setup/registry.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/registry.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -20,7 +20,7 @@
 
 #include "setup/registry.hpp"
 
-#include <stdint.h>
+#include <boost/cstdint.hpp>
 
 #include "setup/version.hpp"
 #include "util/load.hpp"
@@ -61,21 +61,21 @@
 void registry_entry::load(std::istream & is, const version & version) {
 	
 	if(version < INNO_VERSION(1, 3, 21)) {
-		::load<uint32_t>(is); // uncompressed size of the directory entry structure
+		(void)util::load<boost::uint32_t>(is); // uncompressed size of the entry
 	}
 	
-	is >> encoded_string(key, version.codepage());
+	is >> util::encoded_string(key, version.codepage());
 	if(version.bits != 16) {
-		is >> encoded_string(name, version.codepage());
+		is >> util::encoded_string(name, version.codepage());
 	} else {
 		name.clear();
 	}
-	is >> encoded_string(value, version.codepage());
+	is >> util::encoded_string(value, version.codepage());
 	
 	load_condition_data(is, version);
 	
 	if(version >= INNO_VERSION(4, 0, 11) && version < INNO_VERSION(4, 1, 0)) {
-		is >> encoded_string(permissions, version.codepage());
+		is >> util::encoded_string(permissions, version.codepage());
 	} else {
 		permissions.clear();
 	}
@@ -83,13 +83,13 @@
 	load_version_data(is, version);
 	
 	if(version.bits != 16) {
-		hive = hive_name(load_number<uint32_t>(is) & ~0x80000000);
+		hive = hive_name(util::load<boost::uint32_t>(is) & ~0x80000000);
 	} else {
 		hive = Unset;
 	}
 	
 	if(version >= INNO_VERSION(4, 1, 0)) {
-		permission = load_number<int16_t>(is);
+		permission = util::load<boost::int16_t>(is);
 	} else {
 		permission = -1;
 	}
@@ -102,28 +102,28 @@
 		type = stored_enum<stored_registry_entry_type_0>(is).get();
 	}
 	
-	stored_flag_reader<flags> flags(is, version.bits);
+	stored_flag_reader<flags> flagreader(is, version.bits);
 	
 	if(version.bits != 16) {
-		flags.add(CreateValueIfDoesntExist);
-		flags.add(UninsDeleteValue);
+		flagreader.add(CreateValueIfDoesntExist);
+		flagreader.add(UninsDeleteValue);
 	}
-	flags.add(UninsClearValue);
-	flags.add(UninsDeleteEntireKey);
-	flags.add(UninsDeleteEntireKeyIfEmpty);
-	flags.add(PreserveStringType);
+	flagreader.add(UninsClearValue);
+	flagreader.add(UninsDeleteEntireKey);
+	flagreader.add(UninsDeleteEntireKeyIfEmpty);
+	flagreader.add(PreserveStringType);
 	if(version >= INNO_VERSION(1, 3, 21)) {
-		flags.add(DeleteKey);
-		flags.add(DeleteValue);
-		flags.add(NoError);
-		flags.add(DontCreateKey);
+		flagreader.add(DeleteKey);
+		flagreader.add(DeleteValue);
+		flagreader.add(NoError);
+		flagreader.add(DontCreateKey);
 	}
 	if(version >= INNO_VERSION(5, 1, 0)) {
-		flags.add(Bits32);
-		flags.add(Bits64);
+		flagreader.add(Bits32);
+		flagreader.add(Bits64);
 	}
 	
-	options = flags;
+	options = flagreader;
 }
 
 } // namespace setup
diff -Nru innoextract-1.3/src/setup/run.cpp innoextract-1.4/src/setup/run.cpp
--- innoextract-1.3/src/setup/run.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/run.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -20,7 +20,7 @@
 
 #include "setup/run.hpp"
 
-#include <stdint.h>
+#include <boost/cstdint.hpp>
 
 #include "setup/version.hpp"
 #include "util/load.hpp"
@@ -41,29 +41,29 @@
 void run_entry::load(std::istream & is, const version & version) {
 	
 	if(version < INNO_VERSION(1, 3, 21)) {
-		::load<uint32_t>(is); // uncompressed size of the directory entry structure
+		(void)util::load<boost::uint32_t>(is); // uncompressed size of the entry
 	}
 	
-	is >> encoded_string(name, version.codepage());
-	is >> encoded_string(parameters, version.codepage());
-	is >> encoded_string(working_dir, version.codepage());
+	is >> util::encoded_string(name, version.codepage());
+	is >> util::encoded_string(parameters, version.codepage());
+	is >> util::encoded_string(working_dir, version.codepage());
 	if(version >= INNO_VERSION(1, 3, 21)) {
-		is >> encoded_string(run_once_id, version.codepage());
+		is >> util::encoded_string(run_once_id, version.codepage());
 	} else {
 		run_once_id.clear();
 	}
 	if(version >= INNO_VERSION(2, 0, 2)) {
-		is >> encoded_string(status_message, version.codepage());
+		is >> util::encoded_string(status_message, version.codepage());
 	} else {
 		status_message.clear();
 	}
 	if(version >= INNO_VERSION(5, 1, 13)) {
-		is >> encoded_string(verb, version.codepage());
+		is >> util::encoded_string(verb, version.codepage());
 	} else {
 		verb.clear();
 	}
 	if(version >= INNO_VERSION(2, 0, 0)) {
-		is >> encoded_string(description, version.codepage());
+		is >> util::encoded_string(description, version.codepage());
 	}
 	
 	load_condition_data(is, version);
@@ -71,37 +71,37 @@
 	load_version_data(is, version);
 	
 	if(version >= INNO_VERSION(1, 3, 21)) {
-		show_command = load_number<int32_t>(is);
+		show_command = util::load<boost::int32_t>(is);
 	} else {
 		show_command = 0;
 	}
 	
 	wait = stored_enum<stored_run_wait_condition>(is).get();
 	
-	stored_flag_reader<flags> flags(is, version.bits);
+	stored_flag_reader<flags> flagreader(is, version.bits);
 	
-	flags.add(ShellExec);
+	flagreader.add(ShellExec);
 	if(version >= INNO_VERSION(1, 3, 21)) {
-		flags.add(SkipIfDoesntExist);
+		flagreader.add(SkipIfDoesntExist);
 	}
 	if(version >= INNO_VERSION(2, 0, 0)) {
-		flags.add(PostInstall);
-		flags.add(Unchecked);
-		flags.add(SkipIfSilent);
-		flags.add(Skipif_not_equalSilent);
+		flagreader.add(PostInstall);
+		flagreader.add(Unchecked);
+		flagreader.add(SkipIfSilent);
+		flagreader.add(Skipif_not_equalSilent);
 	}
 	if(version >= INNO_VERSION(2, 0, 8)) {
-		flags.add(HideWizard);
+		flagreader.add(HideWizard);
 	}
 	if(version >= INNO_VERSION(5, 1, 10)) {
-		flags.add(Bits32);
-		flags.add(Bits64);
+		flagreader.add(Bits32);
+		flagreader.add(Bits64);
 	}
 	if(version >= INNO_VERSION(5, 2, 0)) {
-		flags.add(RunAsOriginalUser);
+		flagreader.add(RunAsOriginalUser);
 	}
 	
-	options = flags;
+	options = flagreader;
 }
 
 } // namespace setup
diff -Nru innoextract-1.3/src/setup/task.cpp innoextract-1.4/src/setup/task.cpp
--- innoextract-1.3/src/setup/task.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/task.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -20,7 +20,7 @@
 
 #include "setup/task.hpp"
 
-#include <stdint.h>
+#include <boost/cstdint.hpp>
 
 #include "setup/version.hpp"
 #include "util/load.hpp"
@@ -30,40 +30,40 @@
 
 void task_entry::load(std::istream & is, const version & version) {
 	
-	is >> encoded_string(name, version.codepage());
-	is >> encoded_string(description, version.codepage());
-	is >> encoded_string(group_description, version.codepage());
-	is >> encoded_string(components, version.codepage());
+	is >> util::encoded_string(name, version.codepage());
+	is >> util::encoded_string(description, version.codepage());
+	is >> util::encoded_string(group_description, version.codepage());
+	is >> util::encoded_string(components, version.codepage());
 	if(version >= INNO_VERSION(4, 0, 1)) {
-		is >> encoded_string(languages, version.codepage());
+		is >> util::encoded_string(languages, version.codepage());
 	} else {
 		languages.clear();
 	}
 	if(version >= INNO_VERSION_EXT(3, 0, 6, 1)) {
-		is >> encoded_string(check, version.codepage());
-		level = load_number<int32_t>(is);
-		used = load_number<uint8_t>(is);
+		is >> util::encoded_string(check, version.codepage());
+		level = util::load<boost::int32_t>(is);
+		used = util::load_bool(is);
 	} else {
 		check.clear(), level = 0, used = true;
 	}
 	
 	winver.load(is, version);
 	
-	stored_flag_reader<flags> flags(is);
+	stored_flag_reader<flags> flagreader(is);
 	
-	flags.add(Exclusive);
-	flags.add(Unchecked);
+	flagreader.add(Exclusive);
+	flagreader.add(Unchecked);
 	if(version >= INNO_VERSION(2, 0, 5)) {
-		flags.add(Restart);
+		flagreader.add(Restart);
 	}
 	if(version >= INNO_VERSION(2, 0, 6)) {
-		flags.add(CheckedOnce);
+		flagreader.add(CheckedOnce);
 	}
 	if(version >= INNO_VERSION(4, 2, 3)) {
-		flags.add(DontInheritCheck);
+		flagreader.add(DontInheritCheck);
 	}
 	
-	options = flags;
+	options = flagreader;
 }
 
 } // namespace setup
diff -Nru innoextract-1.3/src/setup/type.cpp innoextract-1.4/src/setup/type.cpp
--- innoextract-1.3/src/setup/type.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/type.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -53,15 +53,17 @@
 
 void type_entry::load(std::istream & is, const version & version) {
 	
-	is >> encoded_string(name, version.codepage());
-	is >> encoded_string(description, version.codepage());
+	USE_FLAG_NAMES(setup::type_flags)
+	
+	is >> util::encoded_string(name, version.codepage());
+	is >> util::encoded_string(description, version.codepage());
 	if(version >= INNO_VERSION(4, 0, 1)) {
-		is >> encoded_string(languages, version.codepage());
+		is >> util::encoded_string(languages, version.codepage());
 	} else {
 		languages.clear();
 	}
 	if(version >= INNO_VERSION_EXT(3, 0, 6, 1)) {
-		is >> encoded_string(check, version.codepage());
+		is >> util::encoded_string(check, version.codepage());
 	} else {
 		check.clear();
 	}
@@ -69,7 +71,7 @@
 	winver.load(is, version);
 	
 	type_flags options = stored_flags<stored_type_flags>(is).get();
-	custom_type = (options & CustomSetupType);
+	custom_type = ((options & CustomSetupType) != 0);
 	
 	if(version >= INNO_VERSION(4, 0, 3)) {
 		type = stored_enum<stored_setup_type>(is).get();
@@ -77,7 +79,11 @@
 		type = User;
 	}
 	
-	size = (version >= INNO_VERSION(4, 0, 0)) ? load_number<uint64_t>(is) : load_number<uint32_t>(is);
+	if(version >= INNO_VERSION(4, 0, 0)) {
+		size = util::load<boost::uint64_t>(is);
+	} else {
+		size = util::load<boost::uint32_t>(is);
+	}
 }
 
 } // namespace setup
diff -Nru innoextract-1.3/src/setup/type.hpp innoextract-1.4/src/setup/type.hpp
--- innoextract-1.3/src/setup/type.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/type.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -21,10 +21,11 @@
 #ifndef INNOEXTRACT_SETUP_TYPE_HPP
 #define INNOEXTRACT_SETUP_TYPE_HPP
 
-#include <stdint.h>
 #include <string>
 #include <iosfwd>
 
+#include <boost/cstdint.hpp>
+
 #include "setup/windows.hpp"
 #include "util/enum.hpp"
 #include "util/flags.hpp"
@@ -55,7 +56,7 @@
 	
 	setup_type type;
 	
-	uint64_t size;
+	boost::uint64_t size;
 	
 	void load(std::istream & is, const version & version);
 	
diff -Nru innoextract-1.3/src/setup/version.cpp innoextract-1.4/src/setup/version.cpp
--- innoextract-1.3/src/setup/version.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/version.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -25,14 +25,13 @@
 #include <istream>
 #include <ostream>
 
+#include <boost/version.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/lexical_cast.hpp>
 
 #include "util/util.hpp"
 #include "util/log.hpp"
 
-using std::string;
-
 namespace setup {
 
 namespace {
@@ -70,79 +69,80 @@
 };
 
 const known_version versions[] = {
-	{ "Inno Setup Setup Data (1.3.21)",                INNO_VERSION_EXT(1, 3, 21, 0), false },
-	{ "Inno Setup Setup Data (1.3.25)",                INNO_VERSION_EXT(1, 3, 25, 0), false },
-	{ "Inno Setup Setup Data (2.0.0)",                 INNO_VERSION_EXT(2, 0,  0, 0), false },
-	{ "Inno Setup Setup Data (2.0.1)",                 INNO_VERSION_EXT(2, 0,  1, 0), false },
-	{ "Inno Setup Setup Data (2.0.2)",                 INNO_VERSION_EXT(2, 0,  2, 0), false }, // !
-	{ "Inno Setup Setup Data (2.0.5)",                 INNO_VERSION_EXT(2, 0,  5, 0), false },
-	{ "Inno Setup Setup Data (2.0.6a)",                INNO_VERSION_EXT(2, 0,  6, 0), false },
-	{ "Inno Setup Setup Data (2.0.7)",                 INNO_VERSION_EXT(2, 0,  7, 0), false },
-	{ "Inno Setup Setup Data (2.0.8)",                 INNO_VERSION_EXT(2, 0,  8, 0), false },
-	{ "Inno Setup Setup Data (2.0.11)",                INNO_VERSION_EXT(2, 0, 11, 0), false },
-	{ "Inno Setup Setup Data (2.0.17)",                INNO_VERSION_EXT(2, 0, 17, 0), false },
-	{ "Inno Setup Setup Data (2.0.18)",                INNO_VERSION_EXT(2, 0, 18, 0), false },
-	{ "Inno Setup Setup Data (3.0.0a)",                INNO_VERSION_EXT(3, 0,  0, 0), false },
-	{ "Inno Setup Setup Data (3.0.1)",                 INNO_VERSION_EXT(3, 0,  1, 0), false },
-	{ "Inno Setup Setup Data (3.0.3)",                 INNO_VERSION_EXT(3, 0,  3, 0), false },
-	{ "Inno Setup Setup Data (3.0.4)",                 INNO_VERSION_EXT(3, 0,  4, 0), false }, // !
-	{ "Inno Setup Setup Data (3.0.5)",                 INNO_VERSION_EXT(3, 0,  5, 0), false },
-	{ "My Inno Setup Extensions Setup Data (3.0.6.1)", INNO_VERSION_EXT(3, 0,  6, 1), false },
-	{ "Inno Setup Setup Data (4.0.0a)",                INNO_VERSION_EXT(4, 0,  0, 0), false },
-	{ "Inno Setup Setup Data (4.0.1)",                 INNO_VERSION_EXT(4, 0,  1, 0), false },
-	{ "Inno Setup Setup Data (4.0.3)",                 INNO_VERSION_EXT(4, 0,  3, 0), false },
-	{ "Inno Setup Setup Data (4.0.5)",                 INNO_VERSION_EXT(4, 0,  5, 0), false },
-	{ "Inno Setup Setup Data (4.0.9)",                 INNO_VERSION_EXT(4, 0,  9, 0), false },
-	{ "Inno Setup Setup Data (4.0.10)",                INNO_VERSION_EXT(4, 0, 10, 0), false },
-	{ "Inno Setup Setup Data (4.0.11)",                INNO_VERSION_EXT(4, 0, 11, 0), false },
-	{ "Inno Setup Setup Data (4.1.0)",                 INNO_VERSION_EXT(4, 1,  0, 0), false },
-	{ "Inno Setup Setup Data (4.1.2)",                 INNO_VERSION_EXT(4, 1,  2, 0), false },
-	{ "Inno Setup Setup Data (4.1.3)",                 INNO_VERSION_EXT(4, 1,  3, 0), false },
-	{ "Inno Setup Setup Data (4.1.4)",                 INNO_VERSION_EXT(4, 1,  4, 0), false },
-	{ "Inno Setup Setup Data (4.1.5)",                 INNO_VERSION_EXT(4, 1,  5, 0), false },
-	{ "Inno Setup Setup Data (4.1.6)",                 INNO_VERSION_EXT(4, 1,  6, 0), false },
-	{ "Inno Setup Setup Data (4.1.8)",                 INNO_VERSION_EXT(4, 1,  8, 0), false },
-	{ "Inno Setup Setup Data (4.2.0)",                 INNO_VERSION_EXT(4, 2,  0, 0), false },
-	{ "Inno Setup Setup Data (4.2.1)",                 INNO_VERSION_EXT(4, 2,  1, 0), false },
-	{ "Inno Setup Setup Data (4.2.2)",                 INNO_VERSION_EXT(4, 2,  2, 0), false },
-	{ "Inno Setup Setup Data (4.2.3)",                 INNO_VERSION_EXT(4, 2,  3, 0), false },
-	{ "Inno Setup Setup Data (4.2.4)",                 INNO_VERSION_EXT(4, 2,  4, 0), false }, // !
-	{ "Inno Setup Setup Data (4.2.5)",                 INNO_VERSION_EXT(4, 2,  5, 0), false },
-	{ "Inno Setup Setup Data (4.2.6)",                 INNO_VERSION_EXT(4, 2,  6, 0), false },
-	{ "Inno Setup Setup Data (5.0.0)",                 INNO_VERSION_EXT(5, 0,  0, 0), false },
-	{ "Inno Setup Setup Data (5.0.1)",                 INNO_VERSION_EXT(5, 0,  1, 0), false },
-	{ "Inno Setup Setup Data (5.0.3)",                 INNO_VERSION_EXT(5, 0,  3, 0), false },
-	{ "Inno Setup Setup Data (5.0.4)",                 INNO_VERSION_EXT(5, 0,  4, 0), false },
-	{ "Inno Setup Setup Data (5.1.0)",                 INNO_VERSION_EXT(5, 1,  0, 0), false },
-	{ "Inno Setup Setup Data (5.1.2)",                 INNO_VERSION_EXT(5, 1,  2, 0), false },
-	{ "Inno Setup Setup Data (5.1.7)",                 INNO_VERSION_EXT(5, 1,  7, 0), false },
-	{ "Inno Setup Setup Data (5.1.10)",                INNO_VERSION_EXT(5, 1, 10, 0), false },
-	{ "Inno Setup Setup Data (5.1.13)",                INNO_VERSION_EXT(5, 1, 13, 0), false },
-	{ "Inno Setup Setup Data (5.2.0)",                 INNO_VERSION_EXT(5, 2,  0, 0), false },
-	{ "Inno Setup Setup Data (5.2.1)",                 INNO_VERSION_EXT(5, 2,  1, 0), false },
-	{ "Inno Setup Setup Data (5.2.3)",                 INNO_VERSION_EXT(5, 2,  3, 0), false },
-	{ "Inno Setup Setup Data (5.2.5)",                 INNO_VERSION_EXT(5, 2,  5, 0), false },
-	{ "Inno Setup Setup Data (5.2.5) (u)",             INNO_VERSION_EXT(5, 2,  5, 0), true  },
-	{ "Inno Setup Setup Data (5.3.0)",                 INNO_VERSION_EXT(5, 3,  0, 0), false },
-	{ "Inno Setup Setup Data (5.3.0) (u)",             INNO_VERSION_EXT(5, 3,  0, 0), true  },
-	{ "Inno Setup Setup Data (5.3.3)",                 INNO_VERSION_EXT(5, 3,  3, 0), false },
-	{ "Inno Setup Setup Data (5.3.3) (u)",             INNO_VERSION_EXT(5, 3,  3, 0), true  },
-	{ "Inno Setup Setup Data (5.3.5)",                 INNO_VERSION_EXT(5, 3,  5, 0), false },
-	{ "Inno Setup Setup Data (5.3.5) (u)",             INNO_VERSION_EXT(5, 3,  5, 0), true  },
-	{ "Inno Setup Setup Data (5.3.6)",                 INNO_VERSION_EXT(5, 3,  6, 0), false },
-	{ "Inno Setup Setup Data (5.3.6) (u)",             INNO_VERSION_EXT(5, 3,  6, 0), true  },
-	{ "Inno Setup Setup Data (5.3.7)",                 INNO_VERSION_EXT(5, 3,  7, 0), false },
-	{ "Inno Setup Setup Data (5.3.7) (u)",             INNO_VERSION_EXT(5, 3,  7, 0), true  },
-	{ "Inno Setup Setup Data (5.3.8)",                 INNO_VERSION_EXT(5, 3,  8, 0), false },
-	{ "Inno Setup Setup Data (5.3.8) (u)",             INNO_VERSION_EXT(5, 3,  8, 0), true  },
-	{ "Inno Setup Setup Data (5.3.9)",                 INNO_VERSION_EXT(5, 3,  9, 0), false },
-	{ "Inno Setup Setup Data (5.3.9) (u)",             INNO_VERSION_EXT(5, 3,  9, 0), true  },
-	{ "Inno Setup Setup Data (5.3.10)",                INNO_VERSION_EXT(5, 3, 10, 0), false },
-	{ "Inno Setup Setup Data (5.3.10) (u)",            INNO_VERSION_EXT(5, 3, 10, 0), true  },
-	{ "Inno Setup Setup Data (5.4.2)",                 INNO_VERSION_EXT(5, 4,  2, 0), false },
-	{ "Inno Setup Setup Data (5.4.2) (u)",             INNO_VERSION_EXT(5, 4,  2, 0), true  },
-	{ "Inno Setup Setup Data (5.5.0)",                 INNO_VERSION_EXT(5, 5,  0, 0), false },
-	{ "Inno Setup Setup Data (5.5.0) (u)",             INNO_VERSION_EXT(5, 5,  0, 0), true  },
+	{ "Inno Setup Setup Data (1.3.21)",     INNO_VERSION_EXT(1, 3, 21, 0), false },
+	{ "Inno Setup Setup Data (1.3.25)",     INNO_VERSION_EXT(1, 3, 25, 0), false },
+	{ "Inno Setup Setup Data (2.0.0)",      INNO_VERSION_EXT(2, 0,  0, 0), false },
+	{ "Inno Setup Setup Data (2.0.1)",      INNO_VERSION_EXT(2, 0,  1, 0), false },
+	{ "Inno Setup Setup Data (2.0.2)",      INNO_VERSION_EXT(2, 0,  2, 0), false }, // !
+	{ "Inno Setup Setup Data (2.0.5)",      INNO_VERSION_EXT(2, 0,  5, 0), false },
+	{ "Inno Setup Setup Data (2.0.6a)",     INNO_VERSION_EXT(2, 0,  6, 0), false },
+	{ "Inno Setup Setup Data (2.0.7)",      INNO_VERSION_EXT(2, 0,  7, 0), false },
+	{ "Inno Setup Setup Data (2.0.8)",      INNO_VERSION_EXT(2, 0,  8, 0), false },
+	{ "Inno Setup Setup Data (2.0.11)",     INNO_VERSION_EXT(2, 0, 11, 0), false },
+	{ "Inno Setup Setup Data (2.0.17)",     INNO_VERSION_EXT(2, 0, 17, 0), false },
+	{ "Inno Setup Setup Data (2.0.18)",     INNO_VERSION_EXT(2, 0, 18, 0), false },
+	{ "Inno Setup Setup Data (3.0.0a)",     INNO_VERSION_EXT(3, 0,  0, 0), false },
+	{ "Inno Setup Setup Data (3.0.1)",      INNO_VERSION_EXT(3, 0,  1, 0), false },
+	{ "Inno Setup Setup Data (3.0.3)",      INNO_VERSION_EXT(3, 0,  3, 0), false },
+	{ "Inno Setup Setup Data (3.0.4)",      INNO_VERSION_EXT(3, 0,  4, 0), false }, // !
+	{ "Inno Setup Setup Data (3.0.5)",      INNO_VERSION_EXT(3, 0,  5, 0), false },
+	{ "My Inno Setup Extensions Setup Data (3.0.6.1)",
+	                                        INNO_VERSION_EXT(3, 0,  6, 1), false },
+	{ "Inno Setup Setup Data (4.0.0a)",     INNO_VERSION_EXT(4, 0,  0, 0), false },
+	{ "Inno Setup Setup Data (4.0.1)",      INNO_VERSION_EXT(4, 0,  1, 0), false },
+	{ "Inno Setup Setup Data (4.0.3)",      INNO_VERSION_EXT(4, 0,  3, 0), false },
+	{ "Inno Setup Setup Data (4.0.5)",      INNO_VERSION_EXT(4, 0,  5, 0), false },
+	{ "Inno Setup Setup Data (4.0.9)",      INNO_VERSION_EXT(4, 0,  9, 0), false },
+	{ "Inno Setup Setup Data (4.0.10)",     INNO_VERSION_EXT(4, 0, 10, 0), false },
+	{ "Inno Setup Setup Data (4.0.11)",     INNO_VERSION_EXT(4, 0, 11, 0), false },
+	{ "Inno Setup Setup Data (4.1.0)",      INNO_VERSION_EXT(4, 1,  0, 0), false },
+	{ "Inno Setup Setup Data (4.1.2)",      INNO_VERSION_EXT(4, 1,  2, 0), false },
+	{ "Inno Setup Setup Data (4.1.3)",      INNO_VERSION_EXT(4, 1,  3, 0), false },
+	{ "Inno Setup Setup Data (4.1.4)",      INNO_VERSION_EXT(4, 1,  4, 0), false },
+	{ "Inno Setup Setup Data (4.1.5)",      INNO_VERSION_EXT(4, 1,  5, 0), false },
+	{ "Inno Setup Setup Data (4.1.6)",      INNO_VERSION_EXT(4, 1,  6, 0), false },
+	{ "Inno Setup Setup Data (4.1.8)",      INNO_VERSION_EXT(4, 1,  8, 0), false },
+	{ "Inno Setup Setup Data (4.2.0)",      INNO_VERSION_EXT(4, 2,  0, 0), false },
+	{ "Inno Setup Setup Data (4.2.1)",      INNO_VERSION_EXT(4, 2,  1, 0), false },
+	{ "Inno Setup Setup Data (4.2.2)",      INNO_VERSION_EXT(4, 2,  2, 0), false },
+	{ "Inno Setup Setup Data (4.2.3)",      INNO_VERSION_EXT(4, 2,  3, 0), false },
+	{ "Inno Setup Setup Data (4.2.4)",      INNO_VERSION_EXT(4, 2,  4, 0), false }, // !
+	{ "Inno Setup Setup Data (4.2.5)",      INNO_VERSION_EXT(4, 2,  5, 0), false },
+	{ "Inno Setup Setup Data (4.2.6)",      INNO_VERSION_EXT(4, 2,  6, 0), false },
+	{ "Inno Setup Setup Data (5.0.0)",      INNO_VERSION_EXT(5, 0,  0, 0), false },
+	{ "Inno Setup Setup Data (5.0.1)",      INNO_VERSION_EXT(5, 0,  1, 0), false },
+	{ "Inno Setup Setup Data (5.0.3)",      INNO_VERSION_EXT(5, 0,  3, 0), false },
+	{ "Inno Setup Setup Data (5.0.4)",      INNO_VERSION_EXT(5, 0,  4, 0), false },
+	{ "Inno Setup Setup Data (5.1.0)",      INNO_VERSION_EXT(5, 1,  0, 0), false },
+	{ "Inno Setup Setup Data (5.1.2)",      INNO_VERSION_EXT(5, 1,  2, 0), false },
+	{ "Inno Setup Setup Data (5.1.7)",      INNO_VERSION_EXT(5, 1,  7, 0), false },
+	{ "Inno Setup Setup Data (5.1.10)",     INNO_VERSION_EXT(5, 1, 10, 0), false },
+	{ "Inno Setup Setup Data (5.1.13)",     INNO_VERSION_EXT(5, 1, 13, 0), false },
+	{ "Inno Setup Setup Data (5.2.0)",      INNO_VERSION_EXT(5, 2,  0, 0), false },
+	{ "Inno Setup Setup Data (5.2.1)",      INNO_VERSION_EXT(5, 2,  1, 0), false },
+	{ "Inno Setup Setup Data (5.2.3)",      INNO_VERSION_EXT(5, 2,  3, 0), false },
+	{ "Inno Setup Setup Data (5.2.5)",      INNO_VERSION_EXT(5, 2,  5, 0), false },
+	{ "Inno Setup Setup Data (5.2.5) (u)",  INNO_VERSION_EXT(5, 2,  5, 0), true  },
+	{ "Inno Setup Setup Data (5.3.0)",      INNO_VERSION_EXT(5, 3,  0, 0), false },
+	{ "Inno Setup Setup Data (5.3.0) (u)",  INNO_VERSION_EXT(5, 3,  0, 0), true  },
+	{ "Inno Setup Setup Data (5.3.3)",      INNO_VERSION_EXT(5, 3,  3, 0), false },
+	{ "Inno Setup Setup Data (5.3.3) (u)",  INNO_VERSION_EXT(5, 3,  3, 0), true  },
+	{ "Inno Setup Setup Data (5.3.5)",      INNO_VERSION_EXT(5, 3,  5, 0), false },
+	{ "Inno Setup Setup Data (5.3.5) (u)",  INNO_VERSION_EXT(5, 3,  5, 0), true  },
+	{ "Inno Setup Setup Data (5.3.6)",      INNO_VERSION_EXT(5, 3,  6, 0), false },
+	{ "Inno Setup Setup Data (5.3.6) (u)",  INNO_VERSION_EXT(5, 3,  6, 0), true  },
+	{ "Inno Setup Setup Data (5.3.7)",      INNO_VERSION_EXT(5, 3,  7, 0), false },
+	{ "Inno Setup Setup Data (5.3.7) (u)",  INNO_VERSION_EXT(5, 3,  7, 0), true  },
+	{ "Inno Setup Setup Data (5.3.8)",      INNO_VERSION_EXT(5, 3,  8, 0), false },
+	{ "Inno Setup Setup Data (5.3.8) (u)",  INNO_VERSION_EXT(5, 3,  8, 0), true  },
+	{ "Inno Setup Setup Data (5.3.9)",      INNO_VERSION_EXT(5, 3,  9, 0), false },
+	{ "Inno Setup Setup Data (5.3.9) (u)",  INNO_VERSION_EXT(5, 3,  9, 0), true  },
+	{ "Inno Setup Setup Data (5.3.10)",     INNO_VERSION_EXT(5, 3, 10, 0), false },
+	{ "Inno Setup Setup Data (5.3.10) (u)", INNO_VERSION_EXT(5, 3, 10, 0), true  },
+	{ "Inno Setup Setup Data (5.4.2)",      INNO_VERSION_EXT(5, 4,  2, 0), false },
+	{ "Inno Setup Setup Data (5.4.2) (u)",  INNO_VERSION_EXT(5, 4,  2, 0), true  },
+	{ "Inno Setup Setup Data (5.5.0)",      INNO_VERSION_EXT(5, 5,  0, 0), false },
+	{ "Inno Setup Setup Data (5.5.0) (u)",  INNO_VERSION_EXT(5, 5,  0, 0), true  },
 };
 
 } // anonymous namespace
@@ -165,6 +165,14 @@
 	return os;
 }
 
+static unsigned to_unsigned(const char * chars, size_t count) {
+#if BOOST_VERSION < 105200
+	return boost::lexical_cast<unsigned>(std::string(chars, count));
+#else
+	return boost::lexical_cast<unsigned>(chars, count);
+#endif
+}
+
 void version::load(std::istream & is) {
 	
 	static const char digits[] = "0123456789";
@@ -172,7 +180,7 @@
 	BOOST_STATIC_ASSERT(sizeof(stored_legacy_version) <= sizeof(stored_version));
 	
 	stored_legacy_version legacy_version;
-	is.read(legacy_version, sizeof(legacy_version));
+	is.read(legacy_version, std::streamsize(sizeof(legacy_version)));
 	
 	if(legacy_version[0] == 'i' && legacy_version[sizeof(legacy_version) - 1] == '\x1a') {
 		
@@ -206,9 +214,9 @@
 		std::string version_str(legacy_version, legacy_version + ARRAY_SIZE(legacy_version));
 		
 		try {
-			unsigned a = boost::lexical_cast<unsigned>(version_str.substr(1, 1));
-			unsigned b = boost::lexical_cast<unsigned>(version_str.substr(3, 1));
-			unsigned c = boost::lexical_cast<unsigned>(version_str.substr(5, 2));
+			unsigned a = to_unsigned(version_str.data() + 1, 1);
+			unsigned b = to_unsigned(version_str.data() + 3, 1);
+			unsigned c = to_unsigned(version_str.data() + 5, 2);
 			value = INNO_VERSION(a, b, c);
 		} catch(boost::bad_lexical_cast) {
 			throw version_error();
@@ -222,7 +230,8 @@
 	
 	stored_version version;
 	memcpy(version, legacy_version, sizeof(legacy_version));
-	is.read(version + sizeof(legacy_version), sizeof(version) - sizeof(legacy_version));
+	is.read(version + sizeof(legacy_version),
+	        std::streamsize(sizeof(version) - sizeof(legacy_version)));
 	
 	
 	for(size_t i = 0; i < ARRAY_SIZE(versions); i++) {
@@ -237,14 +246,14 @@
 	}
 	
 	char * end = std::find(version, version + ARRAY_SIZE(version), '\0');
-	string version_str(version, end);
+	std::string version_str(version, end);
 	debug("unknown version: \"" << version_str << '"');
-	if(version_str.find("Inno Setup") == string::npos) {
+	if(version_str.find("Inno Setup") == std::string::npos) {
 		throw version_error();
 	}
 	
 	size_t bracket = version_str.find('(');
-	for(; bracket != string::npos; bracket = version_str.find('(', bracket + 1)) {
+	for(; bracket != std::string::npos; bracket = version_str.find('(', bracket + 1)) {
 		
 		if(version_str.length() - bracket < 6) {
 			continue;
@@ -254,24 +263,24 @@
 			
 			size_t a_start = bracket + 1;
 			size_t a_end = version_str.find_first_not_of(digits, a_start);
-			if(a_end == string::npos || version_str[a_end] != '.') {
+			if(a_end == std::string::npos || version_str[a_end] != '.') {
 				continue;
 			}
-			unsigned a = boost::lexical_cast<unsigned>(version_str.substr(a_start, a_end - a_start));
+			unsigned a = to_unsigned(version_str.data() + a_start, a_end - a_start);
 			
 			size_t b_start = a_end + 1;
 			size_t b_end = version_str.find_first_not_of(digits, b_start);
-			if(b_end == string::npos || version_str[b_end] != '.') {
+			if(b_end == std::string::npos || version_str[b_end] != '.') {
 				continue;
 			}
-			unsigned b = boost::lexical_cast<unsigned>(version_str.substr(b_start, b_end - b_start));
+			unsigned b = to_unsigned(version_str.data() + b_start, b_end - b_start);
 			
 			size_t c_start = b_end + 1;
 			size_t c_end = version_str.find_first_not_of(digits, c_start);
-			if(c_end == string::npos) {
+			if(c_end == std::string::npos) {
 				continue;
 			}
-			unsigned c = boost::lexical_cast<unsigned>(version_str.substr(c_start, c_end - c_start));
+			unsigned c = to_unsigned(version_str.data() + c_start, c_end - c_start);
 			
 			size_t d_start = c_end;
 			if(version_str[d_start] == 'a') {
@@ -285,8 +294,8 @@
 			if(version_str[d_start] == '.') {
 				d_start++;
 				size_t d_end = version_str.find_first_not_of(digits, d_start);
-				if(d_end != string::npos && d_end != d_start) {
-					d = boost::lexical_cast<unsigned>(version_str.substr(d_start, d_end - d_start));
+				if(d_end != std::string::npos && d_end != d_start) {
+					d = to_unsigned(version_str.data() + d_start, d_end - d_start);
 				}
 			}
 			
@@ -297,12 +306,12 @@
 			continue;
 		}
 	}
-	if(bracket == string::npos) {
+	if(bracket == std::string::npos) {
 		throw version_error();
 	}
 	
 	bits = 32;
-	unicode = (version_str.find("(u)") != string::npos);
+	unicode = (version_str.find("(u)") != std::string::npos);
 	known = false;
 }
 
diff -Nru innoextract-1.3/src/setup/version.hpp innoextract-1.4/src/setup/version.hpp
--- innoextract-1.3/src/setup/version.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/version.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -21,15 +21,16 @@
 #ifndef INNOEXTRACT_SETUP_VERSION_HPP
 #define INNOEXTRACT_SETUP_VERSION_HPP
 
-#include <stdint.h>
 #include <iosfwd>
 #include <exception>
 
+#include <boost/cstdint.hpp>
+
 namespace setup {
 
 struct version_error : public std::exception { };
 
-typedef uint32_t version_constant;
+typedef boost::uint32_t version_constant;
 #define INNO_VERSION_EXT(a, b, c, d) ( \
 	  (::setup::version_constant(a) << 24) \
 	| (::setup::version_constant(b) << 16) \
@@ -42,7 +43,7 @@
 	
 	version_constant value;
 	
-	uint8_t bits; // 16 or 32
+	boost::uint8_t bits; // 16 or 32
 	
 	bool unicode;
 	
@@ -51,12 +52,12 @@
 	version() : known(false) { }
 	
 	version(version_constant value, bool unicode = false,
-	        bool known = false, uint8_t bits = 32)
+	        bool known = false, boost::uint8_t bits = 32)
 		: value(value), bits(bits), unicode(unicode), known(known) { }
 	
 	
-	version(uint8_t a, uint8_t b, uint8_t c, uint8_t d = 0, bool unicode = false,
-	        bool known = false, uint8_t bits = 32)
+	version(boost::uint8_t a, boost::uint8_t b, boost::uint8_t c, boost::uint8_t d = 0,
+	        bool unicode = false, bool known = false, boost::uint8_t bits = 32)
 		: value(INNO_VERSION_EXT(a, b, c, d)), bits(bits), unicode(unicode), known(known) { }
 	
 	unsigned int a() const { return  value >> 24;         }
@@ -67,7 +68,7 @@
 	void load(std::istream & is);
 	
 	//! \return the Windows codepage used to encode strings
-	uint32_t codepage() const { return uint32_t(unicode ? 1200 : 1252); }
+	boost::uint32_t codepage() const { return boost::uint32_t(unicode ? 1200 : 1252); }
 	
 	//! \return true if the version stored might not be correct
 	bool is_ambiguous() const;
diff -Nru innoextract-1.3/src/setup/windows.cpp innoextract-1.4/src/setup/windows.cpp
--- innoextract-1.3/src/setup/windows.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/windows.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -20,9 +20,10 @@
 
 #include "setup/windows.hpp"
 
-#include <stdint.h>
 #include <ostream>
 
+#include <boost/cstdint.hpp>
+
 #include "setup/version.hpp"
 #include "util/load.hpp"
 #include "util/util.hpp"
@@ -34,13 +35,13 @@
 void windows_version::data::load(std::istream & is, const version & version) {
 	
 	if(version >= INNO_VERSION(1, 3, 21)) {
-		build = load_number<uint16_t>(is);
+		build = util::load<boost::uint16_t>(is);
 	} else {
 		build = 0;
 	}
 	
-	minor = load_number<uint8_t>(is);
-	major = load_number<uint8_t>(is);
+	minor = util::load<boost::uint8_t>(is);
+	major = util::load<boost::uint8_t>(is);
 	
 }
 
@@ -50,8 +51,8 @@
 	nt_version.load(is, version);
 	
 	if(version >= INNO_VERSION(1, 3, 21)) {
-		nt_service_pack.minor = load_number<uint8_t>(is);
-		nt_service_pack.major = load_number<uint8_t>(is);
+		nt_service_pack.minor = util::load<boost::uint8_t>(is);
+		nt_service_pack.major = util::load<boost::uint8_t>(is);
 	} else {
 		nt_service_pack.major = 0, nt_service_pack.minor = 0;
 	}
diff -Nru innoextract-1.3/src/setup/windows.hpp innoextract-1.4/src/setup/windows.hpp
--- innoextract-1.3/src/setup/windows.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/setup/windows.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -35,11 +35,11 @@
 		unsigned minor;
 		unsigned build;
 		
-		inline bool operator==(const data & o) const {
+		bool operator==(const data & o) const {
 			return (build == o.build && major == o.major && minor == o.minor);
 		}
 		
-		inline bool operator!=(const data & o) const {
+		bool operator!=(const data & o) const {
 			return !(*this == o);
 		}
 		
@@ -55,11 +55,11 @@
 		unsigned major;
 		unsigned minor;
 	
-		inline bool operator==(const service_pack & o) const {
+		bool operator==(const service_pack & o) const {
 			return (major == o.major && minor == o.minor);
 		}
 		
-		inline bool operator!=(const service_pack & o) const {
+		bool operator!=(const service_pack & o) const {
 			return !(*this == o);
 		}
 		
@@ -69,13 +69,13 @@
 	
 	void load(std::istream & is, const version & version);
 	
-	inline bool operator==(const windows_version & o) const {
+	bool operator==(const windows_version & o) const {
 		return (win_version == o.win_version
 		        && nt_version == o.nt_version
 		        && nt_service_pack == o.nt_service_pack);
 	}
 	
-	inline bool operator!=(const windows_version & o) const {
+	bool operator!=(const windows_version & o) const {
 		return !(*this == o);
 	}
 	
diff -Nru innoextract-1.3/src/stream/block.cpp innoextract-1.4/src/stream/block.cpp
--- innoextract-1.3/src/stream/block.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/stream/block.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -20,13 +20,12 @@
 
 #include "stream/block.hpp"
 
-#include <stdint.h>
 #include <cstring>
 #include <string>
 #include <istream>
 #include <algorithm>
-#include <cassert>
 
+#include <boost/cstdint.hpp>
 #include <boost/iostreams/filtering_stream.hpp>
 #include <boost/iostreams/restrict.hpp>
 #include <boost/iostreams/filter/zlib.hpp>
@@ -35,6 +34,7 @@
 #include <boost/iostreams/read.hpp>
 #include <boost/make_shared.hpp>
 
+#include "release.hpp"
 #include "crypto/crc32.hpp"
 #include "setup/version.hpp"
 #include "stream/lzma.hpp"
@@ -81,18 +81,17 @@
 	template<typename Source>
 	bool read_chunk(Source & src) {
 		
-		uint32_t block_crc32;
-		char temp[sizeof(block_crc32)];
-		std::streamsize nread = boost::iostreams::read(src, temp, sizeof(temp));
+		char temp[sizeof(boost::uint32_t)];
+		std::streamsize temp_size = std::streamsize(sizeof(temp));
+		std::streamsize nread = boost::iostreams::read(src, temp, temp_size);
 		if(nread == EOF) {
 			return false;
 		} else if(nread != sizeof(temp)) {
 			throw block_error("unexpected block end");
 		}
-		std::memcpy(&block_crc32, temp, sizeof(block_crc32));
-		block_crc32 = little_endian::byteswap_if_alien(block_crc32);
+		boost::uint32_t block_crc32 = util::little_endian::load<boost::uint32_t>(temp);
 		
-		length = size_t(boost::iostreams::read(src, buffer, sizeof(buffer)));
+		length = size_t(boost::iostreams::read(src, buffer, std::streamsize(sizeof(buffer))));
 		if(length == size_t(EOF)) {
 			throw block_error("unexpected block end");
 		}
@@ -153,52 +152,53 @@
 
 block_reader::pointer block_reader::get(std::istream & base, const setup::version & version) {
 	
-	(void)enum_names<block_compression>::name;
+	USE_ENUM_NAMES(block_compression)
 	
-	uint32_t expected_checksum = load_number<uint32_t>(base);
+	boost::uint32_t expected_checksum = util::load<boost::uint32_t>(base);
 	crypto::crc32 actual_checksum;
 	actual_checksum.init();
 	
-	uint32_t stored_size;
+	boost::uint32_t stored_size;
 	block_compression compression;
 	
 	if(version >= INNO_VERSION(4, 0, 9)) {
 		
-		stored_size = actual_checksum.load_number<uint32_t>(base);
-		uint8_t compressed = actual_checksum.load_number<uint8_t>(base);
+		stored_size = actual_checksum.load<boost::uint32_t>(base);
+		boost::uint8_t compressed = actual_checksum.load<boost::uint8_t>(base);
 		
 		compression = compressed ? (version >= INNO_VERSION(4, 1, 6) ? LZMA1 : Zlib) : Stored;
 		
 	} else {
 		
-		uint32_t compressed_size = actual_checksum.load_number<uint32_t>(base);
-		uint32_t uncompressed_size = actual_checksum.load_number<uint32_t>(base);
+		boost::uint32_t compressed_size = actual_checksum.load<boost::uint32_t>(base);
+		boost::uint32_t uncompressed_size = actual_checksum.load<boost::uint32_t>(base);
 		
-		if(compressed_size == uint32_t(-1)) {
+		if(compressed_size == boost::uint32_t(-1)) {
 			stored_size = uncompressed_size, compression = Stored;
 		} else {
 			stored_size = compressed_size, compression = Zlib;
 		}
 		
 		// Add the size of a CRC32 checksum for each 4KiB subblock.
-		stored_size += uint32_t(ceildiv<uint64_t>(stored_size, 4096) * 4);
+		stored_size += boost::uint32_t(util::ceildiv<boost::uint64_t>(stored_size, 4096) * 4);
 	}
 	
 	if(actual_checksum.finalize() != expected_checksum) {
-		throw block_error("block CRC32 mismatch");
+		throw block_error("block header CRC32 mismatch");
 	}
 	
 	debug("[block] size: " << stored_size << "  compression: " << compression);
 	
-	boost::shared_ptr<io::filtering_istream> fis = boost::make_shared<io::filtering_istream>();
+	util::unique_ptr<io::filtering_istream>::type fis(new io::filtering_istream);
 	
 	switch(compression) {
 		case Stored: break;
 		case Zlib: fis->push(io::zlib_decompressor(), 8192); break;
-	#ifdef HAVE_LZMA
+	#if INNOEXTRACT_HAVE_LZMA
 		case LZMA1: fis->push(inno_lzma1_decompressor(), 8192); break;
 	#else
-		case LZMA1: throw block_error("LZMA decompression not supported by this Inno Extract build");
+		case LZMA1: throw block_error("LZMA decompression not supported by this "
+			                  + std::string(innoextract_name) + " build");
 	#endif
 	}
 	
@@ -206,7 +206,9 @@
 	
 	fis->push(io::restrict(base, 0, stored_size));
 	
-	return fis;
+	fis->exceptions(std::ios_base::badbit | std::ios_base::failbit);
+	
+	return pointer(fis.release());
 }
 
 } // namespace stream
diff -Nru innoextract-1.3/src/stream/block.hpp innoextract-1.4/src/stream/block.hpp
--- innoextract-1.3/src/stream/block.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/stream/block.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -18,32 +18,64 @@
  * 3. This notice may not be removed or altered from any source distribution.
  */
 
+/*!
+ * Wrapper to read, checksum and decompress header blocks.
+ *
+ * Thse blocks are used to store the setup headers (\ref setup).
+ */
 #ifndef INNOEXTRACT_STREAM_BLOCK_HPP
 #define INNOEXTRACT_STREAM_BLOCK_HPP
 
 #include <ios>
+#include <istream>
 #include <string>
 
-#include <boost/shared_ptr.hpp>
+#include "util/unique_ptr.hpp"
 
 namespace setup { struct version; }
 
 namespace stream {
 
+//! Error thrown by \ref chunk_reader::get or the returned stream if there was a problem.
 struct block_error : public std::ios_base::failure {
 	
-	inline block_error(std::string msg) : std::ios_base::failure(msg) { }
+	explicit block_error(std::string msg) : std::ios_base::failure(msg) { }
 	
 };
 
-//! Reads a compressed and checksumed block of data used to store the setup headers.
+/*!
+ * Wrapper to read compressed and checksumed block of data used to store setup headers.
+ *
+ * The decompressed headers are parsed in \ref setup::info, which also uses this class.
+ */
 class block_reader {
 	
 public:
 	
-	typedef std::istream type;
-	typedef boost::shared_ptr<type> pointer;
+	typedef std::istream                 type;
+	typedef util::unique_ptr<type>::type pointer;
 	
+	/*!
+	 * Wrap an input stream to read and decompress setup header blocks.
+	 *
+	 * Only one wrapper can be used at the same time for each \c base.
+	 *
+	 * \param base     The input stream for the main setup files.
+	 *                 It must already be positioned at start of the block stream.
+	 *                 The first block stream starts directly after the \ref setup::version
+	 *                 identifier whose position is given by
+	 *                 \ref loader::offsets::header_offset.
+	 *                 A second block stream directly follows the first one and contains
+	 *                 the \ref setup::data_entry "data entries".
+	 * \param version  The version of the setup data.
+	 *
+	 * \throws block_error if the block stream header checksum was invalid,
+	 *                     or if the block compression is not supported by this build.
+	 *
+	 * \return a pointer to a non-seekable input stream for the uncompressed headers.
+	 *         Reading from this stream may throw a \ref block_error if a block checksum
+	 *         was invalid.
+	 */
 	static pointer get(std::istream & base, const setup::version & version);
 	
 };
diff -Nru innoextract-1.3/src/stream/checksum.hpp innoextract-1.4/src/stream/checksum.hpp
--- innoextract-1.3/src/stream/checksum.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/stream/checksum.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -18,6 +18,9 @@
  * 3. This notice may not be removed or altered from any source distribution.
  */
 
+/*!
+ * Filter to be used with boost::iostreams for calculating a \ref crypto::checksum.
+ */
 #ifndef INNOEXTRACT_STREAM_CHECKSUM_HPP
 #define INNOEXTRACT_STREAM_CHECKSUM_HPP
 
@@ -29,6 +32,12 @@
 
 namespace stream {
 
+/*!
+ * Filters to be used with boost::iostreams for calculating a \ref crypto::checksum.
+ *
+ * An internal checksum state is updated as bytes are read and the final checksum is
+ * written to the given checksum object when the end of the source stream is reached.
+ */
 class checksum_filter : public boost::iostreams::multichar_input_filter {
 	
 private:
@@ -40,10 +49,15 @@
 	typedef base_type::char_type char_type;
 	typedef base_type::category category;
 	
-	inline checksum_filter(crypto::checksum * output, crypto::checksum_type type) : output(output) {
+	/*!
+	 * \param output Location to store the final checksum at.
+	 * \param type   The type of checksum to calculate.
+	 */
+	checksum_filter(crypto::checksum * output, crypto::checksum_type type)
+		: output(output) {
 		hasher.init(type);
 	}
-	inline checksum_filter(const checksum_filter & o) : hasher(o.hasher), output(o.output) { }
+	checksum_filter(const checksum_filter & o) : hasher(o.hasher), output(o.output) { }
 	
 	template<typename Source>
 	std::streamsize read(Source & src, char * dest, std::streamsize n) {
diff -Nru innoextract-1.3/src/stream/chunk.cpp innoextract-1.4/src/stream/chunk.cpp
--- innoextract-1.3/src/stream/chunk.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/stream/chunk.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -22,11 +22,11 @@
 
 #include <boost/iostreams/filter/bzip2.hpp>
 #include <boost/iostreams/filter/zlib.hpp>
-#include <boost/iostreams/restrict.hpp>
 #include <boost/make_shared.hpp>
-#include <boost/ref.hpp>
 
+#include "release.hpp"
 #include "stream/lzma.hpp"
+#include "stream/restrict.hpp"
 #include "stream/slice.hpp"
 #include "util/log.hpp"
 #include "util/util.hpp"
@@ -65,7 +65,7 @@
 chunk_reader::pointer chunk_reader::get(slice_reader & base, const chunk & chunk) {
 	
 	if(!base.seek(chunk.first_slice, chunk.offset)) {
-		throw chunk_error("error seeking");
+		throw chunk_error("error seeking to chunk start");
 	}
 	
 	char magic[ARRAY_SIZE(chunk_id)];
@@ -73,23 +73,24 @@
 		throw chunk_error("bad chunk magic");
 	}
 	
-	pointer result = boost::make_shared<type>();
+	pointer result(new boost::iostreams::chain<boost::iostreams::input>);
 	
 	switch(chunk.compression) {
 		case Stored: break;
 		case Zlib:   result->push(io::zlib_decompressor(), 8192); break;
 		case BZip2:  result->push(io::bzip2_decompressor(), 8192); break;
-	#ifdef HAVE_LZMA
+	#if INNOEXTRACT_HAVE_LZMA
 		case LZMA1:  result->push(inno_lzma1_decompressor(), 8192); break;
 		case LZMA2:  result->push(inno_lzma2_decompressor(), 8192); break;
 	#else
 		case LZMA1: case LZMA2:
-			throw chunk_error("LZMA decompression not supported by this Inno Extract build");
+			throw chunk_error("LZMA decompression not supported by this "
+			                  + std::string(innoextract_name) + " build");
 	#endif
-		default: throw chunk_error("unknown compression");
+		default: throw chunk_error("unknown chunk compression");
 	}
 	
-	result->push(io::restrict(boost::ref(base), 0, int64_t(chunk.size)));
+	result->push(restrict(base, chunk.size));
 	
 	return result;
 }
diff -Nru innoextract-1.3/src/stream/chunk.hpp innoextract-1.4/src/stream/chunk.hpp
--- innoextract-1.3/src/stream/chunk.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/stream/chunk.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -18,28 +18,37 @@
  * 3. This notice may not be removed or altered from any source distribution.
  */
 
+/*!
+ * Wrapper to read and decompress a chunk from a \ref stream::slice_reader.
+ *
+ * A chunk consists of one compression stream (one of \ref stream::compression_method) and
+ * contains one or more \ref file "files". Files may also have additional filters managed by
+ * \ref stream::file_reader.
+ */
 #ifndef INNOEXTRACT_STREAM_CHUNK_HPP
 #define INNOEXTRACT_STREAM_CHUNK_HPP
 
 #include <stddef.h>
-#include <stdint.h>
 #include <ios>
 
-#include <boost/shared_ptr.hpp>
+#include <boost/cstdint.hpp>
 #include <boost/iostreams/chain.hpp>
 
 #include "util/enum.hpp"
+#include "util/unique_ptr.hpp"
 
 namespace stream {
 
 class slice_reader;
 
+//! Error thrown by \ref chunk_reader::get if there was a problem.
 struct chunk_error : public std::ios_base::failure {
 	
-	inline chunk_error(std::string msg) : std::ios_base::failure(msg) { }
+	explicit chunk_error(std::string msg) : std::ios_base::failure(msg) { }
 	
 };
 
+//! Compression methods supported by chunks.
 enum compression_method {
 	Stored,
 	Zlib,
@@ -49,16 +58,23 @@
 	UnknownCompression
 };
 
+/*!
+ * Information specifying a compressed chunk.
+ *
+ * This data is stored in \ref setup::data_entry "data entries".
+ *
+ * Chunks specified by this struct can be read using \ref chunk_reader.
+ */
 struct chunk {
 	
-	size_t first_slice; //!< Slice where the chunk starts.
-	size_t last_slice;
+	size_t first_slice;             //!< Slice where the chunk starts.
+	size_t last_slice;              //!< Slice where the chunk ends.
 	
-	uint32_t offset;    //!< Offset of the compressed chunk in firstSlice.
-	uint64_t size;      //! Total compressed size of the chunk.
+	boost::uint32_t offset;         //!< Offset of the compressed chunk in firstSlice.
+	boost::uint64_t size;           //! Total compressed size of the chunk.
 	
-	compression_method compression;
-	bool encrypted;
+	compression_method compression; //!< Compression method used by the chunk.
+	bool encrypted;                 //!< Is the chunk encrypted? Unsupported for now.
 	
 	bool operator<(const chunk & o) const;
 	bool operator==(const chunk & o) const;
@@ -66,13 +82,30 @@
 
 class silce_source;
 
+/*!
+ * Wrapper to read and decompress a chunk from a \ref slice_reader.
+ * Restrics the stream to the chunk size and applies the appropriate decompression.
+ */
 class chunk_reader {
 	
 public:
 	
 	typedef boost::iostreams::chain<boost::iostreams::input> type;
-	typedef boost::shared_ptr<type> pointer;
+	typedef util::unique_ptr<type>::type                     pointer;
 	
+	/*!
+	 * Wrap a \ref slice_reader to read and decompress a single chunk.
+	 *
+	 * Only one wrapper can be used at the same time for each \c base.
+	 *
+	 * \param base  The slice reader for the setup file(s).
+	 * \param chunk Information specifying the chunk to read.
+	 *
+	 * \throws chunk_error if the chunk header could not be read or was invalid,
+	 *                     or if the chunk compression is not supported by this build.
+	 *
+	 * \return a pointer to a non-seekable input filter chain for the requested file.
+	 */
 	static pointer get(slice_reader & base, const ::stream::chunk & chunk);
 	
 };
diff -Nru innoextract-1.3/src/stream/exefilter.hpp innoextract-1.4/src/stream/exefilter.hpp
--- innoextract-1.3/src/stream/exefilter.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/stream/exefilter.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -18,17 +18,29 @@
  * 3. This notice may not be removed or altered from any source distribution.
  */
 
+/*!
+ * Filters to be used with boost::iostreams for undoing transformations Inno Setup applies
+ * to stored executable files to make them more compressible.
+ */
 #ifndef INNOEXTRACT_STREAM_EXEFILTER_HPP
 #define INNOEXTRACT_STREAM_EXEFILTER_HPP
 
-#include <stdint.h>
 #include <stddef.h>
 #include <iosfwd>
+#include <cassert>
 
+#include <boost/cstdint.hpp>
 #include <boost/iostreams/char_traits.hpp>
 #include <boost/iostreams/concepts.hpp>
 #include <boost/iostreams/get.hpp>
+#include <boost/iostreams/read.hpp>
 
+/*!
+ * Filter to decode executable files stored by Inno Setup versions before 5.2.0.
+ *
+ * Essentially, it tries to change the addresses stored for x86 CALL and JMP instructions
+ * to be relative to the instruction's position.
+ */
 class inno_exe_decoder_4108 : public boost::iostreams::multichar_input_filter {
 	
 private:
@@ -51,12 +63,18 @@
 		addr_bytes_left = 0, addr_offset = 5;
 	}
 	
-	uint32_t addr;
+	boost::uint32_t addr;
 	size_t addr_bytes_left;
-	uint32_t addr_offset;
+	boost::uint32_t addr_offset;
 	
 };
 
+/*!
+ * Filter to decode executable files stored by Inno Setup versions after 5.2.0.
+ *
+ * It tries to change the addresses stored for x86 CALL and JMP instructions to be
+ * relative to the instruction's position, plus a few other tweaks.
+ */
 class inno_exe_decoder_5200 : public boost::iostreams::multichar_input_filter {
 	
 private:
@@ -68,8 +86,12 @@
 	typedef base_type::char_type char_type;
 	typedef base_type::category category;
 	
-	explicit inno_exe_decoder_5200(bool _flip_high_byte)
-		: flip_high_byte(_flip_high_byte) { close(0); }
+	/*!
+	 * \param flip_high_byte true if the high byte of addresses is flipped if bit 23 is set.
+	 *                       This optimization is used in Inno Setup 5.3.9 and later.
+	 */
+	explicit inno_exe_decoder_5200(bool flip_high_byte)
+		: flip_high_byte(flip_high_byte) { close(0); }
 	
 	template<typename Source>
 	std::streamsize read(Source & src, char * dest, std::streamsize n);
@@ -104,10 +126,10 @@
 	static const size_t block_size = 0x10000;
 	const bool flip_high_byte;
 	
-	uint32_t offset; //! Total number of bytes read from the source.
+	boost::uint32_t offset; //! Total number of bytes read from the source.
 	
-	int8_t flush_bytes;
-	uint8_t buffer[4];
+	boost::int8_t flush_bytes;
+	boost::uint8_t buffer[4];
 	
 };
 
@@ -126,18 +148,18 @@
 			
 			// Check if this is a CALL or JMP instruction.
 			if(byte == 0xe8 || byte == 0xe9) {
-				addr = -addr_offset;
+				addr = ~addr_offset + 1;
 				addr_bytes_left = 4;
 			}
 			
 		} else {
-			addr += uint8_t(byte);
-			byte = uint8_t(addr);
+			addr += boost::uint8_t(byte);
+			byte = boost::uint8_t(addr);
 			addr >>= 8;
 			addr_bytes_left--;
 		}
 		
-		*dest++ = char(uint8_t(byte));
+		*dest++ = char(boost::uint8_t(byte));
 	}
 	
 	return n;
@@ -200,20 +222,23 @@
 		char * dst = reinterpret_cast<char *>(buffer + 4 + flush_bytes);
 		std::streamsize nread = boost::iostreams::read(src, dst, -flush_bytes);
 		if(nread == EOF) {
-			flush(int8_t(4 + flush_bytes));
+			flush(boost::int8_t(4 + flush_bytes));
 			return total_read ? total_read : EOF;
 		}
-		flush_bytes = int8_t(flush_bytes + nread), offset += uint32_t(nread);
+		flush_bytes = boost::int8_t(flush_bytes + nread), offset += boost::uint32_t(nread);
 		if(flush_bytes) { return total_read; }
 		
 		// Verify that the high byte of the address is 0x00 or 00xff.
 		if(buffer[3] == 0x00 || buffer[3] == 0xff) {
 			
-			uint32_t addr = offset & 0xffffff; // may wrap, but OK
+			boost::uint32_t addr = offset & 0xffffff; // may wrap, but OK
 			
-			uint32_t rel = buffer[0] | (uint32_t(buffer[1]) << 8) | (uint32_t(buffer[2]) << 16);
+			boost::uint32_t rel = buffer[0] | (boost::uint32_t(buffer[1]) << 8)
+			                                | (boost::uint32_t(buffer[2]) << 16);
 			rel -= addr;
-			buffer[0] = uint8_t(rel), buffer[1] = uint8_t(rel >> 8), buffer[2] = uint8_t(rel >> 16);
+			buffer[0] = boost::uint8_t(rel);
+			buffer[1] = boost::uint8_t(rel >> 8);
+			buffer[2] = boost::uint8_t(rel >> 16);
 			
 			if(flip_high_byte) {
 				// For a slightly higher compression ratio, we want the resulting high
@@ -221,7 +246,7 @@
 				// of the original relative address is likely to be the sign extension
 				// of bit 23, so if bit 23 is set, toggle all bits in the high byte.
 				if(rel & 0x800000) {
-					buffer[3] = uint8_t(~buffer[3]);
+					buffer[3] = boost::uint8_t(~buffer[3]);
 				}
 			}
 			
diff -Nru innoextract-1.3/src/stream/file.cpp innoextract-1.4/src/stream/file.cpp
--- innoextract-1.3/src/stream/file.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/stream/file.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -20,12 +20,12 @@
 
 #include "stream/file.hpp"
 
-#include <boost/make_shared.hpp>
 #include <boost/iostreams/filtering_stream.hpp>
 #include <boost/iostreams/restrict.hpp>
 
 #include "stream/checksum.hpp"
 #include "stream/exefilter.hpp"
+#include "stream/restrict.hpp"
 
 namespace io = boost::iostreams;
 
@@ -54,7 +54,7 @@
 file_reader::pointer file_reader::get(base_type & base, const file & file,
                                       crypto::checksum * checksum) {
 	
-	boost::shared_ptr<io::filtering_istream> result = boost::make_shared<io::filtering_istream>();
+	util::unique_ptr<io::filtering_istream>::type result(new io::filtering_istream);
 	
 	if(checksum) {
 		result->push(stream::checksum_filter(checksum, file.checksum.type), 8192);
@@ -67,9 +67,9 @@
 		case InstructionFilter5309: result->push(inno_exe_decoder_5200(true), 8192); break;
 	}
 	
-	result->push(io::restrict(base, 0, int64_t(file.size)));
+	result->push(restrict(base, file.size));
 	
-	return result;
+	return pointer(result.release());
 }
 
 } // namespace stream
diff -Nru innoextract-1.3/src/stream/file.hpp innoextract-1.4/src/stream/file.hpp
--- innoextract-1.3/src/stream/file.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/stream/file.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -18,15 +18,18 @@
  * 3. This notice may not be removed or altered from any source distribution.
  */
 
+/*!
+ * Wrapper to read a single file from a chunk (\ref stream::chunk_reader).
+ */
 #ifndef INNOEXTRACT_STREAM_FILE_HPP
 #define INNOEXTRACT_STREAM_FILE_HPP
 
 #include <istream>
 
-#include <boost/shared_ptr.hpp>
 #include <boost/iostreams/chain.hpp>
 
 #include "crypto/checksum.hpp"
+#include "util/unique_ptr.hpp"
 
 namespace stream {
 
@@ -37,33 +40,59 @@
 	InstructionFilter5309,
 };
 
+/*!
+ * Information specifying a single file inside a compressed chunk.
+ *
+ * This data is stored in \ref setup::data_entry "data entries".
+ *
+ * Files specified by this struct can be read using \ref file_reader.
+ */
 struct file {
 	
-	uint64_t offset; //!< Offset of this file within the decompressed chunk.
-	uint64_t size; //!< Decompressed size of this file.
+	boost::uint64_t    offset;   //!< Offset of this file within the decompressed chunk.
+	boost::uint64_t    size;     //!< Decompressed size of this file.
 	
-	crypto::checksum checksum;
+	crypto::checksum   checksum; //!< Checksum for the file.
 	
-	compression_filter filter; //!< Additional filter used before compression.
+	compression_filter filter;   //!< Additional filter used before compression.
 	
 	bool operator<(const file & o) const;
 	bool operator==(const file & o) const;
 	
 };
 
+/*!
+ * Wrapper to read a single file from a \ref chunk_reader.
+ * Restrics the stream to the file size and applies the appropriate filters.
+ */
 class file_reader {
 	
 	typedef boost::iostreams::chain<boost::iostreams::input> base_type;
 	
 public:
 	
-	typedef std::istream type;
-	typedef boost::shared_ptr<type> pointer;
-	
-	static pointer get(base_type & base, const file & file, crypto::checksum * checksum_output);
+	typedef std::istream                 type;
+	typedef util::unique_ptr<type>::type pointer;
+	typedef file                         file_t;
+	
+	/*!
+	 * Wrap a \ref chunk_reader to read a single file.
+	 *
+	 * Only one wrapper can be used at the same time for each \c base.
+	 *
+	 * \param base     The chunk reader containing the file.
+	 *                 It must already be positioned at the file's offset.
+	 * \param file     Information specifying the file to read.
+	 * \param checksum Optional pointer to a checksum that is updated as the file is read.
+	 *                 The type of the checksum will be the same as that stored in the file
+	 *                 struct.
+	 *
+	 * \return a pointer to a non-seekable input stream for the requested file.
+	 */
+	static pointer get(base_type & base, const file_t & file, crypto::checksum * checksum);
 	
 };
 
-}
+} // namespace stream
 
 #endif // INNOEXTRACT_STREAM_FILE_HPP
diff -Nru innoextract-1.3/src/stream/lzma.cpp innoextract-1.4/src/stream/lzma.cpp
--- innoextract-1.3/src/stream/lzma.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/stream/lzma.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -18,19 +18,24 @@
  * 3. This notice may not be removed or altered from any source distribution.
  */
 
+#define INNOEXTRACT_HAVE_LZMA 1
+
 #include "stream/lzma.hpp"
 
-#include <stdint.h>
+#include <boost/cstdint.hpp>
 
 #include <lzma.h>
 
+#include "util/endian.hpp"
+#include "util/load.hpp"
+
 namespace stream {
 
 static lzma_stream * init_raw_lzma_stream(lzma_vli filter, lzma_options_lzma & options) {
 	
 	options.preset_dict = NULL;
 	
-	if(options.dict_size > (uint32_t(1) << 28)) {
+	if(options.dict_size > (boost::uint32_t(1) << 28)) {
 		throw lzma_error("inno lzma dict size too large", LZMA_FORMAT_ERROR);
 	}
 	
@@ -55,10 +60,10 @@
 	
 	lzma_stream * strm = static_cast<lzma_stream *>(stream);
 	
-	strm->next_in = reinterpret_cast<const uint8_t *>(begin_in);
+	strm->next_in = reinterpret_cast<const boost::uint8_t *>(begin_in);
 	strm->avail_in = size_t(end_in - begin_in);
 	
-	strm->next_out = reinterpret_cast<uint8_t *>(begin_out);
+	strm->next_out = reinterpret_cast<boost::uint8_t *>(begin_out);
 	strm->avail_out = size_t(end_out - begin_out);
 	
 	lzma_ret ret = lzma_code(strm, LZMA_RUN);
@@ -98,7 +103,7 @@
 		
 		lzma_options_lzma options;
 		
-		uint8_t properties = uint8_t(header[0]);
+		boost::uint8_t properties = boost::uint8_t(header[0]);
 		if(properties > (9 * 5 * 5)) {
 			throw lzma_error("inno lzma1 property error", LZMA_FORMAT_ERROR);
 		}
@@ -106,10 +111,7 @@
 		options.lp = (properties % (9 * 5)) / 9;
 		options.lc = properties % 9;
 		
-		options.dict_size = 0;
-		for(size_t i = 0; i < 4; i++) {
-			options.dict_size += uint32_t(uint8_t(header[i + 1])) << (i * 8);
-		}
+		options.dict_size = util::little_endian::load<boost::uint32_t>(header + 1);
 		
 		stream = init_raw_lzma_stream(LZMA_FILTER_LZMA1, options);
 	}
@@ -129,7 +131,7 @@
 		
 		lzma_options_lzma options;
 		
-		uint8_t prop = uint8_t(*begin_in++);
+		boost::uint8_t prop = boost::uint8_t(*begin_in++);
 		if(prop > 40) {
 			throw lzma_error("inno lzma2 property error", LZMA_FORMAT_ERROR);
 		}
@@ -137,7 +139,7 @@
 		if(prop == 40) {
 			options.dict_size = 0xffffffff;
 		} else {
-			options.dict_size = ((uint32_t(2) | uint32_t((prop) & 1)) << ((prop) / 2 + 11));
+			options.dict_size = ((boost::uint32_t(2) | boost::uint32_t((prop) & 1)) << ((prop) / 2 + 11));
 		}
 		
 		stream = init_raw_lzma_stream(LZMA_FILTER_LZMA2, options);
diff -Nru innoextract-1.3/src/stream/lzma.hpp innoextract-1.4/src/stream/lzma.hpp
--- innoextract-1.3/src/stream/lzma.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/stream/lzma.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -18,12 +18,15 @@
  * 3. This notice may not be removed or altered from any source distribution.
  */
 
+/*!
+ * LZMA 1 and 2 (aka xz) descompression filters to be used with boost::iostreams.
+ */
 #ifndef INNOEXTRACT_STREAM_LZMA_HPP
 #define INNOEXTRACT_STREAM_LZMA_HPP
 
 #include "configure.hpp"
 
-#ifdef HAVE_LZMA
+#if INNOEXTRACT_HAVE_LZMA
 
 #include <stddef.h>
 #include <iosfwd>
@@ -33,12 +36,14 @@
 
 namespace stream {
 
+//! Error thrown if there was en error in an LZMA stream
 struct lzma_error : public std::ios_base::failure {
 	
-	inline lzma_error(std::string msg, int code)
+	lzma_error(std::string msg, int code)
 		: std::ios_base::failure(msg), error_code(code) { }
 	
-	inline int error() const { return error_code; }
+	//! \return the liblzma code for the error.
+	int error() const { return error_code; }
 	
 private:
 	
@@ -51,7 +56,7 @@
 	
 	typedef char char_type;
 	
-	inline ~lzma_decompressor_impl_base() { close(); }
+	~lzma_decompressor_impl_base() { close(); }
 	
 	bool filter(const char * & begin_in, const char * end_in,
 	            char * & begin_out, char * end_out, bool flush);
@@ -61,7 +66,7 @@
 protected:
 	
 	//! Abstract base class, subclasses need to intialize stream.
-	inline lzma_decompressor_impl_base() : stream(NULL) { }
+	lzma_decompressor_impl_base() : stream(NULL) { }
 	
 	void * stream;
 	
@@ -71,12 +76,12 @@
 	
 public:
 	
-	inline inno_lzma1_decompressor_impl() : nread(0) { }
+	inno_lzma1_decompressor_impl() : nread(0) { }
 	
 	bool filter(const char * & begin_in, const char * end_in,
 	            char * & begin_out, char * end_out, bool flush);
 	
-	inline void close() { lzma_decompressor_impl_base::close(), nread = 0; }
+	void close() { lzma_decompressor_impl_base::close(), nread = 0; }
 	
 private:
 	
@@ -110,7 +115,8 @@
  *
  * The LZMA1 streams used by Inno Setup differ slightly from the LZMA Alone file format:
  * The stream header only stores the properties (lc, lp, pb) and the dictionary size and
- * is missing the uncompressed size field. The fiels that are present are encoded identically.
+ * is missing the uncompressed size field. The fiels that are present are encoded
+ * identically.
  */
 typedef lzma_decompressor<inno_lzma1_decompressor_impl> inno_lzma1_decompressor;
 
@@ -118,12 +124,13 @@
  * A filter that decompressess LZMA2 streams found in Inno Setup installers,
  * to be used with boost::iostreams.
  *
- * Inno Setup uses raw LZMA2 streams. (preceded only by the dictionary size encoded as one byte)
+ * Inno Setup uses raw LZMA2 streams.
+ * (preceded only by the dictionary size encoded as one byte)
  */
 typedef lzma_decompressor<inno_lzma2_decompressor_impl> inno_lzma2_decompressor;
 
 } // namespace stream
 
-#endif // HAVE_LZMA
+#endif // INNOEXTRACT_HAVE_LZMA
 
 #endif // INNOEXTRACT_STREAM_LZMA_HPP
diff -Nru innoextract-1.3/src/stream/restrict.hpp innoextract-1.4/src/stream/restrict.hpp
--- innoextract-1.3/src/stream/restrict.hpp	1970-01-01 00:00:00.000000000 +0000
+++ innoextract-1.4/src/stream/restrict.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2013 Daniel Scharrer
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the author(s) be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/*!
+ * Wrapper class for a boost::iostreams-compatible source that can be used to restrict
+ * sources to appear smaller than they really are.
+ */
+#ifndef INNOEXTRACT_STREAM_RESTRICT_HPP
+#define INNOEXTRACT_STREAM_RESTRICT_HPP
+
+#include <boost/cstdint.hpp>
+#include <boost/iostreams/concepts.hpp>
+#include <boost/iostreams/read.hpp>
+
+namespace stream {
+
+//! Like boost::iostreams::restriction, but always has a 64-bit counter.
+template <typename BaseSource>
+class restricted_source : public boost::iostreams::source {
+	
+	BaseSource &    base;      //!< The base source to read from.
+	boost::uint64_t remaining; //!< Number of bytes remaining in the restricted source.
+	
+public:
+	
+	restricted_source(const restricted_source & o)
+		: base(o.base), remaining(o.remaining) { }
+	
+	restricted_source(BaseSource & base, boost::uint64_t size)
+		: base(base), remaining(size) { }
+	
+	std::streamsize read(char * buffer, std::streamsize bytes) {
+		
+		if(bytes <= 0) {
+			return 0;
+		}
+		
+		// Restrict the number of bytes to read
+		bytes = std::streamsize(std::min(boost::uint64_t(bytes), remaining));
+		if(bytes == 0) {
+			return -1; // End of the restricted source reached
+		}
+		
+		std::streamsize nread = boost::iostreams::read(base, buffer, bytes);
+		
+		// Remember how many bytes were read so far
+		if(nread > 0) {
+			remaining -= std::min(boost::uint64_t(nread), remaining);
+		}
+		
+		return nread;
+	}
+	
+};
+
+/*!
+ * Restricts a source to a specific size from the current position and makes
+ * it non-seekable.
+ *
+ * Like boost::iostreams::restrict, but always has a 64-bit counter.
+ */
+template <typename BaseSource>
+restricted_source<BaseSource> restrict(BaseSource & source, boost::uint64_t size) {
+	return restricted_source<BaseSource>(source, size);
+}
+
+} // namespace stream
+
+#endif // INNOEXTRACT_STREAM_RESTRICT_HPP
diff -Nru innoextract-1.3/src/stream/slice.cpp innoextract-1.4/src/stream/slice.cpp
--- innoextract-1.3/src/stream/slice.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/stream/slice.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -20,11 +20,12 @@
 
 #include "stream/slice.hpp"
 
-#include <stdint.h>
 #include <sstream>
 #include <cstring>
 #include <limits>
 
+#include <boost/cstdint.hpp>
+
 #include "util/console.hpp"
 #include "util/load.hpp"
 #include "util/log.hpp"
@@ -41,32 +42,37 @@
 
 } // anonymous namespace
 
-slice_reader::slice_reader(const path_type & setup_file, uint32_t data_offset)
-	: dir(), last_dir(), base_file(), data_offset(data_offset), slices_per_disk(1),
-	  current_slice(0) {
-	
-	ifs.open(setup_file, std::ios_base::binary | std::ios_base::in | std::ios_base::ate);
-	
-	slice_size = uint32_t(std::min<std::streampos>(ifs.tellg(), std::numeric_limits<int32_t>::max()));
-	if(ifs.seekg(data_offset).fail()) {
-		ifs.close();
+slice_reader::slice_reader(std::istream * istream, boost::uint32_t data_offset)
+	: data_offset(data_offset),
+	  dir(), last_dir(), base_file(), slices_per_disk(1),
+	  current_slice(0), slice_file(), slice_size(0),
+	  ifs(), is(istream) {
+	
+	std::streampos max_size = std::streampos(std::numeric_limits<boost::int32_t>::max());
+	
+	std::streampos file_size = is->seekg(0, std::ios_base::end).tellg();
+	
+	slice_size = boost::uint32_t(std::min(file_size, max_size));
+	if(is->seekg(data_offset).fail()) {
+		throw slice_error("could not seek to data");
 	}
 }
 
 slice_reader::slice_reader(const path_type & dir, const path_type & base_file,
                            size_t slices_per_disk)
-	: dir(dir), last_dir(dir), base_file(base_file), data_offset(0),
-	  slices_per_disk(slices_per_disk), current_slice(0) { }
+	: data_offset(0),
+	  dir(dir), last_dir(dir), base_file(base_file), slices_per_disk(slices_per_disk),
+	  current_slice(0), slice_file(), slice_size(0),
+	  ifs(), is(&ifs) { }
 
 bool slice_reader::seek(size_t slice) {
 	
-	if(slice == current_slice && ifs.is_open()) {
+	if(slice == current_slice && is_open()) {
 		return true;
 	}
 	
 	if(data_offset != 0) {
-		log_error << "[slice] cannot change slices in single-file setup";
-		return false;
+		throw slice_error("[slice] cannot change slices in single-file setup");
 	}
 	
 	return open(slice, path_type());
@@ -77,20 +83,20 @@
 	log_info << "opening \"" << color::cyan << file.string() << color::reset << '"';
 	
 	ifs.close();
+	ifs.clear();
 	
 	ifs.open(file, std::ios_base::in | std::ios_base::binary | std::ios_base::ate);
 	if(ifs.fail()) {
 		return false;
 	}
 	
-	std::streampos fileSize = ifs.tellg();
+	std::streampos file_size = ifs.tellg();
 	ifs.seekg(0);
 	
 	char magic[8];
 	if(ifs.read(magic, 8).fail()) {
 		ifs.close();
-		log_error << "[slice] error reading magic number";
-		return false;
+		throw slice_error("error reading slice magic number");
 	}
 	bool found = false;
 	for(size_t i = 0; ARRAY_SIZE(slice_ids); i++) {
@@ -100,16 +106,24 @@
 		}
 	}
 	if(!found) {
-		log_error << "[slice] bad magic number";
 		ifs.close();
-		return false;
+		throw slice_error("bad slice magic number");
 	}
 	
-	slice_size = load_number<uint32_t>(ifs);
-	if(ifs.fail() || std::streampos(slice_size) > fileSize) {
-		log_error << "[slice] bad slice size: " << slice_size << " > " << fileSize;
+	slice_size = util::load<boost::uint32_t>(ifs);
+	if(ifs.fail()) {
 		ifs.close();
-		return false;
+		throw slice_error("error reading slice size");
+	} else if(std::streampos(slice_size) > file_size) {
+		ifs.close();
+		std::ostringstream oss;
+		oss << "bad slice size: " << slice_size << " > " << file_size;
+		throw slice_error(oss.str());
+	} else if(std::streampos(slice_size) < ifs.tellg()) {
+		ifs.close();
+		std::ostringstream oss;
+		oss << "bad slice size: " << slice_size << " < " << ifs.tellg();
+		throw slice_error(oss.str());
 	}
 	
 	slice_file = file;
@@ -122,11 +136,11 @@
 bool slice_reader::open(size_t slice, const path_type & file) {
 	
 	current_slice = slice;
+	is = &ifs;
 	ifs.close();
 	
 	if(slices_per_disk == 0) {
-		log_error << "[slice] slices per disk must not be zero";
-		return false;
+		throw std::runtime_error("[slice] slices per disk must not be zero");
 	}
 	
 	path_type slice_file = file;
@@ -140,7 +154,7 @@
 		} else {
 			size_t major = (slice / slices_per_disk) + 1;
 			size_t minor = slice % slices_per_disk;
-			oss << major << char(uint8_t('a') + minor);
+			oss << major << char(boost::uint8_t('a') + minor);
 		}
 		oss << ".bin";
 		
@@ -155,20 +169,28 @@
 		return true;
 	}
 	
+	if(dir != last_dir) {
+		log_error << "error opening " << slice_file << " in " << last_dir << " or " << dir;
+	} else {
+		log_error << "error opening " << last_dir / slice_file;
+	}
+	
 	return false;
 }
 
-bool slice_reader::seek(size_t slice, uint32_t offset) {
+bool slice_reader::seek(size_t slice, boost::uint32_t offset) {
 	
 	if(!seek(slice)) {
 		return false;
 	}
 	
-	if(offset > slice_size - data_offset) {
+	offset += data_offset;
+	
+	if(offset > slice_size) {
 		return false;
 	}
 	
-	if(ifs.seekg(data_offset + offset).fail()) {
+	if(is->seekg(offset).fail()) {
 		return false;
 	}
 	
@@ -177,28 +199,39 @@
 
 std::streamsize slice_reader::read(char * buffer, std::streamsize bytes) {
 	
-	std::streamsize nread = 0;
-	
 	if(!seek(current_slice)) {
-		return nread;
+		return (bytes == 0) ? 0 : -1;
 	}
 	
+	std::streamsize nread = 0;
+	
 	while(bytes > 0) {
 		
-		std::streamsize remaining = std::streamsize(slice_size - size_t(ifs.tellg()));
+		boost::uint32_t read_pos = boost::uint32_t(is->tellg());
+		if(read_pos > slice_size) {
+			break;
+		}
+		std::streamsize remaining = std::streamsize(slice_size - read_pos);
 		if(!remaining) {
 			if(!seek(current_slice + 1)) {
-				return nread;
+				break;
 			}
-			remaining = std::streamsize(slice_size - size_t(ifs.tellg()));
+			read_pos = boost::uint32_t(is->tellg());
+			if(read_pos > slice_size) {
+				break;
+			}
+			remaining = std::streamsize(slice_size - read_pos);
 		}
 		
-		std::streamsize read = ifs.read(buffer, std::min(remaining, bytes)).gcount();
+		if(is->read(buffer, std::min(remaining, bytes)).fail()) {
+			break;
+		}
 		
+		std::streamsize read = is->gcount();
 		nread += read, buffer += read, bytes -= read;
 	}
 	
-	return nread;
+	return (nread != 0 || bytes == 0) ? nread : -1;
 }
 
 } // namespace stream
diff -Nru innoextract-1.3/src/stream/slice.hpp innoextract-1.4/src/stream/slice.hpp
--- innoextract-1.3/src/stream/slice.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/stream/slice.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -18,50 +18,133 @@
  * 3. This notice may not be removed or altered from any source distribution.
  */
 
+/*!
+ * Abstraction for reading the embedded or external raw setup data.
+ */
 #ifndef INNOEXTRACT_STREAM_SLICEREADER_HPP
 #define INNOEXTRACT_STREAM_SLICEREADER_HPP
 
+#include <ios>
+
 #include <boost/iostreams/concepts.hpp>
 #include <boost/filesystem/path.hpp>
-#include <boost/filesystem/fstream.hpp>
+
+#include "util/fstream.hpp"
 
 namespace stream {
 
+//! Error thrown by \ref chunk_reader if there was a problem.
+struct slice_error : public std::ios_base::failure {
+	
+	explicit slice_error(std::string msg) : std::ios_base::failure(msg) { }
+	
+};
+
+/*!
+ * Abstraction for reading either data embedded inside the setup executable or from
+ * multiple external slices.
+ *
+ * Setup data contained in the executable is located by a non-zeore
+ * \ref loader::offsets::data_offset.
+ *
+ * The contained data is made up of one or more \ref chunk "chunks"
+ * (read by \ref chunk_reader), which in turn contain one or more  \ref file "files"
+ * (read by \ref file_reader).
+ */
 class slice_reader : public boost::iostreams::source {
 	
 	typedef boost::filesystem::path path_type;
 	
-	path_type dir;
-	path_type last_dir;
-	path_type base_file;
-	const uint32_t data_offset;
-	const size_t slices_per_disk;
-	
-	size_t current_slice;
-	path_type slice_file;
-	uint32_t slice_size;
+	// Information for reading embedded setup data
+	const boost::uint32_t data_offset;
 	
-	boost::filesystem::ifstream ifs;
+	// Information for eading external setup data
+	path_type    dir;             //!< Slice directory specified at construction.
+	path_type    last_dir;        //!< Directory containing the current slice.
+	path_type    base_file;       //!< Base file name for slices.
+	const size_t slices_per_disk; //!< Number of slices grouped into each disk (for names).
+	
+	// Information about the current slice
+	size_t          current_slice; //!< Number of the currently opened slice.
+	path_type       slice_file;    //!< Filename of the currently opened slice.
+	boost::uint32_t slice_size;    //!< Size in bytes of the currently opened slice.
+	
+	// Streams
+	util::ifstream ifs; //!< File input stream used when reading from external slices.
+	std::istream * is;  //!< Input stream to read from.
 	
 	bool seek(size_t slice);
 	bool open_file(const path_type & file);
+	bool open(size_t slice, const path_type & slice_file);
 	
 public:
 	
-	slice_reader(const path_type & setup_file, uint32_t data_offset);
-	
-	slice_reader(const path_type & dir, const path_type & base_file, size_t slices_per_disk);
-	
-	bool seek(size_t slice, uint32_t offset);
-	
+	/*!
+	 * Construct a \ref slice_reader to read from data inside the setup file.
+	 * Seeking to anything except the zeroeth slice is not allowed.
+	 *
+	 * \param istream     A seekable input stream for the setup executable.
+	 *                    The initial read position of the stream is ignored.
+	 * \param data_offset The offset within the given stream where the setup data starts.
+	 *                    This offset is given by \ref loader::offsets::data_offset.
+	 *
+	 * The constructed reader will allow reading the byte range [data_offset, file end)
+	 * from the setup executable and provide this as the range [0, file end - data_offset).
+	 */
+	slice_reader(std::istream * istream, boost::uint32_t data_offset);
+	
+	/*!
+	 * Construct a \ref slice_reader to read from external data slices (aka disks).
+	 *
+	 * Slice files must be located at \c $dir/$base_file-$disk.bin
+	 * or \c $dir/$base_file-$disk$sliceletter.bin if \c slices_per_disk is greater
+	 * than \c 1.
+	 *
+	 * The disk number is given by \code slice / slices_per_disk + 1 \endcode while
+	 * the sliceletter is the ASCII char \code 'a' + (slice % slices_per_disk) \endcode.
+	 *
+	 * \param dir             The directory containing the slice files.
+	 * \param basename        The base name for slice files.
+	 * \param slices_per_disk How many slices are grouped into one disk. Must not be \c 0.
+	 */
+	slice_reader(const path_type & dir, const path_type & basename, size_t slices_per_disk);
+	
+	/*!
+	 * Attempt to seek to an offset within a slice.
+	 *
+	 * \param slice  The slice to seek to.
+	 * \param offset The byte offset to seek to within the given slice.
+	 *
+	 * \return \c false if the requested slice could not be opened, or if the requested
+	 *         offset is not a valid position in that slice - \c true otherwise.
+	 */
+	bool seek(size_t slice, boost::uint32_t offset);
+	
+	/*!
+	 * Read a number of bytes starting at the current slice and offset within that slice.
+	 *
+	 * \param buffer Buffer to receive the bytes read.
+	 * \param bytes  Number of bytes to read.
+	 *
+	 * The current offset will be advanced by the number of bytes read. It is not an error
+	 * to read past the end of the current slice (unless it is the last slice). Doing so
+	 * will automatically seek to the start of the next slice and continue reading from
+	 * there.
+	 *
+	 * \return The number of bytes read or \c -1 if there was an error. Unless we are at the
+	 *         end of the last slice, this function blocks until the number of requested
+	 *         bytes have been read.
+	 */
 	std::streamsize read(char * buffer, std::streamsize bytes);
 	
-	inline size_t slice() { return current_slice; }
-	inline path_type & file() { return slice_file; }
+	//! \return the number currently opened slice.
+	size_t slice() { return current_slice; }
 	
-	bool open(size_t slice, const path_type & slice_file);
+	//! \return filename for the currently opened slice.
+	path_type & file() { return slice_file; }
 	
-	inline bool is_open() { return ifs.is_open(); }
+	//! \return true a slice is currently open.
+	bool is_open() { return (is != &ifs || ifs.is_open()); }
 	
 };
 
diff -Nru innoextract-1.3/src/util/boostfs_compat.hpp innoextract-1.4/src/util/boostfs_compat.hpp
--- innoextract-1.3/src/util/boostfs_compat.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/util/boostfs_compat.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012 Daniel Scharrer
+ * Copyright (C) 2012-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -18,6 +18,9 @@
  * 3. This notice may not be removed or altered from any source distribution.
  */
 
+/*!
+ * Compatibility functions for older \ref boost::filesystem versions.
+ */
 #ifndef INNOEXTRACT_UTIL_BOOSTFS_COMPAT_HPP
 #define INNOEXTRACT_UTIL_BOOSTFS_COMPAT_HPP
 
diff -Nru innoextract-1.3/src/util/console.cpp innoextract-1.4/src/util/console.cpp
--- innoextract-1.3/src/util/console.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/util/console.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -20,101 +20,302 @@
 
 #include "util/console.hpp"
 
-#include <iostream>
-#include <cmath>
 #include <algorithm>
+#include <cmath>
+#include <signal.h>
+#include <iostream>
+#include <cstdlib>
+#include <cstdio>
 
 #include "configure.hpp"
 
-#ifdef HAVE_ISATTY
+#if defined(_WIN32)
+#include <windows.h>
+#endif
+
+#if INNOEXTRACT_HAVE_ISATTY
 #include <unistd.h>
+#elif INNOEXTRACT_HAVE_MS_ISATTY
+#include <stdio.h>
+#include <io.h>
 #endif
 
-#ifdef HAVE_IOCTL
+#if INNOEXTRACT_HAVE_IOCTL
 #include <sys/ioctl.h>
 #endif
 
 #include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <boost/lexical_cast.hpp>
 
 #include "util/output.hpp"
 
 static bool show_progress = true;
 
+#if defined(SIGWINCH)
+
+// The last known screen width.
+static int screen_width;
+
+// A flag that signals that the console may have been resized
+static volatile sig_atomic_t screen_resized;
+
+static void sigwinch_handler(int sig) {
+	(void)sig;
+	screen_resized = 1;
+	signal(SIGWINCH, sigwinch_handler);
+}
+
+#endif
+
+#if defined(_WIN32)
+static HANDLE console_handle;
+#endif
+
 namespace color {
 
-shell_command reset = { "\x1b[0m" };
+#if defined(_WIN32)
+
+std::ostream & operator<<(std::ostream & os, const shell_command command) {
+	
+	color::current = command;
+	
+	if(command.command == boost::uint16_t(-1) || !console_handle) {
+		// Color output is disabled
+		return os;
+	}
+	
+	if(&os != &std::cout && &os != &std::cerr) {
+		// Colors are only supported for standard output
+		return os;
+	}
+	
+	std::cout.flush();
+	std::cerr.flush();
+	
+	SetConsoleTextAttribute(console_handle, command.command);
+	
+	return os;
+}
+
+shell_command black =       { FOREGROUND_INTENSITY };
+shell_command red =         { FOREGROUND_INTENSITY | FOREGROUND_RED };
+shell_command green =       { FOREGROUND_INTENSITY | FOREGROUND_GREEN };
+shell_command yellow =      { FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN };
+shell_command blue =        { FOREGROUND_INTENSITY | FOREGROUND_BLUE };
+shell_command magenta =     { FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_BLUE };
+shell_command cyan =        { FOREGROUND_INTENSITY | FOREGROUND_BLUE | FOREGROUND_GREEN };
+shell_command white =       { FOREGROUND_INTENSITY
+                              | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE };
+
+shell_command dim_black =   { 0 };
+shell_command dim_red =     { FOREGROUND_RED };
+shell_command dim_green =   { FOREGROUND_GREEN };
+shell_command dim_yellow =  { FOREGROUND_RED | FOREGROUND_GREEN };
+shell_command dim_blue =    { FOREGROUND_BLUE };
+shell_command dim_magenta = { FOREGROUND_RED | FOREGROUND_BLUE };
+shell_command dim_cyan =    { FOREGROUND_BLUE | FOREGROUND_GREEN };
+shell_command dim_white =   { FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE };
+
+shell_command reset =       dim_white;
+shell_command original_color;
+
+static void restore_color() {
+	std::cout << original_color;
+}
+
+#else
 
-shell_command black = { "\x1b[1;30m" };
-shell_command red = { "\x1b[1;31m" };
-shell_command green = { "\x1b[1;32m" };
-shell_command yellow = { "\x1b[1;33m" };
-shell_command blue = { "\x1b[1;34m" };
-shell_command magenta = { "\x1b[1;35m" };
-shell_command cyan = { "\x1b[1;36m" };
-shell_command white = { "\x1b[1;37m" };
-
-shell_command dim_black = { "\x1b[0;30m" };
-shell_command dim_red = { "\x1b[0;31m" };
-shell_command dim_green = { "\x1b[0;32m" };
-shell_command dim_yellow = { "\x1b[0;33m" };
-shell_command dim_blue = { "\x1b[0;34m" };
+shell_command black =       { "\x1b[1;30m" };
+shell_command red =         { "\x1b[1;31m" };
+shell_command green =       { "\x1b[1;32m" };
+shell_command yellow =      { "\x1b[1;33m" };
+shell_command blue =        { "\x1b[1;34m" };
+shell_command magenta =     { "\x1b[1;35m" };
+shell_command cyan =        { "\x1b[1;36m" };
+shell_command white =       { "\x1b[1;37m" };
+
+shell_command dim_black =   { "\x1b[0;30m" };
+shell_command dim_red =     { "\x1b[0;31m" };
+shell_command dim_green =   { "\x1b[0;32m" };
+shell_command dim_yellow =  { "\x1b[0;33m" };
+shell_command dim_blue =    { "\x1b[0;34m" };
 shell_command dim_magenta = { "\x1b[0;35m" };
-shell_command dim_cyan = { "\x1b[0;36m" };
-shell_command dim_white = { "\x1b[0;37m" };
+shell_command dim_cyan =    { "\x1b[0;36m" };
+shell_command dim_white =   { "\x1b[0;37m" };
+
+shell_command reset =       { "\x1b[0m" };
+
+#endif
 
 shell_command current = reset;
 
 void init(is_enabled color, is_enabled progress) {
 	
-	bool is_tty = isatty(1) && isatty(2);
+	bool is_tty = false;
+	#if INNOEXTRACT_HAVE_ISATTY
+	is_tty = isatty(1) && isatty(2);
+	#elif INNOEXTRACT_HAVE_MS_ISATTY
+	is_tty = _isatty(_fileno(stdout)) && _isatty(_fileno(stderr));
+	#endif
+	
+	#if defined(_WIN32)
+	console_handle = GetStdHandle(STD_OUTPUT_HANDLE);
+	CONSOLE_SCREEN_BUFFER_INFO info;
+	if(console_handle && GetConsoleScreenBufferInfo(console_handle, &info)) {
+		original_color.command = info.wAttributes;
+	} else {
+		is_tty = false;
+		color = disable;
+		progress = disable;
+	}
+	#endif
+	
+	// Initialize the progress bar
+	
+	#if defined(SIGWINCH)
+	sigwinch_handler(0);
+	#endif
+	
+	show_progress = (progress == enable);
+	#if defined(_WIN32) || (INNOEXTRACT_HAVE_IOCTL && defined(TIOCGWINSZ))
+	// Only automatically enable the progress bar if we have a way to determine the width
+	if(progress == automatic && is_tty) {
+		show_progress = true;
+	}
+	#endif
+	#if defined(_WIN32)
+	if(show_progress) {
+		// Buffer output so that the progress bar won't flicker (we flush after each update)
+		static char buffer[BUFSIZ];
+		std::setbuf(stdout, buffer);
+	}
+	#endif
 	
-	show_progress = (progress == enable) || (progress == automatic && is_tty);
+	// Initialize color output
 	
 	if(color == disable || (color == automatic && !is_tty)) {
 		
+		#if defined(_WIN32)
+		reset.command = boost::uint16_t(-1);
+		#else
 		reset.command = "";
+		#endif
 		
-		black.command = "";
-		red.command = "";
-		green.command = "";
-		yellow.command = "";
-		blue.command = "";
-		magenta.command = "";
-		cyan.command = "";
-		white.command = "";
-		
-		dim_black.command = "";
-		dim_red.command = "";
-		dim_green.command = "";
-		dim_yellow.command = "";
-		dim_blue.command = "";
-		dim_magenta.command = "";
-		dim_cyan.command = "";
-		dim_white.command = "";
-		
+		black = red = green = yellow = blue = magenta = cyan = white = reset;
+		dim_black = dim_red = dim_green = dim_yellow = reset;
+		dim_blue = dim_magenta = dim_cyan = dim_white = reset;
 		current = reset;
 		
+	} else {
+		#if defined(_WIN32)
+		std::cout << reset;
+		std::atexit(restore_color);
+		#endif
 	}
+	
 }
 
 } // namespace color
 
-void progress::show(float value, const std::string & label) {
+static int query_screen_width() {
 	
-	if(!show_progress) {
-		return;
+	#if defined(_WIN32)
+	
+	CONSOLE_SCREEN_BUFFER_INFO info;
+	if(GetConsoleScreenBufferInfo(console_handle, &info)) {
+		return info.srWindow.Right - info.srWindow.Left + 1;
 	}
 	
-#if defined(HAVE_IOCTL) && defined(TIOCGWINSZ)
+	#endif
+	
+	#if INNOEXTRACT_HAVE_IOCTL && defined(TIOCGWINSZ)
 	
 	struct winsize w;
-	ioctl(0, TIOCGWINSZ, &w);
+	if(ioctl(0, TIOCGWINSZ, &w) >= 0) {
+		return w.ws_col;
+	}
+	
+	#endif
+	
+	#if !defined(_WIN32)
+	try {
+		char * columns = std::getenv("COLUMNS");
+		if(columns) {
+			return boost::lexical_cast<int>(columns);
+		}
+	} catch(...) { /* ignore bad values */ }
+	#endif
+	
+	// Assume a default screen width of 80 columns
+	return 80;
+	
+}
+
+static int get_screen_width() {
+	
+	#if defined(SIGWINCH)
+	
+	if(screen_resized) {
+		screen_resized = 0;
+		screen_width = query_screen_width();
+	}
+	
+	return screen_width;
+	
+	#else
+	return query_screen_width();
+	#endif
+	
+}
+
+static bool progress_cleared = true;
+
+int progress::clear() {
+	
+	int width = get_screen_width();
+	
+	if(!show_progress) {
+		return width;
+	}
+	
+	#if defined(_WIN32)
+	
+	// Overwrite the current line with whitespace
 	
-	clear();
+	static std::string buffer;
+	static int last_width = 0;
+	if(width != last_width) {
+		size_t cwidth = size_t(std::max(width, 1) - 1);
+		buffer.resize(cwidth, ' ');
+		last_width = width;
+	}
+	
+	std::cout << '\r' << buffer << '\r';
+	
+	#else
+	
+	// Use the ANSI/VT100 control sequence to clear the current line
+	
+	std::cout << "\33[2K\r";
+	
+	#endif
+	
+	progress_cleared = true;
+	
+	return width;
+}
+
+void progress::show(float value, const std::string & label) {
+	
+	if(!show_progress) {
+		return;
+	}
+	
+	int width = clear();
 	
 	std::ios_base::fmtflags flags = std::cout.flags();
 	
-	int progress_length = w.ws_col - int(label.length()) - 6 - 2 - 2 - 1;
+	int progress_length = width - int(label.length()) - 6 - 2 - 2 - 1;
 	
 	if(progress_length > 10) {
 		
@@ -138,8 +339,7 @@
 	
 	std::cout.flags(flags);
 	
-#endif
-	
+	progress_cleared = false;
 }
 
 void progress::show_unbounded(float value, const std::string & label) {
@@ -148,16 +348,11 @@
 		return;
 	}
 	
-#if defined(HAVE_IOCTL) && defined(TIOCGWINSZ)
-	
-	struct winsize w;
-	ioctl(0, TIOCGWINSZ, &w);
-	
-	clear();
+	int width = clear();
 	
 	std::ios_base::fmtflags flags = std::cout.flags();
 	
-	int progress_length = w.ws_col - int(label.length()) - 2 - 2 - 6;
+	int progress_length = width - int(label.length()) - 2 - 2 - 6;
 	
 	if(progress_length > 10) {
 		
@@ -181,46 +376,21 @@
 	
 	std::cout.flags(flags);
 	
-#else
-	
-	(void)value, (void)label;
-	
-#endif
-	
-}
-
-static bool progress_cleared = true;
-
-void progress::clear() {
-	
-	if(!show_progress) {
-		return;
-	}
-	
-#if defined(HAVE_IOCTL) && defined(TIOCGWINSZ)
-	
-	std::cout << "\33[2K\r";
-	
-	progress_cleared = true;
-	
-#endif
+	progress_cleared = false;
 }
 
-progress::progress(uint64_t max, bool show_rate)
+progress::progress(boost::uint64_t max, bool show_rate)
 	: max(max), value(0), show_rate(show_rate),
 	  start_time(boost::posix_time::microsec_clock::universal_time()),
 	  last_status(-1.f), last_time(0), last_rate(0.f) { }
 
-void progress::update(uint64_t delta, bool force) {
+void progress::update(boost::uint64_t delta, bool force) {
 	
 	if(!show_progress) {
 		return;
 	}
 	
-#if defined(HAVE_IOCTL) && defined(TIOCGWINSZ)
-	
 	force = force || progress_cleared;
-	progress_cleared = false;
 	
 	value += delta;
 	
@@ -234,9 +404,14 @@
 	}
 	
 	boost::posix_time::ptime now(boost::posix_time::microsec_clock::universal_time());
-	uint64_t time = uint64_t((now - start_time).total_microseconds());
+	boost::uint64_t time = boost::uint64_t((now - start_time).total_microseconds());
 	
-	if(!force && time - last_time < 100000) {
+	#if defined(_WIN32)
+	const boost::uint64_t update_interval = 100000;
+	#else
+	const boost::uint64_t update_interval = 50000;
+	#endif
+	if(!force && time - last_time < update_interval) {
 		return;
 	}
 	
@@ -268,10 +443,8 @@
 		show_unbounded(status, label.str());
 	}
 	
-#else
-	
-	(void)delta, (void)force;
-	
-#endif
-	
+}
+
+void progress::set_enabled(bool enable) {
+	show_progress = enable;
 }
diff -Nru innoextract-1.3/src/util/console.hpp innoextract-1.4/src/util/console.hpp
--- innoextract-1.3/src/util/console.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/util/console.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -18,23 +18,39 @@
  * 3. This notice may not be removed or altered from any source distribution.
  */
 
+/*!
+ * Terminal output functions: colors, progress bar.
+ */
 #ifndef INNOEXTRACT_UTIL_CONSOLE_HPP
 #define INNOEXTRACT_UTIL_CONSOLE_HPP
 
 #include <stddef.h>
-#include <stdint.h>
 #include <ostream>
 #include <iomanip>
 #include <sstream>
 
 #include <boost/date_time/posix_time/ptime.hpp>
+#include <boost/cstdint.hpp>
 
 namespace color {
 
+/*!
+ * Object that can be written to the console to change the output color.
+ *
+ * On some operating systems these will only work if streamed directly into std::cout
+ * ot std::cerr.
+ */
 struct shell_command {
+#if defined(_WIN32)
+	boost::uint16_t command;
+#else
 	const char * command;
+#endif
 };
 
+std::ostream & operator<<(std::ostream & os, const shell_command command);
+
+//! Reset the output color to the original value.
 extern shell_command reset;
 
 extern shell_command black;
@@ -55,53 +71,90 @@
 extern shell_command dim_cyan;
 extern shell_command dim_white;
 
+//! The last set output color.
 extern shell_command current;
 
+#if !defined(_WIN32)
+inline std::ostream & operator<<(std::ostream & os, const shell_command command) {
+	color::current = command;
+	return os << command.command;
+}
+#endif
+
 enum is_enabled {
 	enable,
 	disable,
 	automatic
 };
 
+/*!
+ * Initilize console output functions.
+ *
+ * \param color    Enable or disable color output.
+ * \param progress Enable or disable progress bar output.
+ */
 void init(is_enabled color = automatic, is_enabled progress = automatic);
 
-inline std::ostream & operator<<(std::ostream & os, const shell_command command) {
-	color::current = command;
-	return os << command.command;
-}
-
 } // namespace color
 
+//! A text-based progress bar for terminals.
 class progress {
 	
-	uint64_t max;
-	uint64_t value;
+	boost::uint64_t max;
+	boost::uint64_t value;
 	bool show_rate;
 	
 	boost::posix_time::ptime start_time;
 	
 	float last_status;
-	uint64_t last_time;
+	boost::uint64_t last_time;
 	
 	float last_rate;
 	std::ostringstream label;
 	
 public:
 	
-	progress(uint64_t max = 0, bool show_rate = true);
+	/*!
+	 * \param max       Maximumum progress values.
+	 *                  If this value is \c 0, the progress bar will be unbounded.
+	 * \param show_rate Display the rate at which the progress changes.
+	 */
+	progress(boost::uint64_t max = 0, bool show_rate = true);
 	progress(const progress & o)
 		: max(o.max), value(o.value), show_rate(o.show_rate), start_time(o.start_time),
 		  last_status(o.last_status), last_time(o.last_time),
 		  last_rate(o.last_rate), label(o.label.str()) { }
 	
-	void update(uint64_t delta = 0, bool force = false);
-	
+	/*!
+	 * Update the progress bar.
+	 *
+	 * \param delta Value to add to the progress. When the total progress value reaches the
+	 *              maximum set in the constructor, the bar will be full.
+	 * \param force Force updating the progress bar. Normally, the progress bar. Otherwise,
+	 *              updates are rate-limited and small deltas are not displayed immediately.
+	 */
+	void update(boost::uint64_t delta = 0, bool force = false);
+	
+	/*!
+	 * Draw a bounded progress bar (with a maximum).
+	 *
+	 * \param value The progress value, between \c 0.f and \c 1.f.
+	 * \param label A label to draw next to the progress bar.
+	 */
 	static void show(float value, const std::string & label = std::string());
 	
+	/*!
+	 * Draw an unbounded progress bar (without a maximum).
+	 *
+	 * \param value The progress value, between \c 0.f and \c 1.f.
+	 * \param label A label to draw next to the progress bar.
+	 */
 	static void show_unbounded(float value, const std::string & label = std::string());
 	
-	static void clear();
+	//! Clear any progress bar to make way for other output.
+	static int clear();
 	
+	//! Enable or disable the progress bar.
 	static void set_enabled(bool enable);
 	
 };
diff -Nru innoextract-1.3/src/util/endian.hpp innoextract-1.4/src/util/endian.hpp
--- innoextract-1.3/src/util/endian.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/util/endian.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -18,131 +18,265 @@
  * 3. This notice may not be removed or altered from any source distribution.
  */
 
+/*!
+ * Utility function for dealing with different endiannesses.
+ */
 #ifndef INNOEXTRACT_UTIL_ENDIAN_HPP
 #define INNOEXTRACT_UTIL_ENDIAN_HPP
 
 #include <cstdlib>
+#include <cstring>
 
 #include "configure.hpp"
 
-inline uint8_t byteswap(uint8_t value) {
+#if INNOEXTRACT_HAVE_BSWAP_16 || INNOEXTRACT_HAVE_BSWAP_32 || INNOEXTRACT_HAVE_BSWAP_64
+#include <byteswap.h>
+#endif
+
+#include <boost/cstdint.hpp>
+
+namespace util {
+
+namespace detail {
+
+inline boost::uint8_t byteswap(boost::uint8_t value) {
 	return value;
 }
 
-inline int8_t byteswap(int8_t value) {
-	return int8_t(byteswap(uint8_t(value)));
+inline boost::int8_t byteswap(boost::int8_t value) {
+	return boost::int8_t(byteswap(boost::uint8_t(value)));
 }
 
-inline uint16_t byteswap(uint16_t value) {
+inline boost::uint16_t byteswap(boost::uint16_t value) {
 #if defined(_MSC_VER) && _MSC_VER >= 1300
 	return _byteswap_ushort(value);
+#elif INNOEXTRACT_HAVE_BSWAP_16 \
+	&& (!defined(__GLIBC__) || !defined(__GLIBC_MINOR__) \
+	    || (__GLIBC__ << 16) + __GLIBC_MINOR__ >= (2 << 16) + 16) \
+	    // prevent conversion warnings
+	return bswap_16(value);
 #else
-	return uint16_t((uint16_t(uint8_t(value)) << 8) | uint8_t(value >> 8));
+	return boost::uint16_t((boost::uint16_t(boost::uint8_t(value)) << 8)
+	                       | boost::uint8_t(value >> 8));
 #endif
 }
 
-inline int16_t byteswap(int16_t value) {
-	return int16_t(byteswap(uint16_t(value)));
+inline boost::int16_t byteswap(boost::int16_t value) {
+	return boost::int16_t(byteswap(boost::uint16_t(value)));
 }
 
-inline uint32_t byteswap(uint32_t value) {
+inline boost::uint32_t byteswap(boost::uint32_t value) {
 #if defined(__GNUC__) && !defined(__PATHCC__) \
     && __GNUC__ >= 4 && (__GNUC__ > 4 || __GNUC_MINOR__ >= 3)
 	return __builtin_bswap32(value);
 #elif defined(_MSC_VER) && (_MSC_VER >= 1400 || (_MSC_VER >= 1300 && !defined(_DLL)))
 	return _byteswap_ulong(value);
+#elif INNOEXTRACT_HAVE_BSWAP_32
+	return bswap_32(value);
 #else
-	return (uint32_t(byteswap(uint16_t(value))) << 16) | byteswap(uint16_t(value >> 16));
+	return (boost::uint32_t(byteswap(boost::uint16_t(value))) << 16)
+	       | byteswap(boost::uint16_t(value >> 16));
 #endif
 }
 
-inline int32_t byteswap(int32_t value) {
-	return int32_t(byteswap(uint32_t(value)));
+inline boost::int32_t byteswap(boost::int32_t value) {
+	return boost::int32_t(byteswap(boost::uint32_t(value)));
 }
 
-inline uint64_t byteswap(uint64_t value) {
+inline boost::uint64_t byteswap(boost::uint64_t value) {
 #if defined(__GNUC__) && !defined(__PATHCC__) \
     && __GNUC__ >= 4 && (__GNUC__ > 4 || __GNUC_MINOR__ >= 3)
 	return __builtin_bswap64(value);
 #elif defined(_MSC_VER) && _MSC_VER >= 1300
 	return _byteswap_uint64(value);
+#elif INNOEXTRACT_HAVE_BSWAP_64
+	return bswap_64(value);
 #else
-	return (uint64_t(byteswap(uint32_t(value))) << 32) | byteswap(uint32_t(value >> 32));
+	return (boost::uint64_t(byteswap(boost::uint32_t(value))) << 32)
+	       | byteswap(boost::uint32_t(value >> 32));
 #endif
 }
 
-inline int64_t byteswap(int64_t value) {
-	return int64_t(byteswap(uint64_t(value)));
+inline boost::int64_t byteswap(boost::int64_t value) {
+	return boost::int64_t(byteswap(boost::uint64_t(value)));
 }
 
-template <class T>
-void byteswap(T * out, const T * in, size_t byte_count) {
-	for(size_t i = 0; i < byte_count / sizeof(T); i++) {
-		out[i] = byteswap(in[i]);
-	}
-}
+} // namespace detail
 
-template <bool Native>
+//! Load/store functions for a specific endianness.
+template <typename Endianness>
 struct endianness {
 	
-	static const size_t native = false;
+	/*!
+	 * Load a single integer.
+	 *
+	 * \param buffer Memory location containing the integer. Will read sizeof(T) bytes.
+	 * \return the loaded integer.
+	 */
+	template <typename T>
+	static T load(const char * buffer) {
+		if(Endianness::native()) {
+			T value;
+			std::memcpy(&value, buffer, sizeof(value));
+			return value;
+		} else {
+			return load_alien<T>(buffer);
+		}
+	}
 	
-	template <class T>
-	static T byteswap_if_alien(T value) { return byteswap(value); }
+	/*!
+	 * Load an array of integers.
+	 *
+	 * \param buffer Memory location containing the integers (without padding).
+	 *               Will read <code>sizeof(T) * count</code> bytes.
+	 * \param values Output array for the loaded integers.
+	 * \param count  How many integers to load.
+	 */
+	template <typename T>
+	static void load(const char * buffer, T * values, size_t count) {
+		if(Endianness::native() || sizeof(*values) == 8) {
+			std::memcpy(values, buffer, sizeof(*values) * count);
+		} else {
+			for(size_t i = 0; i < count; i++, buffer += sizeof(*values)) {
+				values[i] = load_alien<T>(buffer);
+			}
+		}
+	}
 	
-	template <class T>
-	static void byteswap_if_alien(const T * in, T * out, size_t byte_count) {
-		byteswap(out, in, byte_count);
+	/*!
+	 * Store a single integer.
+	 *
+	 * \param value  The integer to store.
+	 * \param buffer Memory location to receive the integer. Will write sizeof(T) bytes.
+	 */
+	template <typename T>
+	static void store(T value, char * buffer) {
+		if(Endianness::native()) {
+			std::memcpy(buffer, &value, sizeof(value));
+		} else {
+			return store_alien(value, buffer);
+		}
 	}
 	
-};
-
-template <>
-struct endianness<true> {
+	/*!
+	 * Store an array of integers.
+	 *
+	 * \param values The integers to store.
+	 * \param count  How many integers to store.
+	 * \param buffer Memory location to receive the integers (without padding).
+	 *               Will write <code>sizeof(T) * count</code> bytes.
+	 */
+	template <typename T>
+	static void store(T * values, size_t count, char * buffer) {
+		if(Endianness::native() || sizeof(*values) == 8) {
+			std::memcpy(buffer, values, sizeof(*values) * count);
+		} else {
+			for(size_t i = 0; i < count; i++, buffer += sizeof(*values)) {
+				store_alien(values[i], buffer);
+			}
+		}
+	}
+	
+private:
 	
-	static const size_t native = true;
+	bool reversed() { return false; }
 	
-	template <class T>
-	static T byteswap_if_alien(T value) { return value; }
+	template <typename T>
+	static T load_alien(const char * buffer) {
+		if(Endianness::reversed()) {
+			T value;
+			std::memcpy(&value, buffer, sizeof(value));
+			return detail::byteswap(value);
+		} else {
+			return Endianness::template decode<T>(buffer);
+		}
+	}
 	
-	template <class T>
-	static void byteswap_if_alien(const T * in, T * out, size_t byte_count) {
-		if(in != out) {
-			std::memcpy(out, in, byte_count);
+	template <typename T>
+	static void store_alien(T value, char * buffer) {
+		if(Endianness::reversed()) {
+			value = detail::byteswap(value);
+			std::memcpy(buffer, &value, sizeof(value));
+		} else {
+			Endianness::template encode<T>(value, buffer);
 		}
 	}
 	
 };
 
-#ifndef LITTLE_ENDIAN
-#define LITTLE_ENDIAN 1234
-#endif
+namespace detail {
 
-#ifndef BIG_ENDIAN
-#define BIG_ENDIAN    4321
-#endif
+inline bool is_little_endian() {
+	boost::uint32_t signature = 0x04030201;
+	return (*reinterpret_cast<char *>(&signature) == 1);
+}
 
-#ifdef IS_BIG_ENDIAN
-#define ENDIANNESS    BIG_ENDIAN
-#else
-#define ENDIANNESS    LITTLE_ENDIAN
-#endif
+inline bool is_big_endian() {
+	boost::uint32_t signature = 0x04030201;
+	return (*reinterpret_cast<char *>(&signature) == 4);
+}
+
+} // namespace detail
 
 
-struct little_endian : public endianness<ENDIANNESS == LITTLE_ENDIAN> {
-	static const size_t offset = 0;
+//! Load and store little-endian integers.
+struct little_endian : endianness<little_endian> {
+	
+	//! \return true if we are running on a little-endian machine.
+	static bool native() { return detail::is_little_endian(); }
+	
+private:
+	
+	static bool reversed() { return detail::is_big_endian(); }
+	
+	template <typename T>
+	static T decode(const char * buffer) {
+		T value = 0;
+		for(size_t i = 0; i < sizeof(T); i++) {
+			value = T(value | (T(buffer[i]) << (i * 8)));
+		}
+		return value;
+	}
+	
+	template <typename T>
+	static void encode(T value, char * buffer) {
+		for(size_t i = 0; i < sizeof(T); i++) {
+			buffer[i] = char((value >> (i * 8)) & 0xff);
+		}
+	}
+	
+	friend struct endianness<little_endian>;
 };
 
-struct big_endian : public endianness<ENDIANNESS == BIG_ENDIAN> {
-	static const size_t offset = 1;
+//! Load and store big-endian integers.
+struct big_endian : endianness<big_endian> {
+	
+	//! \return true if we are running on a big-endian machine.
+	static bool native() { return detail::is_big_endian(); }
+	
+private:
+	
+	static bool reversed() { return detail::is_little_endian(); }
+	
+	template <typename T>
+	static T decode(const char * buffer) {
+		T value = 0;
+		for(size_t i = 0; i < sizeof(T); i++) {
+			value = T(value | T(buffer[i]) << ((sizeof(T) - i - 1) * 8));
+		}
+		return value;
+	}
+	
+	template <typename T>
+	static void encode(T value, char * buffer) {
+		for(size_t i = 0; i < sizeof(T); i++) {
+			buffer[i] = char((value >> ((sizeof(T) - i - 1) * 8)) & 0xff);
+		}
+	}
+	
+	friend struct endianness<big_endian>;
 };
 
-#if ENDIANNESS == LITTLE_ENDIAN
-typedef little_endian native_endian;
-#elif ENDIANNESS == BIG_ENDIAN
-typedef big_endian native_endian;
-#else
-#error "Unsupported host endianness."
-#endif
+} // namespace util
 
 #endif // INNOEXTRACT_UTIL_ENDIAN_HPP
diff -Nru innoextract-1.3/src/util/enum.hpp innoextract-1.4/src/util/enum.hpp
--- innoextract-1.3/src/util/enum.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/util/enum.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -46,7 +46,7 @@
 	
 	const char * name;
 	
-	const char * names[];
+	const char * names[1];
 	
 };
 
@@ -68,6 +68,15 @@
 	const size_t enum_names<get_enum<Enum>::type>::count \
 	 = ARRAY_SIZE(enum_names<get_enum<Enum>::type>::names);
 
+#define USE_ENUM_NAMES(Enum) \
+	(void)enum_names<get_enum<Enum>::type>::count; \
+	(void)enum_names<get_enum<Enum>::type>::name; \
+	(void)enum_names<get_enum<Enum>::type>::names;
+
+#define USE_FLAG_NAMES(Flags) \
+	USE_FLAGS_OVERLOADS(Flags) \
+	USE_ENUM_NAMES(Flags)
+
 template <class Enum>
 typename boost::enable_if_c<enum_names<Enum>::named, std::ostream &>::type
 operator<<(std::ostream & os, Enum value) {
diff -Nru innoextract-1.3/src/util/flags.hpp innoextract-1.4/src/util/flags.hpp
--- innoextract-1.3/src/util/flags.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/util/flags.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -18,6 +18,9 @@
  * 3. This notice may not be removed or altered from any source distribution.
  */
 
+/*!
+ * Typesafe flags.
+ */
 #ifndef INNOEXTRACT_UTIL_FLAGS_HPP
 #define INNOEXTRACT_UTIL_FLAGS_HPP
 
@@ -52,108 +55,116 @@
 	
 	Type _flags;
 	
-	inline flags(Type flag) : _flags(flag) { }
+	explicit flags(Type flag) : _flags(flag) { }
 	
 public:
 	
-	inline flags(enum_type flag) : _flags(Type().set(size_t(flag))) { }
+	/* implicit */ inline flags(enum_type flag) : _flags(Type().set(size_t(flag))) { }
 	
-	inline flags(Zero = 0) : _flags() { }
+	/* implicit */ inline flags(Zero = 0) : _flags() { }
 	
-	inline flags(const flags & o) : _flags(o._flags) { }
+	flags(const flags & o) : _flags(o._flags) { }
 	
-	static inline flags load(Type _flags) {
+	static flags load(Type _flags) {
 		return flags(_flags, true);
 	}
 	
-	inline bool has(enum_type flag) const {
+	//! Test if a specific flag is set.
+	bool has(enum_type flag) const {
 		return _flags.test(size_t(flag));
 	}
 	
-	inline bool hasAll(flags o) const {
+	//! Test if a collection of flags are all set.
+	bool hasAll(flags o) const {
 		return (_flags & o._flags) == o._flags;
 	}
 	
-	inline operator TypesafeBoolean() const {
+	operator TypesafeBoolean() const {
 		return reinterpret_cast<TypesafeBoolean>(_flags.any());
 	}
 	
-	inline flags operator~() const {
+	flags operator~() const {
 		return flags(~_flags);
 	}
 	
-	inline bool operator!() const {
+	bool operator!() const {
 		return _flags.none();
 	}
 	
-	inline flags operator&(flags o) const {
+	flags operator&(flags o) const {
 		return flags(_flags & o._flags);
 	}
 	
-	inline flags operator|(flags o) const {
+	flags operator|(flags o) const {
 		return flags(_flags | o._flags);
 	}
 	
-	inline flags operator^(flags o) const {
+	flags operator^(flags o) const {
 		return flags(_flags ^ o._flags);
 	}
 	
-	inline flags & operator&=(const flags & o) {
+	flags & operator&=(const flags & o) {
 		_flags &= o._flags;
 		return *this;
 	}
 	
-	inline flags & operator|=(flags o) {
+	flags & operator|=(flags o) {
 		_flags |= o._flags;
 		return *this;
 	}
 	
-	inline flags & operator^=(flags o) {
+	flags & operator^=(flags o) {
 		_flags ^= o._flags;
 		return *this;
 	}
 	
-	inline flags operator&(enum_type flag) const {
+	flags operator&(enum_type flag) const {
 		return operator&(flags(flag));
 	}
 	
-	inline flags operator|(enum_type flag) const {
+	flags operator|(enum_type flag) const {
 		return operator|(flags(flag));
 	}
 	
-	inline flags operator^(enum_type flag) const {
+	flags operator^(enum_type flag) const {
 		return operator^(flags(flag));
 	}
 	
-	inline flags & operator&=(enum_type flag) {
+	flags & operator&=(enum_type flag) {
 		return operator&=(flags(flag));
 	}
 	
-	inline flags & operator|=(enum_type flag) {
+	flags & operator|=(enum_type flag) {
 		return operator|=(flags(flag));
 	}
 	
-	inline flags & operator^=(enum_type flag) {
+	flags & operator^=(enum_type flag) {
 		return operator^=(flag);
 	}
 	
-	inline flags & operator=(flags o) {
+	flags & operator=(flags o) {
 		_flags = o._flags;
 		return *this;
 	}
 	
-	static inline flags all() {
+	//! Get a set of flags with all possible values set.
+	static flags all() {
 		return flags(Type().flip());
 	}
 	
 };
 
+template <typename Enum, size_t Bits>
+flags<Enum, Bits> operator|(Enum a, flags<Enum, Bits> b) {
+	return b | a;
+}
+
 #define DECLARE_ENUM_SIZE(Enum, Size) \
 	template <> \
 	struct enum_size<Enum> { \
 		static const size_t value = (Size); \
 	};
-#define FLAGS_ENUM_END_HELPER(Enum) Enum ## __End
+#define FLAGS_ENUM_END_HELPER(Enum) Enum ## _End_
 #define FLAGS_ENUM_END(Enum) FLAGS_ENUM_END_HELPER(Enum)
 
 /*!
@@ -165,15 +176,12 @@
 	inline Flagname operator|(Flagname::enum_type a, Flagname::enum_type b) { \
 		return Flagname(a) | b; \
 	} \
-	inline Flagname operator|(Flagname::enum_type a, Flagname b) { \
-		return b | a; \
-	} \
 	inline Flagname operator~(Flagname::enum_type a) { \
 		return ~Flagname(a); \
 	}
 
 //! Get the enum name for a set of flags
-#define FLAGS_ENUM(Flagname) Flagname ## __Enum
+#define FLAGS_ENUM(Flagname) Flagname ## _Enum_
 
 /*!
  * Declare a set of flags
@@ -197,4 +205,8 @@
 	DECLARE_ENUM_SIZE(FLAGS_ENUM(Flagname), FLAGS_ENUM_END(Flagname)) \
 	DECLARE_FLAGS_OPERATORS(Flagname)
 
+#define USE_FLAGS_OVERLOADS(Flagname) \
+	(void)(~Flagname::enum_type(0)); \
+	(void)(Flagname::enum_type(0) | Flagname::enum_type(0));
+
 #endif // INNOEXTRACT_UTIL_FLAGS_HPP
diff -Nru innoextract-1.3/src/util/fstream.hpp innoextract-1.4/src/util/fstream.hpp
--- innoextract-1.3/src/util/fstream.hpp	1970-01-01 00:00:00.000000000 +0000
+++ innoextract-1.4/src/util/fstream.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2013 Daniel Scharrer
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the author(s) be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/*!
+ * boost::filesystems::{i,o,}fstream doesn't support unicode names on windows
+ * Implement our own wrapper using boost::iostreams.
+ */
+#ifndef INNOEXTRACT_UTIL_FSTREAM_HPP
+#define INNOEXTRACT_UTIL_FSTREAM_HPP
+
+#if !defined(_WIN32)
+
+#include <boost/filesystem/fstream.hpp>
+
+namespace util {
+
+typedef boost::filesystem::ifstream ifstream;
+typedef boost::filesystem::ofstream ofstream;
+typedef boost::filesystem::fstream  fstream;
+
+} // namespace util
+
+#else // if defined(_WIN32)
+
+#include <boost/filesystem/path.hpp>
+#include <boost/iostreams/device/file_descriptor.hpp>
+#include <boost/iostreams/stream.hpp>
+
+namespace util {
+
+/*!
+ * {i,o,}fstream implementation with support for Unicode filenames.
+ * Create a subclass instead of a typedef to force boost::filesystem::path parameters.
+ */
+template <typename Device>
+class path_fstream : public boost::iostreams::stream<Device> {
+	
+private: // disallow copying
+	
+	path_fstream(const path_fstream &);
+	const path_fstream & operator=(const path_fstream &);
+	
+	typedef boost::filesystem::path path;
+	typedef boost::iostreams::stream<Device> base;
+	
+	Device & device() { return **this; }
+	
+	void fix_open_mode(std::ios_base::openmode mode);
+	
+public:
+	
+	path_fstream() : base(Device()) { }
+	
+	explicit path_fstream(const path & p) : base(p) { }
+	
+	path_fstream(const path & p, std::ios_base::openmode mode) : base(p, mode) {
+		fix_open_mode(mode);
+	}
+	
+	void open(const path & p) {
+		base::close();
+		base::open(p);
+	}
+
+	void open(const path & p, std::ios_base::openmode mode) {
+		base::close();
+		base::open(p, mode);
+		fix_open_mode(mode);
+	}
+	
+	bool is_open() {
+		return device().is_open(); // return the real open state, not base::is_open()
+	}
+	
+	virtual ~path_fstream() { }
+};
+
+template <>
+inline void path_fstream<boost::iostreams::file_descriptor_source>
+	::fix_open_mode(std::ios_base::openmode mode) {
+	if((mode & std::ios_base::ate) && is_open()) {
+		seekg(0, std::ios_base::end);
+	}
+}
+
+template <>
+inline void path_fstream<boost::iostreams::file_descriptor_sink>
+	::fix_open_mode(std::ios_base::openmode mode) {
+	if((mode & std::ios_base::ate) && is_open()) {
+		seekp(0, std::ios_base::end);
+	}
+}
+
+template <>
+inline void path_fstream<boost::iostreams::file_descriptor>
+	::fix_open_mode(std::ios_base::openmode mode) {
+	if((mode & std::ios_base::ate) && is_open()) {
+		seekg(0, std::ios_base::end);
+		seekp(0, std::ios_base::end);
+	}
+}
+
+typedef path_fstream<boost::iostreams::file_descriptor_source> ifstream;
+typedef path_fstream<boost::iostreams::file_descriptor_sink>   ofstream;
+typedef path_fstream<boost::iostreams::file_descriptor>        fstream;
+
+} // namespace util
+
+#endif // defined(_WIN32)
+
+#endif // INNOEXTRACT_UTIL_FSTREAM_HPP
diff -Nru innoextract-1.3/src/util/load.cpp innoextract-1.4/src/util/load.cpp
--- innoextract-1.3/src/util/load.cpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/util/load.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -24,39 +24,168 @@
 #include <map>
 #include <sstream>
 #include <algorithm>
+#include <iomanip>
 
 #include <iconv.h>
 #include <errno.h>
 
+#include <boost/foreach.hpp>
+
 #include "util/log.hpp"
 
+namespace util {
+
 namespace {
 
-std::map<uint32_t, iconv_t> converters;
+static const boost::uint32_t cp_utf8  = 65001;
+static const boost::uint32_t cp_ascii = 20127;
+static const char replacement_char = '_';
+
+std::map<boost::uint32_t, iconv_t> converters;
+
+static size_t get_encoding_size(boost::uint32_t codepage) {
+	switch(codepage) {
+		case  1200: return 2u; // UTF-16LE
+		case  1201: return 2u; // UTF-16BE
+		case 12000: return 4u; // UTF-32LE
+		case 12001: return 4u; // UTF-32BE
+		default:    return 1u;
+	}
+}
 
-iconv_t get_converter(uint32_t codepage) {
-	
-	std::map<uint32_t, iconv_t>::iterator i = converters.find(codepage);
+//! Get names for encodings where iconv doesn't have the codepage alias
+static const char * get_encoding_name(boost::uint32_t codepage) {
+	switch(codepage) {
+		case   708: return "ISO-8859-6";
+		case   936: return "GBK";
+		case   949: return "UHC";
+		case   950: return "BIG5";
+		// iconv's behavior for "UTF-16" is platform-dependant if there is no BOM.
+		// There never is any BOM in Inno Setup files and it's always little-endian,
+		// so we specify the exact encoding.
+		case  1200: return "UTF-16LE";
+		case  1201: return "UTF-16BE";
+		case  1252: return "MS-ANSI";
+		case  1361: return "JOHAB";
+		case 10000: return "MACINTOSH";
+		case 10002: return "BIG5";
+		case 10008: return "GB2312";
+		case 12000: return "UTF-32LE";
+		case 12001: return "UTF-32BE";
+		case 20003: return "IBM5550";
+		case 20127: return "US-ASCII";
+		case 20261: return "T.61";
+		case 20269: return "ISO_6937";
+		case 20273: return "IBM273";
+		case 20277: return "IBM277";
+		case 20278: return "IBM278";
+		case 20280: return "IBM280";
+		case 20284: return "IBM284";
+		case 20285: return "IBM285";
+		case 20290: return "IBM290";
+		case 20297: return "IBM297";
+		case 20420: return "IBM420";
+		case 20423: return "IBM423";
+		case 20424: return "IBM424";
+		case 20866: return "KOI8-R";
+		case 20871: return "IBM871";
+		case 20880: return "IBM880";
+		case 20905: return "IBM905";
+		case 20924: return "IBM1047";
+		case 20932: return "EUC-JP-MS";
+		case 20936: return "EUC-CN";
+		case 21025: return "IBM1025";
+		case 21866: return "KOI8-U";
+		case 28591: return "ISO-8859-1";
+		case 28592: return "ISO-8859-2";
+		case 28593: return "ISO-8859-3";
+		case 28594: return "ISO-8859-4";
+		case 28595: return "ISO-8859-5";
+		case 28596: return "ISO-8859-6";
+		case 28597: return "ISO-8859-7";
+		case 28598: return "ISO-8859-8";
+		case 28599: return "ISO-8859-9";
+		case 28603: return "ISO-8859-13";
+		case 28605: return "ISO-8859-15";
+		case 38598: return "ISO-8859-8";
+		case 50220: return "ISO-2022-JP";
+		case 50221: return "ISO-2022-JP-2";
+		case 50222: return "ISO-2022-JP-3";
+		case 50225: return "ISO-2022-KR";
+		case 50227: return "ISO-2022-CN";
+		case 50229: return "ISO-2022-CN-EXT";
+		case 50930: return "EBCDIC-JP-E";
+		case 51932: return "EUC-JP";
+		case 51936: return "EUC-CN";
+		case 51949: return "EUC-KR";
+		case 51950: return "EUC-CN";
+		case 54936: return "GB18030";
+		case 65000: return "UTF-7";
+		case 65001: return "UTF-8";
+		default: return NULL;
+	}
+}
+
+static iconv_t get_converter(boost::uint32_t codepage) {
 	
+	// Try to reuse an existing converter if possible
+	std::map<boost::uint32_t, iconv_t>::iterator i = converters.find(codepage);
 	if(i != converters.end()) {
 		return i->second;
 	}
 	
-	std::ostringstream oss;
-	if(codepage == 1200) {
-		oss << "UTF-16";
-	} else {
-		oss << "CP" << codepage;
+	iconv_t handle = iconv_t(-1);
+	
+	const char * encoding = get_encoding_name(codepage);
+	if(encoding) {
+		handle = iconv_open("UTF-8", encoding);
+	}
+	
+	// Otherwise, try a few different codepage name prefixes
+	if(handle == iconv_t(-1)) {
+		const char * prefixes[] = { "MSCP", "CP", "WINDOWS-", "MS", "IBM", "IBM-", "" };
+		BOOST_FOREACH(const char * prefix, prefixes) {
+			std::ostringstream oss;
+			oss << prefix << std::setfill('0') << std::setw(3) << codepage;
+			handle = iconv_open("UTF-8", oss.str().c_str());
+			if(handle != iconv_t(-1)) {
+				break;
+			}
+		}
+	}
+	
+	if(handle == iconv_t(-1)) {
+		log_warning << "could not get codepage " << codepage << " -> UTF-8 converter";
 	}
 	
-	return converters[codepage] = iconv_open("UTF-8", oss.str().c_str());
+	return converters[codepage] = handle;
+}
+
+//! Fallback conversion that will at least work for ASCII characters
+static void to_utf8_fallback(const std::string & from, std::string & to,
+                             boost::uint32_t codepage) {
+	
+	size_t skip = get_encoding_size(codepage);
+	
+	to.clear();
+	to.reserve(ceildiv(from.size(), skip));
+	
+	for(size_t i = 0; i < from.size(); i += skip) {
+		if((unsigned char)from[i] <= 127) {
+			// copy ASCII characters
+			to.push_back(from[i]);
+		} else {
+			// replace everything else with underscores
+			to.push_back(replacement_char);
+		}
+	}
 }
 
-};
+} // anonymous namespace
 
 void binary_string::load(std::istream & is, std::string & target) {
 	
-	int32_t length = load_number<int32_t>(is);
+	boost::uint32_t length = util::load<boost::uint32_t>(is);
 	if(is.fail()) {
 		return;
 	}
@@ -65,26 +194,54 @@
 	
 	while(length) {
 		char buffer[10 * 1024];
-		int32_t buf_size = std::min(length, int32_t(sizeof(buffer)));
-		is.read(buffer, buf_size);
-		target.append(buffer, size_t(buf_size));
+		boost::uint32_t buf_size = std::min(length, boost::uint32_t(sizeof(buffer)));
+		is.read(buffer, std::streamsize(buf_size));
+		target.append(buffer, buf_size);
 		length -= buf_size;
 	}
 }
 
-void encoded_string::load(std::istream & is, std::string & target, uint32_t codepage) {
+void binary_string::skip(std::istream&  is) {
 	
-	std::string temp;
-	binary_string::load(is, temp);
+	boost::uint32_t length = util::load<boost::uint32_t>(is);
+	if(is.fail()) {
+		return;
+	}
 	
-	to_utf8(temp, target, codepage);
+	discard(is, length);
+}
+
+void encoded_string::load(std::istream & is, std::string & target, boost::uint32_t codepage) {
+	to_utf8(binary_string::load(is), target, codepage);
 }
 
-void to_utf8(const std::string & from, std::string & to, uint32_t codepage) {
+void to_utf8(const std::string & from, std::string & to, boost::uint32_t codepage) {
+	
+	if(codepage == cp_utf8 || codepage == cp_ascii) {
+		// copy UTF-8 directly
+		to = from;
+		return;
+	}
 	
 	iconv_t converter = get_converter(codepage);
+	if(converter == iconv_t(-1)) {
+		to_utf8_fallback(from, to, codepage);
+		return;
+	}
+	
+	
+	/*
+	 * Some iconv implementations declare the second parameter of iconv() as
+	 * const char **, others as char **.
+	 * Use this little hack to compile with both variants.
+	 */
+	struct inbuf_ {
+		const char * buf;
+		explicit inbuf_(const char * data) : buf(data) { }
+		operator const char **() { return &buf; }
+		operator char **() { return const_cast<char **>(&buf); }
+	} inbuf(from.data());
 	
-	const char * inbuf = from.data();
 	size_t insize = from.size();
 	
 	size_t outbase = 0;
@@ -96,22 +253,47 @@
 	
 	iconv(converter, NULL, NULL, NULL, NULL);
 	
+	size_t skip = get_encoding_size(codepage);
+	
+	bool warn = false;
+	
 	while(insize) {
 		
-		to.resize(outbase + insize + 4);
+		to.resize(outbase + ceildiv(insize, skip) + 4);
 		
 		char * outbuf = &to[0] + outbase;
 		size_t outsize = to.size() - outbase;
 		
-		size_t ret = iconv(converter, const_cast<char**>(&inbuf), &insize, &outbuf, &outsize);
-		if(ret == size_t(-1) && errno != E2BIG) {
-			log_error << "iconv error while converting from CP" << codepage << ": " << errno;
-			to.clear();
-			return;
+		size_t ret = iconv(converter, inbuf, &insize, &outbuf, &outsize);
+		if(ret == size_t(-1)) {
+			if(errno == E2BIG) {
+				// not enough output space - we'll allocate more in the next loop
+			} else if(/*errno == EILSEQ &&*/ insize >= 2) {
+				// invalid byte (sequence) - add a replacement char nd try the next byte
+				if(outsize == 0) {
+					to.push_back(replacement_char);
+				} else {
+					*outbuf = replacement_char;
+					outsize--;
+				}
+				inbuf.buf += skip;
+				insize -= skip;
+				warn = true;
+			} else {
+				// something else went wrong - return what we have so far
+				insize = 0;
+				warn = true;
+			}
 		}
 		
 		outbase = to.size() - outsize;
 	}
 	
+	if(warn) {
+		log_warning << "unexpected data while converting from CP" << codepage << " to UTF-8";
+	}
+	
 	to.resize(outbase);
 }
+
+} // namespace util
diff -Nru innoextract-1.3/src/util/load.hpp innoextract-1.4/src/util/load.hpp
--- innoextract-1.3/src/util/load.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/util/load.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -18,103 +18,183 @@
  * 3. This notice may not be removed or altered from any source distribution.
  */
 
+/*!
+ * Utility function to load stored data while properly handling encodings and endianness.
+ */
 #ifndef INNOEXTRACT_UTIL_LOAD_HPP
 #define INNOEXTRACT_UTIL_LOAD_HPP
 
-#include <stdint.h>
 #include <cstring>
-#include <iostream>
+#include <istream>
 #include <string>
 
+#include <boost/cstdint.hpp>
+
 #include "util/endian.hpp"
 #include "util/types.hpp"
 #include "util/util.hpp"
 
+namespace util {
+
+/*!
+ * Convert a string to UTF-8 from a specified encoding.
+ * \param from     The input string to convert.
+ * \param to       The output for the converted string.
+ * \param codepage The Windows codepage number for the input string encoding.
+ */
+void to_utf8(const std::string & from, std::string & to, boost::uint32_t codepage = 1252);
+
+/*!
+ * Wrapper to load a length-prefixed string from an input stream into a std::string.
+ * The string length is stored as 32-bit integer.
+ *
+ * Usage: <code>is >> binary_string(str)</code>
+ *
+ * Use \ref encoded_string to also convert the string to UTF-8.
+ */
 struct binary_string {
 	
 	std::string & data;
 	
-	inline binary_string(std::string & target) : data(target) { }
+	/*!
+	 * \param target The std::string object to receive the loaded string.
+	 */
+	explicit binary_string(std::string & target) : data(target) { }
 	
+	//! Load a length-prefixed string
 	static void load(std::istream & is, std::string & target);
 	
+	static void skip(std::istream & is);
+	
+	//! Load a length-prefixed string
+	static std::string load(std::istream & is) {
+		std::string target;
+		load(is, target);
+		return target;
+	}
+	
 };
-
 inline std::istream & operator>>(std::istream & is, const binary_string & str) {
 	binary_string::load(is, str.data);
 	return is;
 }
 
-void to_utf8(const std::string & from, std::string & to, uint32_t codepage = 1252);
-
+/*!
+ * Wrapper to load a length-prefixed string with a specified encoding from an input stream
+ * into a UTF-8 encoded std::string.
+ * The string length is stored as 32-bit integer.
+ *
+ * Usage: <code>is >> encoded_string(str, codepage)</code>
+ *
+ * You can also use the \ref ansi_string convenience wrapper for Windows-1252 strings.
+ */
 struct encoded_string {
 	
 	std::string & data;
-	uint32_t codepage;
-	
-	inline encoded_string(std::string & target, uint32_t _codepage)
-		: data(target), codepage(_codepage) { }
+	boost::uint32_t codepage;
 	
-	static void load(std::istream & is, std::string & target, uint32_t codepage);
+	/*!
+	 * \param target   The std::string object to receive the loaded UTF-8 string.
+	 * \param codepage The Windows codepage for the encoding of the stored string.
+	 */
+	encoded_string(std::string & target, boost::uint32_t codepage)
+		: data(target), codepage(codepage) { }
+	
+	//! Load and convert a length-prefixed string
+	static void load(std::istream & is, std::string & target, boost::uint32_t codepage);
+	
+	//! Load and convert a length-prefixed string
+	static std::string load(std::istream & is, boost::uint32_t codepage) {
+		std::string target;
+		load(is, target, codepage);
+		return target;
+	}
 	
 };
-
 inline std::istream & operator>>(std::istream & is, const encoded_string & str) {
 	encoded_string::load(is, str.data, str.codepage);
 	return is;
 }
 
+//! Convenience specialization of \ref encoded_string for loading Windows-1252 strings
 struct ansi_string : encoded_string {
 	
-	inline ansi_string(std::string & target) : encoded_string(target, 1252) { }
+	explicit ansi_string(std::string & target) : encoded_string(target, 1252) { }
 	
 };
 
-template <class T>
-inline T load(std::istream & is) {
-	T value;
-	char buffer[sizeof(value)];
-	is.read(buffer, sizeof(buffer));
-	std::memcpy(&value, buffer, sizeof(value));
-	return value;
-}
-
+//! Load a value of type T that is stored with a specific endianness.
 template <class T, class Endianness>
-inline T load_number(std::istream & is) {
-	return Endianness::byteswap_if_alien(load<T>(is));
+T load(std::istream & is) {
+	char buffer[sizeof(T)];
+	is.read(buffer, std::streamsize(sizeof(buffer)));
+	return Endianness::template load<T>(buffer);
 }
-
+//! Load a value of type T that is stored as little endian.
 template <class T>
-inline T load_number(std::istream & is) {
-	return load_number<T, little_endian>(is);
+T load(std::istream & is) { return load<T, little_endian>(is); }
+
+//! Load a bool value
+inline bool load_bool(std::istream & is) {
+	return !!load<boost::uint8_t>(is);
 }
 
+/*!
+ * Load a value of type T that is stored with a specific endianness.
+ * \param is   Input stream to load from.
+ * \param bits The number of bits used to store the number.
+ */
 template <class T, class Endianness>
-T load_number(std::istream & is, size_t bits) {
+T load(std::istream & is, size_t bits) {
 	if(bits == 8) {
-		return load_number<typename compatible_integer<T, 8>::type, Endianness>(is);
+		return load<typename compatible_integer<T, 8>::type, Endianness>(is);
 	} else if(bits == 16) {
-		return load_number<typename compatible_integer<T, 16>::type, Endianness>(is);
+		return load<typename compatible_integer<T, 16>::type, Endianness>(is);
 	} else if(bits == 32) {
-		return load_number<typename compatible_integer<T, 32>::type, Endianness>(is);
+		return load<typename compatible_integer<T, 32>::type, Endianness>(is);
 	} else {
-		return load_number<typename compatible_integer<T, 64>::type, Endianness>(is);
+		return load<typename compatible_integer<T, 64>::type, Endianness>(is);
 	}
 }
-
+/*!
+ * Load a value of type T that is stored as little endian.
+ * \param is   Input stream to load from.
+ * \param bits The number of bits used to store the number.
+ */
 template <class T>
-inline T load_number(std::istream & is, size_t bits) {
-	return load_number<T, little_endian>(is, bits);
-}
+T load(std::istream & is, size_t bits) { return load<T, little_endian>(is, bits); }
 
+/*!
+ * Discard a number of bytes from a non-seekable input stream or stream-like object
+ * \param is    The stream to "seek"
+ * \param bytes Number of bytes to skip ahead
+ */
 template <class T>
-void discard(T & is, uint64_t bytes) {
+void discard(T & is, boost::uint64_t bytes) {
 	char buf[1024];
 	while(bytes) {
-		std::streamsize n = std::streamsize(std::min<uint64_t>(bytes, ARRAY_SIZE(buf)));
+		std::streamsize n = std::streamsize(std::min<boost::uint64_t>(bytes, ARRAY_SIZE(buf)));
 		is.read(buf, n);
-		bytes -= uint64_t(n);
+		bytes -= boost::uint64_t(n);
 	}
 }
 
+/*!
+ * Get the number represented by a specific range of bits of another number.
+ * All other bis are masked and the requested bits are shifted to position 0.
+ * \param number The number containing the desired bits.
+ * \param first  Index of the first desired bit.
+ * \param last   Index of the last desired bit (inclusive).
+ */
+template <typename T>
+T get_bits(T number, int first, int last) {
+	typedef typename uint_t<sizeof(T) * 8>::exact UT;
+	UT data = UT(number);
+	data = UT(data >> first), last -= first;
+	UT mask = UT(((last + 1 == sizeof(T) * 8) ? UT(0) : UT(UT(1) << (last + 1))) - 1);
+	return T(data & mask);
+}
+
+} // namespace util
+
 #endif // INNOEXTRACT_UTIL_LOAD_HPP
diff -Nru innoextract-1.3/src/util/log.hpp innoextract-1.4/src/util/log.hpp
--- innoextract-1.3/src/util/log.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/util/log.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -18,6 +18,9 @@
  * 3. This notice may not be removed or altered from any source distribution.
  */
 
+/*!
+ * Logging functions.
+ */
 #ifndef INNOEXTRACT_UTIL_LOG_HPP
 #define INNOEXTRACT_UTIL_LOG_HPP
 
@@ -27,20 +30,16 @@
 #ifdef DEBUG
 #define debug(...) \
 	if(::logger::debug) \
-		::logger(__FILE__, __LINE__, ::logger::Debug) << __VA_ARGS__
-#define log_info \
-	if(!::logger::quiet) \
-		::logger(__FILE__, __LINE__, ::logger::Info)
-#define log_warning ::logger(__FILE__, __LINE__, ::logger::Warning)
-#define log_error   ::logger(__FILE__, __LINE__, ::logger::Error)
+		::logger(::logger::Debug) << __VA_ARGS__
 #else
 #define debug(...)
+#endif
+
 #define log_info \
 	if(!::logger::quiet) \
 		::logger(::logger::Info)
 #define log_warning ::logger(::logger::Warning)
 #define log_error   ::logger(::logger::Error)
-#endif
 
 /*!
  * logger class that allows longging via the stream operator.
@@ -58,32 +57,28 @@
 	
 private:
 	
-#ifdef DEBUG
-	const char * const file;
-	const int line;
-#endif
-	
 	const log_level level;
 	
 	std::ostringstream buffer; //! Buffer for the log message excluding level, file and line.
 	
 public:
 	
-	static size_t total_warnings;
-	static size_t total_errors;
+	static size_t total_warnings; //! Total number of \ref log_warning uses so far.
+	static size_t total_errors;   //! Total number of \ref log_error uses so far.
 	
-	static bool debug;
-	static bool quiet;
+	static bool debug; //! Is \ref debug output enabled?
+	static bool quiet; //! Is \ref log_info disabled?
 	
-#ifdef DEBUG
-	inline logger(const char * _file, int _line, log_level _level)
-		: file(_file), line(_line), level(_level) { }
-#else
-	inline logger(log_level _level) : level(_level) { }
-#endif
+	/*!
+	 * Construct a log line output stream.
+	 *
+	 * You probably don't want to use this directly - use \ref debug, \ref log_info,
+	 * \ref log_warning and \ref log_error instead.
+	 */
+	explicit logger(log_level _level) : level(_level) { }
 	
 	template<class T>
-	inline logger & operator<<(const T & i) {
+	logger & operator<<(const T & i) {
 		buffer << i;
 		return *this;
 	}
diff -Nru innoextract-1.3/src/util/output.hpp innoextract-1.4/src/util/output.hpp
--- innoextract-1.3/src/util/output.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/util/output.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -18,13 +18,17 @@
  * 3. This notice may not be removed or altered from any source distribution.
  */
 
+/*!
+ * Output utility functions.
+ */
 #ifndef INNOEXTRACT_UTIL_OUTPUT_HPP
 #define INNOEXTRACT_UTIL_OUTPUT_HPP
 
-#include <stdint.h>
-#include <iostream>
+#include <ostream>
 #include <string>
 
+#include <boost/cstdint.hpp>
+
 #include "util/console.hpp"
 #include "util/util.hpp"
 
@@ -90,7 +94,7 @@
 };
 
 template <class T>
-inline std::ostream & operator<<(std::ostream & os, const if_not<T> & s) {
+std::ostream & operator<<(std::ostream & os, const if_not<T> & s) {
 	if(s.value != s.excluded) {
 		color::shell_command prev = color::current;
 		return os << s.name << ": " << color::cyan << s.value << prev << '\n';
@@ -144,12 +148,16 @@
 	return detail::print_hex<T>(value);
 }
 
-const char * const byte_size_units[5] = {
+const char * const byte_size_units[] = {
 	"B",
 	"KiB",
 	"MiB",
 	"GiB",
-	"TiB"
+	"TiB",
+	"PiB",
+	"EiB",
+	"ZiB",
+	"YiB",
 };
 
 namespace detail {
@@ -168,12 +176,12 @@
 };
 
 template <class T>
-inline std::ostream & operator<<(std::ostream & os, const print_bytes<T> & s) {
+std::ostream & operator<<(std::ostream & os, const print_bytes<T> & s) {
 	
 	std::streamsize precision = os.precision();
 	
-	size_t frac = size_t(1024 * (s.value - T(uint64_t(s.value))));
-	uint64_t whole = uint64_t(s.value);
+	size_t frac = size_t(1024 * (s.value - T(boost::uint64_t(s.value))));
+	boost::uint64_t whole = boost::uint64_t(s.value);
 	
 	size_t i = 0;
 	
diff -Nru innoextract-1.3/src/util/storedenum.hpp innoextract-1.4/src/util/storedenum.hpp
--- innoextract-1.3/src/util/storedenum.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/util/storedenum.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -21,19 +21,22 @@
 #ifndef INNOEXTRACT_UTIL_STOREDENUM_HPP
 #define INNOEXTRACT_UTIL_STOREDENUM_HPP
 
-#include <stdint.h>
 #include <stddef.h>
 #include <vector>
+#include <bitset>
 
-#include <boost/utility/enable_if.hpp>
+#include <boost/cstdint.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/typeof/typeof.hpp>
+#include <boost/utility/enable_if.hpp>
 
 #include "util/enum.hpp"
 #include "util/load.hpp"
 #include "util/log.hpp"
 #include "util/util.hpp"
 
+#include "configure.hpp"
+
 template <class Enum>
 struct enum_value_map {
 	
@@ -67,9 +70,9 @@
 	
 	static const size_t size = Mapping::count;
 	
-	inline stored_enum(std::istream & is) {
+	explicit stored_enum(std::istream & is) {
 		BOOST_STATIC_ASSERT(size <= (1 << 8));
-		value = load_number<uint8_t>(is);
+		value = util::load<boost::uint8_t>(is);
 	}
 	
 	enum_type get() {
@@ -92,7 +95,7 @@
 template <size_t Bits, size_t PadBits = 32>
 class stored_bitfield {
 	
-	typedef uint8_t base_type;
+	typedef boost::uint8_t base_type;
 	
 	static const size_t base_size = sizeof(base_type) * 8;
 	static const size_t count = (Bits + (base_size - 1)) / base_size; // ceildiv
@@ -103,46 +106,38 @@
 	
 	static const size_t size = Bits;
 	
-	inline stored_bitfield(std::istream & is) {
+	explicit stored_bitfield(std::istream & is) {
 		for(size_t i = 0; i < count; i++) {
-			bits[i] = load_number<base_type>(is);
+			bits[i] = util::load<base_type>(is);
 		}
 		if(count == 3 && PadBits == 32) {
 			// 3-byte sets are padded to 4 bytes
-			(void)load_number<base_type>(is);
+			(void)util::load<base_type>(is);
 		}
 	}
 	
-	inline uint64_t lower_bits() const {
+	boost::uint64_t lower_bits() const {
 		
-		BOOST_STATIC_ASSERT(sizeof(uint64_t) % sizeof(base_type) == 0);
+		BOOST_STATIC_ASSERT(sizeof(boost::uint64_t) % sizeof(base_type) == 0);
 		
-		uint64_t result = 0;
+		boost::uint64_t result = 0;
 		
-		for(size_t i = 0; i < std::min(sizeof(uint64_t) / sizeof(base_type), size_t(count)); i++) {
-			result |= (uint64_t(bits[i]) << (i * base_size));
+		for(size_t i = 0; i < std::min(sizeof(boost::uint64_t) / sizeof(base_type), size_t(count)); i++) {
+			result |= (boost::uint64_t(bits[i]) << (i * base_size));
 		}
 		
 		return result;
 	}
 	
-	inline operator std::bitset<size>() const {
+	operator std::bitset<size>() const {
 		
-		// Make `make style` shut up since we really need unsigned long here.
-		#define stored_enum_concat_(a, b, c, d) a##b c##d
-		typedef stored_enum_concat_(unsi, gned, lo, ng) ulong_type;
-		#undef stored_enum_concat_
-		
-		static const size_t ulong_size = sizeof(ulong_type) * 8;
-		
-		BOOST_STATIC_ASSERT(base_size % ulong_size == 0 || base_size < ulong_size);
+		#define concat(a, b) a##b
+		BOOST_STATIC_ASSERT(sizeof(base_type) <= sizeof(concat(unsi, gned) concat(lo, ng)));
+		#undef concat
 		
 		std::bitset<size> result(0);
 		for(size_t i = 0; i < count; i++) {
-			for(size_t j = 0; j < ceildiv(base_size, ulong_size); j++) {
-				ulong_type chunk = static_cast<ulong_type>(bits[i] >> (j * ulong_size));
-				result |= std::bitset<size>(chunk) << ((i * base_size) + (j * ulong_size));
-			}
+			result |= std::bitset<size>(bits[i]) << (i * base_size);
 		}
 		return result;
 	}
@@ -163,17 +158,18 @@
 	typedef typename Mapping::enum_type enum_type;
 	typedef flags<enum_type> flag_type;
 	
-	inline stored_flags(std::istream & is) : stored_bitfield<Mapping::count, PadBits>(is) { }
+	explicit stored_flags(std::istream & is)
+		: stored_bitfield<Mapping::count, PadBits>(is) { }
 	
 	flag_type get() {
 		
-		uint64_t bits = this->lower_bits();
+		boost::uint64_t bits = this->lower_bits();
 		flag_type result = 0;
 		
 		for(size_t i = 0; i < this->size; i++) {
-			if(bits & (uint64_t(1) << i)) {
+			if(bits & (boost::uint64_t(1) << i)) {
 				result |= Mapping::values[i];
-				bits &= ~(uint64_t(1) << i);
+				bits &= ~(boost::uint64_t(1) << i);
 			}
 		}
 		
@@ -206,7 +202,7 @@
 	
 	std::istream & is;
 	
-	typedef uint8_t stored_type;
+	typedef boost::uint8_t stored_type;
 	static const size_t stored_bits = sizeof(stored_type) * 8;
 	
 	size_t pos;
@@ -226,7 +222,7 @@
 		
 		if(pos == 0) {
 			bytes++;
-			buffer = load_number<stored_type>(is);
+			buffer = util::load<stored_type>(is);
 		}
 		
 		if(buffer & (stored_type(1) << pos)) {
@@ -239,7 +235,7 @@
 	operator flag_type() const {
 		if(bytes == 3 && pad_bits == 32) {
 			// 3-byte sets are padded to 4 bytes
-			(void)load_number<stored_type>(is);
+			(void)util::load<stored_type>(is);
 		}
 		return result;
 	}
diff -Nru innoextract-1.3/src/util/time.cpp innoextract-1.4/src/util/time.cpp
--- innoextract-1.3/src/util/time.cpp	1970-01-01 00:00:00.000000000 +0000
+++ innoextract-1.4/src/util/time.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -0,0 +1,274 @@
+/*
+ * Copyright (C) 2013 Daniel Scharrer
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the author(s) be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#include "util/time.hpp"
+
+#include "configure.hpp"
+
+#if INNOEXTRACT_HAVE_TIMEGM || INNOEXTRACT_HAVE_MKGMTIME \
+    || INNOEXTRACT_HAVE_GMTIME_R || INNOEXTRACT_HAVE_GMTIME_S
+#include <time.h>
+#endif
+
+#include <stdlib.h>
+
+#if defined(_WIN32)
+#include <windows.h>
+#endif
+
+#if INNOEXTRACT_HAVE_UTIMENSAT && INNOEXTRACT_HAVE_AT_FDCWD
+#include <sys/stat.h>
+#include <fcntl.h>
+#elif !defined(_WIN32) && INNOEXTRACT_HAVE_UTIMES
+#include <sys/time.h>
+#elif !defined(_WIN32)
+#include <boost/filesystem/operations.hpp>
+#endif
+
+#include "util/log.hpp"
+
+namespace util {
+
+static void set_timezone(const char * value) {
+	
+	const char * variable = "TZ";
+	
+#if defined(_WIN32)
+	
+	SetEnvironmentVariable(variable, value);
+	_tzset();
+	
+#else
+	
+	if(value) {
+		setenv(variable, value, 1);
+	} else {
+		unsetenv(variable);
+	}
+	tzset();
+	
+#endif
+	
+}
+
+time parse_time(std::tm tm) {
+	
+	tm.tm_isdst = 0;
+	
+#if INNOEXTRACT_HAVE_MKGMTIME64
+	
+	// Windows
+	
+	return _mkgmtime64(&tm);
+	
+#elif INNOEXTRACT_HAVE_TIMEGM
+	
+	// GNU / BSD extension
+	
+	return timegm(&tm);
+	
+#elif INNOEXTRACT_HAVE_MKGMTIME
+	
+	// Windows (32-bit for MinGW32)
+	
+	return _mkgmtime(&tm);
+	
+#else
+	
+	// Standard, but not thread-safe - should be OK for our use though
+	
+	char * tz = getenv("TZ");
+	
+	set_timezone("UTC");
+	
+	time ret = std::mktime(&tm);
+	
+	set_timezone(tz);
+	
+	return ret;
+	
+#endif
+	
+}
+
+template <typename Time>
+static Time to_time_t(time t, const char * file = "conversion") {
+	
+	Time ret = Time(t);
+	
+	if(time(ret) != t) {
+		log_warning << "truncating timestamp " << t << " to " << ret << " for " << file;
+	}
+	
+	return ret;
+}
+
+std::tm format_time(time t) {
+	
+	std::tm ret;
+	
+#if INNOEXTRACT_HAVE_GMTIME64_S
+	
+	// Windows
+	
+	__time64_t tt = to_time_t<__time64_t>(t);
+	_gmtime64_s(&ret, &tt);
+	
+#elif INNOEXTRACT_HAVE_GMTIME_R
+	
+	// POSIX.1
+	
+	time_t tt = to_time_t<time_t>(t);
+	gmtime_r(&tt, &ret);
+	
+#elif INNOEXTRACT_HAVE_GMTIME_S
+	
+	// Windows (MSVC)
+	
+	time_t tt = to_time_t<time_t>(t);
+	gmtime_s(&ret, &tt);
+	
+#else
+	
+	// Standard C++, but may not be thread-safe
+	
+	std::time_t tt = to_time_t<std::time_t>(t);
+	std::tm * tmp = std::gmtime(&tt);
+	if(tmp) {
+		ret = *tmp;
+	} else {
+		ret.tm_year = ret.tm_mon = ret.tm_mday = -1;
+		ret.tm_hour = ret.tm_min = ret.tm_sec = -1;
+		ret.tm_isdst = -1;
+	}
+	
+#endif
+	
+	return ret;
+}
+
+time to_local_time(time t) {
+	
+	// Format time as UTC ...
+	std::tm time = format_time(t);
+	
+	// ... and interpret it as local time
+	time.tm_isdst = 0;
+	return std::mktime(&time);
+}
+
+void set_local_timezone(std::string timezone) {
+	
+	/*
+	 * The TZ variable interprets the offset as the change from local time 
+	 * to UTC while everyone else does the opposite.
+	 * We flip the direction so that timezone strings such as GMT+1 work as expected.
+	 */
+	for(size_t i = 0; i < timezone.length(); i++) {
+		if(timezone[i] == '+') {
+			timezone[i] = '-';
+		} else if(timezone[i] == '-') {
+			timezone[i] = '+';
+		}
+	}
+	
+	set_timezone(timezone.c_str());
+}
+
+#if defined(_WIN32)
+
+static HANDLE open_file(LPCSTR name) {
+	return CreateFileA(name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
+}
+
+static HANDLE open_file(LPCWSTR name) {
+	return CreateFileW(name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
+}
+
+#endif
+
+bool set_file_time(const boost::filesystem::path & path, time t, boost::uint32_t nsec) {
+	
+#if INNOEXTRACT_HAVE_UTIMENSAT && INNOEXTRACT_HAVE_AT_FDCWD
+	
+	// nanosecond precision, for Linux and POSIX.1-2008+ systems
+	
+	struct timespec times[2];
+	times[0].tv_sec = to_time_t<time_t>(t, path.string().c_str());
+	times[0].tv_nsec = boost::int32_t(nsec);
+	times[1] = times[0];
+	
+	return (utimensat(AT_FDCWD, path.string().c_str(), times, 0) == 0);
+	
+#elif defined(_WIN32)
+	
+	// 100-nanosecond precision, for Windows
+	
+	// Prevent unused function warnings
+	(void)(HANDLE(*)(LPCSTR))open_file;
+	(void)(HANDLE(*)(LPCWSTR))open_file;
+	
+	HANDLE handle = open_file(path.c_str());
+	if(handle == INVALID_HANDLE_VALUE) {
+		return false;
+	}
+	
+	// Convert the std::time_t and nanoseconds to a FILETIME struct
+	static const boost::int64_t FiletimeOffset = 0x19DB1DED53E8000ll;
+	boost::int64_t time = boost::int64_t(t) * 10000000 + boost::int64_t(nsec) / 100;
+	time += FiletimeOffset;
+	FILETIME filetime;
+	filetime.dwLowDateTime = DWORD(time);
+	filetime.dwHighDateTime = DWORD(time >> 32);
+	
+	bool ret = (SetFileTime(handle, &filetime, &filetime, &filetime) != 0);
+	CloseHandle(handle);
+	
+	return ret;
+	
+#elif INNOEXTRACT_HAVE_UTIMES
+	
+	// microsecond precision, for older POSIX systems (4.3BSD, POSIX.1-2001)
+	
+	struct timeval times[2];
+	times[0].tv_sec = to_time_t<time_t>(t, path.string().c_str());
+	times[0].tv_usec = boost::int32_t(nsec / 1000);
+	times[1] = times[0];
+	
+	return (utimes(path.string().c_str(), times) == 0);
+	
+#else
+	
+	// fallback with second precision or worse
+	
+	try {
+		(void)nsec; // sub-second precision not supported by Boost
+		std::time_t tt = to_time_t<std::time_t>(t, path.string().c_str());
+		boost::filesystem::last_write_time(path, tt);
+		return true;
+	} catch(...) {
+		return false;
+	}
+	
+#endif
+	
+}
+
+} // namespace util
diff -Nru innoextract-1.3/src/util/time.hpp innoextract-1.4/src/util/time.hpp
--- innoextract-1.3/src/util/time.hpp	1970-01-01 00:00:00.000000000 +0000
+++ innoextract-1.4/src/util/time.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2013 Daniel Scharrer
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the author(s) be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/*!
+ * Time parsing, formatting, onversion and filetime manipulation functions.
+ */
+#ifndef INNOEXTRACT_UTIL_TIME_HPP
+#define INNOEXTRACT_UTIL_TIME_HPP
+
+#include <ctime>
+#include <string>
+
+#include <boost/cstdint.hpp>
+#include <boost/filesystem/path.hpp>
+
+namespace util {
+
+typedef boost::int64_t time;
+
+/*!
+ * Convert UTC clock time to a timestamp
+ * Note: may not be threadsafe on all systems!
+ */
+time parse_time(std::tm tm);
+
+/*!
+ * Convert a timestamp to UTC clock time
+ * Note: may not be threadsafe on all systems!
+ */
+std::tm format_time(time t);
+
+/*!
+ * Convert a timestamp to local time
+ * Note: may not be threadsafe on all systems!
+ */
+time to_local_time(time t);
+
+//! Set the local timezone used by to_local_time
+void set_local_timezone(std::string timezone);
+
+//! Set a file's creation/modification time
+bool set_file_time(const boost::filesystem::path & path, time t, boost::uint32_t nsec);
+
+} // namespace util
+
+#endif // INNOEXTRACT_UTIL_TIME_HPP
diff -Nru innoextract-1.3/src/util/types.hpp innoextract-1.4/src/util/types.hpp
--- innoextract-1.3/src/util/types.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/util/types.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -18,6 +18,9 @@
  * 3. This notice may not be removed or altered from any source distribution.
  */
 
+/*!
+ * Utility functions for dealing with types.
+ */
 #ifndef INNOEXTRACT_UTIL_TYPES_HPP
 #define INNOEXTRACT_UTIL_TYPES_HPP
 
@@ -29,90 +32,70 @@
 
 #include "util/util.hpp"
 
-template <class Base, size_t Bits,
-          bool Signed = std::numeric_limits<Base>::is_signed>
-struct compatible_integer {
-	typedef void type;
-};
+#include "configure.hpp"
+
+namespace util {
 
 #if BOOST_VERSION < 104200
 
-namespace detail {
-	
-	template <size_t Bits>
-	struct uint_t { };
-	
-	template <>
-	struct uint_t<8> : public boost::uint_t<8> {
-		typedef uint8_t exact;
-	};
-	
-	template <>
-	struct uint_t<16> : public boost::uint_t<16> {
-		typedef uint16_t exact;
-	};
-	
-	template <>
-	struct uint_t<32> : public boost::uint_t<32> {
-		typedef uint32_t exact;
-	};
-	
-	template <>
-	struct uint_t<64> {
-		typedef uint64_t exact;
-	};
-	
-	template <size_t Bits>
-	struct int_t { };
-	
-	template <>
-	struct int_t<8> : public boost::int_t<8> {
-		typedef int8_t exact;
-	};
-	
-	template <>
-	struct int_t<16> : public boost::int_t<16> {
-		typedef int16_t exact;
-	};
-	
-	template <>
-	struct int_t<32> : public boost::int_t<32> {
-		typedef int32_t exact;
-	};
-	
-	template <>
-	struct int_t<64> {
-		typedef int64_t exact;
-	};
-	
-}
+template <size_t Bits>
+struct uint_t { };
+template <>
+struct uint_t<8>  : public boost::uint_t<8>  { typedef boost::uint8_t exact; };
+template <>
+struct uint_t<16> : public boost::uint_t<16> { typedef boost::uint16_t exact; };
+template <>
+struct uint_t<32> : public boost::uint_t<32> { typedef boost::uint32_t exact; };
+template <>
+struct uint_t<64>                            { typedef boost::uint64_t exact; };
+
+template <size_t Bits>
+struct int_t { };
+template <>
+struct int_t<8>  : public boost::int_t<8>  { typedef boost::int8_t exact; };
+template <>
+struct int_t<16> : public boost::int_t<16> { typedef boost::int16_t exact; };
+template <>
+struct int_t<32> : public boost::int_t<32> { typedef boost::int32_t exact; };
+template <>
+struct int_t<64>                           { typedef boost::int64_t exact; };
 
 #else
 
-namespace detail {
-	using boost::uint_t;
-	using boost::int_t;
-}
+using boost::uint_t;
+using boost::int_t;
 
 #endif
 
+/*!
+ * Get an with a specific bit size and signedness,
+ * but with no more bits than the original.
+ */
+template <class Base, size_t Bits,
+          bool Signed = std::numeric_limits<Base>::is_signed>
+struct compatible_integer {
+	typedef void type;
+};
 template <class Base, size_t Bits>
 struct compatible_integer<Base, Bits, false> {
-	typedef typename detail::uint_t<
+	typedef typename uint_t<
 		boost::static_unsigned_min<Bits, sizeof(Base) * 8>::value
 	>::exact type;
 };
-
 template <class Base, size_t Bits>
 struct compatible_integer<Base, Bits, true> {
-	typedef typename detail::int_t<
+	typedef typename int_t<
 		boost::static_unsigned_min<Bits, sizeof(Base) * 8>::value
 	>::exact type;
 };
 
+
+//! Get the alignment of a type.
 template <class T>
-inline unsigned int alignment_of() {
-#if defined(_MSC_VER) && _MSC_VER >= 1300
+unsigned int alignment_of() {
+#if INNOEXTRACT_HAVE_ALIGNOF
+	return alignof(T);
+#elif defined(_MSC_VER) && _MSC_VER >= 1300
 	return __alignof(T);
 #elif defined(__GNUC__)
 	return __alignof__(T);
@@ -121,17 +104,20 @@
 #endif
 }
 
+//! Check if a pointer has aparticular alignment.
 inline bool is_aligned_on(const void * p, size_t alignment) {
 	return alignment == 1
 	       || (is_power_of_2(alignment) ? mod_power_of_2(size_t(p), alignment) == 0
 	                                    : size_t(p) % alignment == 0);
 }
 
+//! Check if a pointer is aligned for a specific type.
 template <class T>
-inline bool is_aligned(const void * p) {
+bool is_aligned(const void * p) {
 	return is_aligned_on(p, alignment_of<T>());
 }
 
+//! CRTP helper class to hide the ugly static casts needed to get to the derived class.
 template <class Impl>
 class static_polymorphic {
 	
@@ -139,10 +125,12 @@
 	
 	typedef Impl impl_type;
 	
-	inline impl_type & impl() { return *static_cast<impl_type *>(this); }
+	impl_type & impl() { return *static_cast<impl_type *>(this); }
 	
-	inline const impl_type & impl() const { return *static_cast<const impl_type *>(this); }
+	const impl_type & impl() const { return *static_cast<const impl_type *>(this); }
 	
 };
 
+} // namespace util
+
 #endif // INNOEXTRACT_UTIL_TYPES_HPP
diff -Nru innoextract-1.3/src/util/unique_ptr.hpp innoextract-1.4/src/util/unique_ptr.hpp
--- innoextract-1.3/src/util/unique_ptr.hpp	1970-01-01 00:00:00.000000000 +0000
+++ innoextract-1.4/src/util/unique_ptr.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2013 Daniel Scharrer
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the author(s) be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/*!
+ * Wrapper to select std::unique_ptr if available, std::auto_ptr otherwise.
+ */
+#ifndef INNOEXTRACT_UTIL_UNIQUE_PTR_HPP
+#define INNOEXTRACT_UTIL_UNIQUE_PTR_HPP
+
+#include <memory>
+
+#include "configure.hpp"
+
+namespace util {
+
+//! Get a unique_ptr or auto_ptr for the given type.
+template <typename T>
+struct unique_ptr {
+#if INNOEXTRACT_HAVE_STD_UNIQUE_PTR
+	typedef std::unique_ptr<T> type;
+#else
+	typedef std::auto_ptr<T> type;
+#endif
+};
+
+} // namespace util
+
+#endif // INNOEXTRACT_UTIL_UNIQUE_PTR_HPP
diff -Nru innoextract-1.3/src/util/util.hpp innoextract-1.4/src/util/util.hpp
--- innoextract-1.3/src/util/util.hpp	2012-10-25 21:00:06.000000000 +0000
+++ innoextract-1.4/src/util/util.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Daniel Scharrer
+ * Copyright (C) 2011-2013 Daniel Scharrer
  *
  * This software is provided 'as-is', without any express or implied
  * warranty.  In no event will the author(s) be held liable for any damages
@@ -18,23 +18,36 @@
  * 3. This notice may not be removed or altered from any source distribution.
  */
 
+/*!
+ * Miscellaneous utility functions.
+ */
 #ifndef INNOEXTRACT_UTIL_UTIL_HPP
 #define INNOEXTRACT_UTIL_UTIL_HPP
 
+#ifdef _MSC_VER
+#include <intrin.h>
+#endif
+
+namespace util {
+
+//! Get the number of elements in a statically-sized array.
 #define ARRAY_SIZE(array) (sizeof(array)/sizeof(*(array)))
 
+//! Divide by a number and round up the result.
 template <typename T>
-inline T ceildiv(T num, T denom) {
+T ceildiv(T num, T denom) {
 	return (num + (denom - T(1))) / denom;
 }
 
+//! Check if an integer is a power of two.
 template <class T>
-inline bool is_power_of_2(const T & n) {
+bool is_power_of_2(const T & n) {
 	return n > 0 && (n & (n - 1)) == 0;
 }
 
+//! Calculate <code>a % b</code> where b is always a power of two.
 template <class T1, class T2>
-inline T2 mod_power_of_2(const T1 & a, const T2 & b) {
+T2 mod_power_of_2(const T1 & a, const T2 & b) {
 	return T2(a) & (b - 1);
 }
 
@@ -44,12 +57,12 @@
 struct safe_shifter {
 	
 	template <class T>
-	static inline T right_shift(T, unsigned int) {
+	static T right_shift(T, unsigned int) {
 		return 0;
 	}
 
 	template <class T>
-	static inline T left_shift(T, unsigned int) {
+	static T left_shift(T, unsigned int) {
 		return 0;
 	}
 	
@@ -59,12 +72,12 @@
 struct safe_shifter<false> {
 	
 	template <class T>
-	static inline T right_shift(T value, unsigned int bits) {
+	static T right_shift(T value, unsigned int bits) {
 		return value >> bits;
 	}
 
 	template <class T>
-	static inline T left_shift(T value, unsigned int bits) {
+	static T left_shift(T value, unsigned int bits) {
 		return value << bits;
 	}
 	
@@ -72,45 +85,51 @@
 
 } // namespace detail
 
+//! Right-shift a value without shifting past the size of the type or return 0.
 template <unsigned int bits, class T>
-inline T safe_right_shift(T value) {
+T safe_right_shift(T value) {
 	return detail::safe_shifter<(bits >= (8 * sizeof(T)))>::right_shift(value, bits);
 }
 
+//! Left-shift a value without shifting past the size of the type or return 0.
 template <unsigned int bits, class T>
-inline T safe_left_shift(T value) {
+T safe_left_shift(T value) {
 	return detail::safe_shifter<(bits >= (8 * sizeof(T)))>::left_shift(value, bits);
 }
 
-template <class T> inline T rotl_fixed(T x, unsigned int y) {
+//! Rotate left.
+template <class T> T rotl_fixed(T x, unsigned int y) {
 	return T((x << y) | (x >> (sizeof(T) * 8 - y)));
 }
 
 #if defined(_MSC_VER) && _MSC_VER >= 1400 && !defined(__INTEL_COMPILER)
 
-template<> inline uint8_t rotl_fixed<uint8_t>(uint8_t x, unsigned int y) {
+template<>
+inline boost::uint8_t rotl_fixed<boost::uint8_t>(boost::uint8_t x, unsigned int y) {
 	return y ? _rotl8(x, y) : x;
 }
 
-// Intel C++ Compiler 10.0 gives undefined externals with these
-template<> inline uint16_t rotl_fixed<uint16_t>(uint16_t x, unsigned int y) {
+template<>
+inline boost::uint16_t rotl_fixed<boost::uint16_t>(boost::uint16_t x, unsigned int y) {
 	return y ? _rotl16(x, y) : x;
 }
 
 #endif
 
 #ifdef _MSC_VER
-template<> inline uint32_t rotl_fixed<uint32_t>(uint32_t x, unsigned int y) {
+template<>
+inline boost::uint32_t rotl_fixed<boost::uint32_t>(boost::uint32_t x, unsigned int y) {
 	return y ? _lrotl(x, y) : x;
 }
 #endif
 
 #if defined(_MSC_VER) && _MSC_VER >= 1300 && !defined(__INTEL_COMPILER)
-// Intel C++ Compiler 10.0 calls a function instead of using the rotate instruction when
-// using these instructions
-template<> inline uint64_t rotl_fixed<uint64_t>(uint64_t x, unsigned int y) {
+template<>
+inline boost::uint64_t rotl_fixed<boost::uint64_t>(boost::uint64_t x, unsigned int y) {
 	return y ? _rotl64(x, y) : x;
 }
 #endif
 
+} // namespace util
+
 #endif // INNOEXTRACT_UTIL_UTIL_HPP
diff -Nru innoextract-1.3/src/util/windows.cpp innoextract-1.4/src/util/windows.cpp
--- innoextract-1.3/src/util/windows.cpp	1970-01-01 00:00:00.000000000 +0000
+++ innoextract-1.4/src/util/windows.cpp	2013-03-11 16:24:33.000000000 +0000
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2013 Daniel Scharrer
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the author(s) be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef _WIN32
+#define _WIN32
+#endif
+#include "util/windows.hpp"
+
+#include <locale>
+#include <clocale>
+
+#include <windows.h>
+
+#include <boost/filesystem/path.hpp>
+
+#include "configure.hpp"
+
+#if INNOEXTRACT_HAVE_STD_CODECVT_UTF8_UTF16
+// C++11
+#include <codecvt>
+namespace { typedef std::codecvt_utf8_utf16<wchar_t> utf8_codecvt; }
+#else
+// Using private Boost stuff - bad, but meh.
+#include <boost/filesystem/detail/utf8_codecvt_facet.hpp>
+namespace { typedef boost::filesystem::detail::utf8_codecvt_facet utf8_codecvt; }
+#endif
+
+// We really want main here, not utf8_main.
+#undef main
+int main() {
+	
+	// We use UTF-8 for everything internally, as almost all modern operating systems
+	// have standardized on that. However, as usual, Windows has to do its own thing
+	// and only supports Unicode input/output via UCS-2^H^H^H^H^HUTF-16.
+	
+	std::setlocale(LC_ALL, "");
+	
+	// Get the UTF-16 command-line parameters and convert it them to UTF-8 ourself.
+	int argc = __argc;
+	wchar_t ** wargv = __wargv;
+	char ** argv = new char *[argc + 1];
+	argv[argc] = NULL;
+	for(int i = 0; i < argc; i++) {
+		int n = WideCharToMultiByte(CP_UTF8, 0, wargv[i], -1, NULL, 0,  NULL, NULL);
+		argv[i] = new char[n];
+		WideCharToMultiByte(CP_UTF8, 0, wargv[i], -1, argv[i], n, NULL, NULL);
+	}
+	
+	// Tell boost::filesystem to interpret our path strings as UTF-8.
+	std::locale global_locale = std::locale();
+	std::locale utf8_locale(global_locale, new utf8_codecvt);
+	boost::filesystem::path::imbue(utf8_locale);
+	
+	return utf8_main(argc, argv);
+}
diff -Nru innoextract-1.3/src/util/windows.hpp innoextract-1.4/src/util/windows.hpp
--- innoextract-1.3/src/util/windows.hpp	1970-01-01 00:00:00.000000000 +0000
+++ innoextract-1.4/src/util/windows.hpp	2013-03-11 16:24:33.000000000 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2013 Daniel Scharrer
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the author(s) be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/*!
+ * Compatibility wrapper to work around deficiencies in Microsoft® Windows™.
+ * Mostly deals with converting between UTF-8 and UTF-16 input/output.
+ * More precisely:
+ *  - Converts wide char command-line arguments to UTF-8 and calls utf8_main().
+ *  - Sets an UTF-8 locale for boost::filesystem::path.
+ *    This makes everything in boost::filesystem UTF-8 aware, except for {i,o,}fstream.
+ *    For those, there are UTF-8 aware implementations in util/fstream.hpp
+ */
+#ifndef INNOEXTRACT_UTIL_WINDOWS_HPP
+#define INNOEXTRACT_UTIL_WINDOWS_HPP
+
+#if defined(_WIN32)
+
+//! Program entry point that will always receive UTF-8 encoded arguments.
+int utf8_main(int argc, char * argv[]);
+
+//! We define our own wrapper main(), so rename the real one.
+#define main utf8_main
+
+#endif // defined(_WIN32)
+
+#endif // INNOEXTRACT_UTIL_WINDOWS_HPP