lib: import ccan modules for tdb2
authorRusty Russell <rusty@rustcorp.com.au>
Mon, 20 Jun 2011 07:24:15 +0000 (16:54 +0930)
committerRusty Russell <rusty@rustcorp.com.au>
Mon, 20 Jun 2011 09:18:34 +0000 (11:18 +0200)
Imported from git://git.ozlabs.org/~ccan/ccan init-1161-g661d41f

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
135 files changed:
lib/ccan/array_size/LICENSE [new file with mode: 0644]
lib/ccan/array_size/_info [new file with mode: 0644]
lib/ccan/array_size/array_size.h [new file with mode: 0644]
lib/ccan/array_size/test/compile_fail-function-param.c [new file with mode: 0644]
lib/ccan/array_size/test/compile_fail.c [new file with mode: 0644]
lib/ccan/array_size/test/run.c [new file with mode: 0644]
lib/ccan/asearch/LICENSE [new file with mode: 0644]
lib/ccan/asearch/_info [new file with mode: 0644]
lib/ccan/asearch/asearch.h [new file with mode: 0644]
lib/ccan/asearch/test/compile_fail-return-value-const.c [new file with mode: 0644]
lib/ccan/asearch/test/compile_fail-return-value.c [new file with mode: 0644]
lib/ccan/asearch/test/run-strings.c [new file with mode: 0644]
lib/ccan/asearch/test/run.c [new file with mode: 0644]
lib/ccan/build_assert/LICENSE [new file with mode: 0644]
lib/ccan/build_assert/_info [new file with mode: 0644]
lib/ccan/build_assert/build_assert.h [new file with mode: 0644]
lib/ccan/build_assert/test/compile_fail-expr.c [new file with mode: 0644]
lib/ccan/build_assert/test/compile_fail.c [new file with mode: 0644]
lib/ccan/build_assert/test/compile_ok.c [new file with mode: 0644]
lib/ccan/build_assert/test/run-BUILD_ASSERT_OR_ZERO.c [new file with mode: 0644]
lib/ccan/build_assert/test/run-EXPR_BUILD_ASSERT.c [new file with mode: 0644]
lib/ccan/cast/LICENSE [new file with mode: 0644]
lib/ccan/cast/_info [new file with mode: 0644]
lib/ccan/cast/cast.h [new file with mode: 0644]
lib/ccan/cast/test/compile_fail-cast_const.c [new file with mode: 0644]
lib/ccan/cast/test/compile_fail-cast_const2.c [new file with mode: 0644]
lib/ccan/cast/test/compile_fail-cast_const3.c [new file with mode: 0644]
lib/ccan/cast/test/compile_fail-cast_signed-const.c [new file with mode: 0644]
lib/ccan/cast/test/compile_fail-cast_signed-sizesame.c [new file with mode: 0644]
lib/ccan/cast/test/compile_fail-cast_signed.c [new file with mode: 0644]
lib/ccan/cast/test/compile_fail-cast_static-2.c [new file with mode: 0644]
lib/ccan/cast/test/compile_fail-cast_static-3.c [new file with mode: 0644]
lib/ccan/cast/test/compile_fail-cast_static.c [new file with mode: 0644]
lib/ccan/cast/test/compile_ok-cast_void.c [new file with mode: 0644]
lib/ccan/compiler/LICENSE [new file with mode: 0644]
lib/ccan/compiler/_info [new file with mode: 0644]
lib/ccan/compiler/compiler.h [new file with mode: 0644]
lib/ccan/compiler/test/compile_fail-printf.c [new file with mode: 0644]
lib/ccan/compiler/test/run-is_compile_constant.c [new file with mode: 0644]
lib/ccan/endian/LICENSE [new file with mode: 0644]
lib/ccan/endian/_info [new file with mode: 0644]
lib/ccan/endian/endian.h [new file with mode: 0644]
lib/ccan/endian/test/run.c [new file with mode: 0644]
lib/ccan/hash/_info [new file with mode: 0644]
lib/ccan/hash/hash.c [new file with mode: 0644]
lib/ccan/hash/hash.h [new file with mode: 0644]
lib/ccan/hash/test/api-hash_stable.c [new file with mode: 0644]
lib/ccan/hash/test/run.c [new file with mode: 0644]
lib/ccan/htable/LICENSE [new file with mode: 0644]
lib/ccan/htable/_info [new file with mode: 0644]
lib/ccan/htable/htable.c [new file with mode: 0644]
lib/ccan/htable/htable.h [new file with mode: 0644]
lib/ccan/htable/htable_type.h [new file with mode: 0644]
lib/ccan/htable/test/run-type.c [new file with mode: 0644]
lib/ccan/htable/test/run.c [new file with mode: 0644]
lib/ccan/htable/tools/Makefile [new file with mode: 0644]
lib/ccan/htable/tools/speed.c [new file with mode: 0644]
lib/ccan/ilog/LICENSE [new file with mode: 0644]
lib/ccan/ilog/_info [new file with mode: 0644]
lib/ccan/ilog/ilog.c [new file with mode: 0644]
lib/ccan/ilog/ilog.h [new file with mode: 0644]
lib/ccan/ilog/test/run-out-of-line.c [new file with mode: 0644]
lib/ccan/ilog/test/run.c [new file with mode: 0644]
lib/ccan/libccan.m4 [new file with mode: 0644]
lib/ccan/likely/LICENSE [new file with mode: 0644]
lib/ccan/likely/_info [new file with mode: 0644]
lib/ccan/likely/likely.c [new file with mode: 0644]
lib/ccan/likely/likely.h [new file with mode: 0644]
lib/ccan/likely/test/run-debug.c [new file with mode: 0644]
lib/ccan/likely/test/run.c [new file with mode: 0644]
lib/ccan/str/LICENSE [new file with mode: 0644]
lib/ccan/str/_info [new file with mode: 0644]
lib/ccan/str/debug.c [new file with mode: 0644]
lib/ccan/str/str.c [new file with mode: 0644]
lib/ccan/str/str.h [new file with mode: 0644]
lib/ccan/str/str_debug.h [new file with mode: 0644]
lib/ccan/str/test/compile_fail-isalnum.c [new file with mode: 0644]
lib/ccan/str/test/compile_fail-isalpha.c [new file with mode: 0644]
lib/ccan/str/test/compile_fail-isascii.c [new file with mode: 0644]
lib/ccan/str/test/compile_fail-isblank.c [new file with mode: 0644]
lib/ccan/str/test/compile_fail-iscntrl.c [new file with mode: 0644]
lib/ccan/str/test/compile_fail-isdigit.c [new file with mode: 0644]
lib/ccan/str/test/compile_fail-islower.c [new file with mode: 0644]
lib/ccan/str/test/compile_fail-isprint.c [new file with mode: 0644]
lib/ccan/str/test/compile_fail-ispunct.c [new file with mode: 0644]
lib/ccan/str/test/compile_fail-isspace.c [new file with mode: 0644]
lib/ccan/str/test/compile_fail-isupper.c [new file with mode: 0644]
lib/ccan/str/test/compile_fail-isxdigit.c [new file with mode: 0644]
lib/ccan/str/test/compile_fail-strchr.c [new file with mode: 0644]
lib/ccan/str/test/compile_fail-strrchr.c [new file with mode: 0644]
lib/ccan/str/test/compile_fail-strstr.c [new file with mode: 0644]
lib/ccan/str/test/debug.c [new file with mode: 0644]
lib/ccan/str/test/run.c [new file with mode: 0644]
lib/ccan/tally/LICENSE [new file with mode: 0644]
lib/ccan/tally/_info [new file with mode: 0644]
lib/ccan/tally/tally.c [new file with mode: 0644]
lib/ccan/tally/tally.h [new file with mode: 0644]
lib/ccan/tally/test/run-bucket_of.c [new file with mode: 0644]
lib/ccan/tally/test/run-divlu64.c [new file with mode: 0644]
lib/ccan/tally/test/run-histogram.c [new file with mode: 0644]
lib/ccan/tally/test/run-mean.c [new file with mode: 0644]
lib/ccan/tally/test/run-median.c [new file with mode: 0644]
lib/ccan/tally/test/run-min-max.c [new file with mode: 0644]
lib/ccan/tally/test/run-mode.c [new file with mode: 0644]
lib/ccan/tally/test/run-renormalize.c [new file with mode: 0644]
lib/ccan/tally/test/run-total.c [new file with mode: 0644]
lib/ccan/typesafe_cb/LICENSE [new file with mode: 0644]
lib/ccan/typesafe_cb/_info [new file with mode: 0644]
lib/ccan/typesafe_cb/test/compile_fail-cast_if_any.c [new file with mode: 0644]
lib/ccan/typesafe_cb/test/compile_fail-cast_if_type-promotable.c [new file with mode: 0644]
lib/ccan/typesafe_cb/test/compile_fail-cast_if_type.c [new file with mode: 0644]
lib/ccan/typesafe_cb/test/compile_fail-typesafe_cb-int.c [new file with mode: 0644]
lib/ccan/typesafe_cb/test/compile_fail-typesafe_cb.c [new file with mode: 0644]
lib/ccan/typesafe_cb/test/compile_fail-typesafe_cb_cast-multi.c [new file with mode: 0644]
lib/ccan/typesafe_cb/test/compile_fail-typesafe_cb_cast.c [new file with mode: 0644]
lib/ccan/typesafe_cb/test/compile_fail-typesafe_cb_exact.c [new file with mode: 0644]
lib/ccan/typesafe_cb/test/compile_fail-typesafe_cb_postargs.c [new file with mode: 0644]
lib/ccan/typesafe_cb/test/compile_fail-typesafe_cb_preargs.c [new file with mode: 0644]
lib/ccan/typesafe_cb/test/compile_ok-cast_if_any.c [new file with mode: 0644]
lib/ccan/typesafe_cb/test/compile_ok-typesafe_cb-NULL.c [new file with mode: 0644]
lib/ccan/typesafe_cb/test/compile_ok-typesafe_cb-const.c [new file with mode: 0644]
lib/ccan/typesafe_cb/test/compile_ok-typesafe_cb-undefined.c [new file with mode: 0644]
lib/ccan/typesafe_cb/test/compile_ok-typesafe_cb-vars.c [new file with mode: 0644]
lib/ccan/typesafe_cb/test/compile_ok-typesafe_cb-volatile.c [new file with mode: 0644]
lib/ccan/typesafe_cb/test/compile_ok-typesafe_cb_cast.c [new file with mode: 0644]
lib/ccan/typesafe_cb/test/compile_ok-typesafe_cb_def-const.c [new file with mode: 0644]
lib/ccan/typesafe_cb/test/run.c [new file with mode: 0644]
lib/ccan/typesafe_cb/typesafe_cb.h [new file with mode: 0644]
lib/ccan/wscript [new file with mode: 0644]
source3/Makefile.in
source3/configure.in
source3/wscript
source3/wscript_build
wscript
wscript_build

