Import xz-5.0.0.
authorPeter Avalos <pavalos@dragonflybsd.org>
Sun, 19 Dec 2010 00:24:26 +0000 (14:24 -1000)
committerPeter Avalos <pavalos@dragonflybsd.org>
Sun, 19 Dec 2010 00:24:26 +0000 (14:24 -1000)
This is from the XZ Utils project: http://tukaani.org/xz/

188 files changed:
contrib/xz/AUTHORS [new file with mode: 0644]
contrib/xz/COPYING [new file with mode: 0644]
contrib/xz/COPYING.GPLv2 [new file with mode: 0644]
contrib/xz/COPYING.GPLv3 [new file with mode: 0644]
contrib/xz/COPYING.LGPLv2.1 [new file with mode: 0644]
contrib/xz/NEWS [new file with mode: 0644]
contrib/xz/README [new file with mode: 0644]
contrib/xz/README.DELETED [new file with mode: 0644]
contrib/xz/src/common/mythread.h [new file with mode: 0644]
contrib/xz/src/common/sysdefs.h [new file with mode: 0644]
contrib/xz/src/common/tuklib_common.h [new file with mode: 0644]
contrib/xz/src/common/tuklib_config.h [new file with mode: 0644]
contrib/xz/src/common/tuklib_cpucores.c [new file with mode: 0644]
contrib/xz/src/common/tuklib_cpucores.h [new file with mode: 0644]
contrib/xz/src/common/tuklib_exit.c [new file with mode: 0644]
contrib/xz/src/common/tuklib_exit.h [new file with mode: 0644]
contrib/xz/src/common/tuklib_gettext.h [new file with mode: 0644]
contrib/xz/src/common/tuklib_integer.h [new file with mode: 0644]
contrib/xz/src/common/tuklib_mbstr.h [new file with mode: 0644]
contrib/xz/src/common/tuklib_mbstr_fw.c [new file with mode: 0644]
contrib/xz/src/common/tuklib_mbstr_width.c [new file with mode: 0644]
contrib/xz/src/common/tuklib_open_stdxxx.c [new file with mode: 0644]
contrib/xz/src/common/tuklib_open_stdxxx.h [new file with mode: 0644]
contrib/xz/src/common/tuklib_physmem.c [new file with mode: 0644]
contrib/xz/src/common/tuklib_physmem.h [new file with mode: 0644]
contrib/xz/src/common/tuklib_progname.c [new file with mode: 0644]
contrib/xz/src/common/tuklib_progname.h [new file with mode: 0644]
contrib/xz/src/liblzma/api/lzma.h [new file with mode: 0644]
contrib/xz/src/liblzma/api/lzma/base.h [new file with mode: 0644]
contrib/xz/src/liblzma/api/lzma/bcj.h [new file with mode: 0644]
contrib/xz/src/liblzma/api/lzma/block.h [new file with mode: 0644]
contrib/xz/src/liblzma/api/lzma/check.h [new file with mode: 0644]
contrib/xz/src/liblzma/api/lzma/container.h [new file with mode: 0644]
contrib/xz/src/liblzma/api/lzma/delta.h [new file with mode: 0644]
contrib/xz/src/liblzma/api/lzma/filter.h [new file with mode: 0644]
contrib/xz/src/liblzma/api/lzma/hardware.h [new file with mode: 0644]
contrib/xz/src/liblzma/api/lzma/index.h [new file with mode: 0644]
contrib/xz/src/liblzma/api/lzma/index_hash.h [new file with mode: 0644]
contrib/xz/src/liblzma/api/lzma/lzma.h [new file with mode: 0644]
contrib/xz/src/liblzma/api/lzma/stream_flags.h [new file with mode: 0644]
contrib/xz/src/liblzma/api/lzma/version.h [new file with mode: 0644]
contrib/xz/src/liblzma/api/lzma/vli.h [new file with mode: 0644]
contrib/xz/src/liblzma/check/check.c [new file with mode: 0644]
contrib/xz/src/liblzma/check/check.h [new file with mode: 0644]
contrib/xz/src/liblzma/check/crc32_fast.c [new file with mode: 0644]
contrib/xz/src/liblzma/check/crc32_small.c [new file with mode: 0644]
contrib/xz/src/liblzma/check/crc32_table.c [new file with mode: 0644]
contrib/xz/src/liblzma/check/crc32_table_be.h [new file with mode: 0644]
contrib/xz/src/liblzma/check/crc32_table_le.h [new file with mode: 0644]
contrib/xz/src/liblzma/check/crc32_tablegen.c [new file with mode: 0644]
contrib/xz/src/liblzma/check/crc32_x86.S [new file with mode: 0644]
contrib/xz/src/liblzma/check/crc64_fast.c [new file with mode: 0644]
contrib/xz/src/liblzma/check/crc64_small.c [new file with mode: 0644]
contrib/xz/src/liblzma/check/crc64_table.c [new file with mode: 0644]
contrib/xz/src/liblzma/check/crc64_table_be.h [new file with mode: 0644]
contrib/xz/src/liblzma/check/crc64_table_le.h [new file with mode: 0644]
contrib/xz/src/liblzma/check/crc64_tablegen.c [new file with mode: 0644]
contrib/xz/src/liblzma/check/crc64_x86.S [new file with mode: 0644]
contrib/xz/src/liblzma/check/crc_macros.h [new file with mode: 0644]
contrib/xz/src/liblzma/check/sha256.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/alone_decoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/alone_decoder.h [new file with mode: 0644]
contrib/xz/src/liblzma/common/alone_encoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/auto_decoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/block_buffer_decoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/block_buffer_encoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/block_decoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/block_decoder.h [new file with mode: 0644]
contrib/xz/src/liblzma/common/block_encoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/block_encoder.h [new file with mode: 0644]
contrib/xz/src/liblzma/common/block_header_decoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/block_header_encoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/block_util.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/common.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/common.h [new file with mode: 0644]
contrib/xz/src/liblzma/common/easy_buffer_encoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/easy_decoder_memusage.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/easy_encoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/easy_encoder_memusage.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/easy_preset.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/easy_preset.h [new file with mode: 0644]
contrib/xz/src/liblzma/common/filter_buffer_decoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/filter_buffer_encoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/filter_common.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/filter_common.h [new file with mode: 0644]
contrib/xz/src/liblzma/common/filter_decoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/filter_decoder.h [new file with mode: 0644]
contrib/xz/src/liblzma/common/filter_encoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/filter_encoder.h [new file with mode: 0644]
contrib/xz/src/liblzma/common/filter_flags_decoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/filter_flags_encoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/hardware_physmem.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/index.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/index.h [new file with mode: 0644]
contrib/xz/src/liblzma/common/index_decoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/index_encoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/index_encoder.h [new file with mode: 0644]
contrib/xz/src/liblzma/common/index_hash.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/stream_buffer_decoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/stream_buffer_encoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/stream_decoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/stream_decoder.h [new file with mode: 0644]
contrib/xz/src/liblzma/common/stream_encoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/stream_encoder.h [new file with mode: 0644]
contrib/xz/src/liblzma/common/stream_flags_common.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/stream_flags_common.h [new file with mode: 0644]
contrib/xz/src/liblzma/common/stream_flags_decoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/stream_flags_encoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/vli_decoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/vli_encoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/common/vli_size.c [new file with mode: 0644]
contrib/xz/src/liblzma/delta/delta_common.c [new file with mode: 0644]
contrib/xz/src/liblzma/delta/delta_common.h [new file with mode: 0644]
contrib/xz/src/liblzma/delta/delta_decoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/delta/delta_decoder.h [new file with mode: 0644]
contrib/xz/src/liblzma/delta/delta_encoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/delta/delta_encoder.h [new file with mode: 0644]
contrib/xz/src/liblzma/delta/delta_private.h [new file with mode: 0644]
contrib/xz/src/liblzma/lz/lz_decoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/lz/lz_decoder.h [new file with mode: 0644]
contrib/xz/src/liblzma/lz/lz_encoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/lz/lz_encoder.h [new file with mode: 0644]
contrib/xz/src/liblzma/lz/lz_encoder_hash.h [new file with mode: 0644]
contrib/xz/src/liblzma/lz/lz_encoder_hash_table.h [new file with mode: 0644]
contrib/xz/src/liblzma/lz/lz_encoder_mf.c [new file with mode: 0644]
contrib/xz/src/liblzma/lzma/fastpos.h [new file with mode: 0644]
contrib/xz/src/liblzma/lzma/fastpos_table.c [new file with mode: 0644]
contrib/xz/src/liblzma/lzma/fastpos_tablegen.c [new file with mode: 0644]
contrib/xz/src/liblzma/lzma/lzma2_decoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/lzma/lzma2_decoder.h [new file with mode: 0644]
contrib/xz/src/liblzma/lzma/lzma2_encoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/lzma/lzma2_encoder.h [new file with mode: 0644]
contrib/xz/src/liblzma/lzma/lzma_common.h [new file with mode: 0644]
contrib/xz/src/liblzma/lzma/lzma_decoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/lzma/lzma_decoder.h [new file with mode: 0644]
contrib/xz/src/liblzma/lzma/lzma_encoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/lzma/lzma_encoder.h [new file with mode: 0644]
contrib/xz/src/liblzma/lzma/lzma_encoder_optimum_fast.c [new file with mode: 0644]
contrib/xz/src/liblzma/lzma/lzma_encoder_optimum_normal.c [new file with mode: 0644]
contrib/xz/src/liblzma/lzma/lzma_encoder_presets.c [new file with mode: 0644]
contrib/xz/src/liblzma/lzma/lzma_encoder_private.h [new file with mode: 0644]
contrib/xz/src/liblzma/rangecoder/price.h [new file with mode: 0644]
contrib/xz/src/liblzma/rangecoder/price_table.c [new file with mode: 0644]
contrib/xz/src/liblzma/rangecoder/price_tablegen.c [new file with mode: 0644]
contrib/xz/src/liblzma/rangecoder/range_common.h [new file with mode: 0644]
contrib/xz/src/liblzma/rangecoder/range_decoder.h [new file with mode: 0644]
contrib/xz/src/liblzma/rangecoder/range_encoder.h [new file with mode: 0644]
contrib/xz/src/liblzma/simple/arm.c [new file with mode: 0644]
contrib/xz/src/liblzma/simple/armthumb.c [new file with mode: 0644]
contrib/xz/src/liblzma/simple/ia64.c [new file with mode: 0644]
contrib/xz/src/liblzma/simple/powerpc.c [new file with mode: 0644]
contrib/xz/src/liblzma/simple/simple_coder.c [new file with mode: 0644]
contrib/xz/src/liblzma/simple/simple_coder.h [new file with mode: 0644]
contrib/xz/src/liblzma/simple/simple_decoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/simple/simple_decoder.h [new file with mode: 0644]
contrib/xz/src/liblzma/simple/simple_encoder.c [new file with mode: 0644]
contrib/xz/src/liblzma/simple/simple_encoder.h [new file with mode: 0644]
contrib/xz/src/liblzma/simple/simple_private.h [new file with mode: 0644]
contrib/xz/src/liblzma/simple/sparc.c [new file with mode: 0644]
contrib/xz/src/liblzma/simple/x86.c [new file with mode: 0644]
contrib/xz/src/lzmainfo/lzmainfo.1 [new file with mode: 0644]
contrib/xz/src/lzmainfo/lzmainfo.c [new file with mode: 0644]
contrib/xz/src/xz/args.c [new file with mode: 0644]
contrib/xz/src/xz/args.h [new file with mode: 0644]
contrib/xz/src/xz/coder.c [new file with mode: 0644]
contrib/xz/src/xz/coder.h [new file with mode: 0644]
contrib/xz/src/xz/file_io.c [new file with mode: 0644]
contrib/xz/src/xz/file_io.h [new file with mode: 0644]
contrib/xz/src/xz/hardware.c [new file with mode: 0644]
contrib/xz/src/xz/hardware.h [new file with mode: 0644]
contrib/xz/src/xz/list.c [new file with mode: 0644]
contrib/xz/src/xz/list.h [new file with mode: 0644]
contrib/xz/src/xz/main.c [new file with mode: 0644]
contrib/xz/src/xz/main.h [new file with mode: 0644]
contrib/xz/src/xz/message.c [new file with mode: 0644]
contrib/xz/src/xz/message.h [new file with mode: 0644]
contrib/xz/src/xz/options.c [new file with mode: 0644]
contrib/xz/src/xz/options.h [new file with mode: 0644]
contrib/xz/src/xz/private.h [new file with mode: 0644]
contrib/xz/src/xz/signals.c [new file with mode: 0644]
contrib/xz/src/xz/signals.h [new file with mode: 0644]
contrib/xz/src/xz/suffix.c [new file with mode: 0644]
contrib/xz/src/xz/suffix.h [new file with mode: 0644]
contrib/xz/src/xz/util.c [new file with mode: 0644]
contrib/xz/src/xz/util.h [new file with mode: 0644]
contrib/xz/src/xz/xz.1 [new file with mode: 0644]
contrib/xz/src/xzdec/xzdec.1 [new file with mode: 0644]
contrib/xz/src/xzdec/xzdec.c [new file with mode: 0644]

diff --git a/contrib/xz/AUTHORS b/contrib/xz/AUTHORS
new file mode 100644 (file)
index 0000000..63a9815
--- /dev/null
@@ -0,0 +1,27 @@
+
+Authors of XZ Utils
+===================
+
+    XZ Utils is developed and maintained by Lasse Collin
+    <lasse.collin@tukaani.org>.
+
+    Major parts of liblzma are based on code written by Igor Pavlov,
+    specifically the LZMA SDK <http://7-zip.org/sdk.html>. Without
+    this code, XZ Utils wouldn't exist.
+
+    The SHA-256 implementation in liblzma is based on the code found from
+    7-Zip <http://7-zip.org/>, which has a modified version of the SHA-256
+    code found from Crypto++ <http://www.cryptopp.com/>. The SHA-256 code
+    in Crypto++ was written by Kevin Springle and Wei Dai.
+
+    Some scripts have been adapted from gzip. The original versions
+    were written by Jean-loup Gailly, Charles Levert, and Paul Eggert.
+    Andrew Dudman helped adapting the script and their man pages for
+    XZ Utils.
+
+    The GNU Autotools based build system contains files from many authors,
+    which I'm not trying list here.
+
+    Several people have contributed fixes or reported bugs. Most of them
+    are mentioned in the file THANKS.
+
diff --git a/contrib/xz/COPYING b/contrib/xz/COPYING
new file mode 100644 (file)
index 0000000..43c90d0
--- /dev/null
@@ -0,0 +1,65 @@
+
+XZ Utils Licensing
+==================
+
+    Different licenses apply to different files in this package. Here
+    is a rough summary of which licenses apply to which parts of this
+    package (but check the individual files to be sure!):
+
+      - liblzma is in the public domain.
+
+      - xz, xzdec, and lzmadec command line tools are in the public
+        domain unless GNU getopt_long had to be compiled and linked
+        in from the lib directory. The getopt_long code is under
+        GNU LGPLv2.1+.
+
+      - The scripts to grep, diff, and view compressed files have been
+        adapted from gzip. These scripts and their documentation are
+        under GNU GPLv2+.
+
+      - All the documentation in the doc directory and most of the
+        XZ Utils specific documentation files in other directories
+        are in the public domain.
+
+      - Translated messages are in the public domain.
+
+      - The build system contains public domain files, and files that
+        are under GNU GPLv2+ or GNU GPLv3+. None of these files end up
+        in the binaries being built.
+
+      - Test files and test code in the tests directory, and debugging
+        utilities in the debug directory are in the public domain.
+
+      - The extra directory may contain public domain files, and files
+        that are under various free software licenses.
+
+    You can do whatever you want with the files that have been put into
+    the public domain. If you find public domain legally problematic,
+    take the previous sentence as a license grant. If you still find
+    the lack of copyright legally problematic, you have too many
+    lawyers.
+
+    As usual, this software is provided "as is", without any warranty.
+
+    If you copy significant amounts of public domain code from XZ Utils
+    into your project, acknowledging this somewhere in your software is
+    polite (especially if it is proprietary, non-free software), but
+    naturally it is not legally required. Here is an example of a good
+    notice to put into "about box" or into documentation:
+
+        This software includes code from XZ Utils <http://tukaani.org/xz/>.
+
+    The following license texts are included in the following files:
+      - COPYING.LGPLv2.1: GNU Lesser General Public License version 2.1
+      - COPYING.GPLv2: GNU General Public License version 2
+      - COPYING.GPLv3: GNU General Public License version 3
+
+    Note that the toolchain (compiler, linker etc.) may add some code
+    pieces that are copyrighted. Thus, it is possible that e.g. liblzma
+    binary wouldn't actually be in the public domain in its entirety
+    even though it contains no copyrighted code from the XZ Utils source
+    package.
+
+    If you have questions, don't hesitate to ask the author(s) for more
+    information.
+
diff --git a/contrib/xz/COPYING.GPLv2 b/contrib/xz/COPYING.GPLv2
new file mode 100644 (file)
index 0000000..d511905
--- /dev/null
@@ -0,0 +1,339 @@
+                   GNU GENERAL PUBLIC LICENSE
+                      Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                           Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                   GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                           NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                    END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
diff --git a/contrib/xz/COPYING.GPLv3 b/contrib/xz/COPYING.GPLv3
new file mode 100644 (file)
index 0000000..94a9ed0
--- /dev/null
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/contrib/xz/COPYING.LGPLv2.1 b/contrib/xz/COPYING.LGPLv2.1
new file mode 100644 (file)
index 0000000..5ab7695
--- /dev/null
@@ -0,0 +1,504 @@
+                 GNU LESSER GENERAL PUBLIC LICENSE
+                      Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                           Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+\f
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+\f
+                 GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+\f
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+\f
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+\f
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+\f
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+\f
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+\f
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                           NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                    END OF TERMS AND CONDITIONS
+\f
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+
diff --git a/contrib/xz/NEWS b/contrib/xz/NEWS
new file mode 100644 (file)
index 0000000..d9a2f3c
--- /dev/null
@@ -0,0 +1,62 @@
+
+XZ Utils User-Visible Changes
+=============================
+
+5.0.0 (2010-10-23)
+
+    Only the most important changes compared to 4.999.9beta are listed
+    here. One change is especially important:
+
+      * The memory usage limit is now disabled by default. Some scripts
+        written before this change may have used --memory=max on xz command
+        line or in XZ_OPT. THESE USES OF --memory=max SHOULD BE REMOVED
+        NOW, because they interfere with user's ability to set the memory
+        usage limit himself. If user-specified limit causes problems to
+        your script, blame the user.
+
+    Other significant changes:
+
+      * Added support for XZ_DEFAULTS environment variable. This variable
+        allows users to set default options for xz, e.g. default memory
+        usage limit or default compression level. Scripts that use xz
+        must never set or unset XZ_DEFAULTS. Scripts should use XZ_OPT
+        instead if they need a way to pass options to xz via an
+        environment variable.
+
+      * The compression settings associated with the preset levels
+        -0 ... -9 have been changed. --extreme was changed a little too.
+        It is now less likely to make compression worse, but with some
+        files the new --extreme may compress slightly worse than the old
+        --extreme.
+
+      * If a preset level (-0 ... -9) is specified after a custom filter
+        chain options have been used (e.g. --lzma2), the custom filter
+        chain will be forgotten. Earlier the preset options were
+        completely ignored after custom filter chain options had been
+        seen.
+
+      * xz will create sparse files when decompressing if the uncompressed
+        data contains long sequences of binary zeros. This is done even
+        when writing to standard output that is connected to a regular
+        file and certain additional conditions are met to make it safe.
+
+      * Support for "xz --list" was added. Combine with --verbose or
+        --verbose --verbose (-vv) for detailed output.
+
+      * I had hoped that liblzma API would have been stable after
+        4.999.9beta, but there have been a couple of changes in the
+        advanced features, which don't affect most applications:
+
+          - Index handling code was revised. If you were using the old
+            API, you will get a compiler error (so it's easy to notice).
+
+          - A subtle but important change was made to the Block handling
+            API. lzma_block.version has to be initialized even for
+            lzma_block_header_decode(). Code that doesn't do it will work
+            for now, but might break in the future, which makes this API
+            change easy to miss.
+
+      * The major soname has been bumped to 5.0.0. liblzma API and ABI
+        are now stable, so the need to recompile programs linking against
+        liblzma shouldn't arise soon.
+
diff --git a/contrib/xz/README b/contrib/xz/README
new file mode 100644 (file)
index 0000000..d6cfda7
--- /dev/null
@@ -0,0 +1,304 @@
+
+XZ Utils
+========
+
+    0. Overview
+    1. Documentation
+       1.1. Overall documentation
+       1.2. Documentation for command line tools
+       1.3. Documentation for liblzma
+    2. Version numbering
+    3. Reporting bugs
+    4. Translating the xz tool
+    5. Other implementations of the .xz format
+    6. Contact information
+
+
+0. Overview
+-----------
+
+    XZ Utils provide a general-purpose data compression library and
+    command line tools. The native file format is the .xz format, but
+    also the legacy .lzma format is supported. The .xz format supports
+    multiple compression algorithms, which are called "filters" in
+    context of XZ Utils. The primary filter is currently LZMA2. With
+    typical files, XZ Utils create about 30 % smaller files than gzip.
+
+    To ease adapting support for the .xz format into existing applications
+    and scripts, the API of liblzma is somewhat similar to the API of the
+    popular zlib library. For the same reason, the command line tool xz
+    has similar command line syntax than that of gzip.
+
+    When aiming for the highest compression ratio, LZMA2 encoder uses
+    a lot of CPU time and may use, depending on the settings, even
+    hundreds of megabytes of RAM. However, in fast modes, LZMA2 encoder
+    competes with bzip2 in compression speed, RAM usage, and compression
+    ratio.
+
+    LZMA2 is reasonably fast to decompress. It is a little slower than
+    gzip, but a lot faster than bzip2. Being fast to decompress means
+    that the .xz format is especially nice when the same file will be
+    decompressed very many times (usually on different computers), which
+    is the case e.g. when distributing software packages. In such
+    situations, it's not too bad if the compression takes some time,
+    since that needs to be done only once to benefit many people.
+
+    With some file types, combining (or "chaining") LZMA2 with an
+    additional filter can improve compression ratio. A filter chain may
+    contain up to four filters, although usually only one two is used.
+    For example, putting a BCJ (Branch/Call/Jump) filter before LZMA2
+    in the filter chain can improve compression ratio of executable files.
+
+    Since the .xz format allows adding new filter IDs, it is possible that
+    some day there will be a filter that is, for example, much faster to
+    compress than LZMA2 (but probably with worse compression ratio).
+    Similarly, it is possible that some day there is a filter that will
+    compress better than LZMA2.
+
+    XZ Utils doesn't support multithreaded compression or decompression
+    yet. It has been planned though and taken into account when designing
+    the .xz file format.
+
+
+1. Documentation
+----------------
+
+1.1. Overall documentation
+
+    README              This file
+
+    INSTALL.generic     Generic install instructions for those not familiar
+                        with packages using GNU Autotools
+    INSTALL             Installation instructions specific to XZ Utils
+    PACKAGERS           Information to packagers of XZ Utils
+
+    COPYING             XZ Utils copyright and license information
+    COPYING.GPLv2       GNU General Public License version 2
+    COPYING.GPLv3       GNU General Public License version 3
+    COPYING.LGPLv2.1    GNU Lesser General Public License version 2.1
+
+    AUTHORS             The main authors of XZ Utils
+    THANKS              Incomplete list of people who have helped making
+                        this software
+    NEWS                User-visible changes between XZ Utils releases
+    ChangeLog           Detailed list of changes (commit log)
+    TODO                Known bugs and some sort of to-do list
+
+    Note that only some of the above files are included in binary
+    packages.
+
+
+1.2. Documentation for command line tools
+
+    The command line tools are documented as man pages. In source code
+    releases (and possibly also in some binary packages), the man pages
+    are also provided in plain text (ASCII only) and PDF formats in the
+    directory "doc/man" to make the man pages more accessible to those
+    whose operating system doesn't provide an easy way to view man pages.
+
+
+1.3. Documentation for liblzma
+
+    The liblzma API headers include short docs about each function
+    and data type as Doxygen tags. These docs should be quite OK as
+    a quick reference.
+
+    I have planned to write a bunch of very well documented example
+    programs, which (due to comments) should work as a tutorial to
+    various features of liblzma. No such example programs have been
+    written yet.
+
+    For now, if you have never used liblzma, libbzip2, or zlib, I
+    recommend learning *basics* of zlib API. Once you know that, it
+    should be easier to learn liblzma.
+
+        http://zlib.net/manual.html
+        http://zlib.net/zlib_how.html
+
+
+2. Version numbering
+--------------------
+
+    The version number format of XZ Utils is X.Y.ZS:
+
+      - X is the major version. When this is incremented, the library
+        API and ABI break.
+
+      - Y is the minor version. It is incremented when new features are
+        added without breaking existing API or ABI. Even Y indicates
+        stable release and odd Y indicates unstable (alpha or beta
+        version).
+
+      - Z is the revision. This has different meaning for stable and
+        unstable releases:
+          * Stable: Z is incremented when bugs get fixed without adding
+            any new features.
+          * Unstable: Z is just a counter. API or ABI of features added
+            in earlier unstable releases having the same X.Y may break.
+
+      - S indicates stability of the release. It is missing from the
+        stable releases where Y is an even number. When Y is odd, S
+        is either "alpha" or "beta" to make it very clear that such
+        versions are not stable releases. The same X.Y.Z combination is
+        not used for more than one stability level i.e. after X.Y.Zalpha,
+        the next version can be X.Y.(Z+1)beta but not X.Y.Zbeta.
+
+
+3. Reporting bugs
+-----------------
+
+    Naturally it is easiest for me if you already know what causes the
+    unexpected behavior. Even better if you have a patch to propose.
+    However, quite often the reason for unexpected behavior is unknown,
+    so here are a few things to do before sending a bug report:
+
+      1. Try to create a small example how to reproduce the issue.
+
+      2. Compile XZ Utils with debugging code using configure switches
+         --enable-debug and, if possible, --disable-shared. If you are
+         using GCC, use CFLAGS='-O0 -ggdb3'. Don't strip the resulting
+         binaries.
+
+      3. Turn on core dumps. The exact command depends on your shell;
+         for example in GNU bash it is done with "ulimit -c unlimited",
+         and in tcsh with "limit coredumpsize unlimited".
+
+      4. Try to reproduce the suspected bug. If you get "assertion failed"
+         message, be sure to include the complete message in your bug
+         report. If the application leaves a coredump, get a backtrace
+         using gdb:
+           $ gdb /path/to/app-binary   # Load the app to the debugger.
+           (gdb) core core   # Open the coredump.
+           (gdb) bt   # Print the backtrace. Copy & paste to bug report.
+           (gdb) quit   # Quit gdb.
+
+    Report your bug via email or IRC (see Contact information below).
+    Don't send core dump files or any executables. If you have a small
+    example file(s) (total size less than 256 KiB), please include
+    it/them as an attachment. If you have bigger test files, put them
+    online somewhere and include an URL to the file(s) in the bug report.
+
+    Always include the exact version number of XZ Utils in the bug report.
+    If you are using a snapshot from the git repository, use "git describe"
+    to get the exact snapshot version. If you are using XZ Utils shipped
+    in an operating system distribution, mention the distribution name,
+    distribution version, and exact xz package version; if you cannot
+    repeat the bug with the code compiled from unpatched source code,
+    you probably need to report a bug to your distribution's bug tracking
+    system.
+
+
+4. Translating the xz tool
+--------------------------
+
+    The messages from the xz tool have been translated into a few
+    languages. Before starting to translate into a new language, ask
+    the author that someone else hasn't already started working on it.
+
+    Test your translation. Testing includes comparing the translated
+    output to the original English version by running the same commands
+    in both your target locale and with LC_ALL=C. Ask someone to
+    proof-read and test the translation.
+
+    Testing can be done e.g. by installing xz into a temporary directory:
+
+        ./configure --disable-shared --prefix=/tmp/xz-test
+        # <Edit the .po file in the po directory.>
+        make -C po update-po
+        make install
+        bash debug/translations.bash | less
+        bash debug/translations.bash | less -S  # For --list outputs
+
+    Repeat the above as needed (no need to re-run configure though).
+
+    Note especially the following:
+
+      - The output of --help and --long-help must look nice on
+        a 80-column terminal. It's OK to add extra lines if needed.
+
+      - In contrast, don't add extra lines to error messages and such.
+        They are often preceded with e.g. a filename on the same line,
+        so you have no way to predict where to put a \n. Let the terminal
+        do the wrapping even if it looks ugly. Adding new lines will be
+        even uglier in the generic case even if it looks nice in a few
+        limited examples.
+
+      - Be careful with column alignment in tables and table-like output
+        (--list, --list --verbose --verbose, --info-memory, --help, and
+        --long-help):
+
+          * All descriptions of options in --help should start in the
+            same column (but it doesn't need to be the same column as
+            in the English messages; just be consistent if you change it).
+            Check that both --help and --long-help look OK, since they
+            share several strings.
+
+          * --list --verbose and --info-memory print lines that have
+            the format "Description:   %s". If you need a longer
+            description, you can put extra space between the colon
+            and %s. Then you may need to add extra space to other
+            strings too so that the result as a whole looks good (all
+            values start at the same column).
+
+          * The columns of the actual tables in --list --verbose --verbose
+            should be aligned properly. Abbreviate if necessary. It might
+            be good to keep at least 2 or 3 spaces between column headings
+            and avoid spaces in the headings so that the columns stand out
+            better, but this is a matter of opinion. Do what you think
+            looks best.
+
+      - Be careful to put a period at the end of a sentence when the
+        original version has it, and don't put it when the original
+        doesn't have it. Similarly, be careful with \n characters
+        at the beginning and end of the strings.
+
+      - Read the TRANSLATORS comments that have been extracted from the
+        source code and included in xz.pot. If they suggest testing the
+        translation with some type of command, do it. If testing needs
+        input files, use e.g. tests/files/good-*.xz.
+
+      - When updating the translation, read the fuzzy (modified) strings
+        carefully, and don't mark them as updated before you actually
+        have updated them. Reading through the unchanged messages can be
+        good too; sometimes you may find a better wording for them.
+
+      - If you find language problems in the original English strings,
+        feel free to suggest improvements. Ask if something is unclear.
+
+      - The translated messages should be understandable (sometimes this
+        may be a problem with the original English messages too). Don't
+        make a direct word-by-word translation from English especially if
+        the result doesn't sound good in your language.
+
+    In short, take your time and pay attention to the details. Making
+    a good translation is not a quick and trivial thing to do. The
+    translated xz should look as polished as the English version.
+
+
+5. Other implementations of the .xz format
+------------------------------------------
+
+    7-Zip and the p7zip port of 7-Zip support the .xz format starting
+    from the version 9.00alpha.
+
+        http://7-zip.org/
+        http://p7zip.sourceforge.net/
+
+    XZ Embedded is a limited implementation written for use in the Linux
+    kernel, but it is also suitable for other embedded use.
+
+        http://tukaani.org/xz/embedded.html
+
+
+6. Contact information
+----------------------
+
+    If you have questions, bug reports, patches etc. related to XZ Utils,
+    contact Lasse Collin <lasse.collin@tukaani.org> (in Finnish or English).
+    I'm sometimes slow at replying. If you haven't got a reply within two
+    weeks, assume that your email has got lost and resend it or use IRC.
+
+    You can find me also from #tukaani on Freenode; my nick is Larhzu.
+    The channel tends to be pretty quiet, so just ask your question and
+    someone may wake up.
+
diff --git a/contrib/xz/README.DELETED b/contrib/xz/README.DELETED
new file mode 100644 (file)
index 0000000..150da11
--- /dev/null
@@ -0,0 +1,53 @@
+ABOUT-NLS
+ChangeLog
+Doxyfile.in
+INSTALL
+INSTALL.generic
+Makefile.am
+Makefile.in
+PACKAGERS
+THANKS
+TODO
+aclocal.m4
+autogen.sh
+build-aux/
+config.h.in
+configure
+configure.ac
+debug/
+doc/
+dos/
+extra/
+lib/
+m4/
+po/
+src/Makefile.am
+src/Makefile.in
+src/common/common_w32res.rc
+src/liblzma/Makefile.am
+src/liblzma/Makefile.in
+src/liblzma/api/Makefile.am
+src/liblzma/api/Makefile.in
+src/liblzma/check/Makefile.inc
+src/liblzma/common/Makefile.inc
+src/liblzma/delta/Makefile.inc
+src/liblzma/liblzma.pc.in
+src/liblzma/liblzma_w32res.rc
+src/liblzma/lz/Makefile.inc
+src/liblzma/lzma/Makefile.inc
+src/liblzma/rangecoder/Makefile.inc
+src/liblzma/simple/Makefile.inc
+src/lzmainfo/Makefile.am
+src/lzmainfo/Makefile.in
+src/lzmainfo/lzmainfo_w32res.rc
+src/scripts/Makefile.am
+src/scripts/Makefile.in
+src/xz/Makefile.am
+src/xz/Makefile.in
+src/xz/xz_w32res.rc
+src/xzdec/Makefile.am
+src/xzdec/Makefile.in
+src/xzdec/lzmadec_w32res.rc
+src/xzdec/xzdec_w32res.rc
+tests/
+windows/
diff --git a/contrib/xz/src/common/mythread.h b/contrib/xz/src/common/mythread.h
new file mode 100644 (file)
index 0000000..476c2fc
--- /dev/null
@@ -0,0 +1,42 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       mythread.h
+/// \brief      Wrappers for threads
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "sysdefs.h"
+
+
+#ifdef HAVE_PTHREAD
+#      include <pthread.h>
+
+#      define mythread_once(func) \
+       do { \
+               static pthread_once_t once_ = PTHREAD_ONCE_INIT; \
+               pthread_once(&once_, &func); \
+       } while (0)
+
+#      define mythread_sigmask(how, set, oset) \
+               pthread_sigmask(how, set, oset)
+
+#else
+
+#      define mythread_once(func) \
+       do { \
+               static bool once_ = false; \
+               if (!once_) { \
+                       func(); \
+                       once_ = true; \
+               } \
+       } while (0)
+
+#      define mythread_sigmask(how, set, oset) \
+               sigprocmask(how, set, oset)
+
+#endif
diff --git a/contrib/xz/src/common/sysdefs.h b/contrib/xz/src/common/sysdefs.h
new file mode 100644 (file)
index 0000000..c74c621
--- /dev/null
@@ -0,0 +1,174 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       sysdefs.h
+/// \brief      Common includes, definitions, system-specific things etc.
+///
+/// This file is used also by the lzma command line tool, that's why this
+/// file is separate from common.h.
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef LZMA_SYSDEFS_H
+#define LZMA_SYSDEFS_H
+
+//////////////
+// Includes //
+//////////////
+
+#ifdef HAVE_CONFIG_H
+#      include <config.h>
+#endif
+
+// Get standard-compliant stdio functions under MinGW and MinGW-w64.
+#ifdef __MINGW32__
+#      define __USE_MINGW_ANSI_STDIO 1
+#endif
+
+// size_t and NULL
+#include <stddef.h>
+
+#ifdef HAVE_INTTYPES_H
+#      include <inttypes.h>
+#endif
+
+// C99 says that inttypes.h always includes stdint.h, but some systems
+// don't do that, and require including stdint.h separately.
+#ifdef HAVE_STDINT_H
+#      include <stdint.h>
+#endif
+
+// Some pre-C99 systems have SIZE_MAX in limits.h instead of stdint.h. The
+// limits are also used to figure out some macros missing from pre-C99 systems.
+#ifdef HAVE_LIMITS_H
+#      include <limits.h>
+#endif
+
+// Be more compatible with systems that have non-conforming inttypes.h.
+// We assume that int is 32-bit and that long is either 32-bit or 64-bit.
+// Full Autoconf test could be more correct, but this should work well enough.
+// Note that this duplicates some code from lzma.h, but this is better since
+// we can work without inttypes.h thanks to Autoconf tests.
+#ifndef UINT32_C
+#      if UINT_MAX != 4294967295U
+#              error UINT32_C is not defined and unsigned int is not 32-bit.
+#      endif
+#      define UINT32_C(n) n ## U
+#endif
+#ifndef UINT32_MAX
+#      define UINT32_MAX UINT32_C(4294967295)
+#endif
+#ifndef PRIu32
+#      define PRIu32 "u"
+#endif
+#ifndef PRIX32
+#      define PRIX32 "X"
+#endif
+
+#if ULONG_MAX == 4294967295UL
+#      ifndef UINT64_C
+#              define UINT64_C(n) n ## ULL
+#      endif
+#      ifndef PRIu64
+#              define PRIu64 "llu"
+#      endif
+#      ifndef PRIX64
+#              define PRIX64 "llX"
+#      endif
+#else
+#      ifndef UINT64_C
+#              define UINT64_C(n) n ## UL
+#      endif
+#      ifndef PRIu64
+#              define PRIu64 "lu"
+#      endif
+#      ifndef PRIX64
+#              define PRIX64 "lX"
+#      endif
+#endif
+#ifndef UINT64_MAX
+#      define UINT64_MAX UINT64_C(18446744073709551615)
+#endif
+
+// Interix has broken header files, which typedef size_t to unsigned long,
+// but a few lines later define SIZE_MAX to INT32_MAX.
+#ifdef __INTERIX
+#      undef SIZE_MAX
+#endif
+
+// The code currently assumes that size_t is either 32-bit or 64-bit.
+#ifndef SIZE_MAX
+#      if SIZEOF_SIZE_T == 4
+#              define SIZE_MAX UINT32_MAX
+#      elif SIZEOF_SIZE_T == 8
+#              define SIZE_MAX UINT64_MAX
+#      else
+#              error size_t is not 32-bit or 64-bit
+#      endif
+#endif
+#if SIZE_MAX != UINT32_MAX && SIZE_MAX != UINT64_MAX
+#      error size_t is not 32-bit or 64-bit
+#endif
+
+#include <stdlib.h>
+#include <assert.h>
+
+// Pre-C99 systems lack stdbool.h. All the code in LZMA Utils must be written
+// so that it works with fake bool type, for example:
+//
+//    bool foo = (flags & 0x100) != 0;
+//    bool bar = !!(flags & 0x100);
+//
+// This works with the real C99 bool but breaks with fake bool:
+//
+//    bool baz = (flags & 0x100);
+//
+#ifdef HAVE_STDBOOL_H
+#      include <stdbool.h>
+#else
+#      if ! HAVE__BOOL
+typedef unsigned char _Bool;
+#      endif
+#      define bool _Bool
+#      define false 0
+#      define true 1
+#      define __bool_true_false_are_defined 1
+#endif
+
+// string.h should be enough but let's include strings.h and memory.h too if
+// they exists, since that shouldn't do any harm, but may improve portability.
+#ifdef HAVE_STRING_H
+#      include <string.h>
+#endif
+
+#ifdef HAVE_STRINGS_H
+#      include <strings.h>
+#endif
+
+#ifdef HAVE_MEMORY_H
+#      include <memory.h>
+#endif
+
+
+////////////
+// Macros //
+////////////
+
+#undef memzero
+#define memzero(s, n) memset(s, 0, n)
+
+// NOTE: Avoid using MIN() and MAX(), because even conditionally defining
+// those macros can cause some portability trouble, since on some systems
+// the system headers insist defining their own versions.
+#define my_min(x, y) ((x) < (y) ? (x) : (y))
+#define my_max(x, y) ((x) > (y) ? (x) : (y))
+
+#ifndef ARRAY_SIZE
+#      define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))
+#endif
+
+#endif
diff --git a/contrib/xz/src/common/tuklib_common.h b/contrib/xz/src/common/tuklib_common.h
new file mode 100644 (file)
index 0000000..31fbab5
--- /dev/null
@@ -0,0 +1,71 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       tuklib_common.h
+/// \brief      Common definitions for tuklib modules
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef TUKLIB_COMMON_H
+#define TUKLIB_COMMON_H
+
+// The config file may be replaced by a package-specific file.
+// It should include at least stddef.h, inttypes.h, and limits.h.
+#include "tuklib_config.h"
+
+// TUKLIB_SYMBOL_PREFIX is prefixed to all symbols exported by
+// the tuklib modules. If you use a tuklib module in a library,
+// you should use TUKLIB_SYMBOL_PREFIX to make sure that there
+// are no symbol conflicts in case someone links your library
+// into application that also uses the same tuklib module.
+#ifndef TUKLIB_SYMBOL_PREFIX
+#      define TUKLIB_SYMBOL_PREFIX
+#endif
+
+#define TUKLIB_CAT_X(a, b) a ## b
+#define TUKLIB_CAT(a, b) TUKLIB_CAT_X(a, b)
+
+#ifndef TUKLIB_SYMBOL
+#      define TUKLIB_SYMBOL(sym) TUKLIB_CAT(TUKLIB_SYMBOL_PREFIX, sym)
+#endif
+
+#ifndef TUKLIB_DECLS_BEGIN
+#      ifdef __cplusplus
+#              define TUKLIB_DECLS_BEGIN extern "C" {
+#      else
+#              define TUKLIB_DECLS_BEGIN
+#      endif
+#endif
+
+#ifndef TUKLIB_DECLS_END
+#      ifdef __cplusplus
+#              define TUKLIB_DECLS_END }
+#      else
+#              define TUKLIB_DECLS_END
+#      endif
+#endif
+
+#if defined(__GNUC__) && defined(__GNUC_MINOR__)
+#      define TUKLIB_GNUC_REQ(major, minor) \
+               ((__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)) \
+                       || __GNUC__ > (major))
+#else
+#      define TUKLIB_GNUC_REQ(major, minor) 0
+#endif
+
+#if TUKLIB_GNUC_REQ(2, 5)
+#      define tuklib_attr_noreturn __attribute__((__noreturn__))
+#else
+#      define tuklib_attr_noreturn
+#endif
+
+#if (defined(_WIN32) && !defined(__CYGWIN__)) \
+               || defined(__OS2__) || defined(__MSDOS__)
+#      define TUKLIB_DOSLIKE 1
+#endif
+
+#endif
diff --git a/contrib/xz/src/common/tuklib_config.h b/contrib/xz/src/common/tuklib_config.h
new file mode 100644 (file)
index 0000000..549cb24
--- /dev/null
@@ -0,0 +1,7 @@
+#ifdef HAVE_CONFIG_H
+#      include "sysdefs.h"
+#else
+#      include <stddef.h>
+#      include <inttypes.h>
+#      include <limits.h>
+#endif
diff --git a/contrib/xz/src/common/tuklib_cpucores.c b/contrib/xz/src/common/tuklib_cpucores.c
new file mode 100644 (file)
index 0000000..1da13df
--- /dev/null
@@ -0,0 +1,62 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       tuklib_cpucores.c
+/// \brief      Get the number of CPU cores online
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "tuklib_cpucores.h"
+
+#if defined(TUKLIB_CPUCORES_SYSCTL)
+#      ifdef HAVE_SYS_PARAM_H
+#              include <sys/param.h>
+#      endif
+#      include <sys/sysctl.h>
+
+#elif defined(TUKLIB_CPUCORES_SYSCONF)
+#      include <unistd.h>
+
+// HP-UX
+#elif defined(TUKLIB_CPUCORES_PSTAT_GETDYNAMIC)
+#      include <sys/param.h>
+#      include <sys/pstat.h>
+#endif
+
+
+extern uint32_t
+tuklib_cpucores(void)
+{
+       uint32_t ret = 0;
+
+#if defined(TUKLIB_CPUCORES_SYSCTL)
+       int name[2] = { CTL_HW, HW_NCPU };
+       int cpus;
+       size_t cpus_size = sizeof(cpus);
+       if (sysctl(name, 2, &cpus, &cpus_size, NULL, 0) != -1
+                       && cpus_size == sizeof(cpus) && cpus > 0)
+               ret = cpus;
+
+#elif defined(TUKLIB_CPUCORES_SYSCONF)
+#      ifdef _SC_NPROCESSORS_ONLN
+       // Most systems
+       const long cpus = sysconf(_SC_NPROCESSORS_ONLN);
+#      else
+       // IRIX
+       const long cpus = sysconf(_SC_NPROC_ONLN);
+#      endif
+       if (cpus > 0)
+               ret = cpus;
+
+#elif defined(TUKLIB_CPUCORES_PSTAT_GETDYNAMIC)
+       struct pst_dynamic pst;
+       if (pstat_getdynamic(&pst, sizeof(pst), 1, 0) != -1)
+               ret = pst.psd_proc_cnt;
+#endif
+
+       return ret;
+}
diff --git a/contrib/xz/src/common/tuklib_cpucores.h b/contrib/xz/src/common/tuklib_cpucores.h
new file mode 100644 (file)
index 0000000..be1ce1c
--- /dev/null
@@ -0,0 +1,23 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       tuklib_cpucores.h
+/// \brief      Get the number of CPU cores online
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef TUKLIB_CPUCORES_H
+#define TUKLIB_CPUCORES_H
+
+#include "tuklib_common.h"
+TUKLIB_DECLS_BEGIN
+
+#define tuklib_cpucores TUKLIB_SYMBOL(tuklib_cpucores)
+extern uint32_t tuklib_cpucores(void);
+
+TUKLIB_DECLS_END
+#endif
diff --git a/contrib/xz/src/common/tuklib_exit.c b/contrib/xz/src/common/tuklib_exit.c
new file mode 100644 (file)
index 0000000..c393be6
--- /dev/null
@@ -0,0 +1,57 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       tuklib_exit.c
+/// \brief      Close stdout and stderr, and exit
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "tuklib_common.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "tuklib_gettext.h"
+#include "tuklib_progname.h"
+#include "tuklib_exit.h"
+
+
+extern void
+tuklib_exit(int status, int err_status, int show_error)
+{
+       if (status != err_status) {
+               // Close stdout. If something goes wrong,
+               // print an error message to stderr.
+               const int ferror_err = ferror(stdout);
+               const int fclose_err = fclose(stdout);
+               if (ferror_err || fclose_err) {
+                       status = err_status;
+
+                       // If it was fclose() that failed, we have the reason
+                       // in errno. If only ferror() indicated an error,
+                       // we have no idea what the reason was.
+                       if (show_error)
+                               fprintf(stderr, "%s: %s: %s\n", progname,
+                                               _("Writing to standard "
+                                                       "output failed"),
+                                               fclose_err ? strerror(errno)
+                                                       : _("Unknown error"));
+               }
+       }
+
+       if (status != err_status) {
+               // Close stderr. If something goes wrong, there's
+               // nothing where we could print an error message.
+               // Just set the exit status.
+               const int ferror_err = ferror(stderr);
+               const int fclose_err = fclose(stderr);
+               if (fclose_err || ferror_err)
+                       status = err_status;
+       }
+
+       exit(status);
+}
diff --git a/contrib/xz/src/common/tuklib_exit.h b/contrib/xz/src/common/tuklib_exit.h
new file mode 100644 (file)
index 0000000..b11776f
--- /dev/null
@@ -0,0 +1,25 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       tuklib_exit.h
+/// \brief      Close stdout and stderr, and exit
+/// \note       Requires tuklib_progname and tuklib_gettext modules
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef TUKLIB_EXIT_H
+#define TUKLIB_EXIT_H
+
+#include "tuklib_common.h"
+TUKLIB_DECLS_BEGIN
+
+#define tuklib_exit TUKLIB_SYMBOL(tuklib_exit)
+extern void tuklib_exit(int status, int err_status, int show_error)
+               tuklib_attr_noreturn;
+
+TUKLIB_DECLS_END
+#endif
diff --git a/contrib/xz/src/common/tuklib_gettext.h b/contrib/xz/src/common/tuklib_gettext.h
new file mode 100644 (file)
index 0000000..ff18904
--- /dev/null
@@ -0,0 +1,44 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       tuklib_gettext.h
+/// \brief      Wrapper for gettext and friends
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef TUKLIB_GETTEXT_H
+#define TUKLIB_GETTEXT_H
+
+#include "tuklib_common.h"
+#include <locale.h>
+
+#ifndef TUKLIB_GETTEXT
+#      ifdef ENABLE_NLS
+#              define TUKLIB_GETTEXT 1
+#      else
+#              define TUKLIB_GETTEXT 0
+#      endif
+#endif
+
+#if TUKLIB_GETTEXT
+#      include <libintl.h>
+#      define tuklib_gettext_init(package, localedir) \
+               do { \
+                       setlocale(LC_ALL, ""); \
+                       bindtextdomain(package, localedir); \
+                       textdomain(package); \
+               } while (0)
+#      define _(msgid) gettext(msgid)
+#else
+#      define tuklib_gettext_init(package, localedir) \
+               setlocale(LC_ALL, "")
+#      define _(msgid) (msgid)
+#      define ngettext(msgid1, msgid2, n) ((n) == 1 ? (msgid1) : (msgid2))
+#endif
+#define N_(msgid) msgid
+
+#endif
diff --git a/contrib/xz/src/common/tuklib_integer.h b/contrib/xz/src/common/tuklib_integer.h
new file mode 100644 (file)
index 0000000..e6daa77
--- /dev/null
@@ -0,0 +1,523 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       tuklib_integer.h
+/// \brief      Various integer and bit operations
+///
+/// This file provides macros or functions to do some basic integer and bit
+/// operations.
+///
+/// Endianness related integer operations (XX = 16, 32, or 64; Y = b or l):
+///   - Byte swapping: bswapXX(num)
+///   - Byte order conversions to/from native: convXXYe(num)
+///   - Aligned reads: readXXYe(ptr)
+///   - Aligned writes: writeXXYe(ptr, num)
+///   - Unaligned reads (16/32-bit only): unaligned_readXXYe(ptr)
+///   - Unaligned writes (16/32-bit only): unaligned_writeXXYe(ptr, num)
+///
+/// Since they can macros, the arguments should have no side effects since
+/// they may be evaluated more than once.
+///
+/// \todo       PowerPC and possibly some other architectures support
+///             byte swapping load and store instructions. This file
+///             doesn't take advantage of those instructions.
+///
+/// Bit scan operations for non-zero 32-bit integers:
+///   - Bit scan reverse (find highest non-zero bit): bsr32(num)
+///   - Count leading zeros: clz32(num)
+///   - Count trailing zeros: ctz32(num)
+///   - Bit scan forward (simply an alias for ctz32()): bsf32(num)
+///
+/// The above bit scan operations return 0-31. If num is zero,
+/// the result is undefined.
+//
+//  Authors:    Lasse Collin
+//              Joachim Henke
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef TUKLIB_INTEGER_H
+#define TUKLIB_INTEGER_H
+
+#include "tuklib_common.h"
+
+
+////////////////////////////////////////
+// Operating system specific features //
+////////////////////////////////////////
+
+#if defined(HAVE_BYTESWAP_H)
+       // glibc, uClibc, dietlibc
+#      include <byteswap.h>
+#      ifdef HAVE_BSWAP_16
+#              define bswap16(num) bswap_16(num)
+#      endif
+#      ifdef HAVE_BSWAP_32
+#              define bswap32(num) bswap_32(num)
+#      endif
+#      ifdef HAVE_BSWAP_64
+#              define bswap64(num) bswap_64(num)
+#      endif
+
+#elif defined(HAVE_SYS_ENDIAN_H)
+       // *BSDs and Darwin
+#      include <sys/endian.h>
+
+#elif defined(HAVE_SYS_BYTEORDER_H)
+       // Solaris
+#      include <sys/byteorder.h>
+#      ifdef BSWAP_16
+#              define bswap16(num) BSWAP_16(num)
+#      endif
+#      ifdef BSWAP_32
+#              define bswap32(num) BSWAP_32(num)
+#      endif
+#      ifdef BSWAP_64
+#              define bswap64(num) BSWAP_64(num)
+#      endif
+#      ifdef BE_16
+#              define conv16be(num) BE_16(num)
+#      endif
+#      ifdef BE_32
+#              define conv32be(num) BE_32(num)
+#      endif
+#      ifdef BE_64
+#              define conv64be(num) BE_64(num)
+#      endif
+#      ifdef LE_16
+#              define conv16le(num) LE_16(num)
+#      endif
+#      ifdef LE_32
+#              define conv32le(num) LE_32(num)
+#      endif
+#      ifdef LE_64
+#              define conv64le(num) LE_64(num)
+#      endif
+#endif
+
+
+///////////////////
+// Byte swapping //
+///////////////////
+
+#ifndef bswap16
+#      define bswap16(num) \
+               (((uint16_t)(num) << 8) | ((uint16_t)(num) >> 8))
+#endif
+
+#ifndef bswap32
+#      define bswap32(num) \
+               ( (((uint32_t)(num) << 24)                       ) \
+               | (((uint32_t)(num) <<  8) & UINT32_C(0x00FF0000)) \
+               | (((uint32_t)(num) >>  8) & UINT32_C(0x0000FF00)) \
+               | (((uint32_t)(num) >> 24)                       ) )
+#endif
+
+#ifndef bswap64
+#      define bswap64(num) \
+               ( (((uint64_t)(num) << 56)                               ) \
+               | (((uint64_t)(num) << 40) & UINT64_C(0x00FF000000000000)) \
+               | (((uint64_t)(num) << 24) & UINT64_C(0x0000FF0000000000)) \
+               | (((uint64_t)(num) <<  8) & UINT64_C(0x000000FF00000000)) \
+               | (((uint64_t)(num) >>  8) & UINT64_C(0x00000000FF000000)) \
+               | (((uint64_t)(num) >> 24) & UINT64_C(0x0000000000FF0000)) \
+               | (((uint64_t)(num) >> 40) & UINT64_C(0x000000000000FF00)) \
+               | (((uint64_t)(num) >> 56)                               ) )
+#endif
+
+// Define conversion macros using the basic byte swapping macros.
+#ifdef WORDS_BIGENDIAN
+#      ifndef conv16be
+#              define conv16be(num) ((uint16_t)(num))
+#      endif
+#      ifndef conv32be
+#              define conv32be(num) ((uint32_t)(num))
+#      endif
+#      ifndef conv64be
+#              define conv64be(num) ((uint64_t)(num))
+#      endif
+#      ifndef conv16le
+#              define conv16le(num) bswap16(num)
+#      endif
+#      ifndef conv32le
+#              define conv32le(num) bswap32(num)
+#      endif
+#      ifndef conv64le
+#              define conv64le(num) bswap64(num)
+#      endif
+#else
+#      ifndef conv16be
+#              define conv16be(num) bswap16(num)
+#      endif
+#      ifndef conv32be
+#              define conv32be(num) bswap32(num)
+#      endif
+#      ifndef conv64be
+#              define conv64be(num) bswap64(num)
+#      endif
+#      ifndef conv16le
+#              define conv16le(num) ((uint16_t)(num))
+#      endif
+#      ifndef conv32le
+#              define conv32le(num) ((uint32_t)(num))
+#      endif
+#      ifndef conv64le
+#              define conv64le(num) ((uint64_t)(num))
+#      endif
+#endif
+
+
+//////////////////////////////
+// Aligned reads and writes //
+//////////////////////////////
+
+static inline uint16_t
+read16be(const uint8_t *buf)
+{
+       uint16_t num = *(const uint16_t *)buf;
+       return conv16be(num);
+}
+
+
+static inline uint16_t
+read16le(const uint8_t *buf)
+{
+       uint16_t num = *(const uint16_t *)buf;
+       return conv16le(num);
+}
+
+
+static inline uint32_t
+read32be(const uint8_t *buf)
+{
+       uint32_t num = *(const uint32_t *)buf;
+       return conv32be(num);
+}
+
+
+static inline uint32_t
+read32le(const uint8_t *buf)
+{
+       uint32_t num = *(const uint32_t *)buf;
+       return conv32le(num);
+}
+
+
+static inline uint64_t
+read64be(const uint8_t *buf)
+{
+       uint64_t num = *(const uint64_t *)buf;
+       return conv64be(num);
+}
+
+
+static inline uint64_t
+read64le(const uint8_t *buf)
+{
+       uint64_t num = *(const uint64_t *)buf;
+       return conv64le(num);
+}
+
+
+// NOTE: Possible byte swapping must be done in a macro to allow GCC
+// to optimize byte swapping of constants when using glibc's or *BSD's
+// byte swapping macros. The actual write is done in an inline function
+// to make type checking of the buf pointer possible similarly to readXXYe()
+// functions.
+
+#define write16be(buf, num) write16ne((buf), conv16be(num))
+#define write16le(buf, num) write16ne((buf), conv16le(num))
+#define write32be(buf, num) write32ne((buf), conv32be(num))
+#define write32le(buf, num) write32ne((buf), conv32le(num))
+#define write64be(buf, num) write64ne((buf), conv64be(num))
+#define write64le(buf, num) write64ne((buf), conv64le(num))
+
+
+static inline void
+write16ne(uint8_t *buf, uint16_t num)
+{
+       *(uint16_t *)buf = num;
+       return;
+}
+
+
+static inline void
+write32ne(uint8_t *buf, uint32_t num)
+{
+       *(uint32_t *)buf = num;
+       return;
+}
+
+
+static inline void
+write64ne(uint8_t *buf, uint64_t num)
+{
+       *(uint64_t *)buf = num;
+       return;
+}
+
+
+////////////////////////////////
+// Unaligned reads and writes //
+////////////////////////////////
+
+// NOTE: TUKLIB_FAST_UNALIGNED_ACCESS indicates only support for 16-bit and
+// 32-bit unaligned integer loads and stores. It's possible that 64-bit
+// unaligned access doesn't work or is slower than byte-by-byte access.
+// Since unaligned 64-bit is probably not needed as often as 16-bit or
+// 32-bit, we simply don't support 64-bit unaligned access for now.
+#ifdef TUKLIB_FAST_UNALIGNED_ACCESS
+#      define unaligned_read16be read16be
+#      define unaligned_read16le read16le
+#      define unaligned_read32be read32be
+#      define unaligned_read32le read32le
+#      define unaligned_write16be write16be
+#      define unaligned_write16le write16le
+#      define unaligned_write32be write32be
+#      define unaligned_write32le write32le
+
+#else
+
+static inline uint16_t
+unaligned_read16be(const uint8_t *buf)
+{
+       uint16_t num = ((uint16_t)buf[0] << 8) | (uint16_t)buf[1];
+       return num;
+}
+
+
+static inline uint16_t
+unaligned_read16le(const uint8_t *buf)
+{
+       uint16_t num = ((uint16_t)buf[0]) | ((uint16_t)buf[1] << 8);
+       return num;
+}
+
+
+static inline uint32_t
+unaligned_read32be(const uint8_t *buf)
+{
+       uint32_t num = (uint32_t)buf[0] << 24;
+       num |= (uint32_t)buf[1] << 16;
+       num |= (uint32_t)buf[2] << 8;
+       num |= (uint32_t)buf[3];
+       return num;
+}
+
+
+static inline uint32_t
+unaligned_read32le(const uint8_t *buf)
+{
+       uint32_t num = (uint32_t)buf[0];
+       num |= (uint32_t)buf[1] << 8;
+       num |= (uint32_t)buf[2] << 16;
+       num |= (uint32_t)buf[3] << 24;
+       return num;
+}
+
+
+static inline void
+unaligned_write16be(uint8_t *buf, uint16_t num)
+{
+       buf[0] = num >> 8;
+       buf[1] = num;
+       return;
+}
+
+
+static inline void
+unaligned_write16le(uint8_t *buf, uint16_t num)
+{
+       buf[0] = num;
+       buf[1] = num >> 8;
+       return;
+}
+
+
+static inline void
+unaligned_write32be(uint8_t *buf, uint32_t num)
+{
+       buf[0] = num >> 24;
+       buf[1] = num >> 16;
+       buf[2] = num >> 8;
+       buf[3] = num;
+       return;
+}
+
+
+static inline void
+unaligned_write32le(uint8_t *buf, uint32_t num)
+{
+       buf[0] = num;
+       buf[1] = num >> 8;
+       buf[2] = num >> 16;
+       buf[3] = num >> 24;
+       return;
+}
+
+#endif
+
+
+static inline uint32_t
+bsr32(uint32_t n)
+{
+       // Check for ICC first, since it tends to define __GNUC__ too.
+#if defined(__INTEL_COMPILER)
+       return _bit_scan_reverse(n);
+
+#elif TUKLIB_GNUC_REQ(3, 4) && UINT_MAX == UINT32_MAX
+       // GCC >= 3.4 has __builtin_clz(), which gives good results on
+       // multiple architectures. On x86, __builtin_clz() ^ 31U becomes
+       // either plain BSR (so the XOR gets optimized away) or LZCNT and
+       // XOR (if -march indicates that SSE4a instructions are supported).
+       return __builtin_clz(n) ^ 31U;
+
+#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
+       uint32_t i;
+       __asm__("bsrl %1, %0" : "=r" (i) : "rm" (n));
+       return i;
+
+#elif defined(_MSC_VER) && _MSC_VER >= 1400
+       // MSVC isn't supported by tuklib, but since this code exists,
+       // it doesn't hurt to have it here anyway.
+       uint32_t i;
+       _BitScanReverse((DWORD *)&i, n);
+       return i;
+
+#else
+       uint32_t i = 31;
+
+       if ((n & UINT32_C(0xFFFF0000)) == 0) {
+               n <<= 16;
+               i = 15;
+       }
+
+       if ((n & UINT32_C(0xFF000000)) == 0) {
+               n <<= 8;
+               i -= 8;
+       }
+
+       if ((n & UINT32_C(0xF0000000)) == 0) {
+               n <<= 4;
+               i -= 4;
+       }
+
+       if ((n & UINT32_C(0xC0000000)) == 0) {
+               n <<= 2;
+               i -= 2;
+       }
+
+       if ((n & UINT32_C(0x80000000)) == 0)
+               --i;
+
+       return i;
+#endif
+}
+
+
+static inline uint32_t
+clz32(uint32_t n)
+{
+#if defined(__INTEL_COMPILER)
+       return _bit_scan_reverse(n) ^ 31U;
+
+#elif TUKLIB_GNUC_REQ(3, 4) && UINT_MAX == UINT32_MAX
+       return __builtin_clz(n);
+
+#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
+       uint32_t i;
+       __asm__("bsrl %1, %0\n\t"
+               "xorl $31, %0"
+               : "=r" (i) : "rm" (n));
+       return i;
+
+#elif defined(_MSC_VER) && _MSC_VER >= 1400
+       uint32_t i;
+       _BitScanReverse((DWORD *)&i, n);
+       return i ^ 31U;
+
+#else
+       uint32_t i = 0;
+
+       if ((n & UINT32_C(0xFFFF0000)) == 0) {
+               n <<= 16;
+               i = 16;
+       }
+
+       if ((n & UINT32_C(0xFF000000)) == 0) {
+               n <<= 8;
+               i += 8;
+       }
+
+       if ((n & UINT32_C(0xF0000000)) == 0) {
+               n <<= 4;
+               i += 4;
+       }
+
+       if ((n & UINT32_C(0xC0000000)) == 0) {
+               n <<= 2;
+               i += 2;
+       }
+
+       if ((n & UINT32_C(0x80000000)) == 0)
+               ++i;
+
+       return i;
+#endif
+}
+
+
+static inline uint32_t
+ctz32(uint32_t n)
+{
+#if defined(__INTEL_COMPILER)
+       return _bit_scan_forward(n);
+
+#elif TUKLIB_GNUC_REQ(3, 4) && UINT_MAX >= UINT32_MAX
+       return __builtin_ctz(n);
+
+#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
+       uint32_t i;
+       __asm__("bsfl %1, %0" : "=r" (i) : "rm" (n));
+       return i;
+
+#elif defined(_MSC_VER) && _MSC_VER >= 1400
+       uint32_t i;
+       _BitScanForward((DWORD *)&i, n);
+       return i;
+
+#else
+       uint32_t i = 0;
+
+       if ((n & UINT32_C(0x0000FFFF)) == 0) {
+               n >>= 16;
+               i = 16;
+       }
+
+       if ((n & UINT32_C(0x000000FF)) == 0) {
+               n >>= 8;
+               i += 8;
+       }
+
+       if ((n & UINT32_C(0x0000000F)) == 0) {
+               n >>= 4;
+               i += 4;
+       }
+
+       if ((n & UINT32_C(0x00000003)) == 0) {
+               n >>= 2;
+               i += 2;
+       }
+
+       if ((n & UINT32_C(0x00000001)) == 0)
+               ++i;
+
+       return i;
+#endif
+}
+
+#define bsf32 ctz32
+
+#endif
diff --git a/contrib/xz/src/common/tuklib_mbstr.h b/contrib/xz/src/common/tuklib_mbstr.h
new file mode 100644 (file)
index 0000000..9f35835
--- /dev/null
@@ -0,0 +1,66 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       tuklib_mstr.h
+/// \brief      Utility functions for handling multibyte strings
+///
+/// If not enough multibyte string support is available in the C library,
+/// these functions keep working with the assumption that all strings
+/// are in a single-byte character set without combining characters, e.g.
+/// US-ASCII or ISO-8859-*.
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef TUKLIB_MBSTR_H
+#define TUKLIB_MBSTR_H
+
+#include "tuklib_common.h"
+TUKLIB_DECLS_BEGIN
+
+#define tuklib_mbstr_width TUKLIB_SYMBOL(tuklib_mbstr_width)
+extern size_t tuklib_mbstr_width(const char *str, size_t *bytes);
+///<
+/// \brief      Get the number of columns needed for the multibyte string
+///
+/// This is somewhat similar to wcswidth() but works on multibyte strings.
+///
+/// \param      str         String whose width is to be calculated. If the
+///                         current locale uses a multibyte character set
+///                         that has shift states, the string must begin
+///                         and end in the initial shift state.
+/// \param      bytes       If this is not NULL, *bytes is set to the
+///                         value returned by strlen(str) (even if an
+///                         error occurs when calculating the width).
+///
+/// \return     On success, the number of columns needed to display the
+///             string e.g. in a terminal emulator is returned. On error,
+///             (size_t)-1 is returned. Possible errors include invalid,
+///             partial, or non-printable multibyte character in str, or
+///             that str doesn't end in the initial shift state.
+
+#define tuklib_mbstr_fw TUKLIB_SYMBOL(tuklib_mbstr_fw)
+extern int tuklib_mbstr_fw(const char *str, int columns_min);
+///<
+/// \brief      Get the field width for printf() e.g. to align table columns
+///
+/// Printing simple tables to a terminal can be done using the field field
+/// feature in the printf() format string, but it works only with single-byte
+/// character sets. To do the same with multibyte strings, tuklib_mbstr_fw()
+/// can be used to calculate appropriate field width.
+///
+/// The behavior of this function is undefined, if
+///   - str is NULL or not terminated with '\0';
+///   - columns_min <= 0; or
+///   - the calculated field width exceeds INT_MAX.
+///
+/// \return     If tuklib_mbstr_width(str, NULL) fails, -1 is returned.
+///             If str needs more columns than columns_min, zero is returned.
+///             Otherwise a positive integer is returned, which can be
+///             used as the field width, e.g. printf("%*s", fw, str).
+
+TUKLIB_DECLS_END
+#endif
diff --git a/contrib/xz/src/common/tuklib_mbstr_fw.c b/contrib/xz/src/common/tuklib_mbstr_fw.c
new file mode 100644 (file)
index 0000000..978a3fe
--- /dev/null
@@ -0,0 +1,31 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       tuklib_mstr_fw.c
+/// \brief      Get the field width for printf() e.g. to align table columns
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "tuklib_mbstr.h"
+
+
+extern int
+tuklib_mbstr_fw(const char *str, int columns_min)
+{
+       size_t len;
+       const size_t width = tuklib_mbstr_width(str, &len);
+       if (width == (size_t)-1)
+               return -1;
+
+       if (width > (size_t)columns_min)
+               return 0;
+
+       if (width < (size_t)columns_min)
+               len += (size_t)columns_min - width;
+
+       return len;
+}
diff --git a/contrib/xz/src/common/tuklib_mbstr_width.c b/contrib/xz/src/common/tuklib_mbstr_width.c
new file mode 100644 (file)
index 0000000..3c38990
--- /dev/null
@@ -0,0 +1,64 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       tuklib_mstr_width.c
+/// \brief      Calculate width of a multibyte string
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "tuklib_mbstr.h"
+
+#if defined(HAVE_MBRTOWC) && defined(HAVE_WCWIDTH)
+#      include <wchar.h>
+#endif
+
+
+extern size_t
+tuklib_mbstr_width(const char *str, size_t *bytes)
+{
+       const size_t len = strlen(str);
+       if (bytes != NULL)
+               *bytes = len;
+
+#if !(defined(HAVE_MBRTOWC) && defined(HAVE_WCWIDTH))
+       // In single-byte mode, the width of the string is the same
+       // as its length.
+       return len;
+
+#else
+       mbstate_t state;
+       memset(&state, 0, sizeof(state));
+
+       size_t width = 0;
+       size_t i = 0;
+
+       // Convert one multibyte character at a time to wchar_t
+       // and get its width using wcwidth().
+       while (i < len) {
+               wchar_t wc;
+               const size_t ret = mbrtowc(&wc, str + i, len - i, &state);
+               if (ret < 1 || ret > len)
+                       return (size_t)-1;
+
+               i += ret;
+
+               const int wc_width = wcwidth(wc);
+               if (wc_width < 0)
+                       return (size_t)-1;
+
+               width += wc_width;
+       }
+
+       // Require that the string ends in the initial shift state.
+       // This way the caller can be combine the string with other
+       // strings without needing to worry about the shift states.
+       if (!mbsinit(&state))
+               return (size_t)-1;
+
+       return width;
+#endif
+}
diff --git a/contrib/xz/src/common/tuklib_open_stdxxx.c b/contrib/xz/src/common/tuklib_open_stdxxx.c
new file mode 100644 (file)
index 0000000..08bc60d
--- /dev/null
@@ -0,0 +1,55 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       tuklib_open_stdxxx.c
+/// \brief      Make sure that file descriptors 0, 1, and 2 are open
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "tuklib_open_stdxxx.h"
+
+#ifndef TUKLIB_DOSLIKE
+#      include <stdlib.h>
+#      include <errno.h>
+#      include <fcntl.h>
+#      include <unistd.h>
+#endif
+
+
+extern void
+tuklib_open_stdxxx(int err_status)
+{
+#ifdef TUKLIB_DOSLIKE
+       // Do nothing, just silence warnings.
+       (void)err_status;
+
+#else
+       for (int i = 0; i <= 2; ++i) {
+               // We use fcntl() to check if the file descriptor is open.
+               if (fcntl(i, F_GETFD) == -1 && errno == EBADF) {
+                       // With stdin, we could use /dev/full so that
+                       // writing to stdin would fail. However, /dev/full
+                       // is Linux specific, and if the program tries to
+                       // write to stdin, there's already a problem anyway.
+                       const int fd = open("/dev/null", O_NOCTTY
+                                       | (i == 0 ? O_WRONLY : O_RDONLY));
+
+                       if (fd != i) {
+                               // Something went wrong. Exit with the
+                               // exit status we were given. Don't try
+                               // to print an error message, since stderr
+                               // may very well be non-existent. This
+                               // error should be extremely rare.
+                               (void)close(fd);
+                               exit(err_status);
+                       }
+               }
+       }
+#endif
+
+       return;
+}
diff --git a/contrib/xz/src/common/tuklib_open_stdxxx.h b/contrib/xz/src/common/tuklib_open_stdxxx.h
new file mode 100644 (file)
index 0000000..b911616
--- /dev/null
@@ -0,0 +1,23 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       tuklib_open_stdxxx.h
+/// \brief      Make sure that file descriptors 0, 1, and 2 are open
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef TUKLIB_OPEN_STDXXX_H
+#define TUKLIB_OPEN_STDXXX_H
+
+#include "tuklib_common.h"
+TUKLIB_DECLS_BEGIN
+
+#define tuklib_open_stdxx TUKLIB_SYMBOL(tuklib_open_stdxxx)
+extern void tuklib_open_stdxxx(int err_status);
+
+TUKLIB_DECLS_END
+#endif
diff --git a/contrib/xz/src/common/tuklib_physmem.c b/contrib/xz/src/common/tuklib_physmem.c
new file mode 100644 (file)
index 0000000..623b6e7
--- /dev/null
@@ -0,0 +1,196 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       tuklib_physmem.c
+/// \brief      Get the amount of physical memory
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "tuklib_physmem.h"
+
+// We want to use Windows-specific code on Cygwin, which also has memory
+// information available via sysconf(), but on Cygwin 1.5 and older it
+// gives wrong results (from our point of view).
+#if defined(_WIN32) || defined(__CYGWIN__)
+#      ifndef _WIN32_WINNT
+#              define _WIN32_WINNT 0x0500
+#      endif
+#      include <windows.h>
+
+#elif defined(__OS2__)
+#      define INCL_DOSMISC
+#      include <os2.h>
+
+#elif defined(__DJGPP__)
+#      include <dpmi.h>
+
+#elif defined(__VMS)
+#      include <lib$routines.h>
+#      include <syidef.h>
+#      include <ssdef.h>
+
+// AIX
+#elif defined(TUKLIB_PHYSMEM_AIX)
+#      include <sys/systemcfg.h>
+
+#elif defined(TUKLIB_PHYSMEM_SYSCONF)
+#      include <unistd.h>
+
+#elif defined(TUKLIB_PHYSMEM_SYSCTL)
+#      ifdef HAVE_SYS_PARAM_H
+#              include <sys/param.h>
+#      endif
+#      include <sys/sysctl.h>
+
+// Tru64
+#elif defined(TUKLIB_PHYSMEM_GETSYSINFO)
+#      include <sys/sysinfo.h>
+#      include <machine/hal_sysinfo.h>
+
+// HP-UX
+#elif defined(TUKLIB_PHYSMEM_PSTAT_GETSTATIC)
+#      include <sys/param.h>
+#      include <sys/pstat.h>
+
+// IRIX
+#elif defined(TUKLIB_PHYSMEM_GETINVENT_R)
+#      include <invent.h>
+
+// This sysinfo() is Linux-specific.
+#elif defined(TUKLIB_PHYSMEM_SYSINFO)
+#      include <sys/sysinfo.h>
+#endif
+
+
+extern uint64_t
+tuklib_physmem(void)
+{
+       uint64_t ret = 0;
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+       if ((GetVersion() & 0xFF) >= 5) {
+               // Windows 2000 and later have GlobalMemoryStatusEx() which
+               // supports reporting values greater than 4 GiB. To keep the
+               // code working also on older Windows versions, use
+               // GlobalMemoryStatusEx() conditionally.
+               HMODULE kernel32 = GetModuleHandle("kernel32.dll");
+               if (kernel32 != NULL) {
+                       BOOL (WINAPI *gmse)(LPMEMORYSTATUSEX) = GetProcAddress(
+                                       kernel32, "GlobalMemoryStatusEx");
+                       if (gmse != NULL) {
+                               MEMORYSTATUSEX meminfo;
+                               meminfo.dwLength = sizeof(meminfo);
+                               if (gmse(&meminfo))
+                                       ret = meminfo.ullTotalPhys;
+                       }
+               }
+       }
+
+       if (ret == 0) {
+               // GlobalMemoryStatus() is supported by Windows 95 and later,
+               // so it is fine to link against it unconditionally. Note that
+               // GlobalMemoryStatus() has no return value.
+               MEMORYSTATUS meminfo;
+               meminfo.dwLength = sizeof(meminfo);
+               GlobalMemoryStatus(&meminfo);
+               ret = meminfo.dwTotalPhys;
+       }
+
+#elif defined(__OS2__)
+       unsigned long mem;
+       if (DosQuerySysInfo(QSV_TOTPHYSMEM, QSV_TOTPHYSMEM,
+                       &mem, sizeof(mem)) == 0)
+               ret = mem;
+
+#elif defined(__DJGPP__)
+       __dpmi_free_mem_info meminfo;
+       if (__dpmi_get_free_memory_information(&meminfo) == 0
+                       && meminfo.total_number_of_physical_pages
+                               != (unsigned long)-1)
+               ret = (uint64_t)meminfo.total_number_of_physical_pages * 4096;
+
+#elif defined(__VMS)
+       int vms_mem;
+       int val = SYI$_MEMSIZE;
+       if (LIB$GETSYI(&val, &vms_mem, 0, 0, 0, 0) == SS$_NORMAL)
+               ret = (uint64_t)vms_mem * 8192;
+
+#elif defined(TUKLIB_PHYSMEM_AIX)
+       ret = _system_configuration.physmem;
+
+#elif defined(TUKLIB_PHYSMEM_SYSCONF)
+       const long pagesize = sysconf(_SC_PAGESIZE);
+       const long pages = sysconf(_SC_PHYS_PAGES);
+       if (pagesize != -1 && pages != -1)
+               // According to docs, pagesize * pages can overflow.
+               // Simple case is 32-bit box with 4 GiB or more RAM,
+               // which may report exactly 4 GiB of RAM, and "long"
+               // being 32-bit will overflow. Casting to uint64_t
+               // hopefully avoids overflows in the near future.
+               ret = (uint64_t)pagesize * (uint64_t)pages;
+
+#elif defined(TUKLIB_PHYSMEM_SYSCTL)
+       int name[2] = {
+               CTL_HW,
+#ifdef HW_PHYSMEM64
+               HW_PHYSMEM64
+#else
+               HW_PHYSMEM
+#endif
+       };
+       union {
+               uint32_t u32;
+               uint64_t u64;
+       } mem;
+       size_t mem_ptr_size = sizeof(mem.u64);
+       if (sysctl(name, 2, &mem.u64, &mem_ptr_size, NULL, 0) != -1) {
+               // IIRC, 64-bit "return value" is possible on some 64-bit
+               // BSD systems even with HW_PHYSMEM (instead of HW_PHYSMEM64),
+               // so support both.
+               if (mem_ptr_size == sizeof(mem.u64))
+                       ret = mem.u64;
+               else if (mem_ptr_size == sizeof(mem.u32))
+                       ret = mem.u32;
+       }
+
+#elif defined(TUKLIB_PHYSMEM_GETSYSINFO)
+       // Docs are unclear if "start" is needed, but it doesn't hurt
+       // much to have it.
+       int memkb;
+       int start = 0;
+       if (getsysinfo(GSI_PHYSMEM, (caddr_t)&memkb, sizeof(memkb), &start)
+                       != -1)
+               ret = (uint64_t)memkb * 1024;
+
+#elif defined(TUKLIB_PHYSMEM_PSTAT_GETSTATIC)
+       struct pst_static pst;
+       if (pstat_getstatic(&pst, sizeof(pst), 1, 0) != -1)
+               ret = (uint64_t)pst.physical_memory * (uint64_t)pst.page_size;
+
+#elif defined(TUKLIB_PHYSMEM_GETINVENT_R)
+       inv_state_t *st = NULL;
+       if (setinvent_r(&st) != -1) {
+               inventory_t *i;
+               while ((i = getinvent_r(st)) != NULL) {
+                       if (i->inv_class == INV_MEMORY
+                                       && i->inv_type == INV_MAIN_MB) {
+                               ret = (uint64_t)i->inv_state << 20;
+                               break;
+                       }
+               }
+
+               endinvent_r(st);
+       }
+
+#elif defined(TUKLIB_PHYSMEM_SYSINFO)
+       struct sysinfo si;
+       if (sysinfo(&si) == 0)
+               ret = (uint64_t)si.totalram * si.mem_unit;
+#endif
+
+       return ret;
+}
diff --git a/contrib/xz/src/common/tuklib_physmem.h b/contrib/xz/src/common/tuklib_physmem.h
new file mode 100644 (file)
index 0000000..09e2a51
--- /dev/null
@@ -0,0 +1,28 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       tuklib_physmem.h
+/// \brief      Get the amount of physical memory
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef TUKLIB_PHYSMEM_H
+#define TUKLIB_PHYSMEM_H
+
+#include "tuklib_common.h"
+TUKLIB_DECLS_BEGIN
+
+#define tuklib_physmem TUKLIB_SYMBOL(tuklib_physmem)
+extern uint64_t tuklib_physmem(void);
+///<
+/// \brief      Get the amount of physical memory in bytes
+///
+/// \return     Amount of physical memory in bytes. On error, zero is
+///             returned.
+
+TUKLIB_DECLS_END
+#endif
diff --git a/contrib/xz/src/common/tuklib_progname.c b/contrib/xz/src/common/tuklib_progname.c
new file mode 100644 (file)
index 0000000..7cb7e20
--- /dev/null
@@ -0,0 +1,50 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       tuklib_progname.c
+/// \brief      Program name to be displayed in messages
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "tuklib_progname.h"
+#include <string.h>
+
+
+#if !HAVE_DECL_PROGRAM_INVOCATION_NAME
+char *progname = NULL;
+#endif
+
+
+extern void
+tuklib_progname_init(char **argv)
+{
+#ifdef TUKLIB_DOSLIKE
+       // On these systems, argv[0] always has the full path and .exe
+       // suffix even if the user just types the plain program name.
+       // We modify argv[0] to make it nicer to read.
+
+       // Strip the leading path.
+       char *p = argv[0] + strlen(argv[0]);
+       while (argv[0] < p && p[-1] != '/' && p[-1] != '\\')
+               --p;
+
+       argv[0] = p;
+
+       // Strip the .exe suffix.
+       p = strrchr(p, '.');
+       if (p != NULL)
+               *p = '\0';
+
+       // Make it lowercase.
+       for (p = argv[0]; *p != '\0'; ++p)
+               if (*p >= 'A' && *p <= 'Z')
+                       *p = *p - 'A' + 'a';
+#endif
+
+       progname = argv[0];
+       return;
+}
diff --git a/contrib/xz/src/common/tuklib_progname.h b/contrib/xz/src/common/tuklib_progname.h
new file mode 100644 (file)
index 0000000..791b125
--- /dev/null
@@ -0,0 +1,32 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       tuklib_progname.h
+/// \brief      Program name to be displayed in messages
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef TUKLIB_PROGNAME_H
+#define TUKLIB_PROGNAME_H
+
+#include "tuklib_common.h"
+#include <errno.h>
+
+TUKLIB_DECLS_BEGIN
+
+#if HAVE_DECL_PROGRAM_INVOCATION_NAME
+#      define progname program_invocation_name
+#else
+#      define progname TUKLIB_SYMBOL(tuklib_progname)
+       extern char *progname;
+#endif
+
+#define tuklib_progname_init TUKLIB_SYMBOL(tuklib_progname_init)
+extern void tuklib_progname_init(char **argv);
+
+TUKLIB_DECLS_END
+#endif
diff --git a/contrib/xz/src/liblzma/api/lzma.h b/contrib/xz/src/liblzma/api/lzma.h
new file mode 100644 (file)
index 0000000..fb874c3
--- /dev/null
@@ -0,0 +1,313 @@
+/**
+ * \file        api/lzma.h
+ * \brief       The public API of liblzma data compression library
+ *
+ * liblzma is a public domain general-purpose data compression library with
+ * a zlib-like API. The native file format is .xz, but also the old .lzma
+ * format and raw (no headers) streams are supported. Multiple compression
+ * algorithms (filters) are supported. Currently LZMA2 is the primary filter.
+ *
+ * liblzma is part of XZ Utils <http://tukaani.org/xz/>. XZ Utils includes
+ * a gzip-like command line tool named xz and some other tools. XZ Utils
+ * is developed and maintained by Lasse Collin.
+ *
+ * Major parts of liblzma are based on Igor Pavlov's public domain LZMA SDK
+ * <http://7-zip.org/sdk.html>.
+ *
+ * The SHA-256 implementation is based on the public domain code found from
+ * 7-Zip <http://7-zip.org/>, which has a modified version of the public
+ * domain SHA-256 code found from Crypto++ <http://www.cryptopp.com/>.
+ * The SHA-256 code in Crypto++ was written by Kevin Springle and Wei Dai.
+ */
+
+/*
+ * Author: Lasse Collin
+ *
+ * This file has been put into the public domain.
+ * You can do whatever you want with this file.
+ */
+
+#ifndef LZMA_H
+#define LZMA_H
+
+/*****************************
+ * Required standard headers *
+ *****************************/
+
+/*
+ * liblzma API headers need some standard types and macros. To allow
+ * including lzma.h without requiring the application to include other
+ * headers first, lzma.h includes the required standard headers unless
+ * they already seem to be included already or if LZMA_MANUAL_HEADERS
+ * has been defined.
+ *
+ * Here's what types and macros are needed and from which headers:
+ *  - stddef.h: size_t, NULL
+ *  - stdint.h: uint8_t, uint32_t, uint64_t, UINT32_C(n), uint64_C(n),
+ *    UINT32_MAX, UINT64_MAX
+ *
+ * However, inttypes.h is a little more portable than stdint.h, although
+ * inttypes.h declares some unneeded things compared to plain stdint.h.
+ *
+ * The hacks below aren't perfect, specifically they assume that inttypes.h
+ * exists and that it typedefs at least uint8_t, uint32_t, and uint64_t,
+ * and that, in case of incomplete inttypes.h, unsigned int is 32-bit.
+ * If the application already takes care of setting up all the types and
+ * macros properly (for example by using gnulib's stdint.h or inttypes.h),
+ * we try to detect that the macros are already defined and don't include
+ * inttypes.h here again. However, you may define LZMA_MANUAL_HEADERS to
+ * force this file to never include any system headers.
+ *
+ * Some could argue that liblzma API should provide all the required types,
+ * for example lzma_uint64, LZMA_UINT64_C(n), and LZMA_UINT64_MAX. This was
+ * seen as an unnecessary mess, since most systems already provide all the
+ * necessary types and macros in the standard headers.
+ *
+ * Note that liblzma API still has lzma_bool, because using stdbool.h would
+ * break C89 and C++ programs on many systems. sizeof(bool) in C99 isn't
+ * necessarily the same as sizeof(bool) in C++.
+ */
+
+#ifndef LZMA_MANUAL_HEADERS
+       /*
+        * I suppose this works portably also in C++. Note that in C++,
+        * we need to get size_t into the global namespace.
+        */
+#      include <stddef.h>
+
+       /*
+        * Skip inttypes.h if we already have all the required macros. If we
+        * have the macros, we assume that we have the matching typedefs too.
+        */
+#      if !defined(UINT32_C) || !defined(UINT64_C) \
+                       || !defined(UINT32_MAX) || !defined(UINT64_MAX)
+               /*
+                * MSVC has no C99 support, and thus it cannot be used to
+                * compile liblzma. The liblzma API has to still be usable
+                * from MSVC, so we need to define the required standard
+                * integer types here.
+                */
+#              if defined(_WIN32) && defined(_MSC_VER)
+                       typedef unsigned __int8 uint8_t;
+                       typedef unsigned __int32 uint32_t;
+                       typedef unsigned __int64 uint64_t;
+#              else
+                       /* Use the standard inttypes.h. */
+#                      ifdef __cplusplus
+                               /*
+                                * C99 sections 7.18.2 and 7.18.4 specify
+                                * that C++ implementations define the limit
+                                * and constant macros only if specifically
+                                * requested. Note that if you want the
+                                * format macros (PRIu64 etc.) too, you need
+                                * to define __STDC_FORMAT_MACROS before
+                                * including lzma.h, since re-including
+                                * inttypes.h with __STDC_FORMAT_MACROS
+                                * defined doesn't necessarily work.
+                                */
+#                              ifndef __STDC_LIMIT_MACROS
+#                                      define __STDC_LIMIT_MACROS 1
+#                              endif
+#                              ifndef __STDC_CONSTANT_MACROS
+#                                      define __STDC_CONSTANT_MACROS 1
+#                              endif
+#                      endif
+
+#                      include <inttypes.h>
+#              endif
+
+               /*
+                * Some old systems have only the typedefs in inttypes.h, and
+                * lack all the macros. For those systems, we need a few more
+                * hacks. We assume that unsigned int is 32-bit and unsigned
+                * long is either 32-bit or 64-bit. If these hacks aren't
+                * enough, the application has to setup the types manually
+                * before including lzma.h.
+                */
+#              ifndef UINT32_C
+#                      if defined(_WIN32) && defined(_MSC_VER)
+#                              define UINT32_C(n) n ## UI32
+#                      else
+#                              define UINT32_C(n) n ## U
+#                      endif
+#              endif
+
+#              ifndef UINT64_C
+#                      if defined(_WIN32) && defined(_MSC_VER)
+#                              define UINT64_C(n) n ## UI64
+#                      else
+                               /* Get ULONG_MAX. */
+#                              include <limits.h>
+#                              if ULONG_MAX == 4294967295UL
+#                                      define UINT64_C(n) n ## ULL
+#                              else
+#                                      define UINT64_C(n) n ## UL
+#                              endif
+#                      endif
+#              endif
+
+#              ifndef UINT32_MAX
+#                      define UINT32_MAX (UINT32_C(4294967295))
+#              endif
+
+#              ifndef UINT64_MAX
+#                      define UINT64_MAX (UINT64_C(18446744073709551615))
+#              endif
+#      endif
+#endif /* ifdef LZMA_MANUAL_HEADERS */
+
+
+/******************
+ * LZMA_API macro *
+ ******************/
+
+/*
+ * Some systems require that the functions and function pointers are
+ * declared specially in the headers. LZMA_API_IMPORT is for importing
+ * symbols and LZMA_API_CALL is to specify the calling convention.
+ *
+ * By default it is assumed that the application will link dynamically
+ * against liblzma. #define LZMA_API_STATIC in your application if you
+ * want to link against static liblzma. If you don't care about portability
+ * to operating systems like Windows, or at least don't care about linking
+ * against static liblzma on them, don't worry about LZMA_API_STATIC. That
+ * is, most developers will never need to use LZMA_API_STATIC.
+ *
+ * The GCC variants are a special case on Windows (Cygwin and MinGW).
+ * We rely on GCC doing the right thing with its auto-import feature,
+ * and thus don't use __declspec(dllimport). This way developers don't
+ * need to worry about LZMA_API_STATIC. Also the calling convention is
+ * omitted on Cygwin but not on MinGW.
+ */
+#ifndef LZMA_API_IMPORT
+#      if !defined(LZMA_API_STATIC) && defined(_WIN32) && !defined(__GNUC__)
+#              define LZMA_API_IMPORT __declspec(dllimport)
+#      else
+#              define LZMA_API_IMPORT
+#      endif
+#endif
+
+#ifndef LZMA_API_CALL
+#      if defined(_WIN32) && !defined(__CYGWIN__)
+#              define LZMA_API_CALL __cdecl
+#      else
+#              define LZMA_API_CALL
+#      endif
+#endif
+
+#ifndef LZMA_API
+#      define LZMA_API(type) LZMA_API_IMPORT type LZMA_API_CALL
+#endif
+
+
+/***********
+ * nothrow *
+ ***********/
+
+/*
+ * None of the functions in liblzma may throw an exception. Even
+ * the functions that use callback functions won't throw exceptions,
+ * because liblzma would break if a callback function threw an exception.
+ */
+#ifndef lzma_nothrow
+#      if defined(__cplusplus)
+#              define lzma_nothrow throw()
+#      elif __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)
+#              define lzma_nothrow __attribute__((__nothrow__))
+#      else
+#              define lzma_nothrow
+#      endif
+#endif
+
+
+/********************
+ * GNU C extensions *
+ ********************/
+
+/*
+ * GNU C extensions are used conditionally in the public API. It doesn't
+ * break anything if these are sometimes enabled and sometimes not, only
+ * affects warnings and optimizations.
+ */
+#if __GNUC__ >= 3
+#      ifndef lzma_attribute
+#              define lzma_attribute(attr) __attribute__(attr)
+#      endif
+
+       /* warn_unused_result was added in GCC 3.4. */
+#      ifndef lzma_attr_warn_unused_result
+#              if __GNUC__ == 3 && __GNUC_MINOR__ < 4
+#                      define lzma_attr_warn_unused_result
+#              endif
+#      endif
+
+#else
+#      ifndef lzma_attribute
+#              define lzma_attribute(attr)
+#      endif
+#endif
+
+
+#ifndef lzma_attr_pure
+#      define lzma_attr_pure lzma_attribute((__pure__))
+#endif
+
+#ifndef lzma_attr_const
+#      define lzma_attr_const lzma_attribute((__const__))
+#endif
+
+#ifndef lzma_attr_warn_unused_result
+#      define lzma_attr_warn_unused_result \
+               lzma_attribute((__warn_unused_result__))
+#endif
+
+
+/**************
+ * Subheaders *
+ **************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Subheaders check that this is defined. It is to prevent including
+ * them directly from applications.
+ */
+#define LZMA_H_INTERNAL 1
+
+/* Basic features */
+#include "lzma/version.h"
+#include "lzma/base.h"
+#include "lzma/vli.h"
+#include "lzma/check.h"
+
+/* Filters */
+#include "lzma/filter.h"
+#include "lzma/bcj.h"
+#include "lzma/delta.h"
+#include "lzma/lzma.h"
+
+/* Container formats */
+#include "lzma/container.h"
+
+/* Advanced features */
+#include "lzma/stream_flags.h"
+#include "lzma/block.h"
+#include "lzma/index.h"
+#include "lzma/index_hash.h"
+
+/* Hardware information */
+#include "lzma/hardware.h"
+
+/*
+ * All subheaders included. Undefine LZMA_H_INTERNAL to prevent applications
+ * re-including the subheaders.
+ */
+#undef LZMA_H_INTERNAL
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef LZMA_H */
diff --git a/contrib/xz/src/liblzma/api/lzma/base.h b/contrib/xz/src/liblzma/api/lzma/base.h
new file mode 100644 (file)
index 0000000..43dde8d
--- /dev/null
@@ -0,0 +1,601 @@
+/**
+ * \file        lzma/base.h
+ * \brief       Data types and functions used in many places in liblzma API
+ */
+
+/*
+ * Author: Lasse Collin
+ *
+ * This file has been put into the public domain.
+ * You can do whatever you want with this file.
+ *
+ * See ../lzma.h for information about liblzma as a whole.
+ */
+
+#ifndef LZMA_H_INTERNAL
+#      error Never include this file directly. Use <lzma.h> instead.
+#endif
+
+
+/**
+ * \brief       Boolean
+ *
+ * This is here because C89 doesn't have stdbool.h. To set a value for
+ * variables having type lzma_bool, you can use
+ *   - C99's `true' and `false' from stdbool.h;
+ *   - C++'s internal `true' and `false'; or
+ *   - integers one (true) and zero (false).
+ */
+typedef unsigned char lzma_bool;
+
+
+/**
+ * \brief       Type of reserved enumeration variable in structures
+ *
+ * To avoid breaking library ABI when new features are added, several
+ * structures contain extra variables that may be used in future. Since
+ * sizeof(enum) can be different than sizeof(int), and sizeof(enum) may
+ * even vary depending on the range of enumeration constants, we specify
+ * a separate type to be used for reserved enumeration variables. All
+ * enumeration constants in liblzma API will be non-negative and less
+ * than 128, which should guarantee that the ABI won't break even when
+ * new constants are added to existing enumerations.
+ */
+typedef enum {
+       LZMA_RESERVED_ENUM      = 0
+} lzma_reserved_enum;
+
+
+/**
+ * \brief       Return values used by several functions in liblzma
+ *
+ * Check the descriptions of specific functions to find out which return
+ * values they can return. With some functions the return values may have
+ * more specific meanings than described here; those differences are
+ * described per-function basis.
+ */
+typedef enum {
+       LZMA_OK                 = 0,
+               /**<
+                * \brief       Operation completed successfully
+                */
+
+       LZMA_STREAM_END         = 1,
+               /**<
+                * \brief       End of stream was reached
+                *
+                * In encoder, LZMA_SYNC_FLUSH, LZMA_FULL_FLUSH, or
+                * LZMA_FINISH was finished. In decoder, this indicates
+                * that all the data was successfully decoded.
+                *
+                * In all cases, when LZMA_STREAM_END is returned, the last
+                * output bytes should be picked from strm->next_out.
+                */
+
+       LZMA_NO_CHECK           = 2,
+               /**<
+                * \brief       Input stream has no integrity check
+                *
+                * This return value can be returned only if the
+                * LZMA_TELL_NO_CHECK flag was used when initializing
+                * the decoder. LZMA_NO_CHECK is just a warning, and
+                * the decoding can be continued normally.
+                *
+                * It is possible to call lzma_get_check() immediately after
+                * lzma_code has returned LZMA_NO_CHECK. The result will
+                * naturally be LZMA_CHECK_NONE, but the possibility to call
+                * lzma_get_check() may be convenient in some applications.
+                */
+
+       LZMA_UNSUPPORTED_CHECK  = 3,
+               /**<
+                * \brief       Cannot calculate the integrity check
+                *
+                * The usage of this return value is different in encoders
+                * and decoders.
+                *
+                * Encoders can return this value only from the initialization
+                * function. If initialization fails with this value, the
+                * encoding cannot be done, because there's no way to produce
+                * output with the correct integrity check.
+                *
+                * Decoders can return this value only from lzma_code() and
+                * only if the LZMA_TELL_UNSUPPORTED_CHECK flag was used when
+                * initializing the decoder. The decoding can still be
+                * continued normally even if the check type is unsupported,
+                * but naturally the check will not be validated, and possible
+                * errors may go undetected.
+                *
+                * With decoder, it is possible to call lzma_get_check()
+                * immediately after lzma_code() has returned
+                * LZMA_UNSUPPORTED_CHECK. This way it is possible to find
+                * out what the unsupported Check ID was.
+                */
+
+       LZMA_GET_CHECK          = 4,
+               /**<
+                * \brief       Integrity check type is now available
+                *
+                * This value can be returned only by the lzma_code() function
+                * and only if the decoder was initialized with the
+                * LZMA_TELL_ANY_CHECK flag. LZMA_GET_CHECK tells the
+                * application that it may now call lzma_get_check() to find
+                * out the Check ID. This can be used, for example, to
+                * implement a decoder that accepts only files that have
+                * strong enough integrity check.
+                */
+
+       LZMA_MEM_ERROR          = 5,
+               /**<
+                * \brief       Cannot allocate memory
+                *
+                * Memory allocation failed, or the size of the allocation
+                * would be greater than SIZE_MAX.
+                *
+                * Due to internal implementation reasons, the coding cannot
+                * be continued even if more memory were made available after
+                * LZMA_MEM_ERROR.
+                */
+
+       LZMA_MEMLIMIT_ERROR     = 6,
+               /**
+                * \brief       Memory usage limit was reached
+                *
+                * Decoder would need more memory than allowed by the
+                * specified memory usage limit. To continue decoding,
+                * the memory usage limit has to be increased with
+                * lzma_memlimit_set().
+                */
+
+       LZMA_FORMAT_ERROR       = 7,
+               /**<
+                * \brief       File format not recognized
+                *
+                * The decoder did not recognize the input as supported file
+                * format. This error can occur, for example, when trying to
+                * decode .lzma format file with lzma_stream_decoder,
+                * because lzma_stream_decoder accepts only the .xz format.
+                */
+
+       LZMA_OPTIONS_ERROR      = 8,
+               /**<
+                * \brief       Invalid or unsupported options
+                *
+                * Invalid or unsupported options, for example
+                *  - unsupported filter(s) or filter options; or
+                *  - reserved bits set in headers (decoder only).
+                *
+                * Rebuilding liblzma with more features enabled, or
+                * upgrading to a newer version of liblzma may help.
+                */
+
+       LZMA_DATA_ERROR         = 9,
+               /**<
+                * \brief       Data is corrupt
+                *
+                * The usage of this return value is different in encoders
+                * and decoders. In both encoder and decoder, the coding
+                * cannot continue after this error.
+                *
+                * Encoders return this if size limits of the target file
+                * format would be exceeded. These limits are huge, thus
+                * getting this error from an encoder is mostly theoretical.
+                * For example, the maximum compressed and uncompressed
+                * size of a .xz Stream is roughly 8 EiB (2^63 bytes).
+                *
+                * Decoders return this error if the input data is corrupt.
+                * This can mean, for example, invalid CRC32 in headers
+                * or invalid check of uncompressed data.
+                */
+
+       LZMA_BUF_ERROR          = 10,
+               /**<
+                * \brief       No progress is possible
+                *
+                * This error code is returned when the coder cannot consume
+                * any new input and produce any new output. The most common
+                * reason for this error is that the input stream being
+                * decoded is truncated or corrupt.
+                *
+                * This error is not fatal. Coding can be continued normally
+                * by providing more input and/or more output space, if
+                * possible.
+                *
+                * Typically the first call to lzma_code() that can do no
+                * progress returns LZMA_OK instead of LZMA_BUF_ERROR. Only
+                * the second consecutive call doing no progress will return
+                * LZMA_BUF_ERROR. This is intentional.
+                *
+                * With zlib, Z_BUF_ERROR may be returned even if the
+                * application is doing nothing wrong, so apps will need
+                * to handle Z_BUF_ERROR specially. The above hack
+                * guarantees that liblzma never returns LZMA_BUF_ERROR
+                * to properly written applications unless the input file
+                * is truncated or corrupt. This should simplify the
+                * applications a little.
+                */
+
+       LZMA_PROG_ERROR         = 11,
+               /**<
+                * \brief       Programming error
+                *
+                * This indicates that the arguments given to the function are
+                * invalid or the internal state of the decoder is corrupt.
+                *   - Function arguments are invalid or the structures
+                *     pointed by the argument pointers are invalid
+                *     e.g. if strm->next_out has been set to NULL and
+                *     strm->avail_out > 0 when calling lzma_code().
+                *   - lzma_* functions have been called in wrong order
+                *     e.g. lzma_code() was called right after lzma_end().
+                *   - If errors occur randomly, the reason might be flaky
+                *     hardware.
+                *
+                * If you think that your code is correct, this error code
+                * can be a sign of a bug in liblzma. See the documentation
+                * how to report bugs.
+                */
+} lzma_ret;
+
+
+/**
+ * \brief       The `action' argument for lzma_code()
+ *
+ * After the first use of LZMA_SYNC_FLUSH, LZMA_FULL_FLUSH, or LZMA_FINISH,
+ * the same `action' must is used until lzma_code() returns LZMA_STREAM_END.
+ * Also, the amount of input (that is, strm->avail_in) must not be modified
+ * by the application until lzma_code() returns LZMA_STREAM_END. Changing the
+ * `action' or modifying the amount of input will make lzma_code() return
+ * LZMA_PROG_ERROR.
+ */
+typedef enum {
+       LZMA_RUN = 0,
+               /**<
+                * \brief       Continue coding
+                *
+                * Encoder: Encode as much input as possible. Some internal
+                * buffering will probably be done (depends on the filter
+                * chain in use), which causes latency: the input used won't
+                * usually be decodeable from the output of the same
+                * lzma_code() call.
+                *
+                * Decoder: Decode as much input as possible and produce as
+                * much output as possible.
+                */
+
+       LZMA_SYNC_FLUSH = 1,
+               /**<
+                * \brief       Make all the input available at output
+                *
+                * Normally the encoder introduces some latency.
+                * LZMA_SYNC_FLUSH forces all the buffered data to be
+                * available at output without resetting the internal
+                * state of the encoder. This way it is possible to use
+                * compressed stream for example for communication over
+                * network.
+                *
+                * Only some filters support LZMA_SYNC_FLUSH. Trying to use
+                * LZMA_SYNC_FLUSH with filters that don't support it will
+                * make lzma_code() return LZMA_OPTIONS_ERROR. For example,
+                * LZMA1 doesn't support LZMA_SYNC_FLUSH but LZMA2 does.
+                *
+                * Using LZMA_SYNC_FLUSH very often can dramatically reduce
+                * the compression ratio. With some filters (for example,
+                * LZMA2), fine-tuning the compression options may help
+                * mitigate this problem significantly (for example,
+                * match finder with LZMA2).
+                *
+                * Decoders don't support LZMA_SYNC_FLUSH.
+                */
+
+       LZMA_FULL_FLUSH = 2,
+               /**<
+                * \brief       Finish encoding of the current Block
+                *
+                * All the input data going to the current Block must have
+                * been given to the encoder (the last bytes can still be
+                * pending in* next_in). Call lzma_code() with LZMA_FULL_FLUSH
+                * until it returns LZMA_STREAM_END. Then continue normally
+                * with LZMA_RUN or finish the Stream with LZMA_FINISH.
+                *
+                * This action is currently supported only by Stream encoder
+                * and easy encoder (which uses Stream encoder). If there is
+                * no unfinished Block, no empty Block is created.
+                */
+
+       LZMA_FINISH = 3
+               /**<
+                * \brief       Finish the coding operation
+                *
+                * All the input data must have been given to the encoder
+                * (the last bytes can still be pending in next_in).
+                * Call lzma_code() with LZMA_FINISH until it returns
+                * LZMA_STREAM_END. Once LZMA_FINISH has been used,
+                * the amount of input must no longer be changed by
+                * the application.
+                *
+                * When decoding, using LZMA_FINISH is optional unless the
+                * LZMA_CONCATENATED flag was used when the decoder was
+                * initialized. When LZMA_CONCATENATED was not used, the only
+                * effect of LZMA_FINISH is that the amount of input must not
+                * be changed just like in the encoder.
+                */
+} lzma_action;
+
+
+/**
+ * \brief       Custom functions for memory handling
+ *
+ * A pointer to lzma_allocator may be passed via lzma_stream structure
+ * to liblzma, and some advanced functions take a pointer to lzma_allocator
+ * as a separate function argument. The library will use the functions
+ * specified in lzma_allocator for memory handling instead of the default
+ * malloc() and free(). C++ users should note that the custom memory
+ * handling functions must not throw exceptions.
+ *
+ * liblzma doesn't make an internal copy of lzma_allocator. Thus, it is
+ * OK to change these function pointers in the middle of the coding
+ * process, but obviously it must be done carefully to make sure that the
+ * replacement `free' can deallocate memory allocated by the earlier
+ * `alloc' function(s).
+ */
+typedef struct {
+       /**
+        * \brief       Pointer to a custom memory allocation function
+        *
+        * If you don't want a custom allocator, but still want
+        * custom free(), set this to NULL and liblzma will use
+        * the standard malloc().
+        *
+        * \param       opaque  lzma_allocator.opaque (see below)
+        * \param       nmemb   Number of elements like in calloc(). liblzma
+        *                      will always set nmemb to 1, so it is safe to
+        *                      ignore nmemb in a custom allocator if you like.
+        *                      The nmemb argument exists only for
+        *                      compatibility with zlib and libbzip2.
+        * \param       size    Size of an element in bytes.
+        *                      liblzma never sets this to zero.
+        *
+        * \return      Pointer to the beginning of a memory block of
+        *              `size' bytes, or NULL if allocation fails
+        *              for some reason. When allocation fails, functions
+        *              of liblzma return LZMA_MEM_ERROR.
+        *
+        * The allocator should not waste time zeroing the allocated buffers.
+        * This is not only about speed, but also memory usage, since the
+        * operating system kernel doesn't necessarily allocate the requested
+        * memory in physical memory until it is actually used. With small
+        * input files, liblzma may actually need only a fraction of the
+        * memory that it requested for allocation.
+        *
+        * \note        LZMA_MEM_ERROR is also used when the size of the
+        *              allocation would be greater than SIZE_MAX. Thus,
+        *              don't assume that the custom allocator must have
+        *              returned NULL if some function from liblzma
+        *              returns LZMA_MEM_ERROR.
+        */
+       void *(LZMA_API_CALL *alloc)(void *opaque, size_t nmemb, size_t size);
+
+       /**
+        * \brief       Pointer to a custom memory freeing function
+        *
+        * If you don't want a custom freeing function, but still
+        * want a custom allocator, set this to NULL and liblzma
+        * will use the standard free().
+        *
+        * \param       opaque  lzma_allocator.opaque (see below)
+        * \param       ptr     Pointer returned by lzma_allocator.alloc(),
+        *                      or when it is set to NULL, a pointer returned
+        *                      by the standard malloc().
+        */
+       void (LZMA_API_CALL *free)(void *opaque, void *ptr);
+
+       /**
+        * \brief       Pointer passed to .alloc() and .free()
+        *
+        * opaque is passed as the first argument to lzma_allocator.alloc()
+        * and lzma_allocator.free(). This intended to ease implementing
+        * custom memory allocation functions for use with liblzma.
+        *
+        * If you don't need this, you should set this to NULL.
+        */
+       void *opaque;
+
+} lzma_allocator;
+
+
+/**
+ * \brief       Internal data structure
+ *
+ * The contents of this structure is not visible outside the library.
+ */
+typedef struct lzma_internal_s lzma_internal;
+
+
+/**
+ * \brief       Passing data to and from liblzma
+ *
+ * The lzma_stream structure is used for
+ *  - passing pointers to input and output buffers to liblzma;
+ *  - defining custom memory hander functions; and
+ *  - holding a pointer to coder-specific internal data structures.
+ *
+ * Typical usage:
+ *
+ *  - After allocating lzma_stream (on stack or with malloc()), it must be
+ *    initialized to LZMA_STREAM_INIT (see LZMA_STREAM_INIT for details).
+ *
+ *  - Initialize a coder to the lzma_stream, for example by using
+ *    lzma_easy_encoder() or lzma_auto_decoder(). Some notes:
+ *      - In contrast to zlib, strm->next_in and strm->next_out are
+ *        ignored by all initialization functions, thus it is safe
+ *        to not initialize them yet.
+ *      - The initialization functions always set strm->total_in and
+ *        strm->total_out to zero.
+ *      - If the initialization function fails, no memory is left allocated
+ *        that would require freeing with lzma_end() even if some memory was
+ *        associated with the lzma_stream structure when the initialization
+ *        function was called.
+ *
+ *  - Use lzma_code() to do the actual work.
+ *
+ *  - Once the coding has been finished, the existing lzma_stream can be
+ *    reused. It is OK to reuse lzma_stream with different initialization
+ *    function without calling lzma_end() first. Old allocations are
+ *    automatically freed.
+ *
+ *  - Finally, use lzma_end() to free the allocated memory. lzma_end() never
+ *    frees the lzma_stream structure itself.
+ *
+ * Application may modify the values of total_in and total_out as it wants.
+ * They are updated by liblzma to match the amount of data read and
+ * written, but aren't used for anything else.
+ */
+typedef struct {
+       const uint8_t *next_in; /**< Pointer to the next input byte. */
+       size_t avail_in;    /**< Number of available input bytes in next_in. */
+       uint64_t total_in;  /**< Total number of bytes read by liblzma. */
+
+       uint8_t *next_out;  /**< Pointer to the next output position. */
+       size_t avail_out;   /**< Amount of free space in next_out. */
+       uint64_t total_out; /**< Total number of bytes written by liblzma. */
+
+       /**
+        * \brief       Custom memory allocation functions
+        *
+        * In most cases this is NULL which makes liblzma use
+        * the standard malloc() and free().
+        */
+       lzma_allocator *allocator;
+
+       /** Internal state is not visible to applications. */
+       lzma_internal *internal;
+
+       /*
+        * Reserved space to allow possible future extensions without
+        * breaking the ABI. Excluding the initialization of this structure,
+        * you should not touch these, because the names of these variables
+        * may change.
+        */
+       void *reserved_ptr1;
+       void *reserved_ptr2;
+       void *reserved_ptr3;
+       void *reserved_ptr4;
+       uint64_t reserved_int1;
+       uint64_t reserved_int2;
+       size_t reserved_int3;
+       size_t reserved_int4;
+       lzma_reserved_enum reserved_enum1;
+       lzma_reserved_enum reserved_enum2;
+
+} lzma_stream;
+
+
+/**
+ * \brief       Initialization for lzma_stream
+ *
+ * When you declare an instance of lzma_stream, you can immediately
+ * initialize it so that initialization functions know that no memory
+ * has been allocated yet:
+ *
+ *     lzma_stream strm = LZMA_STREAM_INIT;
+ *
+ * If you need to initialize a dynamically allocated lzma_stream, you can use
+ * memset(strm_pointer, 0, sizeof(lzma_stream)). Strictly speaking, this
+ * violates the C standard since NULL may have different internal
+ * representation than zero, but it should be portable enough in practice.
+ * Anyway, for maximum portability, you can use something like this:
+ *
+ *     lzma_stream tmp = LZMA_STREAM_INIT;
+ *     *strm = tmp;
+ */
+#define LZMA_STREAM_INIT \
+       { NULL, 0, 0, NULL, 0, 0, NULL, NULL, \
+       NULL, NULL, NULL, NULL, 0, 0, 0, 0, \
+       LZMA_RESERVED_ENUM, LZMA_RESERVED_ENUM }
+
+
+/**
+ * \brief       Encode or decode data
+ *
+ * Once the lzma_stream has been successfully initialized (e.g. with
+ * lzma_stream_encoder()), the actual encoding or decoding is done
+ * using this function. The application has to update strm->next_in,
+ * strm->avail_in, strm->next_out, and strm->avail_out to pass input
+ * to and get output from liblzma.
+ *
+ * See the description of the coder-specific initialization function to find
+ * out what `action' values are supported by the coder.
+ */
+extern LZMA_API(lzma_ret) lzma_code(lzma_stream *strm, lzma_action action)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Free memory allocated for the coder data structures
+ *
+ * \param       strm    Pointer to lzma_stream that is at least initialized
+ *                      with LZMA_STREAM_INIT.
+ *
+ * After lzma_end(strm), strm->internal is guaranteed to be NULL. No other
+ * members of the lzma_stream structure are touched.
+ *
+ * \note        zlib indicates an error if application end()s unfinished
+ *              stream structure. liblzma doesn't do this, and assumes that
+ *              application knows what it is doing.
+ */
+extern LZMA_API(void) lzma_end(lzma_stream *strm) lzma_nothrow;
+
+
+/**
+ * \brief       Get the memory usage of decoder filter chain
+ *
+ * This function is currently supported only when *strm has been initialized
+ * with a function that takes a memlimit argument. With other functions, you
+ * should use e.g. lzma_raw_encoder_memusage() or lzma_raw_decoder_memusage()
+ * to estimate the memory requirements.
+ *
+ * This function is useful e.g. after LZMA_MEMLIMIT_ERROR to find out how big
+ * the memory usage limit should have been to decode the input. Note that
+ * this may give misleading information if decoding .xz Streams that have
+ * multiple Blocks, because each Block can have different memory requirements.
+ *
+ * \return      How much memory is currently allocated for the filter
+ *              decoders. If no filter chain is currently allocated,
+ *              some non-zero value is still returned, which is less than
+ *              or equal to what any filter chain would indicate as its
+ *              memory requirement.
+ *
+ *              If this function isn't supported by *strm or some other error
+ *              occurs, zero is returned.
+ */
+extern LZMA_API(uint64_t) lzma_memusage(const lzma_stream *strm)
+               lzma_nothrow lzma_attr_pure;
+
+
+/**
+ * \brief       Get the current memory usage limit
+ *
+ * This function is supported only when *strm has been initialized with
+ * a function that takes a memlimit argument.
+ *
+ * \return      On success, the current memory usage limit is returned
+ *              (always non-zero). On error, zero is returned.
+ */
+extern LZMA_API(uint64_t) lzma_memlimit_get(const lzma_stream *strm)
+               lzma_nothrow lzma_attr_pure;
+
+
+/**
+ * \brief       Set the memory usage limit
+ *
+ * This function is supported only when *strm has been initialized with
+ * a function that takes a memlimit argument.
+ *
+ * \return      - LZMA_OK: New memory usage limit successfully set.
+ *              - LZMA_MEMLIMIT_ERROR: The new limit is too small.
+ *                The limit was not changed.
+ *              - LZMA_PROG_ERROR: Invalid arguments, e.g. *strm doesn't
+ *                support memory usage limit or memlimit was zero.
+ */
+extern LZMA_API(lzma_ret) lzma_memlimit_set(
+               lzma_stream *strm, uint64_t memlimit) lzma_nothrow;
diff --git a/contrib/xz/src/liblzma/api/lzma/bcj.h b/contrib/xz/src/liblzma/api/lzma/bcj.h
new file mode 100644 (file)
index 0000000..8e37538
--- /dev/null
@@ -0,0 +1,90 @@
+/**
+ * \file        lzma/bcj.h
+ * \brief       Branch/Call/Jump conversion filters
+ */
+
+/*
+ * Author: Lasse Collin
+ *
+ * This file has been put into the public domain.
+ * You can do whatever you want with this file.
+ *
+ * See ../lzma.h for information about liblzma as a whole.
+ */
+
+#ifndef LZMA_H_INTERNAL
+#      error Never include this file directly. Use <lzma.h> instead.
+#endif
+
+
+/* Filter IDs for lzma_filter.id */
+
+#define LZMA_FILTER_X86         LZMA_VLI_C(0x04)
+       /**<
+        * Filter for x86 binaries
+        */
+
+#define LZMA_FILTER_POWERPC     LZMA_VLI_C(0x05)
+       /**<
+        * Filter for Big endian PowerPC binaries
+        */
+
+#define LZMA_FILTER_IA64        LZMA_VLI_C(0x06)
+       /**<
+        * Filter for IA-64 (Itanium) binaries.
+        */
+
+#define LZMA_FILTER_ARM         LZMA_VLI_C(0x07)
+       /**<
+        * Filter for ARM binaries.
+        */
+
+#define LZMA_FILTER_ARMTHUMB    LZMA_VLI_C(0x08)
+       /**<
+        * Filter for ARM-Thumb binaries.
+        */
+
+#define LZMA_FILTER_SPARC       LZMA_VLI_C(0x09)
+       /**<
+        * Filter for SPARC binaries.
+        */
+
+
+/**
+ * \brief       Options for BCJ filters
+ *
+ * The BCJ filters never change the size of the data. Specifying options
+ * for them is optional: if pointer to options is NULL, default value is
+ * used. You probably never need to specify options to BCJ filters, so just
+ * set the options pointer to NULL and be happy.
+ *
+ * If options with non-default values have been specified when encoding,
+ * the same options must also be specified when decoding.
+ *
+ * \note        At the moment, none of the BCJ filters support
+ *              LZMA_SYNC_FLUSH. If LZMA_SYNC_FLUSH is specified,
+ *              LZMA_OPTIONS_ERROR will be returned. If there is need,
+ *              partial support for LZMA_SYNC_FLUSH can be added in future.
+ *              Partial means that flushing would be possible only at
+ *              offsets that are multiple of 2, 4, or 16 depending on
+ *              the filter, except x86 which cannot be made to support
+ *              LZMA_SYNC_FLUSH predictably.
+ */
+typedef struct {
+       /**
+        * \brief       Start offset for conversions
+        *
+        * This setting is useful only when the same filter is used
+        * _separately_ for multiple sections of the same executable file,
+        * and the sections contain cross-section branch/call/jump
+        * instructions. In that case it is beneficial to set the start
+        * offset of the non-first sections so that the relative addresses
+        * of the cross-section branch/call/jump instructions will use the
+        * same absolute addresses as in the first section.
+        *
+        * When the pointer to options is NULL, the default value (zero)
+        * is used.
+        */
+       uint32_t start_offset;
+
+} lzma_options_bcj;
diff --git a/contrib/xz/src/liblzma/api/lzma/block.h b/contrib/xz/src/liblzma/api/lzma/block.h
new file mode 100644 (file)
index 0000000..3019bf9
--- /dev/null
@@ -0,0 +1,529 @@
+/**
+ * \file        lzma/block.h
+ * \brief       .xz Block handling
+ */
+
+/*
+ * Author: Lasse Collin
+ *
+ * This file has been put into the public domain.
+ * You can do whatever you want with this file.
+ *
+ * See ../lzma.h for information about liblzma as a whole.
+ */
+
+#ifndef LZMA_H_INTERNAL
+#      error Never include this file directly. Use <lzma.h> instead.
+#endif
+
+
+/**
+ * \brief       Options for the Block and Block Header encoders and decoders
+ *
+ * Different Block handling functions use different parts of this structure.
+ * Some read some members, other functions write, and some do both. Only the
+ * members listed for reading need to be initialized when the specified
+ * functions are called. The members marked for writing will be assigned
+ * new values at some point either by calling the given function or by
+ * later calls to lzma_code().
+ */
+typedef struct {
+       /**
+        * \brief       Block format version
+        *
+        * To prevent API and ABI breakages if new features are needed in
+        * the Block field, a version number is used to indicate which
+        * fields in this structure are in use. For now, version must always
+        * be zero. With non-zero version, most Block related functions will
+        * return LZMA_OPTIONS_ERROR.
+        *
+        * Read by:
+        *  - All functions that take pointer to lzma_block as argument,
+        *    including lzma_block_header_decode().
+        *
+        * Written by:
+        *  - lzma_block_header_decode()
+        */
+       uint32_t version;
+
+       /**
+        * \brief       Size of the Block Header field
+        *
+        * This is always a multiple of four.
+        *
+        * Read by:
+        *  - lzma_block_header_encode()
+        *  - lzma_block_header_decode()
+        *  - lzma_block_compressed_size()
+        *  - lzma_block_unpadded_size()
+        *  - lzma_block_total_size()
+        *  - lzma_block_decoder()
+        *  - lzma_block_buffer_decode()
+        *
+        * Written by:
+        *  - lzma_block_header_size()
+        *  - lzma_block_buffer_encode()
+        */
+       uint32_t header_size;
+#      define LZMA_BLOCK_HEADER_SIZE_MIN 8
+#      define LZMA_BLOCK_HEADER_SIZE_MAX 1024
+
+       /**
+        * \brief       Type of integrity Check
+        *
+        * The Check ID is not stored into the Block Header, thus its value
+        * must be provided also when decoding.
+        *
+        * Read by:
+        *  - lzma_block_header_encode()
+        *  - lzma_block_header_decode()
+        *  - lzma_block_compressed_size()
+        *  - lzma_block_unpadded_size()
+        *  - lzma_block_total_size()
+        *  - lzma_block_encoder()
+        *  - lzma_block_decoder()
+        *  - lzma_block_buffer_encode()
+        *  - lzma_block_buffer_decode()
+        */
+       lzma_check check;
+
+       /**
+        * \brief       Size of the Compressed Data in bytes
+        *
+        * Encoding: If this is not LZMA_VLI_UNKNOWN, Block Header encoder
+        * will store this value to the Block Header. Block encoder doesn't
+        * care about this value, but will set it once the encoding has been
+        * finished.
+        *
+        * Decoding: If this is not LZMA_VLI_UNKNOWN, Block decoder will
+        * verify that the size of the Compressed Data field matches
+        * compressed_size.
+        *
+        * Usually you don't know this value when encoding in streamed mode,
+        * and thus cannot write this field into the Block Header.
+        *
+        * In non-streamed mode you can reserve space for this field before
+        * encoding the actual Block. After encoding the data, finish the
+        * Block by encoding the Block Header. Steps in detail:
+        *
+        *  - Set compressed_size to some big enough value. If you don't know
+        *    better, use LZMA_VLI_MAX, but remember that bigger values take
+        *    more space in Block Header.
+        *
+        *  - Call lzma_block_header_size() to see how much space you need to
+        *    reserve for the Block Header.
+        *
+        *  - Encode the Block using lzma_block_encoder() and lzma_code().
+        *    It sets compressed_size to the correct value.
+        *
+        *  - Use lzma_block_header_encode() to encode the Block Header.
+        *    Because space was reserved in the first step, you don't need
+        *    to call lzma_block_header_size() anymore, because due to
+        *    reserving, header_size has to be big enough. If it is "too big",
+        *    lzma_block_header_encode() will add enough Header Padding to
+        *    make Block Header to match the size specified by header_size.
+        *
+        * Read by:
+        *  - lzma_block_header_size()
+        *  - lzma_block_header_encode()
+        *  - lzma_block_compressed_size()
+        *  - lzma_block_unpadded_size()
+        *  - lzma_block_total_size()
+        *  - lzma_block_decoder()
+        *  - lzma_block_buffer_decode()
+        *
+        * Written by:
+        *  - lzma_block_header_decode()
+        *  - lzma_block_compressed_size()
+        *  - lzma_block_encoder()
+        *  - lzma_block_decoder()
+        *  - lzma_block_buffer_encode()
+        *  - lzma_block_buffer_decode()
+        */
+       lzma_vli compressed_size;
+
+       /**
+        * \brief       Uncompressed Size in bytes
+        *
+        * This is handled very similarly to compressed_size above.
+        *
+        * uncompressed_size is needed by fewer functions than
+        * compressed_size. This is because uncompressed_size isn't
+        * needed to validate that Block stays within proper limits.
+        *
+        * Read by:
+        *  - lzma_block_header_size()
+        *  - lzma_block_header_encode()
+        *  - lzma_block_decoder()
+        *  - lzma_block_buffer_decode()
+        *
+        * Written by:
+        *  - lzma_block_header_decode()
+        *  - lzma_block_encoder()
+        *  - lzma_block_decoder()
+        *  - lzma_block_buffer_encode()
+        *  - lzma_block_buffer_decode()
+        */
+       lzma_vli uncompressed_size;
+
+       /**
+        * \brief       Array of filters
+        *
+        * There can be 1-4 filters. The end of the array is marked with
+        * .id = LZMA_VLI_UNKNOWN.
+        *
+        * Read by:
+        *  - lzma_block_header_size()
+        *  - lzma_block_header_encode()
+        *  - lzma_block_encoder()
+        *  - lzma_block_decoder()
+        *  - lzma_block_buffer_encode()
+        *  - lzma_block_buffer_decode()
+        *
+        * Written by:
+        *  - lzma_block_header_decode(): Note that this does NOT free()
+        *    the old filter options structures. All unused filters[] will
+        *    have .id == LZMA_VLI_UNKNOWN and .options == NULL. If
+        *    decoding fails, all filters[] are guaranteed to be
+        *    LZMA_VLI_UNKNOWN and NULL.
+        *
+        * \note        Because of the array is terminated with
+        *              .id = LZMA_VLI_UNKNOWN, the actual array must
+        *              have LZMA_FILTERS_MAX + 1 members or the Block
+        *              Header decoder will overflow the buffer.
+        */
+       lzma_filter *filters;
+
+       /**
+        * \brief       Raw value stored in the Check field
+        *
+        * After successful coding, the first lzma_check_size(check) bytes
+        * of this array contain the raw value stored in the Check field.
+        *
+        * Note that CRC32 and CRC64 are stored in little endian byte order.
+        * Take it into account if you display the Check values to the user.
+        *
+        * Written by:
+        *  - lzma_block_encoder()
+        *  - lzma_block_decoder()
+        *  - lzma_block_buffer_encode()
+        *  - lzma_block_buffer_decode()
+        */
+       uint8_t raw_check[LZMA_CHECK_SIZE_MAX];
+
+       /*
+        * Reserved space to allow possible future extensions without
+        * breaking the ABI. You should not touch these, because the names
+        * of these variables may change. These are and will never be used
+        * with the currently supported options, so it is safe to leave these
+        * uninitialized.
+        */
+       void *reserved_ptr1;
+       void *reserved_ptr2;
+       void *reserved_ptr3;
+       uint32_t reserved_int1;
+       uint32_t reserved_int2;
+       lzma_vli reserved_int3;
+       lzma_vli reserved_int4;
+       lzma_vli reserved_int5;
+       lzma_vli reserved_int6;
+       lzma_vli reserved_int7;
+       lzma_vli reserved_int8;
+       lzma_reserved_enum reserved_enum1;
+       lzma_reserved_enum reserved_enum2;
+       lzma_reserved_enum reserved_enum3;
+       lzma_reserved_enum reserved_enum4;
+       lzma_bool reserved_bool1;
+       lzma_bool reserved_bool2;
+       lzma_bool reserved_bool3;
+       lzma_bool reserved_bool4;
+       lzma_bool reserved_bool5;
+       lzma_bool reserved_bool6;
+       lzma_bool reserved_bool7;
+       lzma_bool reserved_bool8;
+
+} lzma_block;
+
+
+/**
+ * \brief       Decode the Block Header Size field
+ *
+ * To decode Block Header using lzma_block_header_decode(), the size of the
+ * Block Header has to be known and stored into lzma_block.header_size.
+ * The size can be calculated from the first byte of a Block using this macro.
+ * Note that if the first byte is 0x00, it indicates beginning of Index; use
+ * this macro only when the byte is not 0x00.
+ *
+ * There is no encoding macro, because Block Header encoder is enough for that.
+ */
+#define lzma_block_header_size_decode(b) (((uint32_t)(b) + 1) * 4)
+
+
+/**
+ * \brief       Calculate Block Header Size
+ *
+ * Calculate the minimum size needed for the Block Header field using the
+ * settings specified in the lzma_block structure. Note that it is OK to
+ * increase the calculated header_size value as long as it is a multiple of
+ * four and doesn't exceed LZMA_BLOCK_HEADER_SIZE_MAX. Increasing header_size
+ * just means that lzma_block_header_encode() will add Header Padding.
+ *
+ * \return      - LZMA_OK: Size calculated successfully and stored to
+ *                block->header_size.
+ *              - LZMA_OPTIONS_ERROR: Unsupported version, filters or
+ *                filter options.
+ *              - LZMA_PROG_ERROR: Invalid values like compressed_size == 0.
+ *
+ * \note        This doesn't check that all the options are valid i.e. this
+ *              may return LZMA_OK even if lzma_block_header_encode() or
+ *              lzma_block_encoder() would fail. If you want to validate the
+ *              filter chain, consider using lzma_memlimit_encoder() which as
+ *              a side-effect validates the filter chain.
+ */
+extern LZMA_API(lzma_ret) lzma_block_header_size(lzma_block *block)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Encode Block Header
+ *
+ * The caller must have calculated the size of the Block Header already with
+ * lzma_block_header_size(). If a value larger than the one calculated by
+ * lzma_block_header_size() is used, the Block Header will be padded to the
+ * specified size.
+ *
+ * \param       out         Beginning of the output buffer. This must be
+ *                          at least block->header_size bytes.
+ * \param       block       Block options to be encoded.
+ *
+ * \return      - LZMA_OK: Encoding was successful. block->header_size
+ *                bytes were written to output buffer.
+ *              - LZMA_OPTIONS_ERROR: Invalid or unsupported options.
+ *              - LZMA_PROG_ERROR: Invalid arguments, for example
+ *                block->header_size is invalid or block->filters is NULL.
+ */
+extern LZMA_API(lzma_ret) lzma_block_header_encode(
+               const lzma_block *block, uint8_t *out)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Decode Block Header
+ *
+ * block->version should be set to the highest value supported by the
+ * application; currently the only possible version is zero. This function
+ * will set version to the lowest value that still supports all the features
+ * required by the Block Header.
+ *
+ * The size of the Block Header must have already been decoded with
+ * lzma_block_header_size_decode() macro and stored to block->header_size.
+ *
+ * block->filters must have been allocated, but they don't need to be
+ * initialized (possible existing filter options are not freed).
+ *
+ * \param       block       Destination for Block options.
+ * \param       allocator   lzma_allocator for custom allocator functions.
+ *                          Set to NULL to use malloc() (and also free()
+ *                          if an error occurs).
+ * \param       in          Beginning of the input buffer. This must be
+ *                          at least block->header_size bytes.
+ *
+ * \return      - LZMA_OK: Decoding was successful. block->header_size
+ *                bytes were read from the input buffer.
+ *              - LZMA_OPTIONS_ERROR: The Block Header specifies some
+ *                unsupported options such as unsupported filters. This can
+ *                happen also if block->version was set to a too low value
+ *                compared to what would be required to properly represent
+ *                the information stored in the Block Header.
+ *              - LZMA_DATA_ERROR: Block Header is corrupt, for example,
+ *                the CRC32 doesn't match.
+ *              - LZMA_PROG_ERROR: Invalid arguments, for example
+ *                block->header_size is invalid or block->filters is NULL.
+ */
+extern LZMA_API(lzma_ret) lzma_block_header_decode(lzma_block *block,
+               lzma_allocator *allocator, const uint8_t *in)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Validate and set Compressed Size according to Unpadded Size
+ *
+ * Block Header stores Compressed Size, but Index has Unpadded Size. If the
+ * application has already parsed the Index and is now decoding Blocks,
+ * it can calculate Compressed Size from Unpadded Size. This function does
+ * exactly that with error checking:
+ *
+ *  - Compressed Size calculated from Unpadded Size must be positive integer,
+ *    that is, Unpadded Size must be big enough that after Block Header and
+ *    Check fields there's still at least one byte for Compressed Size.
+ *
+ *  - If Compressed Size was present in Block Header, the new value
+ *    calculated from Unpadded Size is compared against the value
+ *    from Block Header.
+ *
+ * \note        This function must be called _after_ decoding the Block Header
+ *              field so that it can properly validate Compressed Size if it
+ *              was present in Block Header.
+ *
+ * \return      - LZMA_OK: block->compressed_size was set successfully.
+ *              - LZMA_DATA_ERROR: unpadded_size is too small compared to
+ *                block->header_size and lzma_check_size(block->check).
+ *              - LZMA_PROG_ERROR: Some values are invalid. For example,
+ *                block->header_size must be a multiple of four and
+ *                between 8 and 1024 inclusive.
+ */
+extern LZMA_API(lzma_ret) lzma_block_compressed_size(
+               lzma_block *block, lzma_vli unpadded_size)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Calculate Unpadded Size
+ *
+ * The Index field stores Unpadded Size and Uncompressed Size. The latter
+ * can be taken directly from the lzma_block structure after coding a Block,
+ * but Unpadded Size needs to be calculated from Block Header Size,
+ * Compressed Size, and size of the Check field. This is where this function
+ * is needed.
+ *
+ * \return      Unpadded Size on success, or zero on error.
+ */
+extern LZMA_API(lzma_vli) lzma_block_unpadded_size(const lzma_block *block)
+               lzma_nothrow lzma_attr_pure;
+
+
+/**
+ * \brief       Calculate the total encoded size of a Block
+ *
+ * This is equivalent to lzma_block_unpadded_size() except that the returned
+ * value includes the size of the Block Padding field.
+ *
+ * \return      On success, total encoded size of the Block. On error,
+ *              zero is returned.
+ */
+extern LZMA_API(lzma_vli) lzma_block_total_size(const lzma_block *block)
+               lzma_nothrow lzma_attr_pure;
+
+
+/**
+ * \brief       Initialize .xz Block encoder
+ *
+ * Valid actions for lzma_code() are LZMA_RUN, LZMA_SYNC_FLUSH (only if the
+ * filter chain supports it), and LZMA_FINISH.
+ *
+ * \return      - LZMA_OK: All good, continue with lzma_code().
+ *              - LZMA_MEM_ERROR
+ *              - LZMA_OPTIONS_ERROR
+ *              - LZMA_UNSUPPORTED_CHECK: block->check specifies a Check ID
+ *                that is not supported by this buid of liblzma. Initializing
+ *                the encoder failed.
+ *              - LZMA_PROG_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_block_encoder(
+               lzma_stream *strm, lzma_block *block)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Initialize .xz Block decoder
+ *
+ * Valid actions for lzma_code() are LZMA_RUN and LZMA_FINISH. Using
+ * LZMA_FINISH is not required. It is supported only for convenience.
+ *
+ * \return      - LZMA_OK: All good, continue with lzma_code().
+ *              - LZMA_UNSUPPORTED_CHECK: Initialization was successful, but
+ *                the given Check ID is not supported, thus Check will be
+ *                ignored.
+ *              - LZMA_PROG_ERROR
+ *              - LZMA_MEM_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_block_decoder(
+               lzma_stream *strm, lzma_block *block)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Calculate maximum output size for single-call Block encoding
+ *
+ * This is equivalent to lzma_stream_buffer_bound() but for .xz Blocks.
+ * See the documentation of lzma_stream_buffer_bound().
+ */
+extern LZMA_API(size_t) lzma_block_buffer_bound(size_t uncompressed_size)
+               lzma_nothrow;
+
+
+/**
+ * \brief       Single-call .xz Block encoder
+ *
+ * In contrast to the multi-call encoder initialized with
+ * lzma_block_encoder(), this function encodes also the Block Header. This
+ * is required to make it possible to write appropriate Block Header also
+ * in case the data isn't compressible, and different filter chain has to be
+ * used to encode the data in uncompressed form using uncompressed chunks
+ * of the LZMA2 filter.
+ *
+ * When the data isn't compressible, header_size, compressed_size, and
+ * uncompressed_size are set just like when the data was compressible, but
+ * it is possible that header_size is too small to hold the filter chain
+ * specified in block->filters, because that isn't necessarily the filter
+ * chain that was actually used to encode the data. lzma_block_unpadded_size()
+ * still works normally, because it doesn't read the filters array.
+ *
+ * \param       block       Block options: block->version, block->check,
+ *                          and block->filters must have been initialized.
+ * \param       allocator   lzma_allocator for custom allocator functions.
+ *                          Set to NULL to use malloc() and free().
+ * \param       in          Beginning of the input buffer
+ * \param       in_size     Size of the input buffer
+ * \param       out         Beginning of the output buffer
+ * \param       out_pos     The next byte will be written to out[*out_pos].
+ *                          *out_pos is updated only if encoding succeeds.
+ * \param       out_size    Size of the out buffer; the first byte into
+ *                          which no data is written to is out[out_size].
+ *
+ * \return      - LZMA_OK: Encoding was successful.
+ *              - LZMA_BUF_ERROR: Not enough output buffer space.
+ *              - LZMA_OPTIONS_ERROR
+ *              - LZMA_MEM_ERROR
+ *              - LZMA_DATA_ERROR
+ *              - LZMA_PROG_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_block_buffer_encode(
+               lzma_block *block, lzma_allocator *allocator,
+               const uint8_t *in, size_t in_size,
+               uint8_t *out, size_t *out_pos, size_t out_size)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Single-call .xz Block decoder
+ *
+ * This is single-call equivalent of lzma_block_decoder(), and requires that
+ * the caller has already decoded Block Header and checked its memory usage.
+ *
+ * \param       block       Block options just like with lzma_block_decoder().
+ * \param       allocator   lzma_allocator for custom allocator functions.
+ *                          Set to NULL to use malloc() and free().
+ * \param       in          Beginning of the input buffer
+ * \param       in_pos      The next byte will be read from in[*in_pos].
+ *                          *in_pos is updated only if decoding succeeds.
+ * \param       in_size     Size of the input buffer; the first byte that
+ *                          won't be read is in[in_size].
+ * \param       out         Beginning of the output buffer
+ * \param       out_pos     The next byte will be written to out[*out_pos].
+ *                          *out_pos is updated only if encoding succeeds.
+ * \param       out_size    Size of the out buffer; the first byte into
+ *                          which no data is written to is out[out_size].
+ *
+ * \return      - LZMA_OK: Decoding was successful.
+ *              - LZMA_OPTIONS_ERROR
+ *              - LZMA_DATA_ERROR
+ *              - LZMA_MEM_ERROR
+ *              - LZMA_BUF_ERROR: Output buffer was too small.
+ *              - LZMA_PROG_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_block_buffer_decode(
+               lzma_block *block, lzma_allocator *allocator,
+               const uint8_t *in, size_t *in_pos, size_t in_size,
+               uint8_t *out, size_t *out_pos, size_t out_size)
+               lzma_nothrow;
diff --git a/contrib/xz/src/liblzma/api/lzma/check.h b/contrib/xz/src/liblzma/api/lzma/check.h
new file mode 100644 (file)
index 0000000..6a243db
--- /dev/null
@@ -0,0 +1,150 @@
+/**
+ * \file        lzma/check.h
+ * \brief       Integrity checks
+ */
+
+/*
+ * Author: Lasse Collin
+ *
+ * This file has been put into the public domain.
+ * You can do whatever you want with this file.
+ *
+ * See ../lzma.h for information about liblzma as a whole.
+ */
+
+#ifndef LZMA_H_INTERNAL
+#      error Never include this file directly. Use <lzma.h> instead.
+#endif
+
+
+/**
+ * \brief       Type of the integrity check (Check ID)
+ *
+ * The .xz format supports multiple types of checks that are calculated
+ * from the uncompressed data. They vary in both speed and ability to
+ * detect errors.
+ */
+typedef enum {
+       LZMA_CHECK_NONE     = 0,
+               /**<
+                * No Check is calculated.
+                *
+                * Size of the Check field: 0 bytes
+                */
+
+       LZMA_CHECK_CRC32    = 1,
+               /**<
+                * CRC32 using the polynomial from the IEEE 802.3 standard
+                *
+                * Size of the Check field: 4 bytes
+                */
+
+       LZMA_CHECK_CRC64    = 4,
+               /**<
+                * CRC64 using the polynomial from the ECMA-182 standard
+                *
+                * Size of the Check field: 8 bytes
+                */
+
+       LZMA_CHECK_SHA256   = 10
+               /**<
+                * SHA-256
+                *
+                * Size of the Check field: 32 bytes
+                */
+} lzma_check;
+
+
+/**
+ * \brief       Maximum valid Check ID
+ *
+ * The .xz file format specification specifies 16 Check IDs (0-15). Some
+ * of them are only reserved, that is, no actual Check algorithm has been
+ * assigned. When decoding, liblzma still accepts unknown Check IDs for
+ * future compatibility. If a valid but unsupported Check ID is detected,
+ * liblzma can indicate a warning; see the flags LZMA_TELL_NO_CHECK,
+ * LZMA_TELL_UNSUPPORTED_CHECK, and LZMA_TELL_ANY_CHECK in container.h.
+ */
+#define LZMA_CHECK_ID_MAX 15
+
+
+/**
+ * \brief       Test if the given Check ID is supported
+ *
+ * Return true if the given Check ID is supported by this liblzma build.
+ * Otherwise false is returned. It is safe to call this with a value that
+ * is not in the range [0, 15]; in that case the return value is always false.
+ *
+ * You can assume that LZMA_CHECK_NONE and LZMA_CHECK_CRC32 are always
+ * supported (even if liblzma is built with limited features).
+ */
+extern LZMA_API(lzma_bool) lzma_check_is_supported(lzma_check check)
+               lzma_nothrow lzma_attr_const;
+
+
+/**
+ * \brief       Get the size of the Check field with the given Check ID
+ *
+ * Although not all Check IDs have a check algorithm associated, the size of
+ * every Check is already frozen. This function returns the size (in bytes) of
+ * the Check field with the specified Check ID. The values are:
+ * { 0, 4, 4, 4, 8, 8, 8, 16, 16, 16, 32, 32, 32, 64, 64, 64 }
+ *
+ * If the argument is not in the range [0, 15], UINT32_MAX is returned.
+ */
+extern LZMA_API(uint32_t) lzma_check_size(lzma_check check)
+               lzma_nothrow lzma_attr_const;
+
+
+/**
+ * \brief       Maximum size of a Check field
+ */
+#define LZMA_CHECK_SIZE_MAX 64
+
+
+/**
+ * \brief       Calculate CRC32
+ *
+ * Calculate CRC32 using the polynomial from the IEEE 802.3 standard.
+ *
+ * \param       buf     Pointer to the input buffer
+ * \param       size    Size of the input buffer
+ * \param       crc     Previously returned CRC value. This is used to
+ *                      calculate the CRC of a big buffer in smaller chunks.
+ *                      Set to zero when starting a new calculation.
+ *
+ * \return      Updated CRC value, which can be passed to this function
+ *              again to continue CRC calculation.
+ */
+extern LZMA_API(uint32_t) lzma_crc32(
+               const uint8_t *buf, size_t size, uint32_t crc)
+               lzma_nothrow lzma_attr_pure;
+
+
+/**
+ * \brief       Calculate CRC64
+ *
+ * Calculate CRC64 using the polynomial from the ECMA-182 standard.
+ *
+ * This function is used similarly to lzma_crc32(). See its documentation.
+ */
+extern LZMA_API(uint64_t) lzma_crc64(
+               const uint8_t *buf, size_t size, uint64_t crc)
+               lzma_nothrow lzma_attr_pure;
+
+
+/*
+ * SHA-256 functions are currently not exported to public API.
+ * Contact Lasse Collin if you think it should be.
+ */
+
+
+/**
+ * \brief       Get the type of the integrity check
+ *
+ * This function can be called only immediately after lzma_code() has
+ * returned LZMA_NO_CHECK, LZMA_UNSUPPORTED_CHECK, or LZMA_GET_CHECK.
+ * Calling this function in any other situation has undefined behavior.
+ */
+extern LZMA_API(lzma_check) lzma_get_check(const lzma_stream *strm)
+               lzma_nothrow;
diff --git a/contrib/xz/src/liblzma/api/lzma/container.h b/contrib/xz/src/liblzma/api/lzma/container.h
new file mode 100644 (file)
index 0000000..83e70b4
--- /dev/null
@@ -0,0 +1,412 @@
+/**
+ * \file        lzma/container.h
+ * \brief       File formats
+ */
+
+/*
+ * Author: Lasse Collin
+ *
+ * This file has been put into the public domain.
+ * You can do whatever you want with this file.
+ *
+ * See ../lzma.h for information about liblzma as a whole.
+ */
+
+#ifndef LZMA_H_INTERNAL
+#      error Never include this file directly. Use <lzma.h> instead.
+#endif
+
+
+/************
+ * Encoding *
+ ************/
+
+/**
+ * \brief       Default compression preset
+ *
+ * It's not straightforward to recommend a default preset, because in some
+ * cases keeping the resource usage relatively low is more important that
+ * getting the maximum compression ratio.
+ */
+#define LZMA_PRESET_DEFAULT     UINT32_C(6)
+
+
+/**
+ * \brief       Mask for preset level
+ *
+ * This is useful only if you need to extract the level from the preset
+ * variable. That should be rare.
+ */
+#define LZMA_PRESET_LEVEL_MASK  UINT32_C(0x1F)
+
+
+/*
+ * Preset flags
+ *
+ * Currently only one flag is defined.
+ */
+
+/**
+ * \brief       Extreme compression preset
+ *
+ * This flag modifies the preset to make the encoding significantly slower
+ * while improving the compression ratio only marginally. This is useful
+ * when you don't mind wasting time to get as small result as possible.
+ *
+ * This flag doesn't affect the memory usage requirements of the decoder (at
+ * least not significantly). The memory usage of the encoder may be increased
+ * a little but only at the lowest preset levels (0-3).
+ */
+#define LZMA_PRESET_EXTREME       (UINT32_C(1) << 31)
+
+
+/**
+ * \brief       Calculate approximate memory usage of easy encoder
+ *
+ * This function is a wrapper for lzma_raw_encoder_memusage().
+ *
+ * \param       preset  Compression preset (level and possible flags)
+ */
+extern LZMA_API(uint64_t) lzma_easy_encoder_memusage(uint32_t preset)
+               lzma_nothrow lzma_attr_pure;
+
+
+/**
+ * \brief       Calculate approximate decoder memory usage of a preset
+ *
+ * This function is a wrapper for lzma_raw_decoder_memusage().
+ *
+ * \param       preset  Compression preset (level and possible flags)
+ */
+extern LZMA_API(uint64_t) lzma_easy_decoder_memusage(uint32_t preset)
+               lzma_nothrow lzma_attr_pure;
+
+
+/**
+ * \brief       Initialize .xz Stream encoder using a preset number
+ *
+ * This function is intended for those who just want to use the basic features
+ * if liblzma (that is, most developers out there).
+ *
+ * \param       strm    Pointer to lzma_stream that is at least initialized
+ *                      with LZMA_STREAM_INIT.
+ * \param       preset  Compression preset to use. A preset consist of level
+ *                      number and zero or more flags. Usually flags aren't
+ *                      used, so preset is simply a number [0, 9] which match
+ *                      the options -0 ... -9 of the xz command line tool.
+ *                      Additional flags can be be set using bitwise-or with
+ *                      the preset level number, e.g. 6 | LZMA_PRESET_EXTREME.
+ * \param       check   Integrity check type to use. See check.h for available
+ *                      checks. The xz command line tool defaults to
+ *                      LZMA_CHECK_CRC64, which is a good choice if you are
+ *                      unsure. LZMA_CHECK_CRC32 is good too as long as the
+ *                      uncompressed file is not many gigabytes.
+ *
+ * \return      - LZMA_OK: Initialization succeeded. Use lzma_code() to
+ *                encode your data.
+ *              - LZMA_MEM_ERROR: Memory allocation failed.
+ *              - LZMA_OPTIONS_ERROR: The given compression preset is not
+ *                supported by this build of liblzma.
+ *              - LZMA_UNSUPPORTED_CHECK: The given check type is not
+ *                supported by this liblzma build.
+ *              - LZMA_PROG_ERROR: One or more of the parameters have values
+ *                that will never be valid. For example, strm == NULL.
+ *
+ * If initialization fails (return value is not LZMA_OK), all the memory
+ * allocated for *strm by liblzma is always freed. Thus, there is no need
+ * to call lzma_end() after failed initialization.
+ *
+ * If initialization succeeds, use lzma_code() to do the actual encoding.
+ * Valid values for `action' (the second argument of lzma_code()) are
+ * LZMA_RUN, LZMA_SYNC_FLUSH, LZMA_FULL_FLUSH, and LZMA_FINISH. In future,
+ * there may be compression levels or flags that don't support LZMA_SYNC_FLUSH.
+ */
+extern LZMA_API(lzma_ret) lzma_easy_encoder(
+               lzma_stream *strm, uint32_t preset, lzma_check check)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Single-call .xz Stream encoding using a preset number
+ *
+ * The maximum required output buffer size can be calculated with
+ * lzma_stream_buffer_bound().
+ *
+ * \param       preset      Compression preset to use. See the description
+ *                          in lzma_easy_encoder().
+ * \param       check       Type of the integrity check to calculate from
+ *                          uncompressed data.
+ * \param       allocator   lzma_allocator for custom allocator functions.
+ *                          Set to NULL to use malloc() and free().
+ * \param       in          Beginning of the input buffer
+ * \param       in_size     Size of the input buffer
+ * \param       out         Beginning of the output buffer
+ * \param       out_pos     The next byte will be written to out[*out_pos].
+ *                          *out_pos is updated only if encoding succeeds.
+ * \param       out_size    Size of the out buffer; the first byte into
+ *                          which no data is written to is out[out_size].
+ *
+ * \return      - LZMA_OK: Encoding was successful.
+ *              - LZMA_BUF_ERROR: Not enough output buffer space.
+ *              - LZMA_OPTIONS_ERROR
+ *              - LZMA_MEM_ERROR
+ *              - LZMA_DATA_ERROR
+ *              - LZMA_PROG_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_easy_buffer_encode(
+               uint32_t preset, lzma_check check,
+               lzma_allocator *allocator, const uint8_t *in, size_t in_size,
+               uint8_t *out, size_t *out_pos, size_t out_size) lzma_nothrow;
+
+
+/**
+ * \brief       Initialize .xz Stream encoder using a custom filter chain
+ *
+ * \param       strm    Pointer to properly prepared lzma_stream
+ * \param       filters Array of filters. This must be terminated with
+ *                      filters[n].id = LZMA_VLI_UNKNOWN. See filter.h for
+ *                      more information.
+ * \param       check   Type of the integrity check to calculate from
+ *                      uncompressed data.
+ *
+ * \return      - LZMA_OK: Initialization was successful.
+ *              - LZMA_MEM_ERROR
+ *              - LZMA_OPTIONS_ERROR
+ *              - LZMA_PROG_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_stream_encoder(lzma_stream *strm,
+               const lzma_filter *filters, lzma_check check)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Initialize .lzma encoder (legacy file format)
+ *
+ * The .lzma format is sometimes called the LZMA_Alone format, which is the
+ * reason for the name of this function. The .lzma format supports only the
+ * LZMA1 filter. There is no support for integrity checks like CRC32.
+ *
+ * Use this function if and only if you need to create files readable by
+ * legacy LZMA tools such as LZMA Utils 4.32.x. Moving to the .xz format
+ * is strongly recommended.
+ *
+ * The valid action values for lzma_code() are LZMA_RUN and LZMA_FINISH.
+ * No kind of flushing is supported, because the file format doesn't make
+ * it possible.
+ *
+ * \return      - LZMA_OK
+ *              - LZMA_MEM_ERROR
+ *              - LZMA_OPTIONS_ERROR
+ *              - LZMA_PROG_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_alone_encoder(
+               lzma_stream *strm, const lzma_options_lzma *options)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Calculate output buffer size for single-call Stream encoder
+ *
+ * When trying to compress uncompressible data, the encoded size will be
+ * slightly bigger than the input data. This function calculates how much
+ * output buffer space is required to be sure that lzma_stream_buffer_encode()
+ * doesn't return LZMA_BUF_ERROR.
+ *
+ * The calculated value is not exact, but it is guaranteed to be big enough.
+ * The actual maximum output space required may be slightly smaller (up to
+ * about 100 bytes). This should not be a problem in practice.
+ *
+ * If the calculated maximum size doesn't fit into size_t or would make the
+ * Stream grow past LZMA_VLI_MAX (which should never happen in practice),
+ * zero is returned to indicate the error.
+ *
+ * \note        The limit calculated by this function applies only to
+ *              single-call encoding. Multi-call encoding may (and probably
+ *              will) have larger maximum expansion when encoding
+ *              uncompressible data. Currently there is no function to
+ *              calculate the maximum expansion of multi-call encoding.
+ */
+extern LZMA_API(size_t) lzma_stream_buffer_bound(size_t uncompressed_size)
+               lzma_nothrow;
+
+
+/**
+ * \brief       Single-call .xz Stream encoder
+ *
+ * \param       filters     Array of filters. This must be terminated with
+ *                          filters[n].id = LZMA_VLI_UNKNOWN. See filter.h
+ *                          for more information.
+ * \param       check       Type of the integrity check to calculate from
+ *                          uncompressed data.
+ * \param       allocator   lzma_allocator for custom allocator functions.
+ *                          Set to NULL to use malloc() and free().
+ * \param       in          Beginning of the input buffer
+ * \param       in_size     Size of the input buffer
+ * \param       out         Beginning of the output buffer
+ * \param       out_pos     The next byte will be written to out[*out_pos].
+ *                          *out_pos is updated only if encoding succeeds.
+ * \param       out_size    Size of the out buffer; the first byte into
+ *                          which no data is written to is out[out_size].
+ *
+ * \return      - LZMA_OK: Encoding was successful.
+ *              - LZMA_BUF_ERROR: Not enough output buffer space.
+ *              - LZMA_OPTIONS_ERROR
+ *              - LZMA_MEM_ERROR
+ *              - LZMA_DATA_ERROR
+ *              - LZMA_PROG_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_stream_buffer_encode(
+               lzma_filter *filters, lzma_check check,
+               lzma_allocator *allocator, const uint8_t *in, size_t in_size,
+               uint8_t *out, size_t *out_pos, size_t out_size)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/************
+ * Decoding *
+ ************/
+
+/**
+ * This flag makes lzma_code() return LZMA_NO_CHECK if the input stream
+ * being decoded has no integrity check. Note that when used with
+ * lzma_auto_decoder(), all .lzma files will trigger LZMA_NO_CHECK
+ * if LZMA_TELL_NO_CHECK is used.
+ */
+#define LZMA_TELL_NO_CHECK              UINT32_C(0x01)
+
+
+/**
+ * This flag makes lzma_code() return LZMA_UNSUPPORTED_CHECK if the input
+ * stream has an integrity check, but the type of the integrity check is not
+ * supported by this liblzma version or build. Such files can still be
+ * decoded, but the integrity check cannot be verified.
+ */
+#define LZMA_TELL_UNSUPPORTED_CHECK     UINT32_C(0x02)
+
+
+/**
+ * This flag makes lzma_code() return LZMA_GET_CHECK as soon as the type
+ * of the integrity check is known. The type can then be got with
+ * lzma_get_check().
+ */
+#define LZMA_TELL_ANY_CHECK             UINT32_C(0x04)
+
+
+/**
+ * This flag enables decoding of concatenated files with file formats that
+ * allow concatenating compressed files as is. From the formats currently
+ * supported by liblzma, only the .xz format allows concatenated files.
+ * Concatenated files are not allowed with the legacy .lzma format.
+ *
+ * This flag also affects the usage of the `action' argument for lzma_code().
+ * When LZMA_CONCATENATED is used, lzma_code() won't return LZMA_STREAM_END
+ * unless LZMA_FINISH is used as `action'. Thus, the application has to set
+ * LZMA_FINISH in the same way as it does when encoding.
+ *
+ * If LZMA_CONCATENATED is not used, the decoders still accept LZMA_FINISH
+ * as `action' for lzma_code(), but the usage of LZMA_FINISH isn't required.
+ */
+#define LZMA_CONCATENATED               UINT32_C(0x08)
+
+
+/**
+ * \brief       Initialize .xz Stream decoder
+ *
+ * \param       strm        Pointer to properly prepared lzma_stream
+ * \param       memlimit    Memory usage limit as bytes. Use UINT64_MAX
+ *                          to effectively disable the limiter.
+ * \param       flags       Bitwise-or of zero or more of the decoder flags:
+ *                          LZMA_TELL_NO_CHECK, LZMA_TELL_UNSUPPORTED_CHECK,
+ *                          LZMA_TELL_ANY_CHECK, LZMA_CONCATENATED
+ *
+ * \return      - LZMA_OK: Initialization was successful.
+ *              - LZMA_MEM_ERROR: Cannot allocate memory.
+ *              - LZMA_OPTIONS_ERROR: Unsupported flags
+ *              - LZMA_PROG_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_stream_decoder(
+               lzma_stream *strm, uint64_t memlimit, uint32_t flags)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Decode .xz Streams and .lzma files with autodetection
+ *
+ * This decoder autodetects between the .xz and .lzma file formats, and
+ * calls lzma_stream_decoder() or lzma_alone_decoder() once the type
+ * of the input file has been detected.
+ *
+ * \param       strm        Pointer to properly prepared lzma_stream
+ * \param       memlimit    Memory usage limit as bytes. Use UINT64_MAX
+ *                          to effectively disable the limiter.
+ * \param       flags       Bitwise-or of flags, or zero for no flags.
+ *
+ * \return      - LZMA_OK: Initialization was successful.
+ *              - LZMA_MEM_ERROR: Cannot allocate memory.
+ *              - LZMA_OPTIONS_ERROR: Unsupported flags
+ *              - LZMA_PROG_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_auto_decoder(
+               lzma_stream *strm, uint64_t memlimit, uint32_t flags)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Initialize .lzma decoder (legacy file format)
+ *
+ * Valid `action' arguments to lzma_code() are LZMA_RUN and LZMA_FINISH.
+ * There is no need to use LZMA_FINISH, but allowing it may simplify
+ * certain types of applications.
+ *
+ * \return      - LZMA_OK
+ *              - LZMA_MEM_ERROR
+ *              - LZMA_PROG_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_alone_decoder(
+               lzma_stream *strm, uint64_t memlimit)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Single-call .xz Stream decoder
+ *
+ * \param       memlimit    Pointer to how much memory the decoder is allowed
+ *                          to allocate. The value pointed by this pointer is
+ *                          modified if and only if LZMA_MEMLIMIT_ERROR is
+ *                          returned.
+ * \param       flags       Bitwise-or of zero or more of the decoder flags:
+ *                          LZMA_TELL_NO_CHECK, LZMA_TELL_UNSUPPORTED_CHECK,
+ *                          LZMA_CONCATENATED. Note that LZMA_TELL_ANY_CHECK
+ *                          is not allowed and will return LZMA_PROG_ERROR.
+ * \param       allocator   lzma_allocator for custom allocator functions.
+ *                          Set to NULL to use malloc() and free().
+ * \param       in          Beginning of the input buffer
+ * \param       in_pos      The next byte will be read from in[*in_pos].
+ *                          *in_pos is updated only if decoding succeeds.
+ * \param       in_size     Size of the input buffer; the first byte that
+ *                          won't be read is in[in_size].
+ * \param       out         Beginning of the output buffer
+ * \param       out_pos     The next byte will be written to out[*out_pos].
+ *                          *out_pos is updated only if decoding succeeds.
+ * \param       out_size    Size of the out buffer; the first byte into
+ *                          which no data is written to is out[out_size].
+ *
+ * \return      - LZMA_OK: Decoding was successful.
+ *              - LZMA_FORMAT_ERROR
+ *              - LZMA_OPTIONS_ERROR
+ *              - LZMA_DATA_ERROR
+ *              - LZMA_NO_CHECK: This can be returned only if using
+ *                the LZMA_TELL_NO_CHECK flag.
+ *              - LZMA_UNSUPPORTED_CHECK: This can be returned only if using
+ *                the LZMA_TELL_UNSUPPORTED_CHECK flag.
+ *              - LZMA_MEM_ERROR
+ *              - LZMA_MEMLIMIT_ERROR: Memory usage limit was reached.
+ *                The minimum required memlimit value was stored to *memlimit.
+ *              - LZMA_BUF_ERROR: Output buffer was too small.
+ *              - LZMA_PROG_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_stream_buffer_decode(
+               uint64_t *memlimit, uint32_t flags, lzma_allocator *allocator,
+               const uint8_t *in, size_t *in_pos, size_t in_size,
+               uint8_t *out, size_t *out_pos, size_t out_size)
+               lzma_nothrow lzma_attr_warn_unused_result;
diff --git a/contrib/xz/src/liblzma/api/lzma/delta.h b/contrib/xz/src/liblzma/api/lzma/delta.h
new file mode 100644 (file)
index 0000000..592fc4f
--- /dev/null
@@ -0,0 +1,77 @@
+/**
+ * \file        lzma/delta.h
+ * \brief       Delta filter
+ */
+
+/*
+ * Author: Lasse Collin
+ *
+ * This file has been put into the public domain.
+ * You can do whatever you want with this file.
+ *
+ * See ../lzma.h for information about liblzma as a whole.
+ */
+
+#ifndef LZMA_H_INTERNAL
+#      error Never include this file directly. Use <lzma.h> instead.
+#endif
+
+
+/**
+ * \brief       Filter ID
+ *
+ * Filter ID of the Delta filter. This is used as lzma_filter.id.
+ */
+#define LZMA_FILTER_DELTA       LZMA_VLI_C(0x03)
+
+
+/**
+ * \brief       Type of the delta calculation
+ *
+ * Currently only byte-wise delta is supported. Other possible types could
+ * be, for example, delta of 16/32/64-bit little/big endian integers, but
+ * these are not currently planned since byte-wise delta is almost as good.
+ */
+typedef enum {
+       LZMA_DELTA_TYPE_BYTE
+} lzma_delta_type;
+
+
+/**
+ * \brief       Options for the Delta filter
+ *
+ * These options are needed by both encoder and decoder.
+ */
+typedef struct {
+       /** For now, this must always be LZMA_DELTA_TYPE_BYTE. */
+       lzma_delta_type type;
+
+       /**
+        * \brief       Delta distance
+        *
+        * With the only currently supported type, LZMA_DELTA_TYPE_BYTE,
+        * the distance is as bytes.
+        *
+        * Examples:
+        *  - 16-bit stereo audio: distance = 4 bytes
+        *  - 24-bit RGB image data: distance = 3 bytes
+        */
+       uint32_t dist;
+#      define LZMA_DELTA_DIST_MIN 1
+#      define LZMA_DELTA_DIST_MAX 256
+
+       /*
+        * Reserved space to allow possible future extensions without
+        * breaking the ABI. You should not touch these, because the names
+        * of these variables may change. These are and will never be used
+        * when type is LZMA_DELTA_TYPE_BYTE, so it is safe to leave these
+        * uninitialized.
+        */
+       uint32_t reserved_int1;
+       uint32_t reserved_int2;
+       uint32_t reserved_int3;
+       uint32_t reserved_int4;
+       void *reserved_ptr1;
+       void *reserved_ptr2;
+
+} lzma_options_delta;
diff --git a/contrib/xz/src/liblzma/api/lzma/filter.h b/contrib/xz/src/liblzma/api/lzma/filter.h
new file mode 100644 (file)
index 0000000..efd036f
--- /dev/null
@@ -0,0 +1,420 @@
+/**
+ * \file        lzma/filter.h
+ * \brief       Common filter related types and functions
+ */
+
+/*
+ * Author: Lasse Collin
+ *
+ * This file has been put into the public domain.
+ * You can do whatever you want with this file.
+ *
+ * See ../lzma.h for information about liblzma as a whole.
+ */
+
+#ifndef LZMA_H_INTERNAL
+#      error Never include this file directly. Use <lzma.h> instead.
+#endif
+
+
+/**
+ * \brief       Maximum number of filters in a chain
+ *
+ * A filter chain can have 1-4 filters, of which three are allowed to change
+ * the size of the data. Usually only one or two filters are needed.
+ */
+#define LZMA_FILTERS_MAX 4
+
+
+/**
+ * \brief       Filter options
+ *
+ * This structure is used to pass Filter ID and a pointer filter's
+ * options to liblzma. A few functions work with a single lzma_filter
+ * structure, while most functions expect a filter chain.
+ *
+ * A filter chain is indicated with an array of lzma_filter structures.
+ * The array is terminated with .id = LZMA_VLI_UNKNOWN. Thus, the filter
+ * array must have LZMA_FILTERS_MAX + 1 elements (that is, five) to
+ * be able to hold any arbitrary filter chain. This is important when
+ * using lzma_block_header_decode() from block.h, because too small
+ * array would make liblzma write past the end of the filters array.
+ */
+typedef struct {
+       /**
+        * \brief       Filter ID
+        *
+        * Use constants whose name begin with `LZMA_FILTER_' to specify
+        * different filters. In an array of lzma_filter structures, use
+        * LZMA_VLI_UNKNOWN to indicate end of filters.
+        *
+        * \note        This is not an enum, because on some systems enums
+        *              cannot be 64-bit.
+        */
+       lzma_vli id;
+
+       /**
+        * \brief       Pointer to filter-specific options structure
+        *
+        * If the filter doesn't need options, set this to NULL. If id is
+        * set to LZMA_VLI_UNKNOWN, options is ignored, and thus
+        * doesn't need be initialized.
+        */
+       void *options;
+
+} lzma_filter;
+
+
+/**
+ * \brief       Test if the given Filter ID is supported for encoding
+ *
+ * Return true if the give Filter ID is supported for encoding by this
+ * liblzma build. Otherwise false is returned.
+ *
+ * There is no way to list which filters are available in this particular
+ * liblzma version and build. It would be useless, because the application
+ * couldn't know what kind of options the filter would need.
+ */
+extern LZMA_API(lzma_bool) lzma_filter_encoder_is_supported(lzma_vli id)
+               lzma_nothrow lzma_attr_const;
+
+
+/**
+ * \brief       Test if the given Filter ID is supported for decoding
+ *
+ * Return true if the give Filter ID is supported for decoding by this
+ * liblzma build. Otherwise false is returned.
+ */
+extern LZMA_API(lzma_bool) lzma_filter_decoder_is_supported(lzma_vli id)
+               lzma_nothrow lzma_attr_const;
+
+
+/**
+ * \brief       Copy the filters array
+ *
+ * Copy the Filter IDs and filter-specific options from src to dest.
+ * Up to LZMA_FILTERS_MAX filters are copied, plus the terminating
+ * .id == LZMA_VLI_UNKNOWN. Thus, dest should have at least
+ * LZMA_FILTERS_MAX + 1 elements space unless the caller knows that
+ * src is smaller than that.
+ *
+ * Unless the filter-specific options is NULL, the Filter ID has to be
+ * supported by liblzma, because liblzma needs to know the size of every
+ * filter-specific options structure. The filter-specific options are not
+ * validated. If options is NULL, any unsupported Filter IDs are copied
+ * without returning an error.
+ *
+ * Old filter-specific options in dest are not freed, so dest doesn't
+ * need to be initialized by the caller in any way.
+ *
+ * If an error occurs, memory possibly already allocated by this function
+ * is always freed.
+ *
+ * \return      - LZMA_OK
+ *              - LZMA_MEM_ERROR
+ *              - LZMA_OPTIONS_ERROR: Unsupported Filter ID and its options
+ *                is not NULL.
+ *              - LZMA_PROG_ERROR: src or dest is NULL.
+ */
+extern LZMA_API(lzma_ret) lzma_filters_copy(const lzma_filter *src,
+               lzma_filter *dest, lzma_allocator *allocator) lzma_nothrow;
+
+
+/**
+ * \brief       Calculate approximate memory requirements for raw encoder
+ *
+ * This function can be used to calculate the memory requirements for
+ * Block and Stream encoders too because Block and Stream encoders don't
+ * need significantly more memory than raw encoder.
+ *
+ * \param       filters     Array of filters terminated with
+ *                          .id == LZMA_VLI_UNKNOWN.
+ *
+ * \return      Number of bytes of memory required for the given
+ *              filter chain when encoding.
+ */
+extern LZMA_API(uint64_t) lzma_raw_encoder_memusage(const lzma_filter *filters)
+               lzma_nothrow lzma_attr_pure;
+
+
+/**
+ * \brief       Calculate approximate memory requirements for raw decoder
+ *
+ * This function can be used to calculate the memory requirements for
+ * Block and Stream decoders too because Block and Stream decoders don't
+ * need significantly more memory than raw decoder.
+ *
+ * \param       filters     Array of filters terminated with
+ *                          .id == LZMA_VLI_UNKNOWN.
+ *
+ * \return      Number of bytes of memory required for the given
+ *              filter chain when decoding.
+ */
+extern LZMA_API(uint64_t) lzma_raw_decoder_memusage(const lzma_filter *filters)
+               lzma_nothrow lzma_attr_pure;
+
+
+/**
+ * \brief       Initialize raw encoder
+ *
+ * This function may be useful when implementing custom file formats.
+ *
+ * \param       strm    Pointer to properly prepared lzma_stream
+ * \param       filters Array of lzma_filter structures. The end of the
+ *                      array must be marked with .id = LZMA_VLI_UNKNOWN.
+ *
+ * The `action' with lzma_code() can be LZMA_RUN, LZMA_SYNC_FLUSH (if the
+ * filter chain supports it), or LZMA_FINISH.
+ *
+ * \return      - LZMA_OK
+ *              - LZMA_MEM_ERROR
+ *              - LZMA_OPTIONS_ERROR
+ *              - LZMA_PROG_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_raw_encoder(
+               lzma_stream *strm, const lzma_filter *filters)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Initialize raw decoder
+ *
+ * The initialization of raw decoder goes similarly to raw encoder.
+ *
+ * The `action' with lzma_code() can be LZMA_RUN or LZMA_FINISH. Using
+ * LZMA_FINISH is not required, it is supported just for convenience.
+ *
+ * \return      - LZMA_OK
+ *              - LZMA_MEM_ERROR
+ *              - LZMA_OPTIONS_ERROR
+ *              - LZMA_PROG_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_raw_decoder(
+               lzma_stream *strm, const lzma_filter *filters)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Update the filter chain in the encoder
+ *
+ * This function is for advanced users only. This function has two slightly
+ * different purposes:
+ *
+ *  - After LZMA_FULL_FLUSH when using Stream encoder: Set a new filter
+ *    chain, which will be used starting from the next Block.
+ *
+ *  - After LZMA_SYNC_FLUSH using Raw, Block, or Stream encoder: Change
+ *    the filter-specific options in the middle of encoding. The actual
+ *    filters in the chain (Filter IDs) cannot be changed. In the future,
+ *    it might become possible to change the filter options without
+ *    using LZMA_SYNC_FLUSH.
+ *
+ * While rarely useful, this function may be called also when no data has
+ * been compressed yet. In that case, this function will behave as if
+ * LZMA_FULL_FLUSH (Stream encoder) or LZMA_SYNC_FLUSH (Raw or Block
+ * encoder) had been used right before calling this function.
+ *
+ * \return      - LZMA_OK
+ *              - LZMA_MEM_ERROR
+ *              - LZMA_MEMLIMIT_ERROR
+ *              - LZMA_OPTIONS_ERROR
+ *              - LZMA_PROG_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_filters_update(
+               lzma_stream *strm, const lzma_filter *filters) lzma_nothrow;
+
+
+/**
+ * \brief       Single-call raw encoder
+ *
+ * \param       filters     Array of lzma_filter structures. The end of the
+ *                          array must be marked with .id = LZMA_VLI_UNKNOWN.
+ * \param       allocator   lzma_allocator for custom allocator functions.
+ *                          Set to NULL to use malloc() and free().
+ * \param       in          Beginning of the input buffer
+ * \param       in_size     Size of the input buffer
+ * \param       out         Beginning of the output buffer
+ * \param       out_pos     The next byte will be written to out[*out_pos].
+ *                          *out_pos is updated only if encoding succeeds.
+ * \param       out_size    Size of the out buffer; the first byte into
+ *                          which no data is written to is out[out_size].
+ *
+ * \return      - LZMA_OK: Encoding was successful.
+ *              - LZMA_BUF_ERROR: Not enough output buffer space.
+ *              - LZMA_OPTIONS_ERROR
+ *              - LZMA_MEM_ERROR
+ *              - LZMA_DATA_ERROR
+ *              - LZMA_PROG_ERROR
+ *
+ * \note        There is no function to calculate how big output buffer
+ *              would surely be big enough. (lzma_stream_buffer_bound()
+ *              works only for lzma_stream_buffer_encode(); raw encoder
+ *              won't necessarily meet that bound.)
+ */
+extern LZMA_API(lzma_ret) lzma_raw_buffer_encode(
+               const lzma_filter *filters, lzma_allocator *allocator,
+               const uint8_t *in, size_t in_size, uint8_t *out,
+               size_t *out_pos, size_t out_size) lzma_nothrow;
+
+
+/**
+ * \brief       Single-call raw decoder
+ *
+ * \param       filters     Array of lzma_filter structures. The end of the
+ *                          array must be marked with .id = LZMA_VLI_UNKNOWN.
+ * \param       allocator   lzma_allocator for custom allocator functions.
+ *                          Set to NULL to use malloc() and free().
+ * \param       in          Beginning of the input buffer
+ * \param       in_pos      The next byte will be read from in[*in_pos].
+ *                          *in_pos is updated only if decoding succeeds.
+ * \param       in_size     Size of the input buffer; the first byte that
+ *                          won't be read is in[in_size].
+ * \param       out         Beginning of the output buffer
+ * \param       out_pos     The next byte will be written to out[*out_pos].
+ *                          *out_pos is updated only if encoding succeeds.
+ * \param       out_size    Size of the out buffer; the first byte into
+ *                          which no data is written to is out[out_size].
+ */
+extern LZMA_API(lzma_ret) lzma_raw_buffer_decode(
+               const lzma_filter *filters, lzma_allocator *allocator,
+               const uint8_t *in, size_t *in_pos, size_t in_size,
+               uint8_t *out, size_t *out_pos, size_t out_size) lzma_nothrow;
+
+
+/**
+ * \brief       Get the size of the Filter Properties field
+ *
+ * This function may be useful when implementing custom file formats
+ * using the raw encoder and decoder.
+ *
+ * \param       size    Pointer to uint32_t to hold the size of the properties
+ * \param       filter  Filter ID and options (the size of the properties may
+ *                      vary depending on the options)
+ *
+ * \return      - LZMA_OK
+ *              - LZMA_OPTIONS_ERROR
+ *              - LZMA_PROG_ERROR
+ *
+ * \note        This function validates the Filter ID, but does not
+ *              necessarily validate the options. Thus, it is possible
+ *              that this returns LZMA_OK while the following call to
+ *              lzma_properties_encode() returns LZMA_OPTIONS_ERROR.
+ */
+extern LZMA_API(lzma_ret) lzma_properties_size(
+               uint32_t *size, const lzma_filter *filter) lzma_nothrow;
+
+
+/**
+ * \brief       Encode the Filter Properties field
+ *
+ * \param       filter  Filter ID and options
+ * \param       props   Buffer to hold the encoded options. The size of
+ *                      buffer must have been already determined with
+ *                      lzma_properties_size().
+ *
+ * \return      - LZMA_OK
+ *              - LZMA_OPTIONS_ERROR
+ *              - LZMA_PROG_ERROR
+ *
+ * \note        Even this function won't validate more options than actually
+ *              necessary. Thus, it is possible that encoding the properties
+ *              succeeds but using the same options to initialize the encoder
+ *              will fail.
+ *
+ * \note        If lzma_properties_size() indicated that the size
+ *              of the Filter Properties field is zero, calling
+ *              lzma_properties_encode() is not required, but it
+ *              won't do any harm either.
+ */
+extern LZMA_API(lzma_ret) lzma_properties_encode(
+               const lzma_filter *filter, uint8_t *props) lzma_nothrow;
+
+
+/**
+ * \brief       Decode the Filter Properties field
+ *
+ * \param       filter      filter->id must have been set to the correct
+ *                          Filter ID. filter->options doesn't need to be
+ *                          initialized (it's not freed by this function). The
+ *                          decoded options will be stored to filter->options.
+ *                          filter->options is set to NULL if there are no
+ *                          properties or if an error occurs.
+ * \param       allocator   Custom memory allocator used to allocate the
+ *                          options. Set to NULL to use the default malloc(),
+ *                          and in case of an error, also free().
+ * \param       props       Input buffer containing the properties.
+ * \param       props_size  Size of the properties. This must be the exact
+ *                          size; giving too much or too little input will
+ *                          return LZMA_OPTIONS_ERROR.
+ *
+ * \return      - LZMA_OK
+ *              - LZMA_OPTIONS_ERROR
+ *              - LZMA_MEM_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_properties_decode(
+               lzma_filter *filter, lzma_allocator *allocator,
+               const uint8_t *props, size_t props_size) lzma_nothrow;
+
+
+/**
+ * \brief       Calculate encoded size of a Filter Flags field
+ *
+ * Knowing the size of Filter Flags is useful to know when allocating
+ * memory to hold the encoded Filter Flags.
+ *
+ * \param       size    Pointer to integer to hold the calculated size
+ * \param       filter  Filter ID and associated options whose encoded
+ *                      size is to be calculated
+ *
+ * \return      - LZMA_OK: *size set successfully. Note that this doesn't
+ *                guarantee that filter->options is valid, thus
+ *                lzma_filter_flags_encode() may still fail.
+ *              - LZMA_OPTIONS_ERROR: Unknown Filter ID or unsupported options.
+ *              - LZMA_PROG_ERROR: Invalid options
+ *
+ * \note        If you need to calculate size of List of Filter Flags,
+ *              you need to loop over every lzma_filter entry.
+ */
+extern LZMA_API(lzma_ret) lzma_filter_flags_size(
+               uint32_t *size, const lzma_filter *filter)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Encode Filter Flags into given buffer
+ *
+ * In contrast to some functions, this doesn't allocate the needed buffer.
+ * This is due to how this function is used internally by liblzma.
+ *
+ * \param       filter      Filter ID and options to be encoded
+ * \param       out         Beginning of the output buffer
+ * \param       out_pos     out[*out_pos] is the next write position. This
+ *                          is updated by the encoder.
+ * \param       out_size    out[out_size] is the first byte to not write.
+ *
+ * \return      - LZMA_OK: Encoding was successful.
+ *              - LZMA_OPTIONS_ERROR: Invalid or unsupported options.
+ *              - LZMA_PROG_ERROR: Invalid options or not enough output
+ *                buffer space (you should have checked it with
+ *                lzma_filter_flags_size()).
+ */
+extern LZMA_API(lzma_ret) lzma_filter_flags_encode(const lzma_filter *filter,
+               uint8_t *out, size_t *out_pos, size_t out_size)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Decode Filter Flags from given buffer
+ *
+ * The decoded result is stored into *filter. The old value of
+ * filter->options is not free()d.
+ *
+ * \return      - LZMA_OK
+ *              - LZMA_OPTIONS_ERROR
+ *              - LZMA_MEM_ERROR
+ *              - LZMA_PROG_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_filter_flags_decode(
+               lzma_filter *filter, lzma_allocator *allocator,
+               const uint8_t *in, size_t *in_pos, size_t in_size)
+               lzma_nothrow lzma_attr_warn_unused_result;
diff --git a/contrib/xz/src/liblzma/api/lzma/hardware.h b/contrib/xz/src/liblzma/api/lzma/hardware.h
new file mode 100644 (file)
index 0000000..e7dd03c
--- /dev/null
@@ -0,0 +1,50 @@
+/**
+ * \file        lzma/hardware.h
+ * \brief       Hardware information
+ *
+ * Since liblzma can consume a lot of system resources, it also provides
+ * ways to limit the resource usage. Applications linking against liblzma
+ * need to do the actual decisions how much resources to let liblzma to use.
+ * To ease making these decisions, liblzma provides functions to find out
+ * the relevant capabilities of the underlaying hardware. Currently there
+ * is only a function to find out the amount of RAM, but in the future there
+ * will be also a function to detect how many concurrent threads the system
+ * can run.
+ *
+ * \note        On some operating systems, these function may temporarily
+ *              load a shared library or open file descriptor(s) to find out
+ *              the requested hardware information. Unless the application
+ *              assumes that specific file descriptors are not touched by
+ *              other threads, this should have no effect on thread safety.
+ *              Possible operations involving file descriptors will restart
+ *              the syscalls if they return EINTR.
+ */
+
+/*
+ * Author: Lasse Collin
+ *
+ * This file has been put into the public domain.
+ * You can do whatever you want with this file.
+ *
+ * See ../lzma.h for information about liblzma as a whole.
+ */
+
+#ifndef LZMA_H_INTERNAL
+#      error Never include this file directly. Use <lzma.h> instead.
+#endif
+
+
+/**
+ * \brief       Get the total amount of physical memory (RAM) in bytes
+ *
+ * This function may be useful when determining a reasonable memory
+ * usage limit for decompressing or how much memory it is OK to use
+ * for compressing.
+ *
+ * \return      On success, the total amount of physical memory in bytes
+ *              is returned. If the amount of RAM cannot be determined,
+ *              zero is returned. This can happen if an error occurs
+ *              or if there is no code in liblzma to detect the amount
+ *              of RAM on the specific operating system.
+ */
+extern LZMA_API(uint64_t) lzma_physmem(void) lzma_nothrow;
diff --git a/contrib/xz/src/liblzma/api/lzma/index.h b/contrib/xz/src/liblzma/api/lzma/index.h
new file mode 100644 (file)
index 0000000..16bacc2
--- /dev/null
@@ -0,0 +1,682 @@
+/**
+ * \file        lzma/index.h
+ * \brief       Handling of .xz Index and related information
+ */
+
+/*
+ * Author: Lasse Collin
+ *
+ * This file has been put into the public domain.
+ * You can do whatever you want with this file.
+ *
+ * See ../lzma.h for information about liblzma as a whole.
+ */
+
+#ifndef LZMA_H_INTERNAL
+#      error Never include this file directly. Use <lzma.h> instead.
+#endif
+
+
+/**
+ * \brief       Opaque data type to hold the Index(es) and other information
+ *
+ * lzma_index often holds just one .xz Index and possibly the Stream Flags
+ * of the same Stream and size of the Stream Padding field. However,
+ * multiple lzma_indexes can be concatenated with lzma_index_cat() and then
+ * there may be information about multiple Streams in the same lzma_index.
+ *
+ * Notes about thread safety: Only one thread may modify lzma_index at
+ * a time. All functions that take non-const pointer to lzma_index
+ * modify it. As long as no thread is modifying the lzma_index, getting
+ * information from the same lzma_index can be done from multiple threads
+ * at the same time with functions that take a const pointer to
+ * lzma_index or use lzma_index_iter. The same iterator must be used
+ * only by one thread at a time, of course, but there can be as many
+ * iterators for the same lzma_index as needed.
+ */
+typedef struct lzma_index_s lzma_index;
+
+
+/**
+ * \brief       Iterator to get information about Blocks and Streams
+ */
+typedef struct {
+       struct {
+               /**
+                * \brief       Pointer to Stream Flags
+                *
+                * This is NULL if Stream Flags have not been set for
+                * this Stream with lzma_index_stream_flags().
+                */
+               const lzma_stream_flags *flags;
+
+               const void *reserved_ptr1;
+               const void *reserved_ptr2;
+               const void *reserved_ptr3;
+
+               /**
+                * \brief       Stream number in the lzma_index
+                *
+                * The first Stream is 1.
+                */
+               lzma_vli number;
+
+               /**
+                * \brief       Number of Blocks in the Stream
+                *
+                * If this is zero, the block structure below has
+                * undefined values.
+                */
+               lzma_vli block_count;
+
+               /**
+                * \brief       Compressed start offset of this Stream
+                *
+                * The offset is relative to the beginning of the lzma_index
+                * (i.e. usually the beginning of the .xz file).
+                */
+               lzma_vli compressed_offset;
+
+               /**
+                * \brief       Uncompressed start offset of this Stream
+                *
+                * The offset is relative to the beginning of the lzma_index
+                * (i.e. usually the beginning of the .xz file).
+                */
+               lzma_vli uncompressed_offset;
+
+               /**
+                * \brief       Compressed size of this Stream
+                *
+                * This includes all headers except the possible
+                * Stream Padding after this Stream.
+                */
+               lzma_vli compressed_size;
+
+               /**
+                * \brief       Uncompressed size of this Stream
+                */
+               lzma_vli uncompressed_size;
+
+               /**
+                * \brief       Size of Stream Padding after this Stream
+                *
+                * If it hasn't been set with lzma_index_stream_padding(),
+                * this defaults to zero. Stream Padding is always
+                * a multiple of four bytes.
+                */
+               lzma_vli padding;
+
+               lzma_vli reserved_vli1;
+               lzma_vli reserved_vli2;
+               lzma_vli reserved_vli3;
+               lzma_vli reserved_vli4;
+       } stream;
+
+       struct {
+               /**
+                * \brief       Block number in the file
+                *
+                * The first Block is 1.
+                */
+               lzma_vli number_in_file;
+
+               /**
+                * \brief       Compressed start offset of this Block
+                *
+                * This offset is relative to the beginning of the
+                * lzma_index (i.e. usually the beginning of the .xz file).
+                * Normally this is where you should seek in the .xz file
+                * to start decompressing this Block.
+                */
+               lzma_vli compressed_file_offset;
+
+               /**
+                * \brief       Uncompressed start offset of this Block
+                *
+                * This offset is relative to the beginning of the lzma_index
+                * (i.e. usually the beginning of the .xz file).
+                *
+                * When doing random-access reading, it is possible that
+                * the target offset is not exactly at Block boundary. One
+                * will need to compare the target offset against
+                * uncompressed_file_offset or uncompressed_stream_offset,
+                * and possibly decode and throw away some amount of data
+                * before reaching the target offset.
+                */
+               lzma_vli uncompressed_file_offset;
+
+               /**
+                * \brief       Block number in this Stream
+                *
+                * The first Block is 1.
+                */
+               lzma_vli number_in_stream;
+
+               /**
+                * \brief       Compressed start offset of this Block
+                *
+                * This offset is relative to the beginning of the Stream
+                * containing this Block.
+                */
+               lzma_vli compressed_stream_offset;
+
+               /**
+                * \brief       Uncompressed start offset of this Block
+                *
+                * This offset is relative to the beginning of the Stream
+                * containing this Block.
+                */
+               lzma_vli uncompressed_stream_offset;
+
+               /**
+                * \brief       Uncompressed size of this Block
+                *
+                * You should pass this to the Block decoder if you will
+                * decode this Block. It will allow the Block decoder to
+                * validate the uncompressed size.
+                */
+               lzma_vli uncompressed_size;
+
+               /**
+                * \brief       Unpadded size of this Block
+                *
+                * You should pass this to the Block decoder if you will
+                * decode this Block. It will allow the Block decoder to
+                * validate the unpadded size.
+                */
+               lzma_vli unpadded_size;
+
+               /**
+                * \brief       Total compressed size
+                *
+                * This includes all headers and padding in this Block.
+                * This is useful if you need to know how many bytes
+                * the Block decoder will actually read.
+                */
+               lzma_vli total_size;
+
+               lzma_vli reserved_vli1;
+               lzma_vli reserved_vli2;
+               lzma_vli reserved_vli3;
+               lzma_vli reserved_vli4;
+
+               const void *reserved_ptr1;
+               const void *reserved_ptr2;
+               const void *reserved_ptr3;
+               const void *reserved_ptr4;
+       } block;
+
+       /*
+        * Internal data which is used to store the state of the iterator.
+        * The exact format may vary between liblzma versions, so don't
+        * touch these in any way.
+        */
+       union {
+               const void *p;
+               size_t s;
+               lzma_vli v;
+       } internal[6];
+} lzma_index_iter;
+
+
+/**
+ * \brief       Operation mode for lzma_index_iter_next()
+ */
+typedef enum {
+       LZMA_INDEX_ITER_ANY             = 0,
+               /**<
+                * \brief       Get the next Block or Stream
+                *
+                * Go to the next Block if the current Stream has at least
+                * one Block left. Otherwise go to the next Stream even if
+                * it has no Blocks. If the Stream has no Blocks
+                * (lzma_index_iter.stream.block_count == 0),
+                * lzma_index_iter.block will have undefined values.
+                */
+
+       LZMA_INDEX_ITER_STREAM          = 1,
+               /**<
+                * \brief       Get the next Stream
+                *
+                * Go to the next Stream even if the current Stream has
+                * unread Blocks left. If the next Stream has at least one
+                * Block, the iterator will point to the first Block.
+                * If there are no Blocks, lzma_index_iter.block will have
+                * undefined values.
+                */
+
+       LZMA_INDEX_ITER_BLOCK           = 2,
+               /**<
+                * \brief       Get the next Block
+                *
+                * Go to the next Block if the current Stream has at least
+                * one Block left. If the current Stream has no Blocks left,
+                * the next Stream with at least one Block is located and
+                * the iterator will be made to point to the first Block of
+                * that Stream.
+                */
+
+       LZMA_INDEX_ITER_NONEMPTY_BLOCK  = 3
+               /**<
+                * \brief       Get the next non-empty Block
+                *
+                * This is like LZMA_INDEX_ITER_BLOCK except that it will
+                * skip Blocks whose Uncompressed Size is zero.
+                */
+
+} lzma_index_iter_mode;
+
+
+/**
+ * \brief       Calculate memory usage of lzma_index
+ *
+ * On disk, the size of the Index field depends on both the number of Records
+ * stored and how big values the Records store (due to variable-length integer
+ * encoding). When the Index is kept in lzma_index structure, the memory usage
+ * depends only on the number of Records/Blocks stored in the Index(es), and
+ * in case of concatenated lzma_indexes, the number of Streams. The size in
+ * RAM is almost always significantly bigger than in the encoded form on disk.
+ *
+ * This function calculates an approximate amount of memory needed hold
+ * the given number of Streams and Blocks in lzma_index structure. This
+ * value may vary between CPU architectures and also between liblzma versions
+ * if the internal implementation is modified.
+ */
+extern LZMA_API(uint64_t) lzma_index_memusage(
+               lzma_vli streams, lzma_vli blocks) lzma_nothrow;
+
+
+/**
+ * \brief       Calculate the memory usage of an existing lzma_index
+ *
+ * This is a shorthand for lzma_index_memusage(lzma_index_stream_count(i),
+ * lzma_index_block_count(i)).
+ */
+extern LZMA_API(uint64_t) lzma_index_memused(const lzma_index *i)
+               lzma_nothrow;
+
+
+/**
+ * \brief       Allocate and initialize a new lzma_index structure
+ *
+ * \return      On success, a pointer to an empty initialized lzma_index is
+ *              returned. If allocation fails, NULL is returned.
+ */
+extern LZMA_API(lzma_index *) lzma_index_init(lzma_allocator *allocator)
+               lzma_nothrow;
+
+
+/**
+ * \brief       Deallocate lzma_index
+ *
+ * If i is NULL, this does nothing.
+ */
+extern LZMA_API(void) lzma_index_end(lzma_index *i, lzma_allocator *allocator)
+               lzma_nothrow;
+
+
+/**
+ * \brief       Add a new Block to lzma_index
+ *
+ * \param       i                 Pointer to a lzma_index structure
+ * \param       allocator         Pointer to lzma_allocator, or NULL to
+ *                                use malloc()
+ * \param       unpadded_size     Unpadded Size of a Block. This can be
+ *                                calculated with lzma_block_unpadded_size()
+ *                                after encoding or decoding the Block.
+ * \param       uncompressed_size Uncompressed Size of a Block. This can be
+ *                                taken directly from lzma_block structure
+ *                                after encoding or decoding the Block.
+ *
+ * Appending a new Block does not invalidate iterators. For example,
+ * if an iterator was pointing to the end of the lzma_index, after
+ * lzma_index_append() it is possible to read the next Block with
+ * an existing iterator.
+ *
+ * \return      - LZMA_OK
+ *              - LZMA_MEM_ERROR
+ *              - LZMA_DATA_ERROR: Compressed or uncompressed size of the
+ *                Stream or size of the Index field would grow too big.
+ *              - LZMA_PROG_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_index_append(
+               lzma_index *i, lzma_allocator *allocator,
+               lzma_vli unpadded_size, lzma_vli uncompressed_size)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Set the Stream Flags
+ *
+ * Set the Stream Flags of the last (and typically the only) Stream
+ * in lzma_index. This can be useful when reading information from the
+ * lzma_index, because to decode Blocks, knowing the integrity check type
+ * is needed.
+ *
+ * The given Stream Flags are copied into internal preallocated structure
+ * in the lzma_index, thus the caller doesn't need to keep the *stream_flags
+ * available after calling this function.
+ *
+ * \return      - LZMA_OK
+ *              - LZMA_OPTIONS_ERROR: Unsupported stream_flags->version.
+ *              - LZMA_PROG_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_index_stream_flags(
+               lzma_index *i, const lzma_stream_flags *stream_flags)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Get the types of integrity Checks
+ *
+ * If lzma_index_stream_flags() is used to set the Stream Flags for
+ * every Stream, lzma_index_checks() can be used to get a bitmask to
+ * indicate which Check types have been used. It can be useful e.g. if
+ * showing the Check types to the user.
+ *
+ * The bitmask is 1 << check_id, e.g. CRC32 is 1 << 1 and SHA-256 is 1 << 10.
+ */
+extern LZMA_API(uint32_t) lzma_index_checks(const lzma_index *i)
+               lzma_nothrow lzma_attr_pure;
+
+
+/**
+ * \brief       Set the amount of Stream Padding
+ *
+ * Set the amount of Stream Padding of the last (and typically the only)
+ * Stream in the lzma_index. This is needed when planning to do random-access
+ * reading within multiple concatenated Streams.
+ *
+ * By default, the amount of Stream Padding is assumed to be zero bytes.
+ *
+ * \return      - LZMA_OK
+ *              - LZMA_DATA_ERROR: The file size would grow too big.
+ *              - LZMA_PROG_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_index_stream_padding(
+               lzma_index *i, lzma_vli stream_padding)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Get the number of Streams
+ */
+extern LZMA_API(lzma_vli) lzma_index_stream_count(const lzma_index *i)
+               lzma_nothrow lzma_attr_pure;
+
+
+/**
+ * \brief       Get the number of Blocks
+ *
+ * This returns the total number of Blocks in lzma_index. To get number
+ * of Blocks in individual Streams, use lzma_index_iter.
+ */
+extern LZMA_API(lzma_vli) lzma_index_block_count(const lzma_index *i)
+               lzma_nothrow lzma_attr_pure;
+
+
+/**
+ * \brief       Get the size of the Index field as bytes
+ *
+ * This is needed to verify the Backward Size field in the Stream Footer.
+ */
+extern LZMA_API(lzma_vli) lzma_index_size(const lzma_index *i)
+               lzma_nothrow lzma_attr_pure;
+
+
+/**
+ * \brief       Get the total size of the Stream
+ *
+ * If multiple lzma_indexes have been combined, this works as if the Blocks
+ * were in a single Stream. This is useful if you are going to combine
+ * Blocks from multiple Streams into a single new Stream.
+ */
+extern LZMA_API(lzma_vli) lzma_index_stream_size(const lzma_index *i)
+               lzma_nothrow lzma_attr_pure;
+
+
+/**
+ * \brief       Get the total size of the Blocks
+ *
+ * This doesn't include the Stream Header, Stream Footer, Stream Padding,
+ * or Index fields.
+ */
+extern LZMA_API(lzma_vli) lzma_index_total_size(const lzma_index *i)
+               lzma_nothrow lzma_attr_pure;
+
+
+/**
+ * \brief       Get the total size of the file
+ *
+ * When no lzma_indexes have been combined with lzma_index_cat() and there is
+ * no Stream Padding, this function is identical to lzma_index_stream_size().
+ * If multiple lzma_indexes have been combined, this includes also the headers
+ * of each separate Stream and the possible Stream Padding fields.
+ */
+extern LZMA_API(lzma_vli) lzma_index_file_size(const lzma_index *i)
+               lzma_nothrow lzma_attr_pure;
+
+
+/**
+ * \brief       Get the uncompressed size of the file
+ */
+extern LZMA_API(lzma_vli) lzma_index_uncompressed_size(const lzma_index *i)
+               lzma_nothrow lzma_attr_pure;
+
+
+/**
+ * \brief       Initialize an iterator
+ *
+ * \param       iter    Pointer to a lzma_index_iter structure
+ * \param       i       lzma_index to which the iterator will be associated
+ *
+ * This function associates the iterator with the given lzma_index, and calls
+ * lzma_index_iter_rewind() on the iterator.
+ *
+ * This function doesn't allocate any memory, thus there is no
+ * lzma_index_iter_end(). The iterator is valid as long as the
+ * associated lzma_index is valid, that is, until lzma_index_end() or
+ * using it as source in lzma_index_cat(). Specifically, lzma_index doesn't
+ * become invalid if new Blocks are added to it with lzma_index_append() or
+ * if it is used as the destination in lzma_index_cat().
+ *
+ * It is safe to make copies of an initialized lzma_index_iter, for example,
+ * to easily restart reading at some particular position.
+ */
+extern LZMA_API(void) lzma_index_iter_init(
+               lzma_index_iter *iter, const lzma_index *i) lzma_nothrow;
+
+
+/**
+ * \brief       Rewind the iterator
+ *
+ * Rewind the iterator so that next call to lzma_index_iter_next() will
+ * return the first Block or Stream.
+ */
+extern LZMA_API(void) lzma_index_iter_rewind(lzma_index_iter *iter)
+               lzma_nothrow;
+
+
+/**
+ * \brief       Get the next Block or Stream
+ *
+ * \param       iter    Iterator initialized with lzma_index_iter_init()
+ * \param       mode    Specify what kind of information the caller wants
+ *                      to get. See lzma_index_iter_mode for details.
+ *
+ * \return      If next Block or Stream matching the mode was found, *iter
+ *              is updated and this function returns false. If no Block or
+ *              Stream matching the mode is found, *iter is not modified
+ *              and this function returns true. If mode is set to an unknown
+ *              value, *iter is not modified and this function returns true.
+ */
+extern LZMA_API(lzma_bool) lzma_index_iter_next(
+               lzma_index_iter *iter, lzma_index_iter_mode mode)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Locate a Block
+ *
+ * If it is possible to seek in the .xz file, it is possible to parse
+ * the Index field(s) and use lzma_index_iter_locate() to do random-access
+ * reading with granularity of Block size.
+ *
+ * \param       iter    Iterator that was earlier initialized with
+ *                      lzma_index_iter_init().
+ * \param       target  Uncompressed target offset which the caller would
+ *                      like to locate from the Stream
+ *
+ * If the target is smaller than the uncompressed size of the Stream (can be
+ * checked with lzma_index_uncompressed_size()):
+ *  - Information about the Stream and Block containing the requested
+ *    uncompressed offset is stored into *iter.
+ *  - Internal state of the iterator is adjusted so that
+ *    lzma_index_iter_next() can be used to read subsequent Blocks or Streams.
+ *  - This function returns false.
+ *
+ * If target is greater than the uncompressed size of the Stream, *iter
+ * is not modified, and this function returns true.
+ */
+extern LZMA_API(lzma_bool) lzma_index_iter_locate(
+               lzma_index_iter *iter, lzma_vli target) lzma_nothrow;
+
+
+/**
+ * \brief       Concatenate lzma_indexes
+ *
+ * Concatenating lzma_indexes is useful when doing random-access reading in
+ * multi-Stream .xz file, or when combining multiple Streams into single
+ * Stream.
+ *
+ * \param       dest      lzma_index after which src is appended
+ * \param       src       lzma_index to be appended after dest. If this
+ *                        function succeeds, the memory allocated for src
+ *                        is freed or moved to be part of dest, and all
+ *                        iterators pointing to src will become invalid.
+ * \param       allocator Custom memory allocator; can be NULL to use
+ *                        malloc() and free().
+ *
+ * \return      - LZMA_OK: lzma_indexes were concatenated successfully.
+ *                src is now a dangling pointer.
+ *              - LZMA_DATA_ERROR: *dest would grow too big.
+ *              - LZMA_MEM_ERROR
+ *              - LZMA_PROG_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_index_cat(
+               lzma_index *dest, lzma_index *src, lzma_allocator *allocator)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Duplicate lzma_index
+ *
+ * \return      A copy of the lzma_index, or NULL if memory allocation failed.
+ */
+extern LZMA_API(lzma_index *) lzma_index_dup(
+               const lzma_index *i, lzma_allocator *allocator)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Initialize .xz Index encoder
+ *
+ * \param       strm        Pointer to properly prepared lzma_stream
+ * \param       i           Pointer to lzma_index which should be encoded.
+ *
+ * The valid `action' values for lzma_code() are LZMA_RUN and LZMA_FINISH.
+ * It is enough to use only one of them (you can choose freely; use LZMA_RUN
+ * to support liblzma versions older than 5.0.0).
+ *
+ * \return      - LZMA_OK: Initialization succeeded, continue with lzma_code().
+ *              - LZMA_MEM_ERROR
+ *              - LZMA_PROG_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_index_encoder(
+               lzma_stream *strm, const lzma_index *i)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Initialize .xz Index decoder
+ *
+ * \param       strm        Pointer to properly prepared lzma_stream
+ * \param       i           The decoded Index will be made available via
+ *                          this pointer. Initially this function will
+ *                          set *i to NULL (the old value is ignored). If
+ *                          decoding succeeds (lzma_code() returns
+ *                          LZMA_STREAM_END), *i will be set to point
+ *                          to a new lzma_index, which the application
+ *                          has to later free with lzma_index_end().
+ * \param       memlimit    How much memory the resulting lzma_index is
+ *                          allowed to require.
+ *
+ * The valid `action' values for lzma_code() are LZMA_RUN and LZMA_FINISH.
+ * It is enough to use only one of them (you can choose freely; use LZMA_RUN
+ * to support liblzma versions older than 5.0.0).
+ *
+ * \return      - LZMA_OK: Initialization succeeded, continue with lzma_code().
+ *              - LZMA_MEM_ERROR
+ *              - LZMA_MEMLIMIT_ERROR
+ *              - LZMA_PROG_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_index_decoder(
+               lzma_stream *strm, lzma_index **i, uint64_t memlimit)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Single-call .xz Index encoder
+ *
+ * \param       i         lzma_index to be encoded
+ * \param       out       Beginning of the output buffer
+ * \param       out_pos   The next byte will be written to out[*out_pos].
+ *                        *out_pos is updated only if encoding succeeds.
+ * \param       out_size  Size of the out buffer; the first byte into
+ *                        which no data is written to is out[out_size].
+ *
+ * \return      - LZMA_OK: Encoding was successful.
+ *              - LZMA_BUF_ERROR: Output buffer is too small. Use
+ *                lzma_index_size() to find out how much output
+ *                space is needed.
+ *              - LZMA_PROG_ERROR
+ *
+ * \note        This function doesn't take allocator argument since all
+ *              the internal data is allocated on stack.
+ */
+extern LZMA_API(lzma_ret) lzma_index_buffer_encode(const lzma_index *i,
+               uint8_t *out, size_t *out_pos, size_t out_size) lzma_nothrow;
+
+
+/**
+ * \brief       Single-call .xz Index decoder
+ *
+ * \param       i           If decoding succeeds, *i will point to a new
+ *                          lzma_index, which the application has to
+ *                          later free with lzma_index_end(). If an error
+ *                          occurs, *i will be NULL. The old value of *i
+ *                          is always ignored and thus doesn't need to be
+ *                          initialized by the caller.
+ * \param       memlimit    Pointer to how much memory the resulting
+ *                          lzma_index is allowed to require. The value
+ *                          pointed by this pointer is modified if and only
+ *                          if LZMA_MEMLIMIT_ERROR is returned.
+ * \param       allocator   Pointer to lzma_allocator, or NULL to use malloc()
+ * \param       in          Beginning of the input buffer
+ * \param       in_pos      The next byte will be read from in[*in_pos].
+ *                          *in_pos is updated only if decoding succeeds.
+ * \param       in_size     Size of the input buffer; the first byte that
+ *                          won't be read is in[in_size].
+ *
+ * \return      - LZMA_OK: Decoding was successful.
+ *              - LZMA_MEM_ERROR
+ *              - LZMA_MEMLIMIT_ERROR: Memory usage limit was reached.
+ *                The minimum required memlimit value was stored to *memlimit.
+ *              - LZMA_DATA_ERROR
+ *              - LZMA_PROG_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_index_buffer_decode(lzma_index **i,
+               uint64_t *memlimit, lzma_allocator *allocator,
+               const uint8_t *in, size_t *in_pos, size_t in_size)
+               lzma_nothrow;
diff --git a/contrib/xz/src/liblzma/api/lzma/index_hash.h b/contrib/xz/src/liblzma/api/lzma/index_hash.h
new file mode 100644 (file)
index 0000000..fa2e048
--- /dev/null
@@ -0,0 +1,107 @@
+/**
+ * \file        lzma/index_hash.h
+ * \brief       Validate Index by using a hash function
+ *
+ * Hashing makes it possible to use constant amount of memory to validate
+ * Index of arbitrary size.
+ */
+
+/*
+ * Author: Lasse Collin
+ *
+ * This file has been put into the public domain.
+ * You can do whatever you want with this file.
+ *
+ * See ../lzma.h for information about liblzma as a whole.
+ */
+
+#ifndef LZMA_H_INTERNAL
+#      error Never include this file directly. Use <lzma.h> instead.
+#endif
+
+/**
+ * \brief       Opaque data type to hold the Index hash
+ */
+typedef struct lzma_index_hash_s lzma_index_hash;
+
+
+/**
+ * \brief       Allocate and initialize a new lzma_index_hash structure
+ *
+ * If index_hash is NULL, a new lzma_index_hash structure is allocated,
+ * initialized, and a pointer to it returned. If allocation fails, NULL
+ * is returned.
+ *
+ * If index_hash is non-NULL, it is reinitialized and the same pointer
+ * returned. In this case, return value cannot be NULL or a different
+ * pointer than the index_hash that was given as an argument.
+ */
+extern LZMA_API(lzma_index_hash *) lzma_index_hash_init(
+               lzma_index_hash *index_hash, lzma_allocator *allocator)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Deallocate lzma_index_hash structure
+ */
+extern LZMA_API(void) lzma_index_hash_end(
+               lzma_index_hash *index_hash, lzma_allocator *allocator)
+               lzma_nothrow;
+
+
+/**
+ * \brief       Add a new Record to an Index hash
+ *
+ * \param       index             Pointer to a lzma_index_hash structure
+ * \param       unpadded_size     Unpadded Size of a Block
+ * \param       uncompressed_size Uncompressed Size of a Block
+ *
+ * \return      - LZMA_OK
+ *              - LZMA_DATA_ERROR: Compressed or uncompressed size of the
+ *                Stream or size of the Index field would grow too big.
+ *              - LZMA_PROG_ERROR: Invalid arguments or this function is being
+ *                used when lzma_index_hash_decode() has already been used.
+ */
+extern LZMA_API(lzma_ret) lzma_index_hash_append(lzma_index_hash *index_hash,
+               lzma_vli unpadded_size, lzma_vli uncompressed_size)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Decode and validate the Index field
+ *
+ * After telling the sizes of all Blocks with lzma_index_hash_append(),
+ * the actual Index field is decoded with this function. Specifically,
+ * once decoding of the Index field has been started, no more Records
+ * can be added using lzma_index_hash_append().
+ *
+ * This function doesn't use lzma_stream structure to pass the input data.
+ * Instead, the input buffer is specified using three arguments. This is
+ * because it matches better the internal APIs of liblzma.
+ *
+ * \param       index_hash      Pointer to a lzma_index_hash structure
+ * \param       in              Pointer to the beginning of the input buffer
+ * \param       in_pos          in[*in_pos] is the next byte to process
+ * \param       in_size         in[in_size] is the first byte not to process
+ *
+ * \return      - LZMA_OK: So far good, but more input is needed.
+ *              - LZMA_STREAM_END: Index decoded successfully and it matches
+ *                the Records given with lzma_index_hash_append().
+ *              - LZMA_DATA_ERROR: Index is corrupt or doesn't match the
+ *                information given with lzma_index_hash_append().
+ *              - LZMA_BUF_ERROR: Cannot progress because *in_pos >= in_size.
+ *              - LZMA_PROG_ERROR
+ */
+extern LZMA_API(lzma_ret) lzma_index_hash_decode(lzma_index_hash *index_hash,
+               const uint8_t *in, size_t *in_pos, size_t in_size)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Get the size of the Index field as bytes
+ *
+ * This is needed to verify the Backward Size field in the Stream Footer.
+ */
+extern LZMA_API(lzma_vli) lzma_index_hash_size(
+               const lzma_index_hash *index_hash)
+               lzma_nothrow lzma_attr_pure;
diff --git a/contrib/xz/src/liblzma/api/lzma/lzma.h b/contrib/xz/src/liblzma/api/lzma/lzma.h
new file mode 100644 (file)
index 0000000..8d5fdb6
--- /dev/null
@@ -0,0 +1,417 @@
+/**
+ * \file        lzma/lzma.h
+ * \brief       LZMA1 and LZMA2 filters
+ */
+
+/*
+ * Author: Lasse Collin
+ *
+ * This file has been put into the public domain.
+ * You can do whatever you want with this file.
+ *
+ * See ../lzma.h for information about liblzma as a whole.
+ */
+
+#ifndef LZMA_H_INTERNAL
+#      error Never include this file directly. Use <lzma.h> instead.
+#endif
+
+
+/**
+ * \brief       LZMA1 Filter ID
+ *
+ * LZMA1 is the very same thing as what was called just LZMA in LZMA Utils,
+ * 7-Zip, and LZMA SDK. It's called LZMA1 here to prevent developers from
+ * accidentally using LZMA when they actually want LZMA2.
+ *
+ * LZMA1 shouldn't be used for new applications unless you _really_ know
+ * what you are doing. LZMA2 is almost always a better choice.
+ */
+#define LZMA_FILTER_LZMA1       LZMA_VLI_C(0x4000000000000001)
+
+/**
+ * \brief       LZMA2 Filter ID
+ *
+ * Usually you want this instead of LZMA1. Compared to LZMA1, LZMA2 adds
+ * support for LZMA_SYNC_FLUSH, uncompressed chunks (smaller expansion
+ * when trying to compress uncompressible data), possibility to change
+ * lc/lp/pb in the middle of encoding, and some other internal improvements.
+ */
+#define LZMA_FILTER_LZMA2       LZMA_VLI_C(0x21)
+
+
+/**
+ * \brief       Match finders
+ *
+ * Match finder has major effect on both speed and compression ratio.
+ * Usually hash chains are faster than binary trees.
+ *
+ * If you will use LZMA_SYNC_FLUSH often, the hash chains may be a better
+ * choice, because binary trees get much higher compression ratio penalty
+ * with LZMA_SYNC_FLUSH.
+ *
+ * The memory usage formulas are only rough estimates, which are closest to
+ * reality when dict_size is a power of two. The formulas are  more complex
+ * in reality, and can also change a little between liblzma versions. Use
+ * lzma_raw_encoder_memusage() to get more accurate estimate of memory usage.
+ */
+typedef enum {
+       LZMA_MF_HC3     = 0x03,
+               /**<
+                * \brief       Hash Chain with 2- and 3-byte hashing
+                *
+                * Minimum nice_len: 3
+                *
+                * Memory usage:
+                *  - dict_size <= 16 MiB: dict_size * 7.5
+                *  - dict_size > 16 MiB: dict_size * 5.5 + 64 MiB
+                */
+
+       LZMA_MF_HC4     = 0x04,
+               /**<
+                * \brief       Hash Chain with 2-, 3-, and 4-byte hashing
+                *
+                * Minimum nice_len: 4
+                *
+                * Memory usage:
+                *  - dict_size <= 32 MiB: dict_size * 7.5
+                *  - dict_size > 32 MiB: dict_size * 6.5
+                */
+
+       LZMA_MF_BT2     = 0x12,
+               /**<
+                * \brief       Binary Tree with 2-byte hashing
+                *
+                * Minimum nice_len: 2
+                *
+                * Memory usage: dict_size * 9.5
+                */
+
+       LZMA_MF_BT3     = 0x13,
+               /**<
+                * \brief       Binary Tree with 2- and 3-byte hashing
+                *
+                * Minimum nice_len: 3
+                *
+                * Memory usage:
+                *  - dict_size <= 16 MiB: dict_size * 11.5
+                *  - dict_size > 16 MiB: dict_size * 9.5 + 64 MiB
+                */
+
+       LZMA_MF_BT4     = 0x14
+               /**<
+                * \brief       Binary Tree with 2-, 3-, and 4-byte hashing
+                *
+                * Minimum nice_len: 4
+                *
+                * Memory usage:
+                *  - dict_size <= 32 MiB: dict_size * 11.5
+                *  - dict_size > 32 MiB: dict_size * 10.5
+                */
+} lzma_match_finder;
+
+
+/**
+ * \brief       Test if given match finder is supported
+ *
+ * Return true if the given match finder is supported by this liblzma build.
+ * Otherwise false is returned. It is safe to call this with a value that
+ * isn't listed in lzma_match_finder enumeration; the return value will be
+ * false.
+ *
+ * There is no way to list which match finders are available in this
+ * particular liblzma version and build. It would be useless, because
+ * a new match finder, which the application developer wasn't aware,
+ * could require giving additional options to the encoder that the older
+ * match finders don't need.
+ */
+extern LZMA_API(lzma_bool) lzma_mf_is_supported(lzma_match_finder match_finder)
+               lzma_nothrow lzma_attr_const;
+
+
+/**
+ * \brief       Compression modes
+ *
+ * This selects the function used to analyze the data produced by the match
+ * finder.
+ */
+typedef enum {
+       LZMA_MODE_FAST = 1,
+               /**<
+                * \brief       Fast compression
+                *
+                * Fast mode is usually at its best when combined with
+                * a hash chain match finder.
+                */
+
+       LZMA_MODE_NORMAL = 2
+               /**<
+                * \brief       Normal compression
+                *
+                * This is usually notably slower than fast mode. Use this
+                * together with binary tree match finders to expose the
+                * full potential of the LZMA1 or LZMA2 encoder.
+                */
+} lzma_mode;
+
+
+/**
+ * \brief       Test if given compression mode is supported
+ *
+ * Return true if the given compression mode is supported by this liblzma
+ * build. Otherwise false is returned. It is safe to call this with a value
+ * that isn't listed in lzma_mode enumeration; the return value will be false.
+ *
+ * There is no way to list which modes are available in this particular
+ * liblzma version and build. It would be useless, because a new compression
+ * mode, which the application developer wasn't aware, could require giving
+ * additional options to the encoder that the older modes don't need.
+ */
+extern LZMA_API(lzma_bool) lzma_mode_is_supported(lzma_mode mode)
+               lzma_nothrow lzma_attr_const;
+
+
+/**
+ * \brief       Options specific to the LZMA1 and LZMA2 filters
+ *
+ * Since LZMA1 and LZMA2 share most of the code, it's simplest to share
+ * the options structure too. For encoding, all but the reserved variables
+ * need to be initialized unless specifically mentioned otherwise.
+ * lzma_lzma_preset() can be used to get a good starting point.
+ *
+ * For raw decoding, both LZMA1 and LZMA2 need dict_size, preset_dict, and
+ * preset_dict_size (if preset_dict != NULL). LZMA1 needs also lc, lp, and pb.
+ */
+typedef struct {
+       /**
+        * \brief       Dictionary size in bytes
+        *
+        * Dictionary size indicates how many bytes of the recently processed
+        * uncompressed data is kept in memory. One method to reduce size of
+        * the uncompressed data is to store distance-length pairs, which
+        * indicate what data to repeat from the dictionary buffer. Thus,
+        * the bigger the dictionary, the better the compression ratio
+        * usually is.
+        *
+        * Maximum size of the dictionary depends on multiple things:
+        *  - Memory usage limit
+        *  - Available address space (not a problem on 64-bit systems)
+        *  - Selected match finder (encoder only)
+        *
+        * Currently the maximum dictionary size for encoding is 1.5 GiB
+        * (i.e. (UINT32_C(1) << 30) + (UINT32_C(1) << 29)) even on 64-bit
+        * systems for certain match finder implementation reasons. In the
+        * future, there may be match finders that support bigger
+        * dictionaries.
+        *
+        * Decoder already supports dictionaries up to 4 GiB - 1 B (i.e.
+        * UINT32_MAX), so increasing the maximum dictionary size of the
+        * encoder won't cause problems for old decoders.
+        *
+        * Because extremely small dictionaries sizes would have unneeded
+        * overhead in the decoder, the minimum dictionary size is 4096 bytes.
+        *
+        * \note        When decoding, too big dictionary does no other harm
+        *              than wasting memory.
+        */
+       uint32_t dict_size;
+#      define LZMA_DICT_SIZE_MIN       UINT32_C(4096)
+#      define LZMA_DICT_SIZE_DEFAULT   (UINT32_C(1) << 23)
+
+       /**
+        * \brief       Pointer to an initial dictionary
+        *
+        * It is possible to initialize the LZ77 history window using
+        * a preset dictionary. It is useful when compressing many
+        * similar, relatively small chunks of data independently from
+        * each other. The preset dictionary should contain typical
+        * strings that occur in the files being compressed. The most
+        * probable strings should be near the end of the preset dictionary.
+        *
+        * This feature should be used only in special situations. For
+        * now, it works correctly only with raw encoding and decoding.
+        * Currently none of the container formats supported by
+        * liblzma allow preset dictionary when decoding, thus if
+        * you create a .xz or .lzma file with preset dictionary, it
+        * cannot be decoded with the regular decoder functions. In the
+        * future, the .xz format will likely get support for preset
+        * dictionary though.
+        */
+       const uint8_t *preset_dict;
+
+       /**
+        * \brief       Size of the preset dictionary
+        *
+        * Specifies the size of the preset dictionary. If the size is
+        * bigger than dict_size, only the last dict_size bytes are
+        * processed.
+        *
+        * This variable is read only when preset_dict is not NULL.
+        * If preset_dict is not NULL but preset_dict_size is zero,
+        * no preset dictionary is used (identical to only setting
+        * preset_dict to NULL).
+        */
+       uint32_t preset_dict_size;
+
+       /**
+        * \brief       Number of literal context bits
+        *
+        * How many of the highest bits of the previous uncompressed
+        * eight-bit byte (also known as `literal') are taken into
+        * account when predicting the bits of the next literal.
+        *
+        * E.g. in typical English text, an upper-case letter is
+        * often followed by a lower-case letter, and a lower-case
+        * letter is usually followed by another lower-case letter.
+        * In the US-ASCII character set, the highest three bits are 010
+        * for upper-case letters and 011 for lower-case letters.
+        * When lc is at least 3, the literal coding can take advantage of
+        * this property in the uncompressed data.
+        *
+        * There is a limit that applies to literal context bits and literal
+        * position bits together: lc + lp <= 4. Without this limit the
+        * decoding could become very slow, which could have security related
+        * results in some cases like email servers doing virus scanning.
+        * This limit also simplifies the internal implementation in liblzma.
+        *
+        * There may be LZMA1 streams that have lc + lp > 4 (maximum possible
+        * lc would be 8). It is not possible to decode such streams with
+        * liblzma.
+        */
+       uint32_t lc;
+#      define LZMA_LCLP_MIN    0
+#      define LZMA_LCLP_MAX    4
+#      define LZMA_LC_DEFAULT  3
+
+       /**
+        * \brief       Number of literal position bits
+        *
+        * lp affects what kind of alignment in the uncompressed data is
+        * assumed when encoding literals. A literal is a single 8-bit byte.
+        * See pb below for more information about alignment.
+        */
+       uint32_t lp;
+#      define LZMA_LP_DEFAULT  0
+
+       /**
+        * \brief       Number of position bits
+        *
+        * pb affects what kind of alignment in the uncompressed data is
+        * assumed in general. The default means four-byte alignment
+        * (2^ pb =2^2=4), which is often a good choice when there's
+        * no better guess.
+        *
+        * When the aligment is known, setting pb accordingly may reduce
+        * the file size a little. E.g. with text files having one-byte
+        * alignment (US-ASCII, ISO-8859-*, UTF-8), setting pb=0 can
+        * improve compression slightly. For UTF-16 text, pb=1 is a good
+        * choice. If the alignment is an odd number like 3 bytes, pb=0
+        * might be the best choice.
+        *
+        * Even though the assumed alignment can be adjusted with pb and
+        * lp, LZMA1 and LZMA2 still slightly favor 16-byte alignment.
+        * It might be worth taking into account when designing file formats
+        * that are likely to be often compressed with LZMA1 or LZMA2.
+        */
+       uint32_t pb;
+#      define LZMA_PB_MIN      0
+#      define LZMA_PB_MAX      4
+#      define LZMA_PB_DEFAULT  2
+
+       /** Compression mode */
+       lzma_mode mode;
+
+       /**
+        * \brief       Nice length of a match
+        *
+        * This determines how many bytes the encoder compares from the match
+        * candidates when looking for the best match. Once a match of at
+        * least nice_len bytes long is found, the encoder stops looking for
+        * better candidates and encodes the match. (Naturally, if the found
+        * match is actually longer than nice_len, the actual length is
+        * encoded; it's not truncated to nice_len.)
+        *
+        * Bigger values usually increase the compression ratio and
+        * compression time. For most files, 32 to 128 is a good value,
+        * which gives very good compression ratio at good speed.
+        *
+        * The exact minimum value depends on the match finder. The maximum
+        * is 273, which is the maximum length of a match that LZMA1 and
+        * LZMA2 can encode.
+        */
+       uint32_t nice_len;
+
+       /** Match finder ID */
+       lzma_match_finder mf;
+
+       /**
+        * \brief       Maximum search depth in the match finder
+        *
+        * For every input byte, match finder searches through the hash chain
+        * or binary tree in a loop, each iteration going one step deeper in
+        * the chain or tree. The searching stops if
+        *  - a match of at least nice_len bytes long is found;
+        *  - all match candidates from the hash chain or binary tree have
+        *    been checked; or
+        *  - maximum search depth is reached.
+        *
+        * Maximum search depth is needed to prevent the match finder from
+        * wasting too much time in case there are lots of short match
+        * candidates. On the other hand, stopping the search before all
+        * candidates have been checked can reduce compression ratio.
+        *
+        * Setting depth to zero tells liblzma to use an automatic default
+        * value, that depends on the selected match finder and nice_len.
+        * The default is in the range [4, 200] or so (it may vary between
+        * liblzma versions).
+        *
+        * Using a bigger depth value than the default can increase
+        * compression ratio in some cases. There is no strict maximum value,
+        * but high values (thousands or millions) should be used with care:
+        * the encoder could remain fast enough with typical input, but
+        * malicious input could cause the match finder to slow down
+        * dramatically, possibly creating a denial of service attack.
+        */
+       uint32_t depth;
+
+       /*
+        * Reserved space to allow possible future extensions without
+        * breaking the ABI. You should not touch these, because the names
+        * of these variables may change. These are and will never be used
+        * with the currently supported options, so it is safe to leave these
+        * uninitialized.
+        */
+       uint32_t reserved_int1;
+       uint32_t reserved_int2;
+       uint32_t reserved_int3;
+       uint32_t reserved_int4;
+       uint32_t reserved_int5;
+       uint32_t reserved_int6;
+       uint32_t reserved_int7;
+       uint32_t reserved_int8;
+       lzma_reserved_enum reserved_enum1;
+       lzma_reserved_enum reserved_enum2;
+       lzma_reserved_enum reserved_enum3;
+       lzma_reserved_enum reserved_enum4;
+       void *reserved_ptr1;
+       void *reserved_ptr2;
+
+} lzma_options_lzma;
+
+
+/**
+ * \brief       Set a compression preset to lzma_options_lzma structure
+ *
+ * 0 is the fastest and 9 is the slowest. These match the switches -0 .. -9
+ * of the xz command line tool. In addition, it is possible to bitwise-or
+ * flags to the preset. Currently only LZMA_PRESET_EXTREME is supported.
+ * The flags are defined in container.h, because the flags are used also
+ * with lzma_easy_encoder().
+ *
+ * The preset values are subject to changes between liblzma versions.
+ *
+ * This function is available only if LZMA1 or LZMA2 encoder has been enabled
+ * when building liblzma.
+ */
+extern LZMA_API(lzma_bool) lzma_lzma_preset(
+               lzma_options_lzma *options, uint32_t preset) lzma_nothrow;
diff --git a/contrib/xz/src/liblzma/api/lzma/stream_flags.h b/contrib/xz/src/liblzma/api/lzma/stream_flags.h
new file mode 100644 (file)
index 0000000..bbdd408
--- /dev/null
@@ -0,0 +1,223 @@
+/**
+ * \file        lzma/stream_flags.h
+ * \brief       .xz Stream Header and Stream Footer encoder and decoder
+ */
+
+/*
+ * Author: Lasse Collin
+ *
+ * This file has been put into the public domain.
+ * You can do whatever you want with this file.
+ *
+ * See ../lzma.h for information about liblzma as a whole.
+ */
+
+#ifndef LZMA_H_INTERNAL
+#      error Never include this file directly. Use <lzma.h> instead.
+#endif
+
+
+/**
+ * \brief       Size of Stream Header and Stream Footer
+ *
+ * Stream Header and Stream Footer have the same size and they are not
+ * going to change even if a newer version of the .xz file format is
+ * developed in future.
+ */
+#define LZMA_STREAM_HEADER_SIZE 12
+
+
+/**
+ * \brief       Options for encoding/decoding Stream Header and Stream Footer
+ */
+typedef struct {
+       /**
+        * \brief       Stream Flags format version
+        *
+        * To prevent API and ABI breakages if new features are needed in
+        * Stream Header or Stream Footer, a version number is used to
+        * indicate which fields in this structure are in use. For now,
+        * version must always be zero. With non-zero version, the
+        * lzma_stream_header_encode() and lzma_stream_footer_encode()
+        * will return LZMA_OPTIONS_ERROR.
+        *
+        * lzma_stream_header_decode() and lzma_stream_footer_decode()
+        * will always set this to the lowest value that supports all the
+        * features indicated by the Stream Flags field. The application
+        * must check that the version number set by the decoding functions
+        * is supported by the application. Otherwise it is possible that
+        * the application will decode the Stream incorrectly.
+        */
+       uint32_t version;
+
+       /**
+        * \brief       Backward Size
+        *
+        * Backward Size must be a multiple of four bytes. In this Stream
+        * format version, Backward Size is the size of the Index field.
+        *
+        * Backward Size isn't actually part of the Stream Flags field, but
+        * it is convenient to include in this structure anyway. Backward
+        * Size is present only in the Stream Footer. There is no need to
+        * initialize backward_size when encoding Stream Header.
+        *
+        * lzma_stream_header_decode() always sets backward_size to
+        * LZMA_VLI_UNKNOWN so that it is convenient to use
+        * lzma_stream_flags_compare() when both Stream Header and Stream
+        * Footer have been decoded.
+        */
+       lzma_vli backward_size;
+#      define LZMA_BACKWARD_SIZE_MIN 4
+#      define LZMA_BACKWARD_SIZE_MAX (LZMA_VLI_C(1) << 34)
+
+       /**
+        * \brief       Check ID
+        *
+        * This indicates the type of the integrity check calculated from
+        * uncompressed data.
+        */
+       lzma_check check;
+
+       /*
+        * Reserved space to allow possible future extensions without
+        * breaking the ABI. You should not touch these, because the
+        * names of these variables may change.
+        *
+        * (We will never be able to use all of these since Stream Flags
+        * is just two bytes plus Backward Size of four bytes. But it's
+        * nice to have the proper types when they are needed.)
+        */
+       lzma_reserved_enum reserved_enum1;
+       lzma_reserved_enum reserved_enum2;
+       lzma_reserved_enum reserved_enum3;
+       lzma_reserved_enum reserved_enum4;
+       lzma_bool reserved_bool1;
+       lzma_bool reserved_bool2;
+       lzma_bool reserved_bool3;
+       lzma_bool reserved_bool4;
+       lzma_bool reserved_bool5;
+       lzma_bool reserved_bool6;
+       lzma_bool reserved_bool7;
+       lzma_bool reserved_bool8;
+       uint32_t reserved_int1;
+       uint32_t reserved_int2;
+
+} lzma_stream_flags;
+
+
+/**
+ * \brief       Encode Stream Header
+ *
+ * \param       options     Stream Header options to be encoded.
+ *                          options->backward_size is ignored and doesn't
+ *                          need to be initialized.
+ * \param       out         Beginning of the output buffer of
+ *                          LZMA_STREAM_HEADER_SIZE bytes.
+ *
+ * \return      - LZMA_OK: Encoding was successful.
+ *              - LZMA_OPTIONS_ERROR: options->version is not supported by
+ *                this liblzma version.
+ *              - LZMA_PROG_ERROR: Invalid options.
+ */
+extern LZMA_API(lzma_ret) lzma_stream_header_encode(
+               const lzma_stream_flags *options, uint8_t *out)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Encode Stream Footer
+ *
+ * \param       options     Stream Footer options to be encoded.
+ * \param       out         Beginning of the output buffer of
+ *                          LZMA_STREAM_HEADER_SIZE bytes.
+ *
+ * \return      - LZMA_OK: Encoding was successful.
+ *              - LZMA_OPTIONS_ERROR: options->version is not supported by
+ *                this liblzma version.
+ *              - LZMA_PROG_ERROR: Invalid options.
+ */
+extern LZMA_API(lzma_ret) lzma_stream_footer_encode(
+               const lzma_stream_flags *options, uint8_t *out)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Decode Stream Header
+ *
+ * \param       options     Target for the decoded Stream Header options.
+ * \param       in          Beginning of the input buffer of
+ *                          LZMA_STREAM_HEADER_SIZE bytes.
+ *
+ * options->backward_size is always set to LZMA_VLI_UNKNOWN. This is to
+ * help comparing Stream Flags from Stream Header and Stream Footer with
+ * lzma_stream_flags_compare().
+ *
+ * \return      - LZMA_OK: Decoding was successful.
+ *              - LZMA_FORMAT_ERROR: Magic bytes don't match, thus the given
+ *                buffer cannot be Stream Header.
+ *              - LZMA_DATA_ERROR: CRC32 doesn't match, thus the header
+ *                is corrupt.
+ *              - LZMA_OPTIONS_ERROR: Unsupported options are present
+ *                in the header.
+ *
+ * \note        When decoding .xz files that contain multiple Streams, it may
+ *              make sense to print "file format not recognized" only if
+ *              decoding of the Stream Header of the _first_ Stream gives
+ *              LZMA_FORMAT_ERROR. If non-first Stream Header gives
+ *              LZMA_FORMAT_ERROR, the message used for LZMA_DATA_ERROR is
+ *              probably more appropriate.
+ *
+ *              For example, Stream decoder in liblzma uses LZMA_DATA_ERROR if
+ *              LZMA_FORMAT_ERROR is returned by lzma_stream_header_decode()
+ *              when decoding non-first Stream.
+ */
+extern LZMA_API(lzma_ret) lzma_stream_header_decode(
+               lzma_stream_flags *options, const uint8_t *in)
+               lzma_nothrow lzma_attr_warn_unused_result;
+
+
+/**
+ * \brief       Decode Stream Footer
+ *
+ * \param       options     Target for the decoded Stream Header options.
+ * \param       in          Beginning of the input buffer of
+ *                          LZMA_STREAM_HEADER_SIZE bytes.
+ *
+ * \return      - LZMA_OK: Decoding was successful.
+ *              - LZMA_FORMAT_ERROR: Magic bytes don't match, thus the given
+ *                buffer cannot be Stream Footer.
+ *              - LZMA_DATA_ERROR: CRC32 doesn't match, thus the Stream Footer
+ *                is corrupt.
+ *              - LZMA_OPTIONS_ERROR: Unsupported options are present
+ *                in Stream Footer.
+ *
+ * \note        If Stream Header was already decoded successfully, but
+ *              decoding Stream Footer returns LZMA_FORMAT_ERROR, the
+ *              application should probably report some other error message
+ *              than "file form