diff --git a/lib/ccan/array_size/LICENSE b/lib/ccan/array_size/LICENSE
new file mode 100644 (file)
index 0000000..5522aa5
--- /dev/null
@@ -0,0 +1,508 @@
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+       51 Franklin St, 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 St, 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/lib/ccan/array_size/_info b/lib/ccan/array_size/_info
new file mode 100644 (file)
index 0000000..af7ef1c
--- /dev/null
@@ -0,0 +1,46 @@
+#include <stdio.h>
+#include <string.h>
+#include "config.h"
+
+/**
+ * array_size - routine for safely deriving the size of a visible array.
+ *
+ * This provides a simple ARRAY_SIZE() macro, which (given a good compiler)
+ * will also break compile if you try to use it on a pointer.
+ *
+ * This can ensure your code is robust to changes, without needing a gratuitous
+ * macro or constant.
+ *
+ * Example:
+ *     // Outputs "Initialized 32 values"
+ *     #include <ccan/array_size/array_size.h>
+ *     #include <stdlib.h>
+ *     #include <stdio.h>
+ *
+ *     // We currently use 32 random values.
+ *     static unsigned int vals[32];
+ *
+ *     int main(void)
+ *     {
+ *             unsigned int i;
+ *             for (i = 0; i < ARRAY_SIZE(vals); i++)
+ *                     vals[i] = random();
+ *             printf("Initialized %u values\n", i);
+ *             return 0;
+ *     }
+ *
+ * License: LGPL (2 or any later version)
+ * Author: Rusty Russell <rusty@rustcorp.com.au>
+ */
+int main(int argc, char *argv[])
+{
+       if (argc != 2)
+               return 1;
+
+       if (strcmp(argv[1], "depends") == 0) {
+               printf("ccan/build_assert\n");
+               return 0;
+       }
+
+       return 1;
+}
diff --git a/lib/ccan/array_size/array_size.h b/lib/ccan/array_size/array_size.h
new file mode 100644 (file)
index 0000000..0876945
--- /dev/null
@@ -0,0 +1,25 @@
+#ifndef CCAN_ARRAY_SIZE_H
+#define CCAN_ARRAY_SIZE_H
+#include "config.h"
+#include <ccan/build_assert/build_assert.h>
+
+/**
+ * ARRAY_SIZE - get the number of elements in a visible array
+ * @arr: the array whose size you want.
+ *
+ * This does not work on pointers, or arrays declared as [], or
+ * function parameters.  With correct compiler support, such usage
+ * will cause a build error (see build_assert).
+ */
+#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]) + _array_size_chk(arr))
+
+#if HAVE_BUILTIN_TYPES_COMPATIBLE_P && HAVE_TYPEOF
+/* Two gcc extensions.
+ * &a[0] degrades to a pointer: a different type from an array */
+#define _array_size_chk(arr)                                           \
+       BUILD_ASSERT_OR_ZERO(!__builtin_types_compatible_p(typeof(arr), \
+                                                       typeof(&(arr)[0])))
+#else
+#define _array_size_chk(arr) 0
+#endif
+#endif /* CCAN_ALIGNOF_H */
diff --git a/lib/ccan/array_size/test/compile_fail-function-param.c b/lib/ccan/array_size/test/compile_fail-function-param.c
new file mode 100644 (file)
index 0000000..cb64d98
--- /dev/null
@@ -0,0 +1,24 @@
+#include <ccan/array_size/array_size.h>
+#include <stdlib.h>
+
+struct foo {
+       unsigned int a, b;
+};
+
+int check_parameter(const struct foo array[4]);
+int check_parameter(const struct foo array[4])
+{
+#ifdef FAIL
+       return (ARRAY_SIZE(array) == 4);
+#if !HAVE_TYPEOF || !HAVE_BUILTIN_TYPES_COMPATIBLE_P
+#error "Unfortunately we don't fail if _array_size_chk is a noop."
+#endif
+#else
+       return sizeof(array) == 4 * sizeof(struct foo);
+#endif
+}
+
+int main(int argc, char *argv[])
+{
+       return check_parameter(NULL);
+}
diff --git a/lib/ccan/array_size/test/compile_fail.c b/lib/ccan/array_size/test/compile_fail.c
new file mode 100644 (file)
index 0000000..37d315f
--- /dev/null
@@ -0,0 +1,14 @@
+#include <ccan/array_size/array_size.h>
+
+int main(int argc, char *argv[8])
+{
+       char array[100];
+#ifdef FAIL
+       return ARRAY_SIZE(argv) + ARRAY_SIZE(array);
+#if !HAVE_TYPEOF || !HAVE_BUILTIN_TYPES_COMPATIBLE_P
+#error "Unfortunately we don't fail if _array_size_chk is a noop."
+#endif
+#else
+       return ARRAY_SIZE(array);
+#endif
+}
diff --git a/lib/ccan/array_size/test/run.c b/lib/ccan/array_size/test/run.c
new file mode 100644 (file)
index 0000000..37b4200
--- /dev/null
@@ -0,0 +1,33 @@
+#include <ccan/array_size/array_size.h>
+#include <ccan/tap/tap.h>
+
+static char array1[1];
+static int array2[2];
+static unsigned long array3[3][5];
+struct foo {
+       unsigned int a, b;
+       char string[100];
+};
+static struct foo array4[4];
+
+/* Make sure they can be used in initializers. */
+static int array1_size = ARRAY_SIZE(array1);
+static int array2_size = ARRAY_SIZE(array2);
+static int array3_size = ARRAY_SIZE(array3);
+static int array4_size = ARRAY_SIZE(array4);
+
+int main(int argc, char *argv[])
+{
+       plan_tests(8);
+       ok1(array1_size == 1);
+       ok1(array2_size == 2);
+       ok1(array3_size == 3);
+       ok1(array4_size == 4);
+
+       ok1(ARRAY_SIZE(array1) == 1);
+       ok1(ARRAY_SIZE(array2) == 2);
+       ok1(ARRAY_SIZE(array3) == 3);
+       ok1(ARRAY_SIZE(array4) == 4);
+
+       return exit_status();
+}
diff --git a/lib/ccan/asearch/LICENSE b/lib/ccan/asearch/LICENSE
new file mode 100644 (file)
index 0000000..5522aa5
--- /dev/null
@@ -0,0 +1,508 @@
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+       51 Franklin St, 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 St, 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/lib/ccan/asearch/_info b/lib/ccan/asearch/_info
new file mode 100644 (file)
index 0000000..8574750
--- /dev/null
@@ -0,0 +1,58 @@
+#include <stdio.h>
+#include <string.h>
+#include "config.h"
+
+/**
+ * asearch - typesafe binary search (bsearch)
+ *
+ * An ordered array of objects can be efficiently searched using a binary
+ * search algorithm; the time taken is around log(number of elements).
+ *
+ * This version uses macros to be typesafe on platforms which support it.
+ *
+ * License: LGPL
+ * Author: Rusty Russell <rusty@rustcorp.com.au>
+ *
+ * Example:
+ *     #include <ccan/asearch/asearch.h>
+ *     #include <stdio.h>
+ *     #include <string.h>
+ *
+ *     static int cmp(const char *key, char *const *elem)
+ *     {
+ *             return strcmp(key, *elem);
+ *     }
+ *
+ *     int main(int argc, char *argv[])
+ *     {
+ *             char **p;
+ *
+ *             if (argc < 2) {
+ *                     fprintf(stderr, "Usage: %s <key> <list>...\n"
+ *                             "Print position of key in (sorted) list\n",
+ *                             argv[0]);
+ *                     exit(1);
+ *             }
+ *
+ *             p = asearch(argv[1], &argv[2], argc-2, cmp);
+ *             if (!p) {
+ *                     printf("Not found!\n");
+ *                     return 1;
+ *             }
+ *             printf("%u\n", p - &argv[2]);
+ *             return 0;
+ *     }
+ */
+int main(int argc, char *argv[])
+{
+       if (argc != 2)
+               return 1;
+
+       if (strcmp(argv[1], "depends") == 0) {
+               printf("ccan/typesafe_cb\n");
+               printf("ccan/array_size\n");
+               return 0;
+       }
+
+       return 1;
+}
diff --git a/lib/ccan/asearch/asearch.h b/lib/ccan/asearch/asearch.h
new file mode 100644 (file)
index 0000000..d252284
--- /dev/null
@@ -0,0 +1,37 @@
+#ifndef CCAN_ASEARCH_H
+#define CCAN_ASEARCH_H
+#include <stdlib.h>
+#include <ccan/typesafe_cb/typesafe_cb.h>
+
+/**
+ * asearch - search an array of elements
+ * @key: pointer to item being searched for
+ * @base: pointer to data to sort
+ * @num: number of elements
+ * @cmp: pointer to comparison function
+ *
+ * This function does a binary search on the given array.  The
+ * contents of the array should already be in ascending sorted order
+ * under the provided comparison function.
+ *
+ * Note that the key need not have the same type as the elements in
+ * the array, e.g. key could be a string and the comparison function
+ * could compare the string with the struct's name field.  However, if
+ * the key and elements in the array are of the same type, you can use
+ * the same comparison function for both sort() and asearch().
+ */
+#if HAVE_TYPEOF
+#define asearch(key, base, num, cmp)                                   \
+       ((__typeof__(*(base))*)(bsearch((key), (base), (num), sizeof(*(base)), \
+               typesafe_cb_cast(int (*)(const void *, const void *),   \
+                                int (*)(const __typeof__(*(key)) *,    \
+                                        const __typeof__(*(base)) *),  \
+                                (cmp)))))
+
+#else
+#define asearch(key, base, num, cmp)                           \
+       (bsearch((key), (base), (num), sizeof(*(base)),         \
+                (int (*)(const void *, const void *))(cmp)))
+#endif
+
+#endif /* CCAN_ASEARCH_H */
diff --git a/lib/ccan/asearch/test/compile_fail-return-value-const.c b/lib/ccan/asearch/test/compile_fail-return-value-const.c
new file mode 100644 (file)
index 0000000..2edee93
--- /dev/null
@@ -0,0 +1,25 @@
+#include <ccan/asearch/asearch.h>
+#include <ccan/array_size/array_size.h>
+#include <string.h>
+
+static int cmp(const char *key, const char *const *elem)
+{
+       return strcmp(key, *elem);
+}
+
+int main(void)
+{
+       const char key[] = "key";
+       const char *elems[] = { "a", "big", "list", "of", "things" };
+
+#ifdef FAIL
+       char **p;
+#if !HAVE_TYPEOF
+#error "Unfortunately we don't fail if no typeof."
+#endif
+#else
+       const char **p;
+#endif
+       p = asearch(key, elems, ARRAY_SIZE(elems), cmp);
+       return p ? 0 : 1;
+}
diff --git a/lib/ccan/asearch/test/compile_fail-return-value.c b/lib/ccan/asearch/test/compile_fail-return-value.c
new file mode 100644 (file)
index 0000000..4aef532
--- /dev/null
@@ -0,0 +1,22 @@
+#include <ccan/asearch/asearch.h>
+
+static int cmp(const char *key, char *const *elem)
+{
+       return 0;
+}
+
+int main(int argc, char **argv)
+{
+       const char key[] = "key";
+
+#ifdef FAIL
+       int **p;
+#if !HAVE_TYPEOF
+#error "Unfortunately we don't fail if no typeof."
+#endif
+#else
+       char **p;
+#endif
+       p = asearch(key, argv+1, argc-1, cmp);
+       return p ? 0 : 1;
+}
diff --git a/lib/ccan/asearch/test/run-strings.c b/lib/ccan/asearch/test/run-strings.c
new file mode 100644 (file)
index 0000000..3ec4538
--- /dev/null
@@ -0,0 +1,22 @@
+#include <ccan/asearch/asearch.h>
+#include <ccan/array_size/array_size.h>
+#include <ccan/tap/tap.h>
+#include <stdlib.h>
+
+static int cmp(const int *key, const char *const *elem)
+{
+       return *key - atoi(*elem);
+}
+
+int main(void)
+{
+       const char *args[] = { "1", "4", "7", "9" };
+       int key = 7;
+       const char **p;
+
+       plan_tests(1);
+       p = asearch(&key, args, ARRAY_SIZE(args), cmp);
+       ok1(p == &args[2]);
+
+       return exit_status();
+}
diff --git a/lib/ccan/asearch/test/run.c b/lib/ccan/asearch/test/run.c
new file mode 100644 (file)
index 0000000..2a896fc
--- /dev/null
@@ -0,0 +1,40 @@
+#include <ccan/asearch/asearch.h>
+#include <ccan/array_size/array_size.h>
+#include <ccan/tap/tap.h>
+#include <limits.h>
+
+static int test_cmp(const int *key, const int *elt)
+{
+       if (*key < *elt)
+               return -1;
+       else if (*key > *elt)
+               return 1;
+       return 0;
+}
+
+int main(void)
+{
+       const int arr[] = { INT_MIN, 0, 1, 2, 3, 4, 5, 6, INT_MAX };
+       unsigned int start, num, i, total = 0;
+       int key;
+
+       plan_tests(285);
+
+       for (start = 0; start < ARRAY_SIZE(arr); start++) {
+               for (num = 0; num < ARRAY_SIZE(arr) - start; num++) {
+                       key = 7;
+                       ok1(asearch(&key, &arr[start], num, test_cmp) == NULL);
+                       total++;
+                       for (i = start; i < start+num; i++) {
+                               const int *ret;
+                               key = arr[i];
+                               ret = asearch(&key, &arr[start], num, test_cmp);
+                               ok1(ret);
+                               ok1(ret && *ret == key);
+                               total++;
+                       }
+               }
+       }
+       diag("Tested %u searches\n", total);
+       return exit_status();
+}
diff --git a/lib/ccan/build_assert/LICENSE b/lib/ccan/build_assert/LICENSE
new file mode 100644 (file)
index 0000000..5522aa5
--- /dev/null
@@ -0,0 +1,508 @@
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+       51 Franklin St, 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 St, 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/lib/ccan/build_assert/_info b/lib/ccan/build_assert/_info
new file mode 100644 (file)
index 0000000..0906af0
--- /dev/null
@@ -0,0 +1,49 @@
+#include <stdio.h>
+#include <string.h>
+#include "config.h"
+
+/**
+ * build_assert - routines for build-time assertions
+ *
+ * This code provides routines which will cause compilation to fail should some
+ * assertion be untrue: such failures are preferable to run-time assertions,
+ * but much more limited since they can only depends on compile-time constants.
+ *
+ * These assertions are most useful when two parts of the code must be kept in
+ * sync: it is better to avoid such cases if possible, but seconds best is to
+ * detect invalid changes at build time.
+ *
+ * For example, a tricky piece of code might rely on a certain element being at
+ * the start of the structure.  To ensure that future changes don't break it,
+ * you would catch such changes in your code like so:
+ *
+ * Example:
+ *     #include <stddef.h>
+ *     #include <ccan/build_assert/build_assert.h>
+ *
+ *     struct foo {
+ *             char string[5];
+ *             int x;
+ *     };
+ *
+ *     static char *foo_string(struct foo *foo)
+ *     {
+ *             // This trick requires that the string be first in the structure
+ *             BUILD_ASSERT(offsetof(struct foo, string) == 0);
+ *             return (char *)foo;
+ *     }
+ *
+ * License: LGPL (2 or any later version)
+ * Author: Rusty Russell <rusty@rustcorp.com.au>
+ */
+int main(int argc, char *argv[])
+{
+       if (argc != 2)
+               return 1;
+
+       if (strcmp(argv[1], "depends") == 0)
+               /* Nothing. */
+               return 0;
+
+       return 1;
+}
diff --git a/lib/ccan/build_assert/build_assert.h b/lib/ccan/build_assert/build_assert.h
new file mode 100644 (file)
index 0000000..24e59c4
--- /dev/null
@@ -0,0 +1,39 @@
+#ifndef CCAN_BUILD_ASSERT_H
+#define CCAN_BUILD_ASSERT_H
+
+/**
+ * BUILD_ASSERT - assert a build-time dependency.
+ * @cond: the compile-time condition which must be true.
+ *
+ * Your compile will fail if the condition isn't true, or can't be evaluated
+ * by the compiler.  This can only be used within a function.
+ *
+ * Example:
+ *     #include <stddef.h>
+ *     ...
+ *     static char *foo_to_char(struct foo *foo)
+ *     {
+ *             // This code needs string to be at start of foo.
+ *             BUILD_ASSERT(offsetof(struct foo, string) == 0);
+ *             return (char *)foo;
+ *     }
+ */
+#define BUILD_ASSERT(cond) \
+       do { (void) sizeof(char [1 - 2*!(cond)]); } while(0)
+
+/**
+ * BUILD_ASSERT_OR_ZERO - assert a build-time dependency, as an expression.
+ * @cond: the compile-time condition which must be true.
+ *
+ * Your compile will fail if the condition isn't true, or can't be evaluated
+ * by the compiler.  This can be used in an expression: its value is "0".
+ *
+ * Example:
+ *     #define foo_to_char(foo)                                        \
+ *              ((char *)(foo)                                         \
+ *               + BUILD_ASSERT_OR_ZERO(offsetof(struct foo, string) == 0))
+ */
+#define BUILD_ASSERT_OR_ZERO(cond) \
+       (sizeof(char [1 - 2*!(cond)]) - 1)
+
+#endif /* CCAN_BUILD_ASSERT_H */
diff --git a/lib/ccan/build_assert/test/compile_fail-expr.c b/lib/ccan/build_assert/test/compile_fail-expr.c
new file mode 100644 (file)
index 0000000..109215b
--- /dev/null
@@ -0,0 +1,10 @@
+#include <ccan/build_assert/build_assert.h>
+
+int main(int argc, char *argv[])
+{
+#ifdef FAIL
+       return BUILD_ASSERT_OR_ZERO(1 == 0);
+#else
+       return 0;
+#endif
+}
diff --git a/lib/ccan/build_assert/test/compile_fail.c b/lib/ccan/build_assert/test/compile_fail.c
new file mode 100644 (file)
index 0000000..37d95ed
--- /dev/null
@@ -0,0 +1,9 @@
+#include <ccan/build_assert/build_assert.h>
+
+int main(int argc, char *argv[])
+{
+#ifdef FAIL
+       BUILD_ASSERT(1 == 0);
+#endif
+       return 0;
+}
diff --git a/lib/ccan/build_assert/test/compile_ok.c b/lib/ccan/build_assert/test/compile_ok.c
new file mode 100644 (file)
index 0000000..4105484
--- /dev/null
@@ -0,0 +1,7 @@
+#include <ccan/build_assert/build_assert.h>
+
+int main(int argc, char *argv[])
+{
+       BUILD_ASSERT(1 == 1);
+       return 0;
+}
diff --git a/lib/ccan/build_assert/test/run-BUILD_ASSERT_OR_ZERO.c b/lib/ccan/build_assert/test/run-BUILD_ASSERT_OR_ZERO.c
new file mode 100644 (file)
index 0000000..4185821
--- /dev/null
@@ -0,0 +1,9 @@
+#include <ccan/build_assert/build_assert.h>
+#include <ccan/tap/tap.h>
+
+int main(int argc, char *argv[])
+{
+       plan_tests(1);
+       ok1(BUILD_ASSERT_OR_ZERO(1 == 1) == 0);
+       return exit_status();
+}
diff --git a/lib/ccan/build_assert/test/run-EXPR_BUILD_ASSERT.c b/lib/ccan/build_assert/test/run-EXPR_BUILD_ASSERT.c
new file mode 100644 (file)
index 0000000..91bbbbb
--- /dev/null
@@ -0,0 +1,9 @@
+#include <ccan/build_assert/build_assert.h>
+#include <ccan/tap/tap.h>
+
+int main(int argc, char *argv[])
+{
+       plan_tests(1);
+       ok1(EXPR_BUILD_ASSERT(1 == 1) == 0);
+       return exit_status();
+}
diff --git a/lib/ccan/cast/LICENSE b/lib/ccan/cast/LICENSE
new file mode 100644 (file)
index 0000000..cca7fc2
--- /dev/null
@@ -0,0 +1,165 @@
+                  GNU LESSER 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.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  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 that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU 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 as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
diff --git a/lib/ccan/cast/_info b/lib/ccan/cast/_info
new file mode 100644 (file)
index 0000000..5f82a05
--- /dev/null
@@ -0,0 +1,84 @@
+#include <string.h>
+#include "config.h"
+
+/**
+ * cast - routines for safer casting.
+ *
+ * Often you want to cast in a limited way, such as removing a const or
+ * switching between integer types.  However, normal casts will work on
+ * almost any type, making them dangerous when the code changes.
+ *
+ * These C++-inspired macros serve two purposes: they make it clear the
+ * exact reason for the cast, and they also (with some compilers) cause
+ * errors when misused.
+ *
+ * Based on Jan Engelhardt's libHX macros: http://libhx.sourceforge.net/
+ *
+ * Author: Jan Engelhardt
+ * Maintainer: Rusty Russell <rusty@rustcorp.com.au>
+ * License: LGPL
+ *
+ * Example:
+ *     // Given "test" contains "3 t's in 'test string'
+ *     #include <ccan/cast/cast.h>
+ *     #include <stdint.h>
+ *     #include <stdio.h>
+ *
+ *     // Find char @orig in @str, if @repl, replace them.  Return number.
+ *     static size_t find_chars(char *str, char orig, char repl)
+ *     {
+ *             size_t i, count = 0;
+ *             for (i = 0; str[i]; i++) {
+ *                     if (str[i] == orig) {
+ *                             count++;
+ *                             if (repl)
+ *                                     str[i] = repl;
+ *                     }
+ *             }
+ *             return count;
+ *     }
+ *
+ *     // Terrible hash function.
+ *     static uint64_t hash_string(const unsigned char *str)
+ *     {
+ *             size_t i;
+ *             uint64_t hash = 0;
+ *             for (i = 0; str[i]; i++)
+ *                     hash += str[i];
+ *             return hash;
+ *     }
+ *
+ *     int main(int argc, char *argv[])
+ *     {
+ *             uint64_t hash;
+ *
+ *             // find_chars wants a non-const string, but doesn't
+ *             // need it if repl == 0.
+ *             printf("%zu %c's in 'test string'\n",
+ *                    find_chars(cast_const(char *, "test string"),
+ *                               argv[1][0], 0),
+ *                    argv[1][0]);
+ *
+ *             // hash_string wants an unsigned char.
+ *             hash = hash_string(cast_signed(unsigned char *, argv[1]));
+ *
+ *             // Need a long long to hand to printf.
+ *             printf("Hash of '%s' = %llu\n", argv[1],
+ *                    cast_static(unsigned long long, hash));
+ *             return 0;
+ *     }
+ *
+ */
+int main(int argc, char *argv[])
+{
+       /* Expect exactly one argument */
+       if (argc != 2)
+               return 1;
+
+       if (strcmp(argv[1], "depends") == 0) {
+               printf("ccan/build_assert\n");
+               return 0;
+       }
+
+       return 1;
+}
diff --git a/lib/ccan/cast/cast.h b/lib/ccan/cast/cast.h
new file mode 100644 (file)
index 0000000..daebd85
--- /dev/null
@@ -0,0 +1,129 @@
+#ifndef CCAN_CAST_H
+#define CCAN_CAST_H
+#include "config.h"
+#include <stdint.h>
+#include <ccan/build_assert/build_assert.h>
+
+/**
+ * cast_signed - cast a (const) char * to/from (const) signed/unsigned char *.
+ * @type: some char * variant.
+ * @expr: expression (of some char * variant) to cast.
+ *
+ * Some libraries insist on an unsigned char in various places; cast_signed
+ * makes sure (with suitable compiler) that the expression you are casting
+ * only differs in signed/unsigned, not in type or const-ness.
+ */
+#define cast_signed(type, expr)                                                \
+       ((type)(expr)                                                   \
+        + BUILD_ASSERT_OR_ZERO(cast_sign_compatible(type, (expr))))
+
+/**
+ * cast_const - remove a const qualifier from a pointer.
+ * @type: some pointer type.
+ * @expr: expression to cast.
+ *
+ * This ensures that you are only removing the const qualifier from an
+ * expression.  The expression must otherwise match @type.
+ *
+ * If @type is a pointer to a pointer, you must use cast_const2 (etc).
+ *
+ * Example:
+ *     // Dumb open-coded strstr variant.
+ *     static char *find_needle(const char *haystack)
+ *     {
+ *             size_t i;
+ *             for (i = 0; i < strlen(haystack); i++)
+ *             if (memcmp("needle", haystack+i, strlen("needle")) == 0)
+ *                     return cast_const(char *, haystack+i);
+ *             return NULL;
+ *     }
+ */
+#define cast_const(type, expr)                                         \
+       ((type)((intptr_t)(expr)                                        \
+               + BUILD_ASSERT_OR_ZERO(cast_const_compat1((expr), type))))
+
+/**
+ * cast_const2 - remove a const qualifier from a pointer to a pointer.
+ * @type: some pointer to pointer type.
+ * @expr: expression to cast.
+ *
+ * This ensures that you are only removing the const qualifier from an
+ * expression.  The expression must otherwise match @type.
+ */
+#define cast_const2(type, expr)                                                \
+       ((type)((intptr_t)(expr)                                        \
+               + BUILD_ASSERT_OR_ZERO(cast_const_compat2((expr), type))))
+
+/**
+ * cast_const3 - remove a const from a pointer to a pointer to a pointer..
+ * @type: some pointer to pointer to pointer type.
+ * @expr: expression to cast.
+ *
+ * This ensures that you are only removing the const qualifier from an
+ * expression.  The expression must otherwise match @type.
+ */
+#define cast_const3(type, expr)                                                \
+       ((type)((intptr_t)(expr)                                        \
+               + BUILD_ASSERT_OR_ZERO(cast_const_compat3((expr), type))))
+
+
+/**
+ * cast_static - explicit mimic of implicit cast.
+ * @type: some type.
+ * @expr: expression to cast.
+ *
+ * This ensures that the cast is not to or from a pointer: it can only be
+ * an implicit cast, such as a pointer to a similar const pointer, or between
+ * integral types.
+ */
+#if HAVE_COMPOUND_LITERALS
+#define cast_static(type, expr)                        \
+       ((struct { type x; }){(expr)}.x)
+#else
+#define cast_static(type, expr)                        \
+       ((type)(expr))
+#endif
+
+/* Herein lies the gcc magic to evoke compile errors. */
+#if HAVE_BUILTIN_CHOOSE_EXPR && HAVE_BUILTIN_TYPES_COMPATIBLE_P && HAVE_TYPEOF
+#define cast_sign_compatible(t, e) \
+  __builtin_choose_expr(                                               \
+         __builtin_types_compatible_p(__typeof__(t), char *) ||        \
+         __builtin_types_compatible_p(__typeof__(t), signed char *) || \
+         __builtin_types_compatible_p(__typeof__(t), unsigned char *), \
+         /* if type is not const qualified */                          \
+         __builtin_types_compatible_p(__typeof__(e), char *) ||        \
+         __builtin_types_compatible_p(__typeof__(e), signed char *) || \
+         __builtin_types_compatible_p(__typeof__(e), unsigned char *), \
+         /* and if it is... */                                         \
+         __builtin_types_compatible_p(__typeof__(e), const char *) ||  \
+         __builtin_types_compatible_p(__typeof__(e), const signed char *) || \
+         __builtin_types_compatible_p(__typeof__(e), const unsigned char *) ||\
+         __builtin_types_compatible_p(__typeof__(e), char *) ||        \
+         __builtin_types_compatible_p(__typeof__(e), signed char *) || \
+         __builtin_types_compatible_p(__typeof__(e), unsigned char *)  \
+         )
+
+#define cast_const_strip1(expr)                        \
+       __typeof__(*(struct { int z; __typeof__(expr) x; }){0}.x)
+#define cast_const_strip2(expr) \
+       __typeof__(**(struct { int z; __typeof__(expr) x; }){0}.x)
+#define cast_const_strip3(expr) \
+       __typeof__(***(struct { int z; __typeof__(expr) x; }){0}.x)
+#define cast_const_compat1(expr, type)                                 \
+       __builtin_types_compatible_p(cast_const_strip1(expr),           \
+                                    cast_const_strip1(type))
+#define cast_const_compat2(expr, type)                                 \
+       __builtin_types_compatible_p(cast_const_strip2(expr),           \
+                                    cast_const_strip2(type))
+#define cast_const_compat3(expr, type)                                 \
+       __builtin_types_compatible_p(cast_const_strip3(expr),           \
+                                    cast_const_strip3(type))
+#else
+#define cast_sign_compatible(type, expr)               \
+       (sizeof(*(type)0) == 1 && sizeof(*(expr)) == 1)
+#define cast_const_compat1(expr, type)         (1)
+#define cast_const_compat2(expr, type)         (1)
+#define cast_const_compat3(expr, type)         (1)
+#endif
+#endif /* CCAN_CAST_H */
diff --git a/lib/ccan/cast/test/compile_fail-cast_const.c b/lib/ccan/cast/test/compile_fail-cast_const.c
new file mode 100644 (file)
index 0000000..277f3de
--- /dev/null
@@ -0,0 +1,29 @@
+#include <ccan/cast/cast.h>
+#include <stdlib.h>
+
+/* Note: this *isn't* sizeof(char) on all platforms. */
+struct char_struct {
+       char c;
+};
+
+int main(int argc, char *argv[])
+{
+       char *uc;
+       const
+#ifdef FAIL
+               struct char_struct
+#else
+               char
+#endif
+               *p = NULL;
+
+       uc = cast_const(char *, p);
+       (void) uc; /* Suppress unused-but-set-variable warning. */
+       return 0;
+}
+
+#ifdef FAIL
+#if !HAVE_TYPEOF||!HAVE_BUILTIN_CHOOSE_EXPR||!HAVE_BUILTIN_TYPES_COMPATIBLE_P
+#error "Unfortunately we don't fail if cast_const can only use size"
+#endif
+#endif
diff --git a/lib/ccan/cast/test/compile_fail-cast_const2.c b/lib/ccan/cast/test/compile_fail-cast_const2.c
new file mode 100644 (file)
index 0000000..e671e88
--- /dev/null
@@ -0,0 +1,29 @@
+#include <ccan/cast/cast.h>
+#include <stdlib.h>
+
+/* Note: this *isn't* sizeof(char) on all platforms. */
+struct char_struct {
+       char c;
+};
+
+int main(int argc, char *argv[])
+{
+       char **uc;
+       const
+#ifdef FAIL
+               struct char_struct
+#else
+               char
+#endif
+               **p = NULL;
+
+       uc = cast_const2(char **, p);
+       (void) uc; /* Suppress unused-but-set-variable warning. */
+       return 0;
+}
+
+#ifdef FAIL
+#if !HAVE_TYPEOF||!HAVE_BUILTIN_CHOOSE_EXPR||!HAVE_BUILTIN_TYPES_COMPATIBLE_P
+#error "Unfortunately we don't fail if cast_const can only use size"
+#endif
+#endif
diff --git a/lib/ccan/cast/test/compile_fail-cast_const3.c b/lib/ccan/cast/test/compile_fail-cast_const3.c
new file mode 100644 (file)
index 0000000..e958e2d
--- /dev/null
@@ -0,0 +1,29 @@
+#include <ccan/cast/cast.h>
+#include <stdlib.h>
+
+/* Note: this *isn't* sizeof(char) on all platforms. */
+struct char_struct {
+       char c;
+};
+
+int main(int argc, char *argv[])
+{
+       char ***uc;
+       const
+#ifdef FAIL
+               struct char_struct
+#else
+               char
+#endif
+               ***p = NULL;
+
+       uc = cast_const3(char ***, p);
+       (void) uc; /* Suppress unused-but-set-variable warning. */
+       return 0;
+}
+
+#ifdef FAIL
+#if !HAVE_TYPEOF||!HAVE_BUILTIN_CHOOSE_EXPR||!HAVE_BUILTIN_TYPES_COMPATIBLE_P
+#error "Unfortunately we don't fail if cast_const can only use size"
+#endif
+#endif
diff --git a/lib/ccan/cast/test/compile_fail-cast_signed-const.c b/lib/ccan/cast/test/compile_fail-cast_signed-const.c
new file mode 100644 (file)
index 0000000..9971dc8
--- /dev/null
@@ -0,0 +1,22 @@
+#include <ccan/cast/cast.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+       unsigned char *uc;
+#ifdef FAIL
+       const
+#endif
+       char
+               *p = NULL;
+
+       uc = cast_signed(unsigned char *, p);
+       (void) uc; /* Suppress unused-but-set-variable warning. */
+       return 0;
+}
+
+#ifdef FAIL
+#if !HAVE_TYPEOF||!HAVE_BUILTIN_CHOOSE_EXPR||!HAVE_BUILTIN_TYPES_COMPATIBLE_P
+#error "Unfortunately we don't fail if cast_const can only use size"
+#endif
+#endif
diff --git a/lib/ccan/cast/test/compile_fail-cast_signed-sizesame.c b/lib/ccan/cast/test/compile_fail-cast_signed-sizesame.c
new file mode 100644 (file)
index 0000000..2bc40b2
--- /dev/null
@@ -0,0 +1,29 @@
+#include <ccan/cast/cast.h>
+#include <stdlib.h>
+
+/* Note: this *isn't* sizeof(char) on all platforms. */
+struct char_struct {
+       char c;
+};
+
+int main(int argc, char *argv[])
+{
+       unsigned char *uc;
+#ifdef FAIL
+       struct char_struct
+#else
+       char
+#endif
+               *p = NULL;
+
+       uc = cast_signed(unsigned char *, p);
+
+       (void) uc; /* Suppress unused-but-set-variable warning. */
+       return 0;
+}
+
+#ifdef FAIL
+#if !HAVE_TYPEOF||!HAVE_BUILTIN_CHOOSE_EXPR||!HAVE_BUILTIN_TYPES_COMPATIBLE_P
+#error "Unfortunately we don't fail if cast_signed can only use size"
+#endif
+#endif
diff --git a/lib/ccan/cast/test/compile_fail-cast_signed.c b/lib/ccan/cast/test/compile_fail-cast_signed.c
new file mode 100644 (file)
index 0000000..66bcc0a
--- /dev/null
@@ -0,0 +1,17 @@
+#include <ccan/cast/cast.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+       unsigned char *uc;
+#ifdef FAIL
+       int
+#else
+       char
+#endif
+               *p = NULL;
+
+       uc = cast_signed(unsigned char *, p);
+       (void) uc; /* Suppress unused-but-set-variable warning. */
+       return 0;
+}
diff --git a/lib/ccan/cast/test/compile_fail-cast_static-2.c b/lib/ccan/cast/test/compile_fail-cast_static-2.c
new file mode 100644 (file)
index 0000000..8a12025
--- /dev/null
@@ -0,0 +1,23 @@
+#include <ccan/cast/cast.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+       char *c;
+#ifdef FAIL
+       long
+#else
+       char
+#endif
+               *p = 0;
+
+       c = cast_static(char *, p);
+       (void) c; /* Suppress unused-but-set-variable warning. */
+       return 0;
+}
+
+#ifdef FAIL
+#if !HAVE_COMPOUND_LITERALS
+#error "Unfortunately we don't fail if cast_static is a noop"
+#endif
+#endif
diff --git a/lib/ccan/cast/test/compile_fail-cast_static-3.c b/lib/ccan/cast/test/compile_fail-cast_static-3.c
new file mode 100644 (file)
index 0000000..6296b75
--- /dev/null
@@ -0,0 +1,21 @@
+#include <ccan/cast/cast.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+       char *c;
+#ifdef FAIL
+       const
+#endif
+               char *p = 0;
+
+       c = cast_static(char *, p);
+       (void) c; /* Suppress unused-but-set-variable warning. */
+       return 0;
+}
+
+#ifdef FAIL
+#if !HAVE_COMPOUND_LITERALS
+#error "Unfortunately we don't fail if cast_static is a noop"
+#endif
+#endif
diff --git a/lib/ccan/cast/test/compile_fail-cast_static.c b/lib/ccan/cast/test/compile_fail-cast_static.c
new file mode 100644 (file)
index 0000000..0f9e478
--- /dev/null
@@ -0,0 +1,17 @@
+#include <ccan/cast/cast.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+       char c;
+#ifdef FAIL
+       char *
+#else
+       long
+#endif
+               x = 0;
+
+       c = cast_static(char, x);
+       (void) c; /* Suppress unused-but-set-variable warning. */
+       return 0;
+}
diff --git a/lib/ccan/cast/test/compile_ok-cast_void.c b/lib/ccan/cast/test/compile_ok-cast_void.c
new file mode 100644 (file)
index 0000000..c649d28
--- /dev/null
@@ -0,0 +1,12 @@
+#include <ccan/cast/cast.h>
+
+static void *remove_void(const void *p)
+{
+       return cast_const(void *, p);
+}
+
+int main(void)
+{
+       void *p = remove_void("foo");
+       return !p;
+}
diff --git a/lib/ccan/compiler/LICENSE b/lib/ccan/compiler/LICENSE
new file mode 100644 (file)
index 0000000..cca7fc2
--- /dev/null
@@ -0,0 +1,165 @@
+                  GNU LESSER 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.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  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 that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU 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 as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
diff --git a/lib/ccan/compiler/_info b/lib/ccan/compiler/_info
new file mode 100644 (file)
index 0000000..c55ba22
--- /dev/null
@@ -0,0 +1,64 @@
+#include <string.h>
+#include <stdio.h>
+#include "config.h"
+
+/**
+ * compiler - macros for common compiler extensions
+ *
+ * Abstracts away some compiler hints.  Currently these include:
+ * - COLD
+ *     For functions not called in fast paths (aka. cold functions)
+ * - PRINTF_FMT
+ *     For functions which take printf-style parameters.
+ * - IDEMPOTENT
+ *     For functions which return the same value for same parameters.
+ * - NEEDED
+ *     For functions and variables which must be emitted even if unused.
+ * - UNNEEDED
+ *     For functions and variables which need not be emitted if unused.
+ * - UNUSED
+ *     For parameters which are not used.
+ * - IS_COMPILE_CONSTANT
+ *     For using different tradeoffs for compiletime vs runtime evaluation.
+ *
+ * License: LGPL (3 or any later version)
+ * Author: Rusty Russell <rusty@rustcorp.com.au>
+ *
+ * Example:
+ *     #include <ccan/compiler/compiler.h>
+ *     #include <stdio.h>
+ *     #include <stdarg.h>
+ *
+ *     // Example of a (slow-path) logging function.
+ *     static int log_threshold = 2;
+ *     static void COLD PRINTF_FMT(2,3)
+ *             logger(int level, const char *fmt, ...)
+ *     {
+ *             va_list ap;
+ *             va_start(ap, fmt);
+ *             if (level >= log_threshold)
+ *                     vfprintf(stderr, fmt, ap);
+ *             va_end(ap);
+ *     }
+ *
+ *     int main(int argc, char *argv[])
+ *     {
+ *             if (argc != 1) {
+ *                     logger(3, "Don't want %i arguments!\n", argc-1);
+ *                     return 1;
+ *             }
+ *             return 0;
+ *     }
+ */
+int main(int argc, char *argv[])
+{
+       /* Expect exactly one argument */
+       if (argc != 2)
+               return 1;
+
+       if (strcmp(argv[1], "depends") == 0) {
+               return 0;
+       }
+
+       return 1;
+}
diff --git a/lib/ccan/compiler/compiler.h b/lib/ccan/compiler/compiler.h
new file mode 100644 (file)
index 0000000..74e0f18
--- /dev/null
@@ -0,0 +1,216 @@
+#ifndef CCAN_COMPILER_H
+#define CCAN_COMPILER_H
+#include "config.h"
+
+#ifndef COLD
+#if HAVE_ATTRIBUTE_COLD
+/**
+ * COLD - a function is unlikely to be called.
+ *
+ * Used to mark an unlikely code path and optimize appropriately.
+ * It is usually used on logging or error routines.
+ *
+ * Example:
+ * static void COLD moan(const char *reason)
+ * {
+ *     fprintf(stderr, "Error: %s (%s)\n", reason, strerror(errno));
+ * }
+ */
+#define COLD __attribute__((cold))
+#else
+#define COLD
+#endif
+#endif
+
+#ifndef NORETURN
+#if HAVE_ATTRIBUTE_NORETURN
+/**
+ * NORETURN - a function does not return
+ *
+ * Used to mark a function which exits; useful for suppressing warnings.
+ *
+ * Example:
+ * static void NORETURN fail(const char *reason)
+ * {
+ *     fprintf(stderr, "Error: %s (%s)\n", reason, strerror(errno));
+ *     exit(1);
+ * }
+ */
+#define NORETURN __attribute__((noreturn))
+#else
+#define NORETURN
+#endif
+#endif
+
+#ifndef PRINTF_FMT
+#if HAVE_ATTRIBUTE_PRINTF
+/**
+ * PRINTF_FMT - a function takes printf-style arguments
+ * @nfmt: the 1-based number of the function's format argument.
+ * @narg: the 1-based number of the function's first variable argument.
+ *
+ * This allows the compiler to check your parameters as it does for printf().
+ *
+ * Example:
+ * void PRINTF_FMT(2,3) my_printf(const char *prefix, const char *fmt, ...);
+ */
+#define PRINTF_FMT(nfmt, narg) \
+       __attribute__((format(__printf__, nfmt, narg)))
+#else
+#define PRINTF_FMT(nfmt, narg)
+#endif
+#endif
+
+#ifndef IDEMPOTENT
+#if HAVE_ATTRIBUTE_CONST
+/**
+ * IDEMPOTENT - a function's return depends only on its argument
+ *
+ * This allows the compiler to assume that the function will return the exact
+ * same value for the exact same arguments.  This implies that the function
+ * must not use global variables, or dereference pointer arguments.
+ */
+#define IDEMPOTENT __attribute__((const))
+#else
+#define IDEMPOTENT
+#endif
+#endif
+
+#if HAVE_ATTRIBUTE_UNUSED
+#ifndef UNNEEDED
+/**
+ * UNNEEDED - a variable/function may not be needed
+ *
+ * This suppresses warnings about unused variables or functions, but tells
+ * the compiler that if it is unused it need not emit it into the source code.
+ *
+ * Example:
+ * // With some preprocessor options, this is unnecessary.
+ * static UNNEEDED int counter;
+ *
+ * // With some preprocessor options, this is unnecessary.
+ * static UNNEEDED void add_to_counter(int add)
+ * {
+ *     counter += add;
+ * }
+ */
+#define UNNEEDED __attribute__((unused))
+#endif
+
+#ifndef NEEDED
+#if HAVE_ATTRIBUTE_USED
+/**
+ * NEEDED - a variable/function is needed
+ *
+ * This suppresses warnings about unused variables or functions, but tells
+ * the compiler that it must exist even if it (seems) unused.
+ *
+ * Example:
+ *     // Even if this is unused, these are vital for debugging.
+ *     static NEEDED int counter;
+ *     static NEEDED void dump_counter(void)
+ *     {
+ *             printf("Counter is %i\n", counter);
+ *     }
+ */
+#define NEEDED __attribute__((used))
+#else
+/* Before used, unused functions and vars were always emitted. */
+#define NEEDED __attribute__((unused))
+#endif
+#endif
+
+#ifndef UNUSED
+/**
+ * UNUSED - a parameter is unused
+ *
+ * Some compilers (eg. gcc with -W or -Wunused) warn about unused
+ * function parameters.  This suppresses such warnings and indicates
+ * to the reader that it's deliberate.
+ *
+ * Example:
+ *     // This is used as a callback, so needs to have this prototype.
+ *     static int some_callback(void *unused UNUSED)
+ *     {
+ *             return 0;
+ *     }
+ */
+#define UNUSED __attribute__((unused))
+#endif
+#else
+#ifndef UNNEEDED
+#define UNNEEDED
+#endif
+#ifndef NEEDED
+#define NEEDED
+#endif
+#ifndef UNUSED
+#define UNUSED
+#endif
+#endif
+
+#ifndef IS_COMPILE_CONSTANT
+#if HAVE_BUILTIN_CONSTANT_P
+/**
+ * IS_COMPILE_CONSTANT - does the compiler know the value of this expression?
+ * @expr: the expression to evaluate
+ *
+ * When an expression manipulation is complicated, it is usually better to
+ * implement it in a function.  However, if the expression being manipulated is
+ * known at compile time, it is better to have the compiler see the entire
+ * expression so it can simply substitute the result.
+ *
+ * This can be done using the IS_COMPILE_CONSTANT() macro.
+ *
+ * Example:
+ *     enum greek { ALPHA, BETA, GAMMA, DELTA, EPSILON };
+ *
+ *     // Out-of-line version.
+ *     const char *greek_name(enum greek greek);
+ *
+ *     // Inline version.
+ *     static inline const char *_greek_name(enum greek greek)
+ *     {
+ *             switch (greek) {
+ *             case ALPHA: return "alpha";
+ *             case BETA: return "beta";
+ *             case GAMMA: return "gamma";
+ *             case DELTA: return "delta";
+ *             case EPSILON: return "epsilon";
+ *             default: return "**INVALID**";
+ *             }
+ *     }
+ *
+ *     // Use inline if compiler knows answer.  Otherwise call function
+ *     // to avoid copies of the same code everywhere.
+ *     #define greek_name(g)                                           \
+ *              (IS_COMPILE_CONSTANT(greek) ? _greek_name(g) : greek_name(g))
+ */
+#define IS_COMPILE_CONSTANT(expr) __builtin_constant_p(expr)
+#else
+/* If we don't know, assume it's not. */
+#define IS_COMPILE_CONSTANT(expr) 0
+#endif
+#endif
+
+#ifndef WARN_UNUSED_RESULT
+#if HAVE_WARN_UNUSED_RESULT
+/**
+ * WARN_UNUSED_RESULT - warn if a function return value is unused.
+ *
+ * Used to mark a function where it is extremely unlikely that the caller
+ * can ignore the result, eg realloc().
+ *
+ * Example:
+ * // buf param may be freed by this; need return value!
+ * static char *WARN_UNUSED_RESULT enlarge(char *buf, unsigned *size)
+ * {
+ *     return realloc(buf, (*size) *= 2);
+ * }
+ */
+#define WARN_UNUSED_RESULT __attribute__((warn_unused_result))
+#else
+#define WARN_UNUSED_RESULT
+#endif
+#endif
+#endif /* CCAN_COMPILER_H */
diff --git a/lib/ccan/compiler/test/compile_fail-printf.c b/lib/ccan/compiler/test/compile_fail-printf.c
new file mode 100644 (file)
index 0000000..8f34ae5
--- /dev/null
@@ -0,0 +1,22 @@
+#include <ccan/compiler/compiler.h>
+
+static void PRINTF_FMT(2,3) my_printf(int x, const char *fmt, ...)
+{
+}
+
+int main(int argc, char *argv[])
+{
+       unsigned int i = 0;
+
+       my_printf(1, "Not a pointer "
+#ifdef FAIL
+                 "%p",
+#if !HAVE_ATTRIBUTE_PRINTF
+#error "Unfortunately we don't fail if !HAVE_ATTRIBUTE_PRINTF."
+#endif
+#else
+                 "%i",
+#endif
+                 i);
+       return 0;
+}
diff --git a/lib/ccan/compiler/test/run-is_compile_constant.c b/lib/ccan/compiler/test/run-is_compile_constant.c
new file mode 100644 (file)
index 0000000..a66f2e1
--- /dev/null
@@ -0,0 +1,15 @@
+#include <ccan/compiler/compiler.h>
+#include <ccan/tap/tap.h>
+
+int main(int argc, char *argv[])
+{
+       plan_tests(2);
+
+       ok1(!IS_COMPILE_CONSTANT(argc));
+#if HAVE_BUILTIN_CONSTANT_P
+       ok1(IS_COMPILE_CONSTANT(7));
+#else
+       pass("If !HAVE_BUILTIN_CONSTANT_P, IS_COMPILE_CONSTANT always false");
+#endif
+       return exit_status();
+}
diff --git a/lib/ccan/endian/LICENSE b/lib/ccan/endian/LICENSE
new file mode 100644 (file)
index 0000000..5522aa5
--- /dev/null
@@ -0,0 +1,508 @@
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+       51 Franklin St, 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 St, 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/lib/ccan/endian/_info b/lib/ccan/endian/_info
new file mode 100644 (file)
index 0000000..5d4d65f
--- /dev/null
@@ -0,0 +1,53 @@
+#include <stdio.h>
+#include <string.h>
+#include "config.h"
+
+/**
+ * endian - endian conversion macros for simple types
+ *
+ * Portable protocols (such as on-disk formats, or network protocols)
+ * are often defined to be a particular endian: little-endian (least
+ * significant bytes first) or big-endian (most significant bytes
+ * first).
+ *
+ * Similarly, some CPUs lay out values in memory in little-endian
+ * order (most commonly, Intel's 8086 and derivatives), or big-endian
+ * order (almost everyone else).
+ *
+ * This module provides conversion routines, inspired by the linux kernel.
+ *
+ * Example:
+ *     #include <stdio.h>
+ *     #include <err.h>
+ *     #include <ccan/endian/endian.h>
+ *
+ *     //
+ *     int main(int argc, char *argv[])
+ *     {
+ *             uint32_t value;
+ *
+ *             if (argc != 2)
+ *                     errx(1, "Usage: %s <value>", argv[0]);
+ *
+ *             value = atoi(argv[1]);
+ *             printf("native:        %08x\n", value);
+ *             printf("little-endian: %08x\n", cpu_to_le32(value));
+ *             printf("big-endian:    %08x\n", cpu_to_be32(value));
+ *             printf("byte-reversed: %08x\n", bswap_32(value));
+ *             exit(0);
+ *     }
+ *
+ * License: LGPL (2 or any later version)
+ * Author: Rusty Russell <rusty@rustcorp.com.au>
+ */
+int main(int argc, char *argv[])
+{
+       if (argc != 2)
+               return 1;
+
+       if (strcmp(argv[1], "depends") == 0)
+               /* Nothing */
+               return 0;
+
+       return 1;
+}
diff --git a/lib/ccan/endian/endian.h b/lib/ccan/endian/endian.h
new file mode 100644 (file)
index 0000000..baee60b
--- /dev/null
@@ -0,0 +1,226 @@
+#ifndef CCAN_ENDIAN_H
+#define CCAN_ENDIAN_H
+#include <stdint.h>
+#include "config.h"
+
+#if HAVE_BYTESWAP_H
+#include <byteswap.h>
+#else
+/**
+ * bswap_16 - reverse bytes in a uint16_t value.
+ * @val: value whose bytes to swap.
+ *
+ * Example:
+ *     // Output contains "1024 is 4 as two bytes reversed"
+ *     printf("1024 is %u as two bytes reversed\n", bswap_16(1024));
+ */
+static inline uint16_t bswap_16(uint16_t val)
+{
+       return ((val & (uint16_t)0x00ffU) << 8)
+               | ((val & (uint16_t)0xff00U) >> 8);
+}
+
+/**
+ * bswap_32 - reverse bytes in a uint32_t value.
+ * @val: value whose bytes to swap.
+ *
+ * Example:
+ *     // Output contains "1024 is 262144 as four bytes reversed"
+ *     printf("1024 is %u as four bytes reversed\n", bswap_32(1024));
+ */
+static inline uint32_t bswap_32(uint32_t val)
+{
+       return ((val & (uint32_t)0x000000ffUL) << 24)
+               | ((val & (uint32_t)0x0000ff00UL) <<  8)
+               | ((val & (uint32_t)0x00ff0000UL) >>  8)
+               | ((val & (uint32_t)0xff000000UL) >> 24);
+}
+#endif /* !HAVE_BYTESWAP_H */
+
+#if !HAVE_BSWAP_64
+/**
+ * bswap_64 - reverse bytes in a uint64_t value.
+ * @val: value whose bytes to swap.
+ *
+ * Example:
+ *     // Output contains "1024 is 1125899906842624 as eight bytes reversed"
+ *     printf("1024 is %llu as eight bytes reversed\n",
+ *             (unsigned long long)bswap_64(1024));
+ */
+static inline uint64_t bswap_64(uint64_t val)
+{
+       return ((val & (uint64_t)0x00000000000000ffULL) << 56)
+               | ((val & (uint64_t)0x000000000000ff00ULL) << 40)
+               | ((val & (uint64_t)0x0000000000ff0000ULL) << 24)
+               | ((val & (uint64_t)0x00000000ff000000ULL) <<  8)
+               | ((val & (uint64_t)0x000000ff00000000ULL) >>  8)
+               | ((val & (uint64_t)0x0000ff0000000000ULL) >> 24)
+               | ((val & (uint64_t)0x00ff000000000000ULL) >> 40)
+               | ((val & (uint64_t)0xff00000000000000ULL) >> 56);
+}
+#endif
+
+/* Sanity check the defines.  We don't handle weird endianness. */
+#if !HAVE_LITTLE_ENDIAN && !HAVE_BIG_ENDIAN
+#error "Unknown endian"
+#elif HAVE_LITTLE_ENDIAN && HAVE_BIG_ENDIAN
+#error "Can't compile for both big and little endian."
+#endif
+
+/**
+ * cpu_to_le64 - convert a uint64_t value to little-endian
+ * @native: value to convert
+ */
+static inline uint64_t cpu_to_le64(uint64_t native)
+{
+#if HAVE_LITTLE_ENDIAN
+       return native;
+#else
+       return bswap_64(native);
+#endif
+}
+
+/**
+ * cpu_to_le32 - convert a uint32_t value to little-endian
+ * @native: value to convert
+ */
+static inline uint32_t cpu_to_le32(uint32_t native)
+{
+#if HAVE_LITTLE_ENDIAN
+       return native;
+#else
+       return bswap_32(native);
+#endif
+}
+
+/**
+ * cpu_to_le16 - convert a uint16_t value to little-endian
+ * @native: value to convert
+ */
+static inline uint16_t cpu_to_le16(uint16_t native)
+{
+#if HAVE_LITTLE_ENDIAN
+       return native;
+#else
+       return bswap_16(native);
+#endif
+}
+
+/**
+ * le64_to_cpu - convert a little-endian uint64_t value
+ * @le_val: little-endian value to convert
+ */
+static inline uint64_t le64_to_cpu(uint64_t le_val)
+{
+#if HAVE_LITTLE_ENDIAN
+       return le_val;
+#else
+       return bswap_64(le_val);
+#endif
+}
+
+/**
+ * le32_to_cpu - convert a little-endian uint32_t value
+ * @le_val: little-endian value to convert
+ */
+static inline uint32_t le32_to_cpu(uint32_t le_val)
+{
+#if HAVE_LITTLE_ENDIAN
+       return le_val;
+#else
+       return bswap_32(le_val);
+#endif
+}
+
+/**
+ * le16_to_cpu - convert a little-endian uint16_t value
+ * @le_val: little-endian value to convert
+ */
+static inline uint16_t le16_to_cpu(uint16_t le_val)
+{
+#if HAVE_LITTLE_ENDIAN
+       return le_val;
+#else
+       return bswap_16(le_val);
+#endif
+}
+
+/**
+ * cpu_to_be64 - convert a uint64_t value to big endian.
+ * @native: value to convert
+ */
+static inline uint64_t cpu_to_be64(uint64_t native)
+{
+#if HAVE_LITTLE_ENDIAN
+       return bswap_64(native);
+#else
+       return native;
+#endif
+}
+
+/**
+ * cpu_to_be32 - convert a uint32_t value to big endian.
+ * @native: value to convert
+ */
+static inline uint32_t cpu_to_be32(uint32_t native)
+{
+#if HAVE_LITTLE_ENDIAN
+       return bswap_32(native);
+#else
+       return native;
+#endif
+}
+
+/**
+ * cpu_to_be16 - convert a uint16_t value to big endian.
+ * @native: value to convert
+ */
+static inline uint16_t cpu_to_be16(uint16_t native)
+{
+#if HAVE_LITTLE_ENDIAN
+       return bswap_16(native);
+#else
+       return native;
+#endif
+}
+
+/**
+ * be64_to_cpu - convert a big-endian uint64_t value
+ * @be_val: big-endian value to convert
+ */
+static inline uint64_t be64_to_cpu(uint64_t be_val)
+{
+#if HAVE_LITTLE_ENDIAN
+       return bswap_64(be_val);
+#else
+       return be_val;
+#endif
+}
+
+/**
+ * be32_to_cpu - convert a big-endian uint32_t value
+ * @be_val: big-endian value to convert
+ */
+static inline uint32_t be32_to_cpu(uint32_t be_val)
+{
+#if HAVE_LITTLE_ENDIAN
+       return bswap_32(be_val);
+#else
+       return be_val;
+#endif
+}
+
+/**
+ * be16_to_cpu - convert a big-endian uint16_t value
+ * @be_val: big-endian value to convert
+ */
+static inline uint16_t be16_to_cpu(uint16_t be_val)
+{
+#if HAVE_LITTLE_ENDIAN
+       return bswap_16(be_val);
+#else
+       return be_val;
+#endif
+}
+
+#endif /* CCAN_ENDIAN_H */
diff --git a/lib/ccan/endian/test/run.c b/lib/ccan/endian/test/run.c
new file mode 100644 (file)
index 0000000..a00fce7
--- /dev/null
@@ -0,0 +1,106 @@
+#include <ccan/endian/endian.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <ccan/tap/tap.h>
+
+int main(int argc, char *argv[])
+{
+       union {
+               uint64_t u64;
+               unsigned char u64_bytes[8];
+       } u64;
+       union {
+               uint32_t u32;
+               unsigned char u32_bytes[4];
+       } u32;
+       union {
+               uint16_t u16;
+               unsigned char u16_bytes[2];
+       } u16;
+
+       plan_tests(48);
+
+       /* Straight swap tests. */
+       u64.u64_bytes[0] = 0x00;
+       u64.u64_bytes[1] = 0x11;
+       u64.u64_bytes[2] = 0x22;
+       u64.u64_bytes[3] = 0x33;
+       u64.u64_bytes[4] = 0x44;
+       u64.u64_bytes[5] = 0x55;
+       u64.u64_bytes[6] = 0x66;
+       u64.u64_bytes[7] = 0x77;
+       u64.u64 = bswap_64(u64.u64);
+       ok1(u64.u64_bytes[7] == 0x00);
+       ok1(u64.u64_bytes[6] == 0x11);
+       ok1(u64.u64_bytes[5] == 0x22);
+       ok1(u64.u64_bytes[4] == 0x33);
+       ok1(u64.u64_bytes[3] == 0x44);
+       ok1(u64.u64_bytes[2] == 0x55);
+       ok1(u64.u64_bytes[1] == 0x66);
+       ok1(u64.u64_bytes[0] == 0x77);
+
+       u32.u32_bytes[0] = 0x00;
+       u32.u32_bytes[1] = 0x11;
+       u32.u32_bytes[2] = 0x22;
+       u32.u32_bytes[3] = 0x33;
+       u32.u32 = bswap_32(u32.u32);
+       ok1(u32.u32_bytes[3] == 0x00);
+       ok1(u32.u32_bytes[2] == 0x11);
+       ok1(u32.u32_bytes[1] == 0x22);
+       ok1(u32.u32_bytes[0] == 0x33);
+
+       u16.u16_bytes[0] = 0x00;
+       u16.u16_bytes[1] = 0x11;
+       u16.u16 = bswap_16(u16.u16);
+       ok1(u16.u16_bytes[1] == 0x00);
+       ok1(u16.u16_bytes[0] == 0x11);
+
+       /* Endian tests. */
+       u64.u64 = cpu_to_le64(0x0011223344556677ULL);
+       ok1(u64.u64_bytes[0] == 0x77);
+       ok1(u64.u64_bytes[1] == 0x66);
+       ok1(u64.u64_bytes[2] == 0x55);
+       ok1(u64.u64_bytes[3] == 0x44);
+       ok1(u64.u64_bytes[4] == 0x33);
+       ok1(u64.u64_bytes[5] == 0x22);
+       ok1(u64.u64_bytes[6] == 0x11);
+       ok1(u64.u64_bytes[7] == 0x00);
+       ok1(le64_to_cpu(u64.u64) == 0x0011223344556677ULL);
+
+       u64.u64 = cpu_to_be64(0x0011223344556677ULL);
+       ok1(u64.u64_bytes[7] == 0x77);
+       ok1(u64.u64_bytes[6] == 0x66);
+       ok1(u64.u64_bytes[5] == 0x55);
+       ok1(u64.u64_bytes[4] == 0x44);
+       ok1(u64.u64_bytes[3] == 0x33);
+       ok1(u64.u64_bytes[2] == 0x22);
+       ok1(u64.u64_bytes[1] == 0x11);
+       ok1(u64.u64_bytes[0] == 0x00);
+       ok1(be64_to_cpu(u64.u64) == 0x0011223344556677ULL);
+
+       u32.u32 = cpu_to_le32(0x00112233);
+       ok1(u32.u32_bytes[0] == 0x33);
+       ok1(u32.u32_bytes[1] == 0x22);
+       ok1(u32.u32_bytes[2] == 0x11);
+       ok1(u32.u32_bytes[3] == 0x00);
+       ok1(le32_to_cpu(u32.u32) == 0x00112233);
+
+       u32.u32 = cpu_to_be32(0x00112233);
+       ok1(u32.u32_bytes[3] == 0x33);
+       ok1(u32.u32_bytes[2] == 0x22);
+       ok1(u32.u32_bytes[1] == 0x11);
+       ok1(u32.u32_bytes[0] == 0x00);
+       ok1(be32_to_cpu(u32.u32) == 0x00112233);
+
+       u16.u16 = cpu_to_le16(0x0011);
+       ok1(u16.u16_bytes[0] == 0x11);
+       ok1(u16.u16_bytes[1] == 0x00);
+       ok1(le16_to_cpu(u16.u16) == 0x0011);
+
+       u16.u16 = cpu_to_be16(0x0011);
+       ok1(u16.u16_bytes[1] == 0x11);
+       ok1(u16.u16_bytes[0] == 0x00);
+       ok1(be16_to_cpu(u16.u16) == 0x0011);
+
+       exit(exit_status());
+}
diff --git a/lib/ccan/hash/_info b/lib/ccan/hash/_info
new file mode 100644 (file)
index 0000000..5aeb912
--- /dev/null
@@ -0,0 +1,31 @@
+#include <string.h>
+#include <stdio.h>
+
+/**
+ * hash - routines for hashing bytes
+ *
+ * When creating a hash table it's important to have a hash function
+ * which mixes well and is fast.  This package supplies such functions.
+ *
+ * The hash functions come in two flavors: the normal ones and the
+ * stable ones.  The normal ones can vary from machine-to-machine and
+ * may change if we find better or faster hash algorithms in future.
+ * The stable ones will always give the same results on any computer,
+ * and on any version of this package.
+ *
+ * License: Public Domain
+ * Maintainer: Rusty Russell <rusty@rustcorp.com.au>
+ * Author: Bob Jenkins <bob_jenkins@burtleburtle.net>
+ */
+int main(int argc, char *argv[])
+{
+       if (argc != 2)
+               return 1;
+
+       if (strcmp(argv[1], "depends") == 0) {
+               printf("ccan/build_assert\n");
+               return 0;
+       }
+
+       return 1;
+}
diff --git a/lib/ccan/hash/hash.c b/lib/ccan/hash/hash.c
new file mode 100644 (file)
index 0000000..0fd6109
--- /dev/null
@@ -0,0 +1,925 @@
+/*
+-------------------------------------------------------------------------------
+lookup3.c, by Bob Jenkins, May 2006, Public Domain.
+
+These are functions for producing 32-bit hashes for hash table lookup.
+hash_word(), hashlittle(), hashlittle2(), hashbig(), mix(), and final()
+are externally useful functions.  Routines to test the hash are included
+if SELF_TEST is defined.  You can use this free for any purpose.  It's in
+the public domain.  It has no warranty.
+
+You probably want to use hashlittle().  hashlittle() and hashbig()
+hash byte arrays.  hashlittle() is is faster than hashbig() on
+little-endian machines.  Intel and AMD are little-endian machines.
+On second thought, you probably want hashlittle2(), which is identical to
+hashlittle() except it returns two 32-bit hashes for the price of one.
+You could implement hashbig2() if you wanted but I haven't bothered here.
+
+If you want to find a hash of, say, exactly 7 integers, do
+  a = i1;  b = i2;  c = i3;
+  mix(a,b,c);
+  a += i4; b += i5; c += i6;
+  mix(a,b,c);
+  a += i7;
+  final(a,b,c);
+then use c as the hash value.  If you have a variable length array of
+4-byte integers to hash, use hash_word().  If you have a byte array (like
+a character string), use hashlittle().  If you have several byte arrays, or
+a mix of things, see the comments above hashlittle().
+
+Why is this so big?  I read 12 bytes at a time into 3 4-byte integers,
+then mix those integers.  This is fast (you can do a lot more thorough
+mixing with 12*3 instructions on 3 integers than you can with 3 instructions
+on 1 byte), but shoehorning those bytes into integers efficiently is messy.
+-------------------------------------------------------------------------------
+*/
+//#define SELF_TEST 1
+
+#if 0
+#include <stdio.h>      /* defines printf for tests */
+#include <time.h>       /* defines time_t for timings in the test */
+#include <stdint.h>     /* defines uint32_t etc */
+#include <sys/param.h>  /* attempt to define endianness */
+
+#ifdef linux
+# include <endian.h>    /* attempt to define endianness */
+#endif
+
+/*
+ * My best guess at if you are big-endian or little-endian.  This may
+ * need adjustment.
+ */
+#if (defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && \
+     __BYTE_ORDER == __LITTLE_ENDIAN) || \
+    (defined(i386) || defined(__i386__) || defined(__i486__) || \
+     defined(__i586__) || defined(__i686__) || defined(__x86_64) || \
+     defined(vax) || defined(MIPSEL))
+# define HASH_LITTLE_ENDIAN 1
+# define HASH_BIG_ENDIAN 0
+#elif (defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && \
+       __BYTE_ORDER == __BIG_ENDIAN) || \
+      (defined(sparc) || defined(POWERPC) || defined(mc68000) || defined(sel))
+# define HASH_LITTLE_ENDIAN 0
+# define HASH_BIG_ENDIAN 1
+#else
+# error Unknown endian
+#endif
+#endif /* old hash.c headers. */
+
+#include "hash.h"
+
+#if HAVE_LITTLE_ENDIAN
+#define HASH_LITTLE_ENDIAN 1
+#define HASH_BIG_ENDIAN 0
+#elif HAVE_BIG_ENDIAN
+#define HASH_LITTLE_ENDIAN 0
+#define HASH_BIG_ENDIAN 1
+#else
+#error Unknown endian
+#endif
+
+#define hashsize(n) ((uint32_t)1<<(n))
+#define hashmask(n) (hashsize(n)-1)
+#define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k))))
+
+/*
+-------------------------------------------------------------------------------
+mix -- mix 3 32-bit values reversibly.
+
+This is reversible, so any information in (a,b,c) before mix() is
+still in (a,b,c) after mix().
+
+If four pairs of (a,b,c) inputs are run through mix(), or through
+mix() in reverse, there are at least 32 bits of the output that
+are sometimes the same for one pair and different for another pair.
+This was tested for:
+* pairs that differed by one bit, by two bits, in any combination
+  of top bits of (a,b,c), or in any combination of bottom bits of
+  (a,b,c).
+* "differ" is defined as +, -, ^, or ~^.  For + and -, I transformed
+  the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
+  is commonly produced by subtraction) look like a single 1-bit
+  difference.
+* the base values were pseudorandom, all zero but one bit set, or
+  all zero plus a counter that starts at zero.
+
+Some k values for my "a-=c; a^=rot(c,k); c+=b;" arrangement that
+satisfy this are
+    4  6  8 16 19  4
+    9 15  3 18 27 15
+   14  9  3  7 17  3
+Well, "9 15 3 18 27 15" didn't quite get 32 bits diffing
+for "differ" defined as + with a one-bit base and a two-bit delta.  I
+used http://burtleburtle.net/bob/hash/avalanche.html to choose
+the operations, constants, and arrangements of the variables.
+
+This does not achieve avalanche.  There are input bits of (a,b,c)
+that fail to affect some output bits of (a,b,c), especially of a.  The
+most thoroughly mixed value is c, but it doesn't really even achieve
+avalanche in c.
+
+This allows some parallelism.  Read-after-writes are good at doubling
+the number of bits affected, so the goal of mixing pulls in the opposite
+direction as the goal of parallelism.  I did what I could.  Rotates
+seem to cost as much as shifts on every machine I could lay my hands
+on, and rotates are much kinder to the top and bottom bits, so I used
+rotates.
+-------------------------------------------------------------------------------
+*/
+#define mix(a,b,c) \
+{ \
+  a -= c;  a ^= rot(c, 4);  c += b; \
+  b -= a;  b ^= rot(a, 6);  a += c; \
+  c -= b;  c ^= rot(b, 8);  b += a; \
+  a -= c;  a ^= rot(c,16);  c += b; \
+  b -= a;  b ^= rot(a,19);  a += c; \
+  c -= b;  c ^= rot(b, 4);  b += a; \
+}
+
+/*
+-------------------------------------------------------------------------------
+final -- final mixing of 3 32-bit values (a,b,c) into c
+
+Pairs of (a,b,c) values differing in only a few bits will usually
+produce values of c that look totally different.  This was tested for
+* pairs that differed by one bit, by two bits, in any combination
+  of top bits of (a,b,c), or in any combination of bottom bits of
+  (a,b,c).
+* "differ" is defined as +, -, ^, or ~^.  For + and -, I transformed
+  the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
+  is commonly produced by subtraction) look like a single 1-bit
+  difference.
+* the base values were pseudorandom, all zero but one bit set, or
+  all zero plus a counter that starts at zero.
+
+These constants passed:
+ 14 11 25 16 4 14 24
+ 12 14 25 16 4 14 24
+and these came close:
+  4  8 15 26 3 22 24
+ 10  8 15 26 3 22 24
+ 11  8 15 26 3 22 24
+-------------------------------------------------------------------------------
+*/
+#define final(a,b,c) \
+{ \
+  c ^= b; c -= rot(b,14); \
+  a ^= c; a -= rot(c,11); \
+  b ^= a; b -= rot(a,25); \
+  c ^= b; c -= rot(b,16); \
+  a ^= c; a -= rot(c,4);  \
+  b ^= a; b -= rot(a,14); \
+  c ^= b; c -= rot(b,24); \
+}
+
+/*
+--------------------------------------------------------------------
+ This works on all machines.  To be useful, it requires
+ -- that the key be an array of uint32_t's, and
+ -- that the length be the number of uint32_t's in the key
+
+ The function hash_word() is identical to hashlittle() on little-endian
+ machines, and identical to hashbig() on big-endian machines,
+ except that the length has to be measured in uint32_ts rather than in
+ bytes.  hashlittle() is more complicated than hash_word() only because
+ hashlittle() has to dance around fitting the key bytes into registers.
+--------------------------------------------------------------------
+*/
+uint32_t hash_u32(
+const uint32_t *k,                   /* the key, an array of uint32_t values */
+size_t          length,               /* the length of the key, in uint32_ts */
+uint32_t        initval)         /* the previous hash, or an arbitrary value */
+{
+  uint32_t a,b,c;
+
+  /* Set up the internal state */
+  a = b = c = 0xdeadbeef + (((uint32_t)length)<<2) + initval;
+
+  /*------------------------------------------------- handle most of the key */
+  while (length > 3)
+  {
+    a += k[0];
+    b += k[1];
+    c += k[2];
+    mix(a,b,c);
+    length -= 3;
+    k += 3;
+  }
+
+  /*------------------------------------------- handle the last 3 uint32_t's */
+  switch(length)                     /* all the case statements fall through */
+  {
+  case 3 : c+=k[2];
+  case 2 : b+=k[1];
+  case 1 : a+=k[0];
+    final(a,b,c);
+  case 0:     /* case 0: nothing left to add */
+    break;
+  }
+  /*------------------------------------------------------ report the result */
+  return c;
+}
+
+/*
+-------------------------------------------------------------------------------
+hashlittle() -- hash a variable-length key into a 32-bit value
+  k       : the key (the unaligned variable-length array of bytes)
+  length  : the length of the key, counting by bytes
+  val2    : IN: can be any 4-byte value OUT: second 32 bit hash.
+Returns a 32-bit value.  Every bit of the key affects every bit of
+the return value.  Two keys differing by one or two bits will have
+totally different hash values.  Note that the return value is better
+mixed than val2, so use that first.
+
+The best hash table sizes are powers of 2.  There is no need to do
+mod a prime (mod is sooo slow!).  If you need less than 32 bits,
+use a bitmask.  For example, if you need only 10 bits, do
+  h = (h & hashmask(10));
+In which case, the hash table should have hashsize(10) elements.
+
+If you are hashing n strings (uint8_t **)k, do it like this:
+  for (i=0, h=0; i<n; ++i) h = hashlittle( k[i], len[i], h);
+
+By Bob Jenkins, 2006.  bob_jenkins@burtleburtle.net.  You may use this
+code any way you wish, private, educational, or commercial.  It's free.
+
+Use for hash table lookup, or anything where one collision in 2^^32 is
+acceptable.  Do NOT use for cryptographic purposes.
+-------------------------------------------------------------------------------
+*/
+
+static uint32_t hashlittle( const void *key, size_t length, uint32_t *val2 )
+{
+  uint32_t a,b,c;                                          /* internal state */
+  union { const void *ptr; size_t i; } u;     /* needed for Mac Powerbook G4 */
+
+  /* Set up the internal state */
+  a = b = c = 0xdeadbeef + ((uint32_t)length) + *val2;
+
+  u.ptr = key;
+  if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) {
+    const uint32_t *k = (const uint32_t *)key;         /* read 32-bit chunks */
+    const uint8_t  *k8;
+
+    /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
+    while (length > 12)
+    {
+      a += k[0];
+      b += k[1];
+      c += k[2];
+      mix(a,b,c);
+      length -= 12;
+      k += 3;
+    }
+
+    /*----------------------------- handle the last (probably partial) block */
+    /*
+     * "k[2]&0xffffff" actually reads beyond the end of the string, but
+     * then masks off the part it's not allowed to read.  Because the
+     * string is aligned, the masked-off tail is in the same word as the
+     * rest of the string.  Every machine with memory protection I've seen
+     * does it on word boundaries, so is OK with this.  But VALGRIND will
+     * still catch it and complain.  The masking trick does make the hash
+     * noticably faster for short strings (like English words).
+     *
+     * Not on my testing with gcc 4.5 on an intel i5 CPU, at least --RR.
+     */
+#if 0
+    switch(length)
+    {
+    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+    case 11: c+=k[2]&0xffffff; b+=k[1]; a+=k[0]; break;
+    case 10: c+=k[2]&0xffff; b+=k[1]; a+=k[0]; break;
+    case 9 : c+=k[2]&0xff; b+=k[1]; a+=k[0]; break;
+    case 8 : b+=k[1]; a+=k[0]; break;
+    case 7 : b+=k[1]&0xffffff; a+=k[0]; break;
+    case 6 : b+=k[1]&0xffff; a+=k[0]; break;
+    case 5 : b+=k[1]&0xff; a+=k[0]; break;
+    case 4 : a+=k[0]; break;
+    case 3 : a+=k[0]&0xffffff; break;
+    case 2 : a+=k[0]&0xffff; break;
+    case 1 : a+=k[0]&0xff; break;
+    case 0 : return c;              /* zero length strings require no mixing */
+    }
+
+#else /* make valgrind happy */
+
+    k8 = (const uint8_t *)k;
+    switch(length)
+    {
+    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+    case 11: c+=((uint32_t)k8[10])<<16;  /* fall through */
+    case 10: c+=((uint32_t)k8[9])<<8;    /* fall through */
+    case 9 : c+=k8[8];                   /* fall through */
+    case 8 : b+=k[1]; a+=k[0]; break;
+    case 7 : b+=((uint32_t)k8[6])<<16;   /* fall through */
+    case 6 : b+=((uint32_t)k8[5])<<8;    /* fall through */
+    case 5 : b+=k8[4];                   /* fall through */
+    case 4 : a+=k[0]; break;
+    case 3 : a+=((uint32_t)k8[2])<<16;   /* fall through */
+    case 2 : a+=((uint32_t)k8[1])<<8;    /* fall through */
+    case 1 : a+=k8[0]; break;
+    case 0 : return c;
+    }
+
+#endif /* !valgrind */
+
+  } else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) {
+    const uint16_t *k = (const uint16_t *)key;         /* read 16-bit chunks */
+    const uint8_t  *k8;
+
+    /*--------------- all but last block: aligned reads and different mixing */
+    while (length > 12)
+    {
+      a += k[0] + (((uint32_t)k[1])<<16);
+      b += k[2] + (((uint32_t)k[3])<<16);
+      c += k[4] + (((uint32_t)k[5])<<16);
+      mix(a,b,c);
+      length -= 12;
+      k += 6;
+    }
+
+    /*----------------------------- handle the last (probably partial) block */
+    k8 = (const uint8_t *)k;
+    switch(length)
+    {
+    case 12: c+=k[4]+(((uint32_t)k[5])<<16);
+             b+=k[2]+(((uint32_t)k[3])<<16);
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 11: c+=((uint32_t)k8[10])<<16;     /* fall through */
+    case 10: c+=k[4];
+             b+=k[2]+(((uint32_t)k[3])<<16);
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 9 : c+=k8[8];                      /* fall through */
+    case 8 : b+=k[2]+(((uint32_t)k[3])<<16);
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 7 : b+=((uint32_t)k8[6])<<16;      /* fall through */
+    case 6 : b+=k[2];
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 5 : b+=k8[4];                      /* fall through */
+    case 4 : a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 3 : a+=((uint32_t)k8[2])<<16;      /* fall through */
+    case 2 : a+=k[0];
+             break;
+    case 1 : a+=k8[0];
+             break;
+    case 0 : return c;                     /* zero length requires no mixing */
+    }
+
+  } else {                        /* need to read the key one byte at a time */
+    const uint8_t *k = (const uint8_t *)key;
+
+    /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
+    while (length > 12)
+    {
+      a += k[0];
+      a += ((uint32_t)k[1])<<8;
+      a += ((uint32_t)k[2])<<16;
+      a += ((uint32_t)k[3])<<24;
+      b += k[4];
+      b += ((uint32_t)k[5])<<8;
+      b += ((uint32_t)k[6])<<16;
+      b += ((uint32_t)k[7])<<24;
+      c += k[8];
+      c += ((uint32_t)k[9])<<8;
+      c += ((uint32_t)k[10])<<16;
+      c += ((uint32_t)k[11])<<24;
+      mix(a,b,c);
+      length -= 12;
+      k += 12;
+    }
+
+    /*-------------------------------- last block: affect all 32 bits of (c) */
+    switch(length)                   /* all the case statements fall through */
+    {
+    case 12: c+=((uint32_t)k[11])<<24;
+    case 11: c+=((uint32_t)k[10])<<16;
+    case 10: c+=((uint32_t)k[9])<<8;
+    case 9 : c+=k[8];
+    case 8 : b+=((uint32_t)k[7])<<24;
+    case 7 : b+=((uint32_t)k[6])<<16;
+    case 6 : b+=((uint32_t)k[5])<<8;
+    case 5 : b+=k[4];
+    case 4 : a+=((uint32_t)k[3])<<24;
+    case 3 : a+=((uint32_t)k[2])<<16;
+    case 2 : a+=((uint32_t)k[1])<<8;
+    case 1 : a+=k[0];
+             break;
+    case 0 : return c;
+    }
+  }
+
+  final(a,b,c);
+  *val2 = b;
+  return c;
+}
+
+/*
+ * hashbig():
+ * This is the same as hash_word() on big-endian machines.  It is different
+ * from hashlittle() on all machines.  hashbig() takes advantage of
+ * big-endian byte ordering.
+ */
+static uint32_t hashbig( const void *key, size_t length, uint32_t *val2)
+{
+  uint32_t a,b,c;
+  union { const void *ptr; size_t i; } u; /* to cast key to (size_t) happily */
+
+  /* Set up the internal state */
+  a = b = c = 0xdeadbeef + ((uint32_t)length) + *val2;
+
+  u.ptr = key;
+  if (HASH_BIG_ENDIAN && ((u.i & 0x3) == 0)) {
+    const uint32_t *k = (const uint32_t *)key;         /* read 32-bit chunks */
+    const uint8_t  *k8;
+
+    /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
+    while (length > 12)
+    {
+      a += k[0];
+      b += k[1];
+      c += k[2];
+      mix(a,b,c);
+      length -= 12;
+      k += 3;
+    }
+
+    /*----------------------------- handle the last (probably partial) block */
+    /*
+     * "k[2]<<8" actually reads beyond the end of the string, but
+     * then shifts out the part it's not allowed to read.  Because the
+     * string is aligned, the illegal read is in the same word as the
+     * rest of the string.  Every machine with memory protection I've seen
+     * does it on word boundaries, so is OK with this.  But VALGRIND will
+     * still catch it and complain.  The masking trick does make the hash
+     * noticably faster for short strings (like English words).
+     *
+     * Not on my testing with gcc 4.5 on an intel i5 CPU, at least --RR.
+     */
+#if 0
+    switch(length)
+    {
+    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+    case 11: c+=k[2]&0xffffff00; b+=k[1]; a+=k[0]; break;
+    case 10: c+=k[2]&0xffff0000; b+=k[1]; a+=k[0]; break;
+    case 9 : c+=k[2]&0xff000000; b+=k[1]; a+=k[0]; break;
+    case 8 : b+=k[1]; a+=k[0]; break;
+    case 7 : b+=k[1]&0xffffff00; a+=k[0]; break;
+    case 6 : b+=k[1]&0xffff0000; a+=k[0]; break;
+    case 5 : b+=k[1]&0xff000000; a+=k[0]; break;
+    case 4 : a+=k[0]; break;
+    case 3 : a+=k[0]&0xffffff00; break;
+    case 2 : a+=k[0]&0xffff0000; break;
+    case 1 : a+=k[0]&0xff000000; break;
+    case 0 : return c;              /* zero length strings require no mixing */
+    }
+
+#else  /* make valgrind happy */
+
+    k8 = (const uint8_t *)k;
+    switch(length)                   /* all the case statements fall through */
+    {
+    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+    case 11: c+=((uint32_t)k8[10])<<8;  /* fall through */
+    case 10: c+=((uint32_t)k8[9])<<16;  /* fall through */
+    case 9 : c+=((uint32_t)k8[8])<<24;  /* fall through */
+    case 8 : b+=k[1]; a+=k[0]; break;
+    case 7 : b+=((uint32_t)k8[6])<<8;   /* fall through */
+    case 6 : b+=((uint32_t)k8[5])<<16;  /* fall through */
+    case 5 : b+=((uint32_t)k8[4])<<24;  /* fall through */
+    case 4 : a+=k[0]; break;
+    case 3 : a+=((uint32_t)k8[2])<<8;   /* fall through */
+    case 2 : a+=((uint32_t)k8[1])<<16;  /* fall through */
+    case 1 : a+=((uint32_t)k8[0])<<24; break;
+    case 0 : return c;
+    }
+
+#endif /* !VALGRIND */
+
+  } else {                        /* need to read the key one byte at a time */
+    const uint8_t *k = (const uint8_t *)key;
+
+    /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
+    while (length > 12)
+    {
+      a += ((uint32_t)k[0])<<24;
+      a += ((uint32_t)k[1])<<16;
+      a += ((uint32_t)k[2])<<8;
+      a += ((uint32_t)k[3]);
+      b += ((uint32_t)k[4])<<24;
+      b += ((uint32_t)k[5])<<16;
+      b += ((uint32_t)k[6])<<8;
+      b += ((uint32_t)k[7]);
+      c += ((uint32_t)k[8])<<24;
+      c += ((uint32_t)k[9])<<16;
+      c += ((uint32_t)k[10])<<8;
+      c += ((uint32_t)k[11]);
+      mix(a,b,c);
+      length -= 12;
+      k += 12;
+    }
+
+    /*-------------------------------- last block: affect all 32 bits of (c) */
+    switch(length)                   /* all the case statements fall through */
+    {
+    case 12: c+=k[11];
+    case 11: c+=((uint32_t)k[10])<<8;
+    case 10: c+=((uint32_t)k[9])<<16;
+    case 9 : c+=((uint32_t)k[8])<<24;
+    case 8 : b+=k[7];
+    case 7 : b+=((uint32_t)k[6])<<8;
+    case 6 : b+=((uint32_t)k[5])<<16;
+    case 5 : b+=((uint32_t)k[4])<<24;
+    case 4 : a+=k[3];
+    case 3 : a+=((uint32_t)k[2])<<8;
+    case 2 : a+=((uint32_t)k[1])<<16;
+    case 1 : a+=((uint32_t)k[0])<<24;
+             break;
+    case 0 : return c;
+    }
+  }
+
+  final(a,b,c);
+  *val2 = b;
+  return c;
+}
+
+/* I basically use hashlittle here, but use native endian within each
+ * element.  This delivers least-surprise: hash such as "int arr[] = {
+ * 1, 2 }; hash_stable(arr, 2, 0);" will be the same on big and little
+ * endian machines, even though a bytewise hash wouldn't be. */
+uint64_t hash64_stable_64(const void *key, size_t n, uint64_t base)
+{
+       const uint64_t *k = key;
+       uint32_t a,b,c;
+
+       /* Set up the internal state */
+       a = b = c = 0xdeadbeef + ((uint32_t)n*8) + (base >> 32) + base;
+
+       while (n > 3) {
+               a += (uint32_t)k[0];
+               b += (uint32_t)(k[0] >> 32);
+               c += (uint32_t)k[1];
+               mix(a,b,c);
+               a += (uint32_t)(k[1] >> 32);
+               b += (uint32_t)k[2];
+               c += (uint32_t)(k[2] >> 32);
+               mix(a,b,c);
+               n -= 3;
+               k += 3;
+       }
+       switch (n) {
+       case 2:
+               a += (uint32_t)k[0];
+               b += (uint32_t)(k[0] >> 32);
+               c += (uint32_t)k[1];
+               mix(a,b,c);
+               a += (uint32_t)(k[1] >> 32);
+               break;
+       case 1:
+               a += (uint32_t)k[0];
+               b += (uint32_t)(k[0] >> 32);
+               break;
+       case 0:
+               return c;
+       }
+       final(a,b,c);
+       return ((uint64_t)b << 32) | c;
+}
+
+uint64_t hash64_stable_32(const void *key, size_t n, uint64_t base)
+{
+       const uint32_t *k = key;
+       uint32_t a,b,c;
+
+       /* Set up the internal state */
+       a = b = c = 0xdeadbeef + ((uint32_t)n*4) + (base >> 32) + base;
+
+       while (n > 3) {
+               a += k[0];
+               b += k[1];
+               c += k[2];
+               mix(a,b,c);
+
+               n -= 3;
+               k += 3;
+       }
+       switch (n) {
+       case 2:
+               b += (uint32_t)k[1];
+       case 1:
+               a += (uint32_t)k[0];
+               break;
+       case 0:
+               return c;
+       }
+       final(a,b,c);
+       return ((uint64_t)b << 32) | c;
+}
+
+uint64_t hash64_stable_16(const void *key, size_t n, uint64_t base)
+{
+       const uint16_t *k = key;
+       uint32_t a,b,c;
+
+       /* Set up the internal state */
+       a = b = c = 0xdeadbeef + ((uint32_t)n*2) + (base >> 32) + base;
+
+       while (n > 6) {
+               a += (uint32_t)k[0] + ((uint32_t)k[1] << 16);
+               b += (uint32_t)k[2] + ((uint32_t)k[3] << 16);
+               c += (uint32_t)k[4] + ((uint32_t)k[5] << 16);
+               mix(a,b,c);
+
+               n -= 6;
+               k += 6;
+       }
+
+       switch (n) {
+       case 5:
+               c += (uint32_t)k[4];
+       case 4:
+               b += ((uint32_t)k[3] << 16);
+       case 3:
+               b += (uint32_t)k[2];
+       case 2:
+               a += ((uint32_t)k[1] << 16);
+       case 1:
+               a += (uint32_t)k[0];
+               break;
+       case 0:
+               return c;
+       }
+       final(a,b,c);
+       return ((uint64_t)b << 32) | c;
+}
+
+uint64_t hash64_stable_8(const void *key, size_t n, uint64_t base)
+{
+       uint32_t b32 = base + (base >> 32);
+       uint32_t lower = hashlittle(key, n, &b32);
+
+       return ((uint64_t)b32 << 32) | lower;
+}
+
+uint32_t hash_any(const void *key, size_t length, uint32_t base)
+{
+       if (HASH_BIG_ENDIAN)
+               return hashbig(key, length, &base);
+       else
+               return hashlittle(key, length, &base);
+}
+
+uint32_t hash_stable_64(const void *key, size_t n, uint32_t base)
+{
+       return hash64_stable_64(key, n, base);
+}
+
+uint32_t hash_stable_32(const void *key, size_t n, uint32_t base)
+{
+       return hash64_stable_32(key, n, base);
+}
+
+uint32_t hash_stable_16(const void *key, size_t n, uint32_t base)
+{
+       return hash64_stable_16(key, n, base);
+}
+
+uint32_t hash_stable_8(const void *key, size_t n, uint32_t base)
+{
+       return hashlittle(key, n, &base);
+}
+
+/* Jenkins' lookup8 is a 64 bit hash, but he says it's obsolete.  Use
+ * the plain one and recombine into 64 bits. */
+uint64_t hash64_any(const void *key, size_t length, uint64_t base)
+{
+       uint32_t b32 = base + (base >> 32);
+       uint32_t lower;
+
+       if (HASH_BIG_ENDIAN)
+               lower = hashbig(key, length, &b32);
+       else
+               lower = hashlittle(key, length, &b32);
+
+       return ((uint64_t)b32 << 32) | lower;
+}
+
+#ifdef SELF_TEST
+
+/* used for timings */
+void driver1()
+{
+  uint8_t buf[256];
+  uint32_t i;
+  uint32_t h=0;
+  time_t a,z;
+
+  time(&a);
+  for (i=0; i<256; ++i) buf[i] = 'x';
+  for (i=0; i<1; ++i)
+  {
+    h = hashlittle(&buf[0],1,h);
+  }
+  time(&z);
+  if (z-a > 0) printf("time %d %.8x\n", z-a, h);
+}
+
+/* check that every input bit changes every output bit half the time */
+#define HASHSTATE 1
+#define HASHLEN   1
+#define MAXPAIR 60
+#define MAXLEN  70
+void driver2()
+{
+  uint8_t qa[MAXLEN+1], qb[MAXLEN+2], *a = &qa[0], *b = &qb[1];
+  uint32_t c[HASHSTATE], d[HASHSTATE], i=0, j=0, k, l, m=0, z;
+  uint32_t e[HASHSTATE],f[HASHSTATE],g[HASHSTATE],h[HASHSTATE];
+  uint32_t x[HASHSTATE],y[HASHSTATE];
+  uint32_t hlen;
+
+  printf("No more than %d trials should ever be needed \n",MAXPAIR/2);
+  for (hlen=0; hlen < MAXLEN; ++hlen)
+  {
+    z=0;
+    for (i=0; i<hlen; ++i)  /*----------------------- for each input byte, */
+    {
+      for (j=0; j<8; ++j)   /*------------------------ for each input bit, */
+      {
+       for (m=1; m<8; ++m) /*------------ for several possible initvals, */
+       {
+         for (l=0; l<HASHSTATE; ++l)
+           e[l]=f[l]=g[l]=h[l]=x[l]=y[l]=~((uint32_t)0);
+
+         /*---- check that every output bit is affected by that input bit */
+         for (k=0; k<MAXPAIR; k+=2)
+         {
+           uint32_t finished=1;
+           /* keys have one bit different */
+           for (l=0; l<hlen+1; ++l) {a[l] = b[l] = (uint8_t)0;}
+           /* have a and b be two keys differing in only one bit */
+           a[i] ^= (k<<j);
+           a[i] ^= (k>>(8-j));
+            c[0] = hashlittle(a, hlen, m);
+           b[i] ^= ((k+1)<<j);
+           b[i] ^= ((k+1)>>(8-j));
+            d[0] = hashlittle(b, hlen, m);
+           /* check every bit is 1, 0, set, and not set at least once */
+           for (l=0; l<HASHSTATE; ++l)
+           {
+             e[l] &= (c[l]^d[l]);
+             f[l] &= ~(c[l]^d[l]);
+             g[l] &= c[l];
+             h[l] &= ~c[l];
+             x[l] &= d[l];
+             y[l] &= ~d[l];
+             if (e[l]|f[l]|g[l]|h[l]|x[l]|y[l]) finished=0;
+           }
+           if (finished) break;
+         }
+         if (k>z) z=k;
+         if (k==MAXPAIR)
+         {
+            printf("Some bit didn't change: ");
+            printf("%.8x %.8x %.8x %.8x %.8x %.8x  ",
+                   e[0],f[0],g[0],h[0],x[0],y[0]);
+            printf("i %d j %d m %d len %d\n", i, j, m, hlen);
+         }
+         if (z==MAXPAIR) goto done;
+       }
+      }
+    }
+   done:
+    if (z < MAXPAIR)
+    {
+      printf("Mix success  %2d bytes  %2d initvals  ",i,m);
+      printf("required  %d  trials\n", z/2);
+    }
+  }
+  printf("\n");
+}
+
+/* Check for reading beyond the end of the buffer and alignment problems */
+void driver3()
+{
+  uint8_t buf[MAXLEN+20], *b;
+  uint32_t len;
+  uint8_t q[] = "This is the time for all good men to come to the aid of their country...";
+  uint32_t h;
+  uint8_t qq[] = "xThis is the time for all good men to come to the aid of their country...";
+  uint32_t i;
+  uint8_t qqq[] = "xxThis is the time for all good men to come to the aid of their country...";
+  uint32_t j;
+  uint8_t qqqq[] = "xxxThis is the time for all good men to come to the aid of their country...";
+  uint32_t ref,x,y;
+  uint8_t *p;
+
+  printf("Endianness.  These lines should all be the same (for values filled in):\n");
+  printf("%.8x                            %.8x                            %.8x\n",
+         hash_word((const uint32_t *)q, (sizeof(q)-1)/4, 13),
+         hash_word((const uint32_t *)q, (sizeof(q)-5)/4, 13),
+         hash_word((const uint32_t *)q, (sizeof(q)-9)/4, 13));
+  p = q;
+  printf("%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",
+         hashlittle(p, sizeof(q)-1, 13), hashlittle(p, sizeof(q)-2, 13),
+         hashlittle(p, sizeof(q)-3, 13), hashlittle(p, sizeof(q)-4, 13),
+         hashlittle(p, sizeof(q)-5, 13), hashlittle(p, sizeof(q)-6, 13),
+         hashlittle(p, sizeof(q)-7, 13), hashlittle(p, sizeof(q)-8, 13),
+         hashlittle(p, sizeof(q)-9, 13), hashlittle(p, sizeof(q)-10, 13),
+         hashlittle(p, sizeof(q)-11, 13), hashlittle(p, sizeof(q)-12, 13));
+  p = &qq[1];
+  printf("%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",
+         hashlittle(p, sizeof(q)-1, 13), hashlittle(p, sizeof(q)-2, 13),
+         hashlittle(p, sizeof(q)-3, 13), hashlittle(p, sizeof(q)-4, 13),
+         hashlittle(p, sizeof(q)-5, 13), hashlittle(p, sizeof(q)-6, 13),
+         hashlittle(p, sizeof(q)-7, 13), hashlittle(p, sizeof(q)-8, 13),
+         hashlittle(p, sizeof(q)-9, 13), hashlittle(p, sizeof(q)-10, 13),
+         hashlittle(p, sizeof(q)-11, 13), hashlittle(p, sizeof(q)-12, 13));
+  p = &qqq[2];
+  printf("%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",
+         hashlittle(p, sizeof(q)-1, 13), hashlittle(p, sizeof(q)-2, 13),
+         hashlittle(p, sizeof(q)-3, 13), hashlittle(p, sizeof(q)-4, 13),
+         hashlittle(p, sizeof(q)-5, 13), hashlittle(p, sizeof(q)-6, 13),
+         hashlittle(p, sizeof(q)-7, 13), hashlittle(p, sizeof(q)-8, 13),
+         hashlittle(p, sizeof(q)-9, 13), hashlittle(p, sizeof(q)-10, 13),
+         hashlittle(p, sizeof(q)-11, 13), hashlittle(p, sizeof(q)-12, 13));
+  p = &qqqq[3];
+  printf("%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",
+         hashlittle(p, sizeof(q)-1, 13), hashlittle(p, sizeof(q)-2, 13),
+         hashlittle(p, sizeof(q)-3, 13), hashlittle(p, sizeof(q)-4, 13),
+         hashlittle(p, sizeof(q)-5, 13), hashlittle(p, sizeof(q)-6, 13),
+         hashlittle(p, sizeof(q)-7, 13), hashlittle(p, sizeof(q)-8, 13),
+         hashlittle(p, sizeof(q)-9, 13), hashlittle(p, sizeof(q)-10, 13),
+         hashlittle(p, sizeof(q)-11, 13), hashlittle(p, sizeof(q)-12, 13));
+  printf("\n");
+
+  /* check that hashlittle2 and hashlittle produce the same results */
+  i=47; j=0;
+  hashlittle2(q, sizeof(q), &i, &j);
+  if (hashlittle(q, sizeof(q), 47) != i)
+    printf("hashlittle2 and hashlittle mismatch\n");
+
+  /* check that hash_word2 and hash_word produce the same results */
+  len = 0xdeadbeef;
+  i=47, j=0;
+  hash_word2(&len, 1, &i, &j);
+  if (hash_word(&len, 1, 47) != i)
+    printf("hash_word2 and hash_word mismatch %x %x\n",
+          i, hash_word(&len, 1, 47));
+
+  /* check hashlittle doesn't read before or after the ends of the string */
+  for (h=0, b=buf+1; h<8; ++h, ++b)
+  {
+    for (i=0; i<MAXLEN; ++i)
+    {
+      len = i;
+      for (j=0; j<i; ++j) *(b+j)=0;
+
+      /* these should all be equal */
+      ref = hashlittle(b, len, (uint32_t)1);
+      *(b+i)=(uint8_t)~0;
+      *(b-1)=(uint8_t)~0;
+      x = hashlittle(b, len, (uint32_t)1);
+      y = hashlittle(b, len, (uint32_t)1);
+      if ((ref != x) || (ref != y))
+      {
+       printf("alignment error: %.8x %.8x %.8x %d %d\n",ref,x,y,
+               h, i);
+      }
+    }
+  }
+}
+
+/* check for problems with nulls */
+ void driver4()
+{
+  uint8_t buf[1];
+  uint32_t h,i,state[HASHSTATE];
+
+
+  buf[0] = ~0;
+  for (i=0; i<HASHSTATE; ++i) state[i] = 1;
+  printf("These should all be different\n");
+  for (i=0, h=0; i<8; ++i)
+  {
+    h = hashlittle(buf, 0, h);
+    printf("%2ld  0-byte strings, hash is  %.8x\n", i, h);
+  }
+}
+
+
+int main()
+{
+  driver1();   /* test that the key is hashed: used for timings */
+  driver2();   /* test that whole key is hashed thoroughly */
+  driver3();   /* test that nothing but the key is hashed */
+  driver4();   /* test hashing multiple buffers (all buffers are null) */
+  return 1;
+}
+
+#endif  /* SELF_TEST */
diff --git a/lib/ccan/hash/hash.h b/lib/ccan/hash/hash.h
new file mode 100644 (file)
index 0000000..5025c0d
--- /dev/null
@@ -0,0 +1,312 @@
+#ifndef CCAN_HASH_H
+#define CCAN_HASH_H
+#include "config.h"
+#include <stdint.h>
+#include <stdlib.h>
+#include <ccan/build_assert/build_assert.h>
+
+/* Stolen mostly from: lookup3.c, by Bob Jenkins, May 2006, Public Domain.
+ *
+ * http://burtleburtle.net/bob/c/lookup3.c
+ */
+
+/**
+ * hash - fast hash of an array for internal use
+ * @p: the array or pointer to first element
+ * @num: the number of elements to hash
+ * @base: the base number to roll into the hash (usually 0)
+ *
+ * The memory region pointed to by p is combined with the base to form
+ * a 32-bit hash.
+ *
+ * This hash will have different results on different machines, so is
+ * only useful for internal hashes (ie. not hashes sent across the
+ * network or saved to disk).
+ *
+ * It may also change with future versions: it could even detect at runtime
+ * what the fastest hash to use is.
+ *
+ * See also: hash64, hash_stable.
+ *
+ * Example:
+ *     #include <ccan/hash/hash.h>
+ *     #include <err.h>
+ *     #include <stdio.h>
+ *     #include <string.h>
+ *
+ *     // Simple demonstration: idential strings will have the same hash, but
+ *     // two different strings will probably not.
+ *     int main(int argc, char *argv[])
+ *     {
+ *             uint32_t hash1, hash2;
+ *
+ *             if (argc != 3)
+ *                     err(1, "Usage: %s <string1> <string2>", argv[0]);
+ *
+ *             hash1 = hash(argv[1], strlen(argv[1]), 0);
+ *             hash2 = hash(argv[2], strlen(argv[2]), 0);
+ *             printf("Hash is %s\n", hash1 == hash2 ? "same" : "different");
+ *             return 0;
+ *     }
+ */
+#define hash(p, num, base) hash_any((p), (num)*sizeof(*(p)), (base))
+
+/**
+ * hash_stable - hash of an array for external use
+ * @p: the array or pointer to first element
+ * @num: the number of elements to hash
+ * @base: the base number to roll into the hash (usually 0)
+ *
+ * The array of simple integer types pointed to by p is combined with
+ * the base to form a 32-bit hash.
+ *
+ * This hash will have the same results on different machines, so can
+ * be used for external hashes (ie. hashes sent across the network or
+ * saved to disk).  The results will not change in future versions of
+ * this module.
+ *
+ * Note that it is only legal to hand an array of simple integer types
+ * to this hash (ie. char, uint16_t, int64_t, etc).  In these cases,
+ * the same values will have the same hash result, even though the
+ * memory representations of integers depend on the machine
+ * endianness.
+ *
+ * See also:
+ *     hash64_stable
+ *
+ * Example:
+ *     #include <ccan/hash/hash.h>
+ *     #include <err.h>
+ *     #include <stdio.h>
+ *     #include <string.h>
+ *
+ *     int main(int argc, char *argv[])
+ *     {
+ *             if (argc != 2)
+ *                     err(1, "Usage: %s <string-to-hash>", argv[0]);
+ *
+ *             printf("Hash stable result is %u\n",
+ *                    hash_stable(argv[1], strlen(argv[1]), 0));
+ *             return 0;
+ *     }
+ */
+#define hash_stable(p, num, base)                                      \
+       (BUILD_ASSERT_OR_ZERO(sizeof(*(p)) == 8 || sizeof(*(p)) == 4    \
+                             || sizeof(*(p)) == 2 || sizeof(*(p)) == 1) + \
+        sizeof(*(p)) == 8 ? hash_stable_64((p), (num), (base))         \
+        : sizeof(*(p)) == 4 ? hash_stable_32((p), (num), (base))       \
+        : sizeof(*(p)) == 2 ? hash_stable_16((p), (num), (base))       \
+        : hash_stable_8((p), (num), (base)))
+
+/**
+ * hash_u32 - fast hash an array of 32-bit values for internal use
+ * @key: the array of uint32_t
+ * @num: the number of elements to hash
+ * @base: the base number to roll into the hash (usually 0)
+ *
+ * The array of uint32_t pointed to by @key is combined with the base
+ * to form a 32-bit hash.  This is 2-3 times faster than hash() on small
+ * arrays, but the advantage vanishes over large hashes.
+ *
+ * This hash will have different results on different machines, so is
+ * only useful for internal hashes (ie. not hashes sent across the
+ * network or saved to disk).
+ */
+uint32_t hash_u32(const uint32_t *key, size_t num, uint32_t base);
+
+/**
+ * hash_string - very fast hash of an ascii string
+ * @str: the nul-terminated string
+ *
+ * The string is hashed, using a hash function optimized for ASCII and
+ * similar strings.  It's weaker than the other hash functions.
+ *
+ * This hash may have different results on different machines, so is
+ * only useful for internal hashes (ie. not hashes sent across the
+ * network or saved to disk).  The results will be different from the
+ * other hash functions in this module, too.
+ */
+static inline uint32_t hash_string(const char *string)
+{
+       /* This is Karl Nelson <kenelson@ece.ucdavis.edu>'s X31 hash.
+        * It's a little faster than the (much better) lookup3 hash(): 56ns vs
+        * 84ns on my 2GHz Intel Core Duo 2 laptop for a 10 char string. */
+       uint32_t ret;
+
+       for (ret = 0; *string; string++)
+               ret = (ret << 5) - ret + *string;
+
+       return ret;
+}
+
+/**
+ * hash64 - fast 64-bit hash of an array for internal use
+ * @p: the array or pointer to first element
+ * @num: the number of elements to hash
+ * @base: the 64-bit base number to roll into the hash (usually 0)
+ *
+ * The memory region pointed to by p is combined with the base to form
+ * a 64-bit hash.
+ *
+ * This hash will have different results on different machines, so is
+ * only useful for internal hashes (ie. not hashes sent across the
+ * network or saved to disk).
+ *
+ * It may also change with future versions: it could even detect at runtime
+ * what the fastest hash to use is.
+ *
+ * See also: hash.
+ *
+ * Example:
+ *     #include <ccan/hash/hash.h>
+ *     #include <err.h>
+ *     #include <stdio.h>
+ *     #include <string.h>
+ *
+ *     // Simple demonstration: idential strings will have the same hash, but
+ *     // two different strings will probably not.
+ *     int main(int argc, char *argv[])
+ *     {
+ *             uint64_t hash1, hash2;
+ *
+ *             if (argc != 3)
+ *                     err(1, "Usage: %s <string1> <string2>", argv[0]);
+ *
+ *             hash1 = hash64(argv[1], strlen(argv[1]), 0);
+ *             hash2 = hash64(argv[2], strlen(argv[2]), 0);
+ *             printf("Hash is %s\n", hash1 == hash2 ? "same" : "different");
+ *             return 0;
+ *     }
+ */
+#define hash64(p, num, base) hash64_any((p), (num)*sizeof(*(p)), (base))
+
+/**
+ * hash64_stable - 64 bit hash of an array for external use
+ * @p: the array or pointer to first element
+ * @num: the number of elements to hash
+ * @base: the base number to roll into the hash (usually 0)
+ *
+ * The array of simple integer types pointed to by p is combined with
+ * the base to form a 64-bit hash.
+ *
+ * This hash will have the same results on different machines, so can
+ * be used for external hashes (ie. hashes sent across the network or
+ * saved to disk).  The results will not change in future versions of
+ * this module.
+ *
+ * Note that it is only legal to hand an array of simple integer types
+ * to this hash (ie. char, uint16_t, int64_t, etc).  In these cases,
+ * the same values will have the same hash result, even though the
+ * memory representations of integers depend on the machine
+ * endianness.
+ *
+ * See also:
+ *     hash_stable
+ *
+ * Example:
+ *     #include <ccan/hash/hash.h>
+ *     #include <err.h>
+ *     #include <stdio.h>
+ *     #include <string.h>
+ *
+ *     int main(int argc, char *argv[])
+ *     {
+ *             if (argc != 2)
+ *                     err(1, "Usage: %s <string-to-hash>", argv[0]);
+ *
+ *             printf("Hash stable result is %llu\n",
+ *                    (long long)hash64_stable(argv[1], strlen(argv[1]), 0));
+ *             return 0;
+ *     }
+ */
+#define hash64_stable(p, num, base)                                    \
+       (BUILD_ASSERT_OR_ZERO(sizeof(*(p)) == 8 || sizeof(*(p)) == 4    \
+                             || sizeof(*(p)) == 2 || sizeof(*(p)) == 1) + \
+        sizeof(*(p)) == 8 ? hash64_stable_64((p), (num), (base))       \
+        : sizeof(*(p)) == 4 ? hash64_stable_32((p), (num), (base))     \
+        : sizeof(*(p)) == 2 ? hash64_stable_16((p), (num), (base))     \
+        : hash64_stable_8((p), (num), (base)))
+
+
+/**
+ * hashl - fast 32/64-bit hash of an array for internal use
+ * @p: the array or pointer to first element
+ * @num: the number of elements to hash
+ * @base: the base number to roll into the hash (usually 0)
+ *
+ * This is either hash() or hash64(), on 32/64 bit long machines.
+ */
+#define hashl(p, num, base)                                            \
+       (BUILD_ASSERT_OR_ZERO(sizeof(long) == sizeof(uint32_t)          \
+                             || sizeof(long) == sizeof(uint64_t)) +    \
+       (sizeof(long) == sizeof(uint64_t)                               \
+        ? hash64((p), (num), (base)) : hash((p), (num), (base))))
+
+/* Our underlying operations. */
+uint32_t hash_any(const void *key, size_t length, uint32_t base);
+uint32_t hash_stable_64(const void *key, size_t n, uint32_t base);
+uint32_t hash_stable_32(const void *key, size_t n, uint32_t base);
+uint32_t hash_stable_16(const void *key, size_t n, uint32_t base);
+uint32_t hash_stable_8(const void *key, size_t n, uint32_t base);
+uint64_t hash64_any(const void *key, size_t length, uint64_t base);
+uint64_t hash64_stable_64(const void *key, size_t n, uint64_t base);
+uint64_t hash64_stable_32(const void *key, size_t n, uint64_t base);
+uint64_t hash64_stable_16(const void *key, size_t n, uint64_t base);
+uint64_t hash64_stable_8(const void *key, size_t n, uint64_t base);
+
+/**
+ * hash_pointer - hash a pointer for internal use
+ * @p: the pointer value to hash
+ * @base: the base number to roll into the hash (usually 0)
+ *
+ * The pointer p (not what p points to!) is combined with the base to form
+ * a 32-bit hash.
+ *
+ * This hash will have different results on different machines, so is
+ * only useful for internal hashes (ie. not hashes sent across the
+ * network or saved to disk).
+ *
+ * Example:
+ *     #include <ccan/hash/hash.h>
+ *
+ *     // Code to keep track of memory regions.
+ *     struct region {
+ *             struct region *chain;
+ *             void *start;
+ *             unsigned int size;
+ *     };
+ *     // We keep a simple hash table.
+ *     static struct region *region_hash[128];
+ *
+ *     static void add_region(struct region *r)
+ *     {
+ *             unsigned int h = hash_pointer(r->start, 0);
+ *
+ *             r->chain = region_hash[h];
+ *             region_hash[h] = r->chain;
+ *     }
+ *
+ *     static struct region *find_region(const void *start)
+ *     {
+ *             struct region *r;
+ *
+ *             for (r = region_hash[hash_pointer(start, 0)]; r; r = r->chain)
+ *                     if (r->start == start)
+ *                             return r;
+ *             return NULL;
+ *     }
+ */
+static inline uint32_t hash_pointer(const void *p, uint32_t base)
+{
+       if (sizeof(p) % sizeof(uint32_t) == 0) {
+               /* This convoluted union is the right way of aliasing. */
+               union {
+                       uint32_t u32[sizeof(p) / sizeof(uint32_t)];
+                       const void *p;
+               } u;
+               u.p = p;
+               return hash_u32(u.u32, sizeof(p) / sizeof(uint32_t), base);
+       } else
+               return hash(&p, 1, base);
+}
+#endif /* HASH_H */
diff --git a/lib/ccan/hash/test/api-hash_stable.c b/lib/ccan/hash/test/api-hash_stable.c
new file mode 100644 (file)
index 0000000..bb58d16
--- /dev/null
@@ -0,0 +1,300 @@
+#include <ccan/hash/hash.h>
+#include <ccan/tap/tap.h>
+#include <stdbool.h>
+#include <string.h>
+
+#define ARRAY_WORDS 5
+
+int main(int argc, char *argv[])
+{
+       unsigned int i;
+       uint8_t u8array[ARRAY_WORDS];
+       uint16_t u16array[ARRAY_WORDS];
+       uint32_t u32array[ARRAY_WORDS];
+       uint64_t u64array[ARRAY_WORDS];
+
+       /* Initialize arrays. */
+       for (i = 0; i < ARRAY_WORDS; i++) {
+               u8array[i] = i;
+               u16array[i] = i;
+               u32array[i] = i;
+               u64array[i] = i;
+       }
+
+       plan_tests(264);
+
+       /* hash_stable is API-guaranteed. */
+       ok1(hash_stable(u8array, ARRAY_WORDS, 0) == 0x1d4833cc);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 1) == 0x37125e2 );
+       ok1(hash_stable(u8array, ARRAY_WORDS, 2) == 0x330a007a);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 4) == 0x7b0df29b);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 8) == 0xe7e5d741);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 16) == 0xaae57471);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 32) == 0xc55399e5);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 64) == 0x67f21f7 );
+       ok1(hash_stable(u8array, ARRAY_WORDS, 128) == 0x1d795b71);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 256) == 0xeb961671);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 512) == 0xc2597247);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 1024) == 0x3f5c4d75);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 2048) == 0xe65cf4f9);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 4096) == 0xf2cd06cb);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 8192) == 0x443041e1);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 16384) == 0xdfc618f5);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 32768) == 0x5e3d5b97);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 65536) == 0xd5f64730);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 131072) == 0x372bbecc);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 262144) == 0x7c194c8d);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 524288) == 0x16cbb416);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 1048576) == 0x53e99222);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 2097152) == 0x6394554a);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 4194304) == 0xd83a506d);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 8388608) == 0x7619d9a4);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 16777216) == 0xfe98e5f6);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 33554432) == 0x6c262927);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 67108864) == 0x3f0106fd);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 134217728) == 0xc91e3a28);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 268435456) == 0x14229579);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 536870912) == 0x9dbefa76);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 1073741824) == 0xb05c0c78);
+       ok1(hash_stable(u8array, ARRAY_WORDS, 2147483648U) == 0x88f24d81);
+
+       ok1(hash_stable(u16array, ARRAY_WORDS, 0) == 0xecb5f507);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 1) == 0xadd666e6);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 2) == 0xea0f214c);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 4) == 0xae4051ba);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 8) == 0x6ed28026);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 16) == 0xa3917a19);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 32) == 0xf370f32b);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 64) == 0x807af460);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 128) == 0xb4c8cd83);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 256) == 0xa10cb5b0);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 512) == 0x8b7d7387);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 1024) == 0x9e49d1c );
+       ok1(hash_stable(u16array, ARRAY_WORDS, 2048) == 0x288830d1);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 4096) == 0xbe078a43);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 8192) == 0xa16d5d88);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 16384) == 0x46839fcd);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 32768) == 0x9db9bd4f);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 65536) == 0xedff58f8);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 131072) == 0x95ecef18);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 262144) == 0x23c31b7d);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 524288) == 0x1d85c7d0);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 1048576) == 0x25218842);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 2097152) == 0x711d985c);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 4194304) == 0x85470eca);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 8388608) == 0x99ed4ceb);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 16777216) == 0x67b3710c);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 33554432) == 0x77f1ab35);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 67108864) == 0x81f688aa);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 134217728) == 0x27b56ca5);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 268435456) == 0xf21ba203);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 536870912) == 0xd48d1d1 );
+       ok1(hash_stable(u16array, ARRAY_WORDS, 1073741824) == 0xa542b62d);
+       ok1(hash_stable(u16array, ARRAY_WORDS, 2147483648U) == 0xa04c7058);
+
+       ok1(hash_stable(u32array, ARRAY_WORDS, 0) == 0x13305f8c);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 1) == 0x171abf74);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 2) == 0x7646fcc7);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 4) == 0xa758ed5);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 8) == 0x2dedc2e4);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 16) == 0x28e2076b);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 32) == 0xb73091c5);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 64) == 0x87daf5db);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 128) == 0xa16dfe20);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 256) == 0x300c63c3);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 512) == 0x255c91fc);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 1024) == 0x6357b26);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 2048) == 0x4bc5f339);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 4096) == 0x1301617c);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 8192) == 0x506792c9);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 16384) == 0xcd596705);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 32768) == 0xa8713cac);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 65536) == 0x94d9794);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 131072) == 0xac753e8);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 262144) == 0xcd8bdd20);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 524288) == 0xd44faf80);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 1048576) == 0x2547ccbe);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 2097152) == 0xbab06dbc);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 4194304) == 0xaac0e882);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 8388608) == 0x443f48d0);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 16777216) == 0xdff49fcc);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 33554432) == 0x9ce0fd65);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 67108864) == 0x9ddb1def);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 134217728) == 0x86096f25);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 268435456) == 0xe713b7b5);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 536870912) == 0x5baeffc5);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 1073741824) == 0xde874f52);
+       ok1(hash_stable(u32array, ARRAY_WORDS, 2147483648U) == 0xeca13b4e);
+
+       ok1(hash_stable(u64array, ARRAY_WORDS, 0) == 0x12ef6302);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 1) == 0xe9aeb406);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 2) == 0xc4218ceb);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 4) == 0xb3d11412);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 8) == 0xdafbd654);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 16) == 0x9c336cba);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 32) == 0x65059721);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 64) == 0x95b5bbe6);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 128) == 0xe7596b84);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 256) == 0x503622a2);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 512) == 0xecdcc5ca);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 1024) == 0xc40d0513);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 2048) == 0xaab25e4d);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 4096) == 0xcc353fb9);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 8192) == 0x18e2319f);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 16384) == 0xfddaae8d);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 32768) == 0xef7976f2);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 65536) == 0x86359fc9);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 131072) == 0x8b5af385);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 262144) == 0x80d4ee31);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 524288) == 0x42f5f85b);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 1048576) == 0x9a6920e1);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 2097152) == 0x7b7c9850);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 4194304) == 0x69573e09);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 8388608) == 0xc942bc0e);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 16777216) == 0x7a89f0f1);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 33554432) == 0x2dd641ca);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 67108864) == 0x89bbd391);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 134217728) == 0xbcf88e31);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 268435456) == 0xfa7a3460);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 536870912) == 0x49a37be0);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 1073741824) == 0x1b346394);
+       ok1(hash_stable(u64array, ARRAY_WORDS, 2147483648U) == 0x6c3a1592);
+
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 0) == 16887282882572727244ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 1) == 12032777473133454818ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 2) == 18183407363221487738ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 4) == 17860764172704150171ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 8) == 18076051600675559233ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 16) == 9909361918431556721ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 32) == 12937969888744675813ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 64) == 5245669057381736951ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 128) == 4376874646406519665ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 256) == 14219974419871569521ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 512) == 2263415354134458951ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 1024) == 4953859694526221685ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 2048) == 3432228642067641593ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 4096) == 1219647244417697483ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 8192) == 7629939424585859553ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 16384) == 10041660531376789749ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 32768) == 13859885793922603927ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 65536) == 15069060338344675120ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 131072) == 818163430835601100ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 262144) == 14914314323019517069ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 524288) == 17518437749769352214ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 1048576) == 14920048004901212706ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 2097152) == 8758567366332536138ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 4194304) == 6226655736088907885ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 8388608) == 13716650013685832100ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 16777216) == 305325651636315638ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 33554432) == 16784147606583781671ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 67108864) == 16509467555140798205ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 134217728) == 8717281234694060584ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 268435456) == 8098476701725660537ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 536870912) == 16345871539461094006ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 1073741824) == 3755557000429964408ULL);
+       ok1(hash64_stable(u8array, ARRAY_WORDS, 2147483648U) == 15017348801959710081ULL);
+
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 0) == 1038028831307724039ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 1) == 10155473272642627302ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 2) == 5714751190106841420ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 4) == 3923885607767527866ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 8) == 3931017318293995558ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 16) == 1469696588339313177ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 32) == 11522218526952715051ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 64) == 6953517591561958496ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 128) == 7406689491740052867ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 256) == 10101844489704093104ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 512) == 12511348870707245959ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 1024) == 1614019938016861468ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 2048) == 5294796182374592721ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 4096) == 16089570706643716675ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 8192) == 1689302638424579464ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 16384) == 1446340172370386893ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 32768) == 16535503506744393039ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 65536) == 3496794142527150328ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 131072) == 6568245367474548504ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 262144) == 9487676460765485949ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 524288) == 4519762130966530000ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 1048576) == 15623412069215340610ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 2097152) == 544013388676438108ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 4194304) == 5594904760290840266ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 8388608) == 18098755780041592043ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 16777216) == 6389168672387330316ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 33554432) == 896986127732419381ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 67108864) == 13232626471143901354ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 134217728) == 53378562890493093ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 268435456) == 10072361400297824771ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 536870912) == 14511948118285144529ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 1073741824) == 6981033484844447277ULL);
+       ok1(hash64_stable(u16array, ARRAY_WORDS, 2147483648U) == 5619339091684126808ULL);
+
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 0) == 3037571077312110476ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 1) == 14732398743825071988ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 2) == 14949132158206672071ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 4) == 1291370080511561429ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 8) == 10792665964172133092ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 16) == 14250138032054339435ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 32) == 17136741522078732741ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 64) == 3260193403318236635ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 128) == 10526616652205653536ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 256) == 9019690373358576579ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 512) == 6997491436599677436ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 1024) == 18302783371416533798ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 2048) == 10149320644446516025ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 4096) == 7073759949410623868ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 8192) == 17442399482223760073ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 16384) == 2983906194216281861ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 32768) == 4975845419129060524ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 65536) == 594019910205413268ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 131072) == 11903010186073691112ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 262144) == 7339636527154847008ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 524288) == 15243305400579108736ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 1048576) == 16737926245392043198ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 2097152) == 15725083267699862972ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 4194304) == 12527834265678833794ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 8388608) == 13908436455987824848ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 16777216) == 9672773345173872588ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 33554432) == 2305314279896710501ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 67108864) == 1866733780381408751ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 134217728) == 11906263969465724709ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 268435456) == 5501594918093830069ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 536870912) == 15823785789276225477ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 1073741824) == 17353000723889475410ULL);
+       ok1(hash64_stable(u32array, ARRAY_WORDS, 2147483648U) == 7494736910655503182ULL);
+
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 0) == 9765419389786481410ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 1) == 11182806172127114246ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 2) == 2559155171395472619ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 4) == 3311692033324815378ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 8) == 1297175419505333844ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 16) == 617896928653569210ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 32) == 1517398559958603553ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 64) == 4504821917445110758ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 128) == 1971743331114904452ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 256) == 6177667912354374306ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 512) == 15570521289777792458ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 1024) == 9204559632415917331ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 2048) == 9008982669760028237ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 4096) == 14803537660281700281ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 8192) == 2873966517448487327ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 16384) == 5859277625928363661ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 32768) == 15520461285618185970ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 65536) == 16746489793331175369ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 131072) == 514952025484227461ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 262144) == 10867212269810675249ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 524288) == 9822204377278314587ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 1048576) == 3295088921987850465ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 2097152) == 7559197431498053712ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 4194304) == 1667267269116771849ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 8388608) == 2916804068951374862ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 16777216) == 14422558383125688561ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 33554432) == 10083112683694342602ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 67108864) == 7222777647078298513ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 134217728) == 18424513674048212529ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 268435456) == 14913668581101810784ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 536870912) == 14377721174297902048ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 1073741824) == 6031715005667500948ULL);
+       ok1(hash64_stable(u64array, ARRAY_WORDS, 2147483648U) == 4827100319722378642ULL);
+
+       return exit_status();
+}
diff --git a/lib/ccan/hash/test/run.c b/lib/ccan/hash/test/run.c
new file mode 100644 (file)
index 0000000..dad8e86
--- /dev/null
@@ -0,0 +1,149 @@
+#include <ccan/hash/hash.h>
+#include <ccan/tap/tap.h>
+#include <ccan/hash/hash.c>
+#include <stdbool.h>
+#include <string.h>
+
+#define ARRAY_WORDS 5
+
+int main(int argc, char *argv[])
+{
+       unsigned int i, j, k;
+       uint32_t array[ARRAY_WORDS], val;
+       char array2[sizeof(array) + sizeof(uint32_t)];
+       uint32_t results[256];
+
+       /* Initialize array. */
+       for (i = 0; i < ARRAY_WORDS; i++)
+               array[i] = i;
+
+       plan_tests(39);
+       /* Hash should be the same, indep of memory alignment. */
+       val = hash(array, ARRAY_WORDS, 0);
+       for (i = 0; i < sizeof(uint32_t); i++) {
+               memcpy(array2 + i, array, sizeof(array));
+               ok(hash(array2 + i, ARRAY_WORDS, 0) != val,
+                  "hash matched at offset %i", i);
+       }
+
+       /* Hash of random values should have random distribution:
+        * check one byte at a time. */
+       for (i = 0; i < sizeof(uint32_t); i++) {
+               unsigned int lowest = -1U, highest = 0;
+
+               memset(results, 0, sizeof(results));
+
+               for (j = 0; j < 256000; j++) {
+                       for (k = 0; k < ARRAY_WORDS; k++)
+                               array[k] = random();
+                       results[(hash(array, ARRAY_WORDS, 0) >> i*8)&0xFF]++;
+               }
+
+               for (j = 0; j < 256; j++) {
+                       if (results[j] < lowest)
+                               lowest = results[j];
+                       if (results[j] > highest)
+                               highest = results[j];
+               }
+               /* Expect within 20% */
+               ok(lowest > 800, "Byte %i lowest %i", i, lowest);
+               ok(highest < 1200, "Byte %i highest %i", i, highest);
+               diag("Byte %i, range %u-%u", i, lowest, highest);
+       }
+
+       /* Hash of random values should have random distribution:
+        * check one byte at a time. */
+       for (i = 0; i < sizeof(uint64_t); i++) {
+               unsigned int lowest = -1U, highest = 0;
+
+               memset(results, 0, sizeof(results));
+
+               for (j = 0; j < 256000; j++) {
+                       for (k = 0; k < ARRAY_WORDS; k++)
+                               array[k] = random();
+                       results[(hash64(array, sizeof(array)/sizeof(uint64_t),
+                                       0) >> i*8)&0xFF]++;
+               }
+
+               for (j = 0; j < 256; j++) {
+                       if (results[j] < lowest)
+                               lowest = results[j];
+                       if (results[j] > highest)
+                               highest = results[j];
+               }
+               /* Expect within 20% */
+               ok(lowest > 800, "Byte %i lowest %i", i, lowest);
+               ok(highest < 1200, "Byte %i highest %i", i, highest);
+               diag("Byte %i, range %u-%u", i, lowest, highest);
+       }
+
+       /* Hash of pointer values should also have random distribution. */
+       for (i = 0; i < sizeof(uint32_t); i++) {
+               unsigned int lowest = -1U, highest = 0;
+               char *p = malloc(256000);
+
+               memset(results, 0, sizeof(results));
+
+               for (j = 0; j < 256000; j++)
+                       results[(hash_pointer(p + j, 0) >> i*8)&0xFF]++;
+               free(p);
+
+               for (j = 0; j < 256; j++) {
+                       if (results[j] < lowest)
+                               lowest = results[j];
+                       if (results[j] > highest)
+                               highest = results[j];
+               }
+               /* Expect within 20% */
+               ok(lowest > 800, "hash_pointer byte %i lowest %i", i, lowest);
+               ok(highest < 1200, "hash_pointer byte %i highest %i",
+                  i, highest);
+               diag("hash_pointer byte %i, range %u-%u", i, lowest, highest);
+       }
+
+       if (sizeof(long) == sizeof(uint32_t))
+               ok1(hashl(array, ARRAY_WORDS, 0)
+                   == hash(array, ARRAY_WORDS, 0));
+       else
+               ok1(hashl(array, ARRAY_WORDS, 0)
+                   == hash64(array, ARRAY_WORDS, 0));
+
+       /* String hash: weak, so only test bottom byte */
+       for (i = 0; i < 1; i++) {
+               unsigned int num = 0, cursor, lowest = -1U, highest = 0;
+               char p[5];
+
+               memset(results, 0, sizeof(results));
+
+               memset(p, 'A', sizeof(p));
+               p[sizeof(p)-1] = '\0';
+
+               for (;;) {
+                       for (cursor = 0; cursor < sizeof(p)-1; cursor++) {
+                               p[cursor]++;
+                               if (p[cursor] <= 'z')
+                                       break;
+                               p[cursor] = 'A';
+                       }
+                       if (cursor == sizeof(p)-1)
+                               break;
+
+                       results[(hash_string(p) >> i*8)&0xFF]++;
+                       num++;
+               }
+
+               for (j = 0; j < 256; j++) {
+                       if (results[j] < lowest)
+                               lowest = results[j];
+                       if (results[j] > highest)
+                               highest = results[j];
+               }
+               /* Expect within 20% */
+               ok(lowest > 35000, "hash_pointer byte %i lowest %i", i, lowest);
+               ok(highest < 53000, "hash_pointer byte %i highest %i",
+                  i, highest);
+               diag("hash_pointer byte %i, range %u-%u", i, lowest, highest);
+       }
+
+       return exit_status();
+}
diff --git a/lib/ccan/htable/LICENSE b/lib/ccan/htable/LICENSE
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/lib/ccan/htable/_info b/lib/ccan/htable/_info
new file mode 100644 (file)
index 0000000..8dabe46
--- /dev/null
@@ -0,0 +1,115 @@
+#include <string.h>
+#include <stdio.h>
+
+/**
+ * htable - hash table routines
+ *
+ * A hash table is an efficient structure for looking up keys.  This version
+ * grows with usage and allows efficient deletion.
+ *
+ * Example:
+ *     #include <ccan/htable/htable.h>
+ *     #include <ccan/hash/hash.h>
+ *     #include <stdio.h>
+ *     #include <err.h>
+ *     #include <string.h>
+ *
+ *     struct name_to_digit {
+ *             const char *name;
+ *             unsigned int val;
+ *     };
+ *
+ *     static struct name_to_digit map[] = {
+ *             { "zero", 0},
+ *             { "one", 1 },
+ *             { "two", 2 },
+ *             { "three", 3 },
+ *             { "four", 4 },
+ *             { "five", 5 },
+ *             { "six", 6 },
+ *             { "seven", 7 },
+ *             { "eight", 8 },
+ *             { "nine", 9 }
+ *     };
+ *
+ *     // Wrapper for rehash function pointer.
+ *     static size_t rehash(const void *e, void *unused)
+ *     {
+ *             return hash_string(((struct name_to_digit *)e)->name);
+ *     }
+ *
+ *     // Comparison function.
+ *     static bool streq(const void *e, void *string)
+ *     {
+ *             return strcmp(((struct name_to_digit *)e)->name, string) == 0;
+ *     }
+ *
+ *     // We let them add their own aliases, eg. --alias=v=5
+ *     static void add_alias(struct htable *ht, const char *alias)
+ *     {
+ *             char *eq;
+ *             struct name_to_digit *n;
+ *
+ *             n = malloc(sizeof(*n));
+ *             n->name = strdup(alias);
+ *
+ *             eq = strchr(n->name, '=');
+ *             if (!eq || ((n->val = atoi(eq+1)) == 0 && !strcmp(eq+1, "0")))
+ *                     errx(1, "Usage: --alias=<name>=<value>");
+ *             *eq = '\0';
+ *             htable_add(ht, hash_string(n->name), n);
+ *     }
+ *
+ *     int main(int argc, char *argv[])
+ *     {
+ *             struct htable *ht;
+ *             unsigned int i;
+ *             unsigned long val;
+ *
+ *             if (argc < 2)
+ *                     errx(1, "Usage: %s [--alias=<name>=<val>]... <str>...",
+ *                          argv[0]);
+ *
+ *             // Create and populate hash table.
+ *             ht = htable_new(rehash, NULL);
+ *             for (i = 0; i < sizeof(map)/sizeof(map[0]); i++)
+ *                     htable_add(ht, hash_string(map[i].name), &map[i]);
+ *
+ *             // Add any aliases to the hash table.
+ *             for (i = 1; i < argc; i++) {
+ *                     if (!strncmp(argv[i], "--alias=", strlen("--alias=")))
+ *                             add_alias(ht, argv[i] + strlen("--alias="));
+ *                     else
+ *                             break;
+ *             }
+ *
+ *             // Find the other args in the hash table.
+ *             for (val = 0; i < argc; i++) {
+ *                     struct name_to_digit *n;
+ *                     n = htable_get(ht, hash_string(argv[i]),
+ *                                    streq, argv[i]);
+ *                     if (!n)
+ *                             errx(1, "Invalid digit name %s", argv[i]);
+ *                     // Append it to the value we are building up.
+ *                     val *= 10;
+ *                     val += n->val;
+ *             }
+ *             printf("%lu\n", val);
+ *             return 0;
+ *     }
+ *
+ * License: GPLv2 (or later)
+ * Author: Rusty Russell <rusty@rustcorp.com.au>
+ */
+int main(int argc, char *argv[])
+{
+       if (argc != 2)
+               return 1;
+
+       if (strcmp(argv[1], "depends") == 0) {
+               printf("ccan/compiler\n");
+               return 0;
+       }
+
+       return 1;
+}
diff --git a/lib/ccan/htable/htable.c b/lib/ccan/htable/htable.c
new file mode 100644 (file)
index 0000000..a15c54d
--- /dev/null
@@ -0,0 +1,290 @@
+#include <ccan/htable/htable.h>
+#include <ccan/compiler/compiler.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <stdbool.h>
+#include <assert.h>
+
+/* This means a struct htable takes at least 512 bytes / 1k (32/64 bits). */
+#define HTABLE_BASE_BITS 7
+
+/* We use 0x1 as deleted marker. */
+#define HTABLE_DELETED (0x1)
+
+struct htable {
+       size_t (*rehash)(const void *elem, void *priv);
+       void *priv;
+       unsigned int bits;
+       size_t elems, deleted, max, max_with_deleted;
+       /* These are the bits which are the same in all pointers. */
+       uintptr_t common_mask, common_bits;
+       uintptr_t perfect_bit;
+       uintptr_t *table;
+};
+
+/* We clear out the bits which are always the same, and put metadata there. */
+static inline uintptr_t get_extra_ptr_bits(const struct htable *ht,
+                                          uintptr_t e)
+{
+       return e & ht->common_mask;
+}
+
+static inline void *get_raw_ptr(const struct htable *ht, uintptr_t e)
+{
+       return (void *)((e & ~ht->common_mask) | ht->common_bits);
+}
+
+static inline uintptr_t make_hval(const struct htable *ht,
+                                 const void *p, uintptr_t bits)
+{
+       return ((uintptr_t)p & ~ht->common_mask) | bits;
+}
+
+static inline bool entry_is_valid(uintptr_t e)
+{
+       return e > HTABLE_DELETED;
+}
+
+static inline uintptr_t get_hash_ptr_bits(const struct htable *ht,
+                                         size_t hash)
+{
+       /* Shuffling the extra bits (as specified in mask) down the
+        * end is quite expensive.  But the lower bits are redundant, so
+        * we fold the value first. */
+       return (hash ^ (hash >> ht->bits))
+               & ht->common_mask & ~ht->perfect_bit;
+}
+
+struct htable *htable_new(size_t (*rehash)(const void *elem, void *priv),
+                         void *priv)
+{
+       struct htable *ht = malloc(sizeof(struct htable));
+       if (ht) {
+               ht->bits = HTABLE_BASE_BITS;
+               ht->rehash = rehash;
+               ht->priv = priv;
+               ht->elems = 0;
+               ht->deleted = 0;
+               ht->max = ((size_t)1 << ht->bits) * 3 / 4;
+               ht->max_with_deleted = ((size_t)1 << ht->bits) * 9 / 10;
+               /* This guarantees we enter update_common first add. */
+               ht->common_mask = -1;
+               ht->common_bits = 0;
+               ht->perfect_bit = 0;
+               ht->table = calloc(1 << ht->bits, sizeof(uintptr_t));
+               if (!ht->table) {
+                       free(ht);
+                       ht = NULL;
+               }
+       }
+       return ht;
+}
+
+void htable_free(const struct htable *ht)
+{
+       free((void *)ht->table);
+       free((void *)ht);
+}
+
+static size_t hash_bucket(const struct htable *ht, size_t h)
+{
+       return h & ((1 << ht->bits)-1);
+}
+
+static void *htable_val(const struct htable *ht,
+                       struct htable_iter *i, size_t hash, uintptr_t perfect)
+{
+       uintptr_t h2 = get_hash_ptr_bits(ht, hash) | perfect;
+
+       while (ht->table[i->off]) {
+               if (ht->table[i->off] != HTABLE_DELETED) {
+                       if (get_extra_ptr_bits(ht, ht->table[i->off]) == h2)
+                               return get_raw_ptr(ht, ht->table[i->off]);
+               }
+               i->off = (i->off + 1) & ((1 << ht->bits)-1);
+               h2 &= ~perfect;
+       }
+       return NULL;
+}
+
+void *htable_firstval(const struct htable *ht,
+                     struct htable_iter *i, size_t hash)
+{
+       i->off = hash_bucket(ht, hash);
+       return htable_val(ht, i, hash, ht->perfect_bit);
+}
+
+void *htable_nextval(const struct htable *ht,
+                    struct htable_iter *i, size_t hash)
+{
+       i->off = (i->off + 1) & ((1 << ht->bits)-1);
+       return htable_val(ht, i, hash, 0);
+}
+
+void *htable_first(const struct htable *ht, struct htable_iter *i)
+{
+       for (i->off = 0; i->off < (size_t)1 << ht->bits; i->off++) {
+               if (entry_is_valid(ht->table[i->off]))
+                       return get_raw_ptr(ht, ht->table[i->off]);
+       }
+       return NULL;
+}
+
+void *htable_next(const struct htable *ht, struct htable_iter *i)
+{
+       for (i->off++; i->off < (size_t)1 << ht->bits; i->off++) {
+               if (entry_is_valid(ht->table[i->off]))
+                       return get_raw_ptr(ht, ht->table[i->off]);
+       }
+       return NULL;
+}
+
+/* This does not expand the hash table, that's up to caller. */
+static void ht_add(struct htable *ht, const void *new, size_t h)
+{
+       size_t i;
+       uintptr_t perfect = ht->perfect_bit;
+
+       i = hash_bucket(ht, h);
+
+       while (entry_is_valid(ht->table[i])) {
+               perfect = 0;
+               i = (i + 1) & ((1 << ht->bits)-1);
+       }
+       ht->table[i] = make_hval(ht, new, get_hash_ptr_bits(ht, h)|perfect);
+}
+
+static COLD bool double_table(struct htable *ht)
+{
+       unsigned int i;
+       size_t oldnum = (size_t)1 << ht->bits;
+       uintptr_t *oldtable, e;
+
+       oldtable = ht->table;
+       ht->table = calloc(1 << (ht->bits+1), sizeof(size_t));
+       if (!ht->table) {
+               ht->table = oldtable;
+               return false;
+       }
+       ht->bits++;
+       ht->max *= 2;
+       ht->max_with_deleted *= 2;
+
+       /* If we lost our "perfect bit", get it back now. */
+       if (!ht->perfect_bit && ht->common_mask) {
+               for (i = 0; i < sizeof(ht->common_mask) * CHAR_BIT; i++) {
+                       if (ht->common_mask & ((size_t)1 << i)) {
+                               ht->perfect_bit = (size_t)1 << i;
+                               break;
+                       }
+               }
+       }
+
+       for (i = 0; i < oldnum; i++) {
+               if (entry_is_valid(e = oldtable[i])) {
+                       void *p = get_raw_ptr(ht, e);
+                       ht_add(ht, p, ht->rehash(p, ht->priv));
+               }
+       }
+       ht->deleted = 0;
+       free(oldtable);
+       return true;
+}
+
+static COLD void rehash_table(struct htable *ht)
+{
+       size_t start, i;
+       uintptr_t e;
+
+       /* Beware wrap cases: we need to start from first empty bucket. */
+       for (start = 0; ht->table[start]; start++);
+
+       for (i = 0; i < (size_t)1 << ht->bits; i++) {
+               size_t h = (i + start) & ((1 << ht->bits)-1);
+               e = ht->table[h];
+               if (!e)
+                       continue;
+               if (e == HTABLE_DELETED)
+                       ht->table[h] = 0;
+               else if (!(e & ht->perfect_bit)) {
+                       void *p = get_raw_ptr(ht, e);
+                       ht->table[h] = 0;
+                       ht_add(ht, p, ht->rehash(p, ht->priv));
+               }
+       }
+       ht->deleted = 0;
+}
+
+/* We stole some bits, now we need to put them back... */
+static COLD void update_common(struct htable *ht, const void *p)
+{
+       unsigned int i;
+       uintptr_t maskdiff, bitsdiff;
+
+       if (ht->elems == 0) {
+               ht->common_mask = -1;
+               ht->common_bits = (uintptr_t)p;
+               ht->perfect_bit = 1;
+               return;
+       }
+
+       /* Find bits which are unequal to old common set. */
+       maskdiff = ht->common_bits ^ ((uintptr_t)p & ht->common_mask);
+
+       /* These are the bits which go there in existing entries. */
+       bitsdiff = ht->common_bits & maskdiff;
+
+       for (i = 0; i < (size_t)1 << ht->bits; i++) {
+               if (!entry_is_valid(ht->table[i]))
+                       continue;
+               /* Clear the bits no longer in the mask, set them as
+                * expected. */
+               ht->table[i] &= ~maskdiff;
+               ht->table[i] |= bitsdiff;
+       }
+
+       /* Take away those bits from our mask, bits and perfect bit. */
+       ht->common_mask &= ~maskdiff;
+       ht->common_bits &= ~maskdiff;
+       ht->perfect_bit &= ~maskdiff;
+}
+
+bool htable_add(struct htable *ht, size_t hash, const void *p)
+{
+       if (ht->elems+1 > ht->max && !double_table(ht))
+               return false;
+       if (ht->elems+1 + ht->deleted > ht->max_with_deleted)
+               rehash_table(ht);
+       assert(p);
+       if (((uintptr_t)p & ht->common_mask) != ht->common_bits)
+               update_common(ht, p);
+
+       ht_add(ht, p, hash);
+       ht->elems++;
+       return true;
+}
+
+bool htable_del(struct htable *ht, size_t h, const void *p)
+{
+       struct htable_iter i;
+       void *c;
+
+       for (c = htable_firstval(ht,&i,h); c; c = htable_nextval(ht,&i,h)) {
+               if (c == p) {
+                       htable_delval(ht, &i);
+                       return true;
+               }
+       }
+       return false;
+}
+
+void htable_delval(struct htable *ht, struct htable_iter *i)
+{
+       assert(i->off < (size_t)1 << ht->bits);
+       assert(entry_is_valid(ht->table[i->off]));
+
+       ht->elems--;
+       ht->table[i->off] = HTABLE_DELETED;
+       ht->deleted++;
+}
diff --git a/lib/ccan/htable/htable.h b/lib/ccan/htable/htable.h
new file mode 100644 (file)
index 0000000..b684429
--- /dev/null
@@ -0,0 +1,138 @@
+#ifndef CCAN_HTABLE_H
+#define CCAN_HTABLE_H
+#include "config.h"
+#include <stdbool.h>
+#include <stdlib.h>
+
+struct htable;
+
+/**
+ * htable_new - allocate a hash tree.
+ * @rehash: hash function to use for rehashing.
+ * @priv: private argument to @rehash function.
+ */
+struct htable *htable_new(size_t (*hash)(const void *elem, void *priv),
+                         void *priv);
+
+/**
+ * htable_free - dellocate a hash tree.
+ *
+ * This doesn't do anything to any pointers left in it.
+ */
+void htable_free(const struct htable *);
+
+/**
+ * htable_rehash - use a hashtree's rehash function
+ * @elem: the argument to rehash()
+ *
+ */
+size_t htable_rehash(const void *elem);
+
+/**
+ * htable_add - add a pointer into a hash tree.
+ * @ht: the htable
+ * @hash: the hash value of the object
+ * @p: the non-NULL pointer
+ *
+ * Also note that this can only fail due to allocation failure.  Otherwise, it
+ * returns true.
+ */
+bool htable_add(struct htable *ht, size_t hash, const void *p);
+
+/**
+ * htable_del - remove a pointer from a hash tree
+ * @ht: the htable
+ * @hash: the hash value of the object
+ * @p: the pointer
+ *
+ * Returns true if the pointer was found (and deleted).
+ */
+bool htable_del(struct htable *ht, size_t hash, const void *p);
+
+/**
+ * struct htable_iter - iterator or htable_first or htable_firstval etc.
+ *
+ * This refers to a location inside the hashtable.
+ */
+struct htable_iter {
+       size_t off;
+};
+
+/**
+ * htable_firstval - find a candidate for a given hash value
+ * @htable: the hashtable
+ * @i: the struct htable_iter to initialize
+ * @hash: the hash value
+ *
+ * You'll need to check the value is what you want; returns NULL if none.
+ * See Also:
+ *     htable_delval()
+ */
+void *htable_firstval(const struct htable *htable,
+                     struct htable_iter *i, size_t hash);
+
+/**
+ * htable_nextval - find another candidate for a given hash value
+ * @htable: the hashtable
+ * @i: the struct htable_iter to initialize
+ * @hash: the hash value
+ *
+ * You'll need to check the value is what you want; returns NULL if no more.
+ */
+void *htable_nextval(const struct htable *htable,
+                    struct htable_iter *i, size_t hash);
+
+/**
+ * htable_get - find an entry in the hash table
+ * @ht: the hashtable
+ * @h: the hash value of the entry
+ * @cmp: the comparison function
+ * @ptr: the pointer to hand to the comparison function.
+ *
+ * Convenient inline wrapper for htable_firstval/htable_nextval loop.
+ */
+static inline void *htable_get(const struct htable *ht,
+                              size_t h,
+                              bool (*cmp)(const void *candidate, void *ptr),
+                              const void *ptr)
+{
+       struct htable_iter i;
+       void *c;
+
+       for (c = htable_firstval(ht,&i,h); c; c = htable_nextval(ht,&i,h)) {
+               if (cmp(c, (void *)ptr))
+                       return c;
+       }
+       return NULL;
+}
+
+/**
+ * htable_first - find an entry in the hash table
+ * @ht: the hashtable
+ * @i: the struct htable_iter to initialize
+ *
+ * Get an entry in the hashtable; NULL if empty.
+ */
+void *htable_first(const struct htable *htable, struct htable_iter *i);
+
+/**
+ * htable_next - find another entry in the hash table
+ * @ht: the hashtable
+ * @i: the struct htable_iter to use
+ *
+ * Get another entry in the hashtable; NULL if all done.
+ * This is usually used after htable_first or prior non-NULL htable_next.
+ */
+void *htable_next(const struct htable *htable, struct htable_iter *i);
+
+/**
+ * htable_delval - remove an iterated pointer from a hash tree
+ * @ht: the htable
+ * @i: the htable_iter
+ *
+ * Usually used to delete a hash entry after it has been found with
+ * htable_firstval etc.
+ */
+void htable_delval(struct htable *ht, struct htable_iter *i);
+
+#endif /* CCAN_HTABLE_H */
diff --git a/lib/ccan/htable/htable_type.h b/lib/ccan/htable/htable_type.h
new file mode 100644 (file)
index 0000000..0d9e3fb
--- /dev/null
@@ -0,0 +1,97 @@
+#ifndef CCAN_HTABLE_TYPE_H
+#define CCAN_HTABLE_TYPE_H
+#include <ccan/htable/htable.h>
+#include "config.h"
+
+/**
+ * HTABLE_DEFINE_TYPE - create a set of htable ops for a type
+ * @type: a type whose pointers will be values in the hash.
+ * @keyof: a function/macro to extract a key from a @type element.
+ * @hashfn: a hash function for a @key
+ * @cmpfn: a comparison function for two keyof()s.
+ * @name: a name for all the functions to define (of form htable_<name>_*)
+ *
+ * NULL values may not be placed into the hash table.
+ *
+ * The following wrapper functions are defined; each one is a
+ * simplified version of the htable.h equivalent:
+ *
+ *     // Creating and freeing.
+ *     struct htable_@name *htable_@name_new(void);
+ *     void htable_@name_free(const struct htable_@name *ht);
+ *
+ *     // Add, delete and find.
+ *     bool htable_@name_add(struct htable_@name *ht, const type *e);
+ *     bool htable_@name_del(struct htable_@name *ht, const type *e);
+ *     bool htable_@name_delkey(struct htable_@name *ht, const ktype *k);
+ *     type *htable_@name_get(const struct htable_@name *ht, const ktype *k);
+ *
+ *     // Iteration.
+ *     struct htable_@name_iter;
+ *     type *htable_@name_first(const struct htable_@name *ht,
+ *                              struct htable_@name_iter *i);
+ *     type *htable_@name_next(const struct htable_@name *ht,
+ *                             struct htable_@name_iter *i);
+ */
+#define HTABLE_DEFINE_TYPE(type, keyof, hashfn, cmpfn, name)           \
+struct htable_##name;                                                  \
+struct htable_##name##_iter { struct htable_iter i; };                 \
+static inline size_t htable_##name##_hash(const void *elem, void *priv)        \
+{                                                                      \
+       return hashfn(keyof((const type *)elem));                       \
+}                                                                      \
+static inline struct htable_##name *htable_##name##_new(void)          \
+{                                                                      \
+       return (struct htable_##name *)htable_new(htable_##name##_hash, \
+                                                 NULL);                \
+}                                                                      \
+static inline void htable_##name##_free(const struct htable_##name *ht)        \
+{                                                                      \
+       htable_free((const struct htable *)ht);                         \
+}                                                                      \
+static inline bool htable_##name##_add(struct htable_##name *ht,       \
+                                      const type *elem)                \
+{                                                                      \
+       return htable_add((struct htable *)ht, hashfn(keyof(elem)), elem); \
+}                                                                      \
+static inline bool htable_##name##_del(const struct htable_##name *ht, \
+                                      const type *elem)                \
+{                                                                      \
+       return htable_del((struct htable *)ht, hashfn(keyof(elem)), elem); \
+}                                                                      \
+static inline type *htable_##name##_get(const struct htable_##name *ht,        \
+                                       const HTABLE_KTYPE(keyof) k)    \
+{                                                                      \
+       /* Typecheck for cmpfn */                                       \
+       (void)sizeof(cmpfn((const type *)NULL,                          \
+                          keyof((const type *)NULL)));                 \
+       return (type *)htable_get((const struct htable *)ht,            \
+                                 hashfn(k),                            \
+                                 (bool (*)(const void *, void *))(cmpfn), \
+                                 k);                                   \
+}                                                                      \
+static inline bool htable_##name##_delkey(struct htable_##name *ht,    \
+                                         const HTABLE_KTYPE(keyof) k) \
+{                                                                      \
+       type *elem = htable_##name##_get(ht, k);                        \
+       if (elem)                                                       \
+               return htable_##name##_del(ht, elem);                   \
+       return false;                                                   \
+}                                                                      \
+static inline type *htable_##name##_first(const struct htable_##name *ht, \
+                                         struct htable_##name##_iter *iter) \
+{                                                                      \
+       return htable_first((const struct htable *)ht, &iter->i);       \
+}                                                                      \
+static inline type *htable_##name##_next(const struct htable_##name *ht, \
+                                        struct htable_##name##_iter *iter) \
+{                                                                      \
+       return htable_next((const struct htable *)ht, &iter->i);        \
+}
+
+#if HAVE_TYPEOF
+#define HTABLE_KTYPE(keyof) typeof(keyof(NULL))
+#else
+#define HTABLE_KTYPE(keyof) void *
+#endif
+#endif /* CCAN_HTABLE_TYPE_H */
diff --git a/lib/ccan/htable/test/run-type.c b/lib/ccan/htable/test/run-type.c
new file mode 100644 (file)
index 0000000..02dac29
--- /dev/null
@@ -0,0 +1,176 @@
+#include <ccan/htable/htable_type.h>
+#include <ccan/htable/htable.c>
+#include <ccan/tap/tap.h>
+#include <stdbool.h>
+#include <string.h>
+
+#define NUM_VALS (1 << HTABLE_BASE_BITS)
+
+struct obj {
+       /* Makes sure we don't try to treat and obj as a key or vice versa */
+       unsigned char unused;
+       unsigned int key;
+};
+
+static const unsigned int *objkey(const struct obj *obj)
+{
+       return &obj->key;
+}
+
+/* We use the number divided by two as the hash (for lots of
+   collisions), plus set all the higher bits so we can detect if they
+   don't get masked out. */
+static size_t objhash(const unsigned int *key)
+{
+       size_t h = *key / 2;
+       h |= -1UL << HTABLE_BASE_BITS;
+       return h;
+}
+
+static bool cmp(const struct obj *obj, const unsigned int *key)
+{
+       return obj->key == *key;
+}
+
+HTABLE_DEFINE_TYPE(struct obj, objkey, objhash, cmp, obj);
+
+static void add_vals(struct htable_obj *ht,
+                    struct obj val[], unsigned int num)
+{
+       unsigned int i;
+
+       for (i = 0; i < num; i++) {
+               if (htable_obj_get(ht, &i)) {
+                       fail("%u already in hash", i);
+                       return;
+               }
+               htable_obj_add(ht, &val[i]);
+               if (htable_obj_get(ht, &i) != &val[i]) {
+                       fail("%u not added to hash", i);
+                       return;
+               }
+       }
+       pass("Added %u numbers to hash", i);
+}
+
+static void find_vals(const struct htable_obj *ht,
+                     const struct obj val[], unsigned int num)
+{
+       unsigned int i;
+
+       for (i = 0; i < num; i++) {
+               if (htable_obj_get(ht, &i) != &val[i]) {
+                       fail("%u not found in hash", i);
+                       return;
+               }
+       }
+       pass("Found %u numbers in hash", i);
+}
+
+static void del_vals(struct htable_obj *ht,
+                    const struct obj val[], unsigned int num)
+{
+       unsigned int i;
+
+       for (i = 0; i < num; i++) {
+               if (!htable_obj_delkey(ht, &val[i].key)) {
+                       fail("%u not deleted from hash", i);
+                       return;
+               }
+       }
+       pass("Deleted %u numbers in hash", i);
+}
+
+static void del_vals_bykey(struct htable_obj *ht,
+                          const struct obj val[], unsigned int num)
+{
+       unsigned int i;
+
+       for (i = 0; i < num; i++) {
+               if (!htable_obj_delkey(ht, &i)) {
+                       fail("%u not deleted by key from hash", i);
+                       return;
+               }
+       }
+       pass("Deleted %u numbers by key from hash", i);
+}
+
+static bool check_mask(struct htable *ht, const struct obj val[], unsigned num)
+{
+       uint64_t i;
+
+       for (i = 0; i < num; i++) {
+               if (((uintptr_t)&val[i] & ht->common_mask) != ht->common_bits)
+                       return false;
+       }
+       return true;
+}
+
+int main(int argc, char *argv[])
+{
+       unsigned int i;
+       struct htable_obj *ht;
+       struct obj val[NUM_VALS];
+       unsigned int dne;
+       void *p;
+       struct htable_obj_iter iter;
+
+       plan_tests(20);
+       for (i = 0; i < NUM_VALS; i++)
+               val[i].key = i;
+       dne = i;
+
+       ht = htable_obj_new();
+       ok1(((struct htable *)ht)->max < (1 << ((struct htable *)ht)->bits));
+       ok1(((struct htable *)ht)->bits == HTABLE_BASE_BITS);
+
+       /* We cannot find an entry which doesn't exist. */
+       ok1(!htable_obj_get(ht, &dne));
+
+       /* Fill it, it should increase in size (once). */
+       add_vals(ht, val, NUM_VALS);
+       ok1(((struct htable *)ht)->bits == HTABLE_BASE_BITS + 1);
+       ok1(((struct htable *)ht)->max < (1 << ((struct htable *)ht)->bits));
+
+       /* Mask should be set. */
+       ok1(((struct htable *)ht)->common_mask != 0);
+       ok1(((struct htable *)ht)->common_mask != -1);
+       ok1(check_mask((struct htable *)ht, val, NUM_VALS));
+
+       /* Find all. */
+       find_vals(ht, val, NUM_VALS);
+       ok1(!htable_obj_get(ht, &dne));
+
+       /* Walk once, should get them all. */
+       i = 0;
+       for (p = htable_obj_first(ht,&iter); p; p = htable_obj_next(ht, &iter))
+               i++;
+       ok1(i == NUM_VALS);
+
+       /* Delete all. */
+       del_vals(ht, val, NUM_VALS);
+       ok1(!htable_obj_get(ht, &val[0].key));
+
+       /* Worst case, a "pointer" which doesn't have any matching bits. */
+       htable_add((struct htable *)ht, 0,
+                  (void *)~(uintptr_t)&val[NUM_VALS-1]);
+       htable_obj_add(ht, &val[NUM_VALS-1]);
+       ok1(((struct htable *)ht)->common_mask == 0);
+       ok1(((struct htable *)ht)->common_bits == 0);
+       /* Delete the bogus one before we trip over it. */
+       htable_del((struct htable *)ht, 0,
+                  (void *)~(uintptr_t)&val[NUM_VALS-1]);
+
+       /* Add the rest. */
+       add_vals(ht, val, NUM_VALS-1);
+
+       /* Check we can find them all. */
+       find_vals(ht, val, NUM_VALS);
+       ok1(!htable_obj_get(ht, &dne));
+
+       /* Delete them all by key. */
+       del_vals_bykey(ht, val, NUM_VALS);
+       htable_obj_free(ht);
+
+       return exit_status();
+}
diff --git a/lib/ccan/htable/test/run.c b/lib/ccan/htable/test/run.c
new file mode 100644 (file)
index 0000000..ece46a0
--- /dev/null
@@ -0,0 +1,176 @@
+#include <ccan/htable/htable.h>
+#include <ccan/htable/htable.c>
+#include <ccan/tap/tap.h>
+#include <stdbool.h>
+#include <string.h>
+
+#define NUM_VALS (1 << HTABLE_BASE_BITS)
+
+/* We use the number divided by two as the hash (for lots of
+   collisions), plus set all the higher bits so we can detect if they
+   don't get masked out. */
+static size_t hash(const void *elem, void *unused)
+{
+       size_t h = *(uint64_t *)elem / 2;
+       h |= -1UL << HTABLE_BASE_BITS;
+       return h;
+}
+
+static bool objcmp(const void *htelem, void *cmpdata)
+{
+       return *(uint64_t *)htelem == *(uint64_t *)cmpdata;
+}
+
+static void add_vals(struct htable *ht,
+                    const uint64_t val[], unsigned int num)
+{
+       uint64_t i;
+
+       for (i = 0; i < num; i++) {
+               if (htable_get(ht, hash(&i, NULL), objcmp, &i)) {
+                       fail("%llu already in hash", (long long)i);
+                       return;
+               }
+               htable_add(ht, hash(&val[i], NULL), &val[i]);
+               if (htable_get(ht, hash(&i, NULL), objcmp, &i) != &val[i]) {
+                       fail("%llu not added to hash", (long long)i);
+                       return;
+               }
+       }
+       pass("Added %llu numbers to hash", (long long)i);
+}
+
+#if 0
+static void refill_vals(struct htable *ht,
+                       const uint64_t val[], unsigned int num)
+{
+       uint64_t i;
+
+       for (i = 0; i < num; i++) {
+               if (htable_get(ht, hash(&i, NULL), objcmp, &i))
+                       continue;
+               htable_add(ht, hash(&val[i], NULL), &val[i]);
+       }
+}
+#endif
+
+static void find_vals(struct htable *ht,
+                     const uint64_t val[], unsigned int num)
+{
+       uint64_t i;
+
+       for (i = 0; i < num; i++) {
+               if (htable_get(ht, hash(&i, NULL), objcmp, &i) != &val[i]) {
+                       fail("%llu not found in hash", (long long)i);
+                       return;
+               }
+       }
+       pass("Found %llu numbers in hash", (long long)i);
+}
+
+static void del_vals(struct htable *ht,
+                    const uint64_t val[], unsigned int num)
+{
+       uint64_t i;
+
+       for (i = 0; i < num; i++) {
+               if (!htable_del(ht, hash(&val[i], NULL), &val[i])) {
+                       fail("%llu not deleted from hash", (long long)i);
+                       return;
+               }
+       }
+       pass("Deleted %llu numbers in hash", (long long)i);
+}
+
+static bool check_mask(struct htable *ht, uint64_t val[], unsigned num)
+{
+       uint64_t i;
+
+       for (i = 0; i < num; i++) {
+               if (((uintptr_t)&val[i] & ht->common_mask) != ht->common_bits)
+                       return false;
+       }
+       return true;
+}
+
+int main(int argc, char *argv[])
+{
+       unsigned int i;
+       uintptr_t perfect_bit;
+       struct htable *ht;
+       uint64_t val[NUM_VALS];
+       uint64_t dne;
+       void *p;
+       struct htable_iter iter;
+
+       plan_tests(23);
+       for (i = 0; i < NUM_VALS; i++)
+               val[i] = i;
+       dne = i;
+
+       ht = htable_new(hash, NULL);
+       ok1(ht->max < (1 << ht->bits));
+       ok1(ht->bits == HTABLE_BASE_BITS);
+
+       /* We cannot find an entry which doesn't exist. */
+       ok1(!htable_get(ht, hash(&dne, NULL), objcmp, &dne));
+
+       /* Fill it, it should increase in size (once). */
+       add_vals(ht, val, NUM_VALS);
+       ok1(ht->bits == HTABLE_BASE_BITS + 1);
+       ok1(ht->max < (1 << ht->bits));
+
+       /* Mask should be set. */
+       ok1(ht->common_mask != 0);
+       ok1(ht->common_mask != -1);
+       ok1(check_mask(ht, val, NUM_VALS));
+
+       /* Find all. */
+       find_vals(ht, val, NUM_VALS);
+       ok1(!htable_get(ht, hash(&dne, NULL), objcmp, &dne));
+
+       /* Walk once, should get them all. */
+       i = 0;
+       for (p = htable_first(ht,&iter); p; p = htable_next(ht, &iter))
+               i++;
+       ok1(i == NUM_VALS);
+
+       /* Delete all. */
+       del_vals(ht, val, NUM_VALS);
+       ok1(!htable_get(ht, hash(&val[0], NULL), objcmp, &val[0]));
+
+       /* Worst case, a "pointer" which doesn't have any matching bits. */
+       htable_add(ht, 0, (void *)~(uintptr_t)&val[NUM_VALS-1]);
+       htable_add(ht, hash(&val[NUM_VALS-1], NULL), &val[NUM_VALS-1]);
+       ok1(ht->common_mask == 0);
+       ok1(ht->common_bits == 0);
+       /* Get rid of bogus pointer before we trip over it! */
+       htable_del(ht, 0, (void *)~(uintptr_t)&val[NUM_VALS-1]);
+
+       /* Add the rest. */
+       add_vals(ht, val, NUM_VALS-1);
+
+       /* Check we can find them all. */
+       find_vals(ht, val, NUM_VALS);
+       ok1(!htable_get(ht, hash(&dne, NULL), objcmp, &dne));
+
+       htable_free(ht);
+
+       /* Corner cases: wipe out the perfect bit using bogus pointer. */
+       ht = htable_new(hash, NULL);
+       htable_add(ht, 0, (void *)((uintptr_t)&val[NUM_VALS-1]));
+       ok1(ht->perfect_bit);
+       perfect_bit = ht->perfect_bit;
+       htable_add(ht, 0, (void *)((uintptr_t)&val[NUM_VALS-1]
+                                  | perfect_bit));
+       ok1(ht->perfect_bit == 0);
+       htable_del(ht, 0, (void *)((uintptr_t)&val[NUM_VALS-1] | perfect_bit));
+
+       /* Enlarging should restore it... */
+       add_vals(ht, val, NUM_VALS-1);
+
+       ok1(ht->perfect_bit != 0);
+       htable_free(ht);
+
+       return exit_status();
+}
diff --git a/lib/ccan/htable/tools/Makefile b/lib/ccan/htable/tools/Makefile
new file mode 100644 (file)
index 0000000..001e160
--- /dev/null
@@ -0,0 +1,5 @@
+CFLAGS=-Wall -Werror -O3 -I../../..
+
+speed: speed.o ../../hash.o
+
+speed.o: speed.c ../htable.h ../htable.c
diff --git a/lib/ccan/htable/tools/speed.c b/lib/ccan/htable/tools/speed.c
new file mode 100644 (file)
index 0000000..2623192
--- /dev/null
@@ -0,0 +1,377 @@
+/* Simple speed tests for hashtables. */
+#include <ccan/htable/htable_type.h>
+#include <ccan/htable/htable.c>
+#include <ccan/hash/hash.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <unistd.h>
+#include <sys/time.h>
+
+static size_t hashcount;
+struct object {
+       /* The key. */
+       unsigned int key;
+
+       /* Some contents. Doubles as consistency check. */
+       struct object *self;
+};
+
+static const unsigned int *objkey(const struct object *obj)
+{
+       return &obj->key;
+}
+
+static size_t hash_obj(const unsigned int *key)
+{
+       hashcount++;
+       return hashl(key, 1, 0);
+}
+
+static bool cmp(const unsigned int *key1, const unsigned int *key2)
+{
+       return *key1 == *key2;
+}
+
+HTABLE_DEFINE_TYPE(struct object, objkey, hash_obj, cmp, obj);
+
+static unsigned int popcount(unsigned long val)
+{
+#if HAVE_BUILTIN_POPCOUNTL
+       return __builtin_popcountl(val);
+#else
+       if (sizeof(long) == sizeof(u64)) {
+               u64 v = val;
+               v = (v & 0x5555555555555555ULL)
+                       + ((v >> 1) & 0x5555555555555555ULL);
+               v = (v & 0x3333333333333333ULL)
+                       + ((v >> 1) & 0x3333333333333333ULL);
+               v = (v & 0x0F0F0F0F0F0F0F0FULL)
+                       + ((v >> 1) & 0x0F0F0F0F0F0F0F0FULL);
+               v = (v & 0x00FF00FF00FF00FFULL)
+                       + ((v >> 1) & 0x00FF00FF00FF00FFULL);
+               v = (v & 0x0000FFFF0000FFFFULL)
+                       + ((v >> 1) & 0x0000FFFF0000FFFFULL);
+               v = (v & 0x00000000FFFFFFFFULL)
+                       + ((v >> 1) & 0x00000000FFFFFFFFULL);
+               return v;
+       }
+       val = (val & 0x55555555ULL) + ((val >> 1) & 0x55555555ULL);
+       val = (val & 0x33333333ULL) + ((val >> 1) & 0x33333333ULL);
+       val = (val & 0x0F0F0F0FULL) + ((val >> 1) & 0x0F0F0F0FULL);
+       val = (val & 0x00FF00FFULL) + ((val >> 1) & 0x00FF00FFULL);
+       val = (val & 0x0000FFFFULL) + ((val >> 1) & 0x0000FFFFULL);
+       return val;
+#endif
+}
+
+static size_t perfect(const struct htable *ht)
+{
+       size_t i, placed_perfect = 0;
+
+       for (i = 0; i < ((size_t)1 << ht->bits); i++) {
+               if (!entry_is_valid(ht->table[i]))
+                       continue;
+               if (hash_bucket(ht, ht->rehash(get_raw_ptr(ht, ht->table[i]),
+                                              ht->priv)) == i) {
+                       assert((ht->table[i] & ht->perfect_bit)
+                              == ht->perfect_bit);
+                       placed_perfect++;
+               }
+       }
+       return placed_perfect;
+}
+
+static size_t count_deleted(const struct htable *ht)
+{
+       size_t i, delete_markers = 0;
+
+       for (i = 0; i < ((size_t)1 << ht->bits); i++) {
+               if (ht->table[i] == HTABLE_DELETED)
+                       delete_markers++;
+       }
+       return delete_markers;
+}
+
+/* Nanoseconds per operation */
+static size_t normalize(const struct timeval *start,
+                       const struct timeval *stop,
+                       unsigned int num)
+{
+       struct timeval diff;
+
+       timersub(stop, start, &diff);
+
+       /* Floating point is more accurate here. */
+       return (double)(diff.tv_sec * 1000000 + diff.tv_usec)
+               / num * 1000;
+}
+
+static size_t worst_run(struct htable *ht, size_t *deleted)
+{
+       size_t longest = 0, len = 0, this_del = 0, i;
+
+       *deleted = 0;
+       /* This doesn't take into account end-wrap, but gives an idea. */
+       for (i = 0; i < ((size_t)1 << ht->bits); i++) {
+               if (ht->table[i]) {
+                       len++;
+                       if (ht->table[i] == HTABLE_DELETED)
+                               this_del++;
+               } else {
+                       if (len > longest) {
+                               longest = len;
+                               *deleted = this_del;
+                       }
+                       len = 0;
+                       this_del = 0;
+               }
+       }
+       return longest;
+}
+
+int main(int argc, char *argv[])
+{
+       struct object *objs;
+       size_t i, j, num, deleted;
+       struct timeval start, stop;
+       struct htable_obj *ht;
+       struct htable *htr;
+       bool make_dumb = false;
+
+       if (argv[1] && strcmp(argv[1], "--dumb") == 0) {
+               argv++;
+               make_dumb = true;
+       }
+       num = argv[1] ? atoi(argv[1]) : 1000000;
+       objs = calloc(num, sizeof(objs[0]));
+
+       for (i = 0; i < num; i++) {
+               objs[i].key = i;
+               objs[i].self = &objs[i];
+       }
+
+       ht = htable_obj_new();
+       htr = (void *)ht;
+
+       printf("Initial insert: ");
+       fflush(stdout);
+       gettimeofday(&start, NULL);
+       for (i = 0; i < num; i++)
+               htable_obj_add(ht, objs[i].self);
+       gettimeofday(&stop, NULL);
+       printf(" %zu ns\n", normalize(&start, &stop, num));
+       printf("Details: hash size %u, mask bits %u, perfect %.0f%%\n",
+              1U << htr->bits, popcount(htr->common_mask),
+              perfect(htr) * 100.0 / htr->elems);
+
+       if (make_dumb) {
+               /* Screw with mask, to hobble us. */
+               update_common(htr, (void *)~htr->common_bits);
+               printf("Details: DUMB MODE: mask bits %u\n",
+                      popcount(htr->common_mask));
+       }
+
+       printf("Initial lookup (match): ");
+       fflush(stdout);
+       gettimeofday(&start, NULL);
+       for (i = 0; i < num; i++)
+               if (htable_obj_get(ht, &i)->self != objs[i].self)
+                       abort();
+       gettimeofday(&stop, NULL);
+       printf(" %zu ns\n", normalize(&start, &stop, num));
+
+       printf("Initial lookup (miss): ");
+       fflush(stdout);
+       gettimeofday(&start, NULL);
+       for (i = 0; i < num; i++) {
+               unsigned int n = i + num;
+               if (htable_obj_get(ht, &n))
+                       abort();
+       }
+       gettimeofday(&stop, NULL);
+       printf(" %zu ns\n", normalize(&start, &stop, num));
+
+       /* Lookups in order are very cache-friendly for judy; try random */
+       printf("Initial lookup (random): ");
+       fflush(stdout);
+       gettimeofday(&start, NULL);
+       for (i = 0, j = 0; i < num; i++, j = (j + 10007) % num)
+               if (htable_obj_get(ht, &j)->self != &objs[j])
+                       abort();
+       gettimeofday(&stop, NULL);
+       printf(" %zu ns\n", normalize(&start, &stop, num));
+
+       hashcount = 0;
+       printf("Initial delete all: ");
+       fflush(stdout);
+       gettimeofday(&start, NULL);
+       for (i = 0; i < num; i++)
+               if (!htable_obj_del(ht, objs[i].self))
+                       abort();
+       gettimeofday(&stop, NULL);
+       printf(" %zu ns\n", normalize(&start, &stop, num));
+       printf("Details: rehashes %zu\n", hashcount);
+
+       printf("Initial re-inserting: ");
+       fflush(stdout);
+       gettimeofday(&start, NULL);
+       for (i = 0; i < num; i++)
+               htable_obj_add(ht, objs[i].self);
+       gettimeofday(&stop, NULL);
+       printf(" %zu ns\n", normalize(&start, &stop, num));
+
+       hashcount = 0;
+       printf("Deleting first half: ");
+       fflush(stdout);
+       gettimeofday(&start, NULL);
+       for (i = 0; i < num; i+=2)
+               if (!htable_obj_del(ht, objs[i].self))
+                       abort();
+       gettimeofday(&stop, NULL);
+       printf(" %zu ns\n", normalize(&start, &stop, num));
+
+       printf("Details: rehashes %zu, delete markers %zu\n",
+              hashcount, count_deleted(htr));
+
+       printf("Adding (a different) half: ");
+       fflush(stdout);
+
+       for (i = 0; i < num; i+=2)
+               objs[i].key = num+i;
+
+       gettimeofday(&start, NULL);
+       for (i = 0; i < num; i+=2)
+               htable_obj_add(ht, objs[i].self);
+       gettimeofday(&stop, NULL);
+       printf(" %zu ns\n", normalize(&start, &stop, num));
+
+       printf("Details: delete markers %zu, perfect %.0f%%\n",
+              count_deleted(htr), perfect(htr) * 100.0 / htr->elems);
+
+       printf("Lookup after half-change (match): ");
+       fflush(stdout);
+       gettimeofday(&start, NULL);
+       for (i = 1; i < num; i+=2)
+               if (htable_obj_get(ht, &i)->self != objs[i].self)
+                       abort();
+       for (i = 0; i < num; i+=2) {
+               unsigned int n = i + num;
+               if (htable_obj_get(ht, &n)->self != objs[i].self)
+                       abort();
+       }
+       gettimeofday(&stop, NULL);
+       printf(" %zu ns\n", normalize(&start, &stop, num));
+
+       printf("Lookup after half-change (miss): ");
+       fflush(stdout);
+       gettimeofday(&start, NULL);
+       for (i = 0; i < num; i++) {
+               unsigned int n = i + num * 2;
+               if (htable_obj_get(ht, &n))
+                       abort();
+       }
+       gettimeofday(&stop, NULL);
+       printf(" %zu ns\n", normalize(&start, &stop, num));
+
+       /* Hashtables with delete markers can fill with markers over time.
+        * so do some changes to see how it operates in long-term. */
+       for (i = 0; i < 5; i++) {
+               if (i == 0) {
+                       /* We don't measure this: jmap is different. */
+                       printf("Details: initial churn\n");
+               } else {
+                       printf("Churning %s time: ",
+                              i == 1 ? "second"
+                              : i == 2 ? "third"
+                              : i == 3 ? "fourth"
+                              : "fifth");
+                       fflush(stdout);
+               }
+               gettimeofday(&start, NULL);
+               for (j = 0; j < num; j++) {
+                       if (!htable_obj_del(ht, &objs[j]))
+                               abort();
+                       objs[j].key = num*i+j;
+                       if (!htable_obj_add(ht, &objs[j]))
+                               abort();
+               }
+               gettimeofday(&stop, NULL);
+               if (i != 0)
+                       printf(" %zu ns\n", normalize(&start, &stop, num));
+       }
+
+       /* Spread out the keys more to try to make it harder. */
+       printf("Details: reinserting with spread\n");
+       for (i = 0; i < num; i++) {
+               if (!htable_obj_del(ht, objs[i].self))
+                       abort();
+               objs[i].key = num * 5 + i * 9;
+               if (!htable_obj_add(ht, objs[i].self))
+                       abort();
+       }
+       printf("Details: delete markers %zu, perfect %.0f%%\n",
+              count_deleted(htr), perfect(htr) * 100.0 / htr->elems);
+       i = worst_run(htr, &deleted);
+       printf("Details: worst run %zu (%zu deleted)\n", i, deleted);
+
+       printf("Lookup after churn & spread (match): ");
+       fflush(stdout);
+       gettimeofday(&start, NULL);
+       for (i = 0; i < num; i++) {
+               unsigned int n = num * 5 + i * 9;
+               if (htable_obj_get(ht, &n)->self != objs[i].self)
+                       abort();
+       }
+       gettimeofday(&stop, NULL);
+       printf(" %zu ns\n", normalize(&start, &stop, num));
+
+       printf("Lookup after churn & spread (miss): ");
+       fflush(stdout);
+       gettimeofday(&start, NULL);
+       for (i = 0; i < num; i++) {
+               unsigned int n = num * (5 + 9) + i * 9;
+               if (htable_obj_get(ht, &n))
+                       abort();
+       }
+       gettimeofday(&stop, NULL);
+       printf(" %zu ns\n", normalize(&start, &stop, num));
+
+       printf("Lookup after churn & spread (random): ");
+       fflush(stdout);
+       gettimeofday(&start, NULL);
+       for (i = 0, j = 0; i < num; i++, j = (j + 10007) % num) {
+               unsigned int n = num * 5 + j * 9;
+               if (htable_obj_get(ht, &n)->self != &objs[j])
+                       abort();
+       }
+       gettimeofday(&stop, NULL);
+       printf(" %zu ns\n", normalize(&start, &stop, num));
+
+       hashcount = 0;
+       printf("Deleting half after churn & spread: ");
+       fflush(stdout);
+       gettimeofday(&start, NULL);
+       for (i = 0; i < num; i+=2)
+               if (!htable_obj_del(ht, objs[i].self))
+                       abort();
+       gettimeofday(&stop, NULL);
+       printf(" %zu ns\n", normalize(&start, &stop, num));
+
+       printf("Adding (a different) half after churn & spread: ");
+       fflush(stdout);
+
+       for (i = 0; i < num; i+=2)
+               objs[i].key = num*6+i*9;
+
+       gettimeofday(&start, NULL);
+       for (i = 0; i < num; i+=2)
+               htable_obj_add(ht, objs[i].self);
+       gettimeofday(&stop, NULL);
+       printf(" %zu ns\n", normalize(&start, &stop, num));
+
+       printf("Details: delete markers %zu, perfect %.0f%%\n",
+              count_deleted(htr), perfect(htr) * 100.0 / htr->elems);
+
+       return 0;
+}
diff --git a/lib/ccan/ilog/LICENSE b/lib/ccan/ilog/LICENSE
new file mode 100644 (file)
index 0000000..5522aa5
--- /dev/null
@@ -0,0 +1,508 @@
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+       51 Franklin St, 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 no