d

c/Memory/src/Memory.Aux.c

@@ -0,0 +1,3 @@
+
+UT_hash
+

c/ext/uthash/.gitignore

@@ -0,0 +1,3 @@
+*~
+*.out
+keystat.*

c/ext/uthash/.travis.yml

@@ -0,0 +1,14 @@
+language: cpp
+matrix:
+  include:
+  - os: linux
+    compiler: gcc
+  - os: linux
+    compiler: clang
+  - os: osx
+script:
+- make -C tests EXTRA_CFLAGS="-W -Wall -Wextra -Wswitch-default"
+- make -C tests clean ; make -C tests pedantic
+- make -C tests clean ; make -C tests pedantic EXTRA_CFLAGS=-DNO_DECLTYPE
+- make -C tests clean ; make -C tests cplusplus
+- make -C tests clean ; make -C tests cplusplus EXTRA_CFLAGS=-DNO_DECLTYPE

c/ext/uthash/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2005-2021, Troy D. Hanson    http://troydhanson.github.com/uthash/
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

c/ext/uthash/README.md

@@ -0,0 +1,8 @@
+
+[![Build status](https://api.travis-ci.org/troydhanson/uthash.svg?branch=master)](https://travis-ci.org/troydhanson/uthash)
+
+Documentation for uthash is available at:
+
+https://troydhanson.github.com/uthash/
+
+

c/ext/uthash/doc/.gitignore

@@ -0,0 +1,7 @@
+ChangeLog.html
+userguide.html
+utarray.html
+utlist.html
+utringbuffer.html
+utstack.html
+utstring.html

c/ext/uthash/doc/ChangeLog.txt

@@ -0,0 +1,282 @@
+uthash ChangeLog
+================
+
+Click to return to the link:index.html[uthash home page].
+
+NOTE: This ChangeLog may be incomplete and/or incorrect. See the git commit log.
+
+Version 2.3.0 (2021-02-25)
+--------------------------
+* remove HASH_FCN; the HASH_FUNCTION and HASH_KEYCMP macros now behave similarly
+* remove uthash_memcmp (deprecated in v2.1.0) in favor of HASH_KEYCMP
+* silence -Wswitch-default warnings (thanks, Olaf Bergmann!)
+
+Version 2.2.0 (2020-12-17)
+--------------------------
+* add HASH_NO_STDINT for platforms without C99 <stdint.h>
+* silence many -Wcast-qual warnings (thanks, Olaf Bergmann!)
+* skip hash computation when finding in an empty hash (thanks, Huansong Fu!)
+* rename oom to utarray_oom, in utarray.h (thanks, Hong Xu!)
+* rename oom to utstring_oom, in utstring.h (thanks, Hong Xu!)
+* remove MurmurHash/HASH_MUR
+
+Version 2.1.0 (2018-12-20)
+--------------------------
+* silence some Clang static analysis warnings
+* add LL_INSERT_INORDER and LL_LOWER_BOUND etc (thanks, Jeffrey Lovitz and Mattias Eriksson!)
+* add uthash_bzero for platforms without <string.h>
+* fix a missing HASH_BLOOM_ADD in HASH_SELECT (thanks, Pawel Veselov!)
+* permit malloc failure to be recoverable via HASH_NONFATAL_OOM (thanks, Pawel Veselov!)
+* avoid repeated calls to uthash_strlen in HASH_FIND_STR
+* rename uthash_memcmp to HASH_KEYCMP, leaving the old name for compatibility
+* add utstack.h
+* remove libut
+
+Version 2.0.2 (2017-03-02)
+--------------------------
+* fix segfault in HASH_ADD_INORDER etc (thanks, Yana Kireyonok!)
+* remove spurious cast to unsigned in utstring_len (thanks, Michal Sestrienka!)
+* add uthash_memcmp and uthash_strlen for platforms without <stdlib.h> (thanks, Pawel Veselov!)
+* fix a C++ incompatibility in utringbuffer
+
+Version 2.0.1 (2016-07-05)
+--------------------------
+* in-order insertion macros HASH_ADD_INORDER etc (thanks, Thilo Schulz!)
+* by-hashvalue insertion macros HASH_ADD_BYHASHVALUE etc
+* during key comparison, check hashvalue before doing a full memcmp
+* add utringbuffer.h
+
+Version 1.9.9.1 (2014-11-18)
+----------------------------
+* inclusion of experimental libut bundle with utvector in opt/
+* use shift in Bernstein hash instead of multiply (thanks, Jimmy Zhuo!)
+* switch ssize_t types in utarray/utstring to size_t (thanks, Hong Xu!)
+* fix utstring pointer math on >4GB strings (thanks, Thomas Bottesch!)
+* change FNV hash to FNV-1a varation (thanks, dwest1975!)
+* fix bug in HASH_REPLACE_STR (thanks, Ilya Kaliman!)
+
+Version 1.9.9 (2014-02-25)
+--------------------------
+* made HASH_ADD_STR compatible with char* or char[] (thanks, Samuel Thibault!)
+* fixed header inclusion of sys/types.h for ssize_t (thanks, Fernando Campos!)
+* added LL_COUNT/DL_COUNT/CDL_COUNT (thansk, Paul Praet!)
+* added LRU cache example in `tests/lru_cache` (thanks, Oliver Lorenz!)
+* fix LL_DELETE2 for VS2008 (thanks, Greg Davydouski!)
+* fix missing argument in `HASH_REPLACE_STR` (thanks, Alex!)
+* bump version number in source files to match docs (thanks, John Crow!)
+* add `HASH_OVERHEAD` macro to get overhead size for hash table
+
+Version 1.9.8 (2013-03-10)
+--------------------------
+* `HASH_REPLACE` now in uthash (thanks, Nick Vatamaniuc!)
+* fixed clang warnings (thanks wynnw!)
+* fixed `utarray_insert` when inserting past array end (thanks Rob Willett!)
+* you can now find http://troydhanson.github.com/uthash/[uthash on GitHub]
+* there's a https://groups.google.com/d/forum/uthash[uthash Google Group]
+* uthash has been downloaded 29,000+ times since 2006 on SourceForge
+
+Version 1.9.7 (2012-10-09)
+--------------------------
+* utstring now supports substring search using `utstring_find` (thanks, Joe Wei!)
+* utlist now supports element 'prepend' and 'replace' (thanks, Zoltán Lajos Kis!)
+* utlist element prev/next fields can now have any names (thanks, Pawel S. Veselov!)
+* uthash cast quiets a clang warning (thanks, Roman Divacky and Baptiste Daroussin!)
+* uthash userguide example shows how to check key uniqueness (thanks, Richard Cook!)
+* uthash HASH_MUR compiles under MSVC++ 10 in C mode (thanks, Arun Kirthi Cherian!)
+* `utstring_printf` now supports format checking (thanks, Donald Carr!)
+
+Version 1.9.6 (2012-04-28)
+--------------------------
+* add utarray_prev (thanks, Ben Hiett!)
+* add parens/casts for greater compatibility (thanks, Atis, Debasis Ganguly, and Steve McClellan!)
+* added ifndef to uthash_malloc and related hooks (thanks, Holger Machens!)
+* edit examples so they do not leak memory (thanks, 任晶磊!)
+
+Version 1.9.5 (2011-11-16)
+--------------------------
+* added `utarray_renew`
+* fixed memory leak in `uthash_clear` when using Bloom filter (thanks, Jan Hättig!)
+* utarray now copies the UT_icd on array creation rather than storing a pointer
+* add parentheses to `HASH_ADD` to fix preprocessing of certain arguments (thanks, Aaron Rosen!)
+* more parenthesizations for greater macro argument flexibility
+
+Version 1.9.4 (2011-06-05)
+--------------------------
+* uthash now supports MurmurHash v3
+* utlist now includes concatenation macros (`LL_CONCAT` and `DL_CONCAT`)
+* utarray now supports binary search (`utarray_find`)
+* utstring now supports a new-or-clear-existing macro (`utstring_renew`)
+* documented technique for a multi-level hash table
+* clarified scope requirements for `UT_icd` in the utarray documentation
+* fixed termination when `utstring_clear` is followed by `utstring_body`
+* fixed utarray_inserta macro when used with complex arguments
+* on Visual Studio define missing type `uint8_t`
+* Debian/Ubuntu include uthash in the package `uthash-dev`.
+* uthash has been downloaded 16,211 times.
+
+Thanks to Yu Feng, Richard Cook, Dino Ciuffetti, Chris Groer, and Arun Cherian
+for feedback and fixes in this release!
+
+Version 1.9.3 (2010-10-31)
+--------------------------
+* fix an `ifdef` for compatibility with Intel compiler (thanks, degski!)
+* fix `HASH_ITER` macro to satisfy C++ casting rules (thanks, Erik Bai!)
+
+Version 1.9.2 (2010-10-04)
+--------------------------
+* new `HASH_ITER` macro for more convenient deletion-safe iteration
+* `hashscan` can now run on FreeBSD 8.1 and later (thanks, Markus Gebert!)
+* More parens to evaluate complex macro arguments properly (thanks, ngg!)
+* Add sz parameter to the `uthash_free` hook for platforms that do their own memory management. Hopefully this minor API change doesn't cause too much breakage for people. (thanks, Niall Douglas!)
+* uthash has been downloaded 12,294 times
+
+Version 1.9.1 (2010-05-15)
+--------------------------
+* Fix a redefinition warning when using `uthash.h` and `utstring.h` together
+* Fix a bug in `utstring_init`
+* Added `HASH_FIND_PTR` and `HASH_ADD_PTR` (thanks, Niall Douglas!)
+
+Version 1.9 (2010-03-31)
+--------------------------
+* uthash now supports Visual Studio 2008 and 2010 in C or C++ code!
+* new headers link:utarray.html[utarray.h] and link:utstring.html[utstring.h]
+        are now included. These implement dynamic arrays and strings using macros
+* link:utlist.html[utlist.h] now has deletion-safe iterators and search macros
+* the test suite now runs under Visual Studio (thanks again degski!)
+* special thanks for suggesting utarray and utlist features to Charalampos P.!
+* uthash has been downloaded 9,616 times
+
+Version 1.8 (2009-09-08)
+--------------------------
+* Added the `hashscan` utility that can report on the size and quality of
+  hash tables in a running process (Linux-only)
+* Added Bloom filter support. This has the potential to speed up certain
+  types of programs that look up non-existant keys in sufficient numbers.
+* Restored the MurmurHash, which can once again be used, if an additional
+  symbol is defined. This is a "safety" by which the user declares they
+  understand that `-fno-strict-aliasing` flag must be used if they are
+  using MurmurHash under gcc with optimization.
+* Unified the bucket/table malloc hooks; now there is only one malloc hook
+* Re-organized the manual into a main section and advanced topics section
+* Fixed a bug in `utlist.h` where sorting a singly-linked list threw a
+  compile-time error.
+* Fixed a bug in `utlist.h` where a doubly-linked list that is sorted
+  did not maintain the special `head->prev` pointer back to the list tail.
+
+Version 1.7 (2009-06-11)
+--------------------------
+* The MurmurHash has been removed, and Jenkin's hash is once again the default.
+  While MurmurHash performed well, it's unsafe with regard to the strict
+  aliasing rule. This results in incorrect code when compiled with optimization.
+  It's not possible to enable `-fno-strict-aliasing` from within a header file.
+* The linked list macros in `utlist.h` now comply with the strict-aliasing
+  rule so they generate correct code under high optimization levels (O2 or O3).
+  The use of the `__typeof__` extension, which was originally a GNU extension,
+  may reduce portability to other compilers that do not support this extension.
+  This extension is used in the singly-linked list macros and the sort macros.
+
+Version 1.6 (2009-05-08)
+--------------------------
+Special thanks to Alfred Heisner for contributing several enhancements:
+
+* Support for two new hash functions:
+  - the Paul Hsieh hash function (`HASH_SFH`)
+  - Austin Appleby's MurmurHash function (`HASH_MUR`)
+* Because of its excellent performance, MurmurHash is now the default hash function.
+* `keystats` now has much better elapsed time accuracy under Cygwin and MinGW
+* fixed casting in `HASH_FNV`, `HASH_SAX` and `HASH_OAT` for non-char keys
+
+This release also includes:
+
+* a new `HASH_CLEAR` operation clears a hash table in one step.
+* a new `HASH_SELECT` operation inserts those elements from one hash that
+  satisfy a given condition into another hash. The selected items have
+  dual presence in both hash tables. For example a game could select the
+  visible polygons from a hash of all polygons.
+* fixed a compile-time error which occurred if the final argument to
+  `HASH_ADD_KEYPTR` was a pointer to an array member like `&a[i]`
+* added another test script `tests/all_funcs` which executes the test suite
+  using every supported hash function
+
+And lastly,
+
+* a new, separate header called link:utlist.html[utlist.h] is included which
+  provides 'linked list macros' for C structures, similar in style to the
+  uthash macros
+
+Version 1.5 (2009-02-19)
+--------------------------
+* now thread-safe for concurrent readers
+* use scratch variables on stack rather than in table (thanks, Petter Arvidsson!).
+  This change made HASH_FIND about 13% faster and enabled reader concurrency.
+* made link:license.html[BSD license] terms even more permissive
+* added link:userguide.pdf[PDF version] of User Guide
+* added http://troydhanson.wordpress.com/feed/[update news] image:rss.png[(RSS)]
+
+Version 1.4 (2008-09-23)
+--------------------------
+* Add `HASH_COUNT` for counting items in the hash
+* Compatibility with C\+\+. Satisfy additional casting requirements.
+  Also in the `tests/` directory, running `make cplusplus` now compiles
+  all the test programs with the C++ compiler.
+* Eliminate `elmt` pointer from the UT_hash_handle. Calculate elmt
+  from hash handle address by subtracting `hho` (hash handle offset).
+* Contributed by L.S.Chin:
+  Cast `void*` to char* before pointer arithmetic to suppress compiler
+  warnings. We assume compilers abide to C standards which impose
+  requirement that `sizeof(void*) == sizeof(char*)`.
+* Return meaningful exit status from do_tests per Tiago Cunha,
+  so that package manager-based install can verify tests are successful
+
+
+Version 1.3 (2008-07-27)
+------------------------
+* use integer-only math-- no floating point! Support FPU-less CPU's.
+* eliminate `hash_q` metric, which measured the fraction of items with
+  non-ideal chain positions. We only need to know if this fraction
+  is below 0.5. This is now determined using fast bitwise tests.
+* when an item is added to the hash, calculate the key's hash value
+  upfront and store it, instead of recomputing it as needed. This hashv
+  is stored in the hash handle. Potentially major speed benefit for
+  bucket expansion algorithm. Deleting is marginally improved too.
+* fixed a minor bug in the calculation of the max ideal chain length;
+  line 446 in v1.2 erroneously calculated a/b*2 instead of a/(b*2).
+  The effect of this bug was that bucket expansion could occur more
+  readily because the per-bucket 'max chain length multiplier factor'
+  (which delays bucket expansion when certain buckets are overused)
+  was set to a lower, expansion-favoring value than intended.
+* improved source commenting and improved variable names in structures
+* remove `HASH_JSW`. Lengthy random number array made code less readable
+* add `HASH_SRT(hh,hash,cmp)` as a generalized `HASH_SORT(hash,cmp)`.
+  It was an omission in uthash 1.2 that there was no sort macro for
+  hash handles with names other than hh.
+* Corrected `HASH_FSCK` so it works with any name for the hash handle.
+* behave properly in pathological `HASH_DEL(a,a)` case where the same
+  variable references the head and the deletee (advancing the head
+  then loses the correct reference to the deletee); fix by using
+  scratch area in the hash table to store deletee hash handle.
+* made tests runnable on MinGW
+* 3000+ downloads since uthash-1.0
+
+
+Version 1.2 (2006-11-22)
+------------------------
+* new `HASH_SORT` macro
+* Cygwin support
+* User Guide now features a clickable Table of Contents.
+  (The technique for generating the TOC on the browser was contributed
+  back to the AsciiDoc project and incorporated into AsciiDoc v8.1.0).
+
+
+Version 1.1 (2006-06-28)
+------------------------
+* uthash-1.1 released
+* supports several built-in user-selectable hash functions
+* new keystats utility quantifies performance of hash functions
+
+
+Version 1.0 (2006-06-02)
+------------------------
+* Initial release
+
+// vim: set syntax=asciidoc:

c/ext/uthash/doc/Makefile

@@ -0,0 +1,18 @@
+HTML=$(patsubst %.txt,%.html,$(wildcard *.txt))
+
+all: $(HTML)
+
+# when each target of a multi-target rule has its own prereq
+# we use a static pattern rule.
+$(HTML): %.html: %.txt
+	asciidoc -a toc2 $<
+
+TMP=/tmp/uthash-gh-pages
+stage:
+	mkdir -p ${TMP}
+	rm -if ${TMP}/*
+	cp *.html *.css *.png ${TMP}
+
+.PHONY: clean
+clean:
+	$(RM) $(HTML)

c/ext/uthash/doc/banner.svg

@@ -0,0 +1,451 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://web.resource.org/cc/"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:xlink="http://www.w3.org/1999/xlink"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="728px"
+   height="90px"
+   id="svg1307"
+   sodipodi:version="0.32"
+   inkscape:version="0.45.1"
+   sodipodi:docbase="/Users/thanson/code/uthash/trunk/doc/html/img"
+   sodipodi:docname="banner.svg"
+   inkscape:export-filename="/home/thanson/code/uthash/doc/html/img/banner.png"
+   inkscape:export-xdpi="90"
+   inkscape:export-ydpi="90"
+   inkscape:output_extension="org.inkscape.output.svg.inkscape">
+  <defs
+     id="defs1309">
+    <linearGradient
+       id="linearGradient12743">
+      <stop
+         style="stop-color:#99e1fa;stop-opacity:1;"
+         offset="0"
+         id="stop12745" />
+      <stop
+         id="stop12753"
+         offset="0"
+         style="stop-color:#99e1fa;stop-opacity:0.49803922;" />
+      <stop
+         style="stop-color:#99e1fa;stop-opacity:0;"
+         offset="1"
+         id="stop12747" />
+    </linearGradient>
+    <marker
+       inkscape:stockid="Arrow1Mend"
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="Arrow1Mend"
+       style="overflow:visible;">
+      <path
+         id="path7755"
+         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt;marker-start:none;"
+         transform="scale(0.4) rotate(180)" />
+    </marker>
+    <marker
+       inkscape:stockid="Arrow1Sstart"
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="Arrow1Sstart"
+       style="overflow:visible">
+      <path
+         id="path7752"
+         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt;marker-start:none"
+         transform="scale(0.2)" />
+    </marker>
+    <marker
+       inkscape:stockid="Arrow1Send"
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="Arrow1Send"
+       style="overflow:visible;">
+      <path
+         id="path7749"
+         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt;marker-start:none;"
+         transform="scale(0.2) rotate(180)" />
+    </marker>
+    <marker
+       inkscape:stockid="StopM"
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="StopM"
+       style="overflow:visible">
+      <path
+         id="path7651"
+         d="M 0.0,5.65 L 0.0,-5.65"
+         style="fill:none;fill-opacity:0.75000000;fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt"
+         transform="scale(0.4)" />
+    </marker>
+    <marker
+       inkscape:stockid="Arrow2Mend"
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="Arrow2Mend"
+       style="overflow:visible;">
+      <path
+         id="path7737"
+         style="font-size:12.0;fill-rule:evenodd;stroke-width:0.62500000;stroke-linejoin:round;"
+         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
+         transform="scale(0.6) rotate(180) translate(-5,0)" />
+    </marker>
+    <marker
+       inkscape:stockid="TriangleInM"
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="TriangleInM"
+       style="overflow:visible">
+      <path
+         id="path7669"
+         d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt;marker-start:none"
+         transform="scale(-0.4)" />
+    </marker>
+    <marker
+       inkscape:stockid="StopL"
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="StopL"
+       style="overflow:visible">
+      <path
+         id="path7654"
+         d="M 0.0,5.65 L 0.0,-5.65"
+         style="fill:none;fill-opacity:0.75000000;fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt"
+         transform="scale(0.8)" />
+    </marker>
+    <marker
+       inkscape:stockid="TriangleOutM"
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="TriangleOutM"
+       style="overflow:visible">
+      <path
+         id="path7660"
+         d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt;marker-start:none"
+         transform="scale(0.4)" />
+    </marker>
+    <marker
+       inkscape:stockid="DiamondS"
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="DiamondS"
+       style="overflow:visible">
+      <path
+         id="path7675"
+         d="M -2.1579186e-005,-7.0710768 L -7.0710894,-8.9383918e-006 L -2.1579186e-005,7.0710589 L 7.0710462,-8.9383918e-006 L -2.1579186e-005,-7.0710768 z "
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt;marker-start:none"
+         transform="scale(0.2)" />
+    </marker>
+    <marker
+       inkscape:stockid="Tail"
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="Tail"
+       style="overflow:visible">
+      <g
+         id="g7716"
+         transform="scale(-1.2)">
+        <path
+           id="path7718"
+           d="M -3.8048674,-3.9585227 L 0.54352094,-0.00068114835"
+           style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.8;marker-start:none;marker-end:none;stroke-linecap:round" />
+        <path
+           id="path7720"
+           d="M -1.2866832,-3.9585227 L 3.0617053,-0.00068114835"
+           style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.8;marker-start:none;marker-end:none;stroke-linecap:round" />
+        <path
+           id="path7722"
+           d="M 1.3053582,-3.9585227 L 5.6537466,-0.00068114835"
+           style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.8;marker-start:none;marker-end:none;stroke-linecap:round" />
+        <path
+           id="path7724"
+           d="M -3.8048674,4.1775838 L 0.54352094,0.21974226"
+           style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.8;marker-start:none;marker-end:none;stroke-linecap:round" />
+        <path
+           id="path7726"
+           d="M -1.2866832,4.1775838 L 3.0617053,0.21974226"
+           style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.8;marker-start:none;marker-end:none;stroke-linecap:round" />
+        <path
+           id="path7728"
+           d="M 1.3053582,4.1775838 L 5.6537466,0.21974226"
+           style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.8;marker-start:none;marker-end:none;stroke-linecap:round" />
+      </g>
+    </marker>
+    <marker
+       inkscape:stockid="Arrow1Lstart"
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="Arrow1Lstart"
+       style="overflow:visible">
+      <path
+         id="path7764"
+         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt;marker-start:none"
+         transform="scale(0.8)" />
+    </marker>
+    <linearGradient
+       inkscape:collect="always"
+       id="linearGradient3964">
+      <stop
+         style="stop-color:#00eb00;stop-opacity:1;"
+         offset="0"
+         id="stop3966" />
+      <stop
+         style="stop-color:#00eb00;stop-opacity:0;"
+         offset="1"
+         id="stop3968" />
+    </linearGradient>
+    <radialGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient3964"
+       id="radialGradient3996"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(1,0,0,0.237347,4.901628e-13,36.5688)"
+       cx="176.99219"
+       cy="47.949429"
+       fx="176.99219"
+       fy="47.949429"
+       r="78.257812" />
+    <radialGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient12743"
+       id="radialGradient12751"
+       cx="165.91866"
+       cy="45.584854"
+       fx="165.91866"
+       fy="45.584854"
+       r="56.51194"
+       gradientTransform="matrix(1,0,0,0.603517,0,18.07364)"
+       gradientUnits="userSpaceOnUse" />
+  </defs>
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="0.9793956"
+     inkscape:cx="372.32157"
+     inkscape:cy="45"
+     inkscape:document-units="px"
+     inkscape:current-layer="g2335"
+     inkscape:window-width="791"
+     inkscape:window-height="581"
+     inkscape:window-x="4"
+     inkscape:window-y="48" />
+  <metadata
+     id="metadata1312">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     id="layer1"
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer">
+    <rect
+       style="opacity:1;fill:#393be9;fill-opacity:1;stroke:#f18a00;stroke-width:5.65522385;stroke-linecap:round;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
+       id="rect3981"
+       width="435.17825"
+       height="78.666664"
+       x="5.1747785"
+       y="6"
+       rx="29.141403"
+       ry="20"
+       inkscape:export-filename="/home/thanson/code/uthash/doc/html/img/logo.png"
+       inkscape:export-xdpi="90"
+       inkscape:export-ydpi="90" />
+    <flowRoot
+       transform="matrix(1.673678,0,0,1.673678,-141.8484,-37.12273)"
+       style="font-size:47.99999774;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr;text-anchor:start;fill:#faf599;fill-opacity:1;stroke:#f3bf33;stroke-opacity:1;font-family:Bitstream Vera Sans"
+       id="flowRoot3988"
+       xml:space="preserve"
+       inkscape:export-filename="/home/thanson/code/uthash/doc/html/img/logo.png"
+       inkscape:export-xdpi="90"
+       inkscape:export-ydpi="90"><flowRegion
+         style="fill:url(#radialGradient3996);fill-opacity:1"
+         id="flowRegion3990"><rect
+           style="font-size:47.99999774;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr;text-anchor:start;fill:#faf599;fill-opacity:1;stroke:#f3bf33;stroke-opacity:1;font-family:Bitstream Vera Sans"
+           y="18"
+           x="94.666664"
+           height="61.333332"
+           width="321.33334"
+           id="rect3992" /></flowRegion><flowPara
+         id="flowPara7831">ut     hash</flowPara></flowRoot>    <rect
+       style="opacity:1;fill:url(#radialGradient12751);fill-opacity:1.0;stroke:none;stroke-width:2.82532263;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
+       id="rect10995"
+       width="113.02388"
+       height="68.211792"
+       x="109.40672"
+       y="11.478957"
+       inkscape:export-filename="/home/thanson/code/uthash/doc/html/img/logo.png"
+       inkscape:export-xdpi="90"
+       inkscape:export-ydpi="90" />
+    <g
+       id="g7808"
+       transform="matrix(0.807859,0,0,0.807859,-140.848,9.677403)"
+       inkscape:export-filename="/home/thanson/code/uthash/doc/html/img/logo.png"
+       inkscape:export-xdpi="90"
+       inkscape:export-ydpi="90">
+      <rect
+         y="37.730064"
+         x="382.39673"
+         height="18.405188"
+         width="23.206543"
+         id="rect4882"
+         style="opacity:1;fill:#9be5ea;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
+      <rect
+         style="opacity:1;fill:#d48c21;fill-opacity:0.97777776;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
+         id="rect4886"
+         width="23.206543"
+         height="18.405188"
+         x="416.39673"
+         y="37.730064" />
+      <path
+         inkscape:connector-type="polyline"
+         id="path4890"
+         d="M 372.60327,46.932658 L 381.39673,46.932658"
+         style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         inkscape:connector-type="polyline"
+         id="path4892"
+         d="M 406.60327,46.932658 L 415.39673,46.932658"
+         style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <rect
+         y="9.7300644"
+         x="348.39673"
+         height="18.405188"
+         width="23.206543"
+         id="rect4896"
+         style="opacity:1;fill:#79c71a;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
+      <rect
+         style="opacity:1;fill:#f5e1a2;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
+         id="rect4898"
+         width="23.206543"
+         height="18.405188"
+         x="382.39673"
+         y="9.7300644" />
+      <path
+         style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+         d="M 372.60327,18.932658 L 381.39673,18.932658"
+         id="path4902"
+         inkscape:connector-type="polyline" />
+      <rect
+         y="14.207111"
+         x="318.45328"
+         height="10.1194"
+         width="10.1194"
+         id="rect4906"
+         style="opacity:1;fill:#1336e6;fill-opacity:1;stroke:none;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
+      <path
+         inkscape:connector-type="polyline"
+         id="path5789"
+         d="M 328.57268,19.220474 L 347.39673,19.048081"
+         style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+         d="M 328.57268,19.220474 L 347.39673,19.048081"
+         id="path5795"
+         inkscape:connector-type="polyline" />
+      <rect
+         y="37.789951"
+         x="348.20978"
+         height="18.405188"
+         width="23.206543"
+         id="rect5803"
+         style="opacity:1;fill:#e5e5e5;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
+      <rect
+         y="42.267002"
+         x="318.26633"
+         height="10.1194"
+         width="10.1194"
+         id="rect5805"
+         style="opacity:1;fill:#1336e6;fill-opacity:1;stroke:none;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
+      <path
+         style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+         d="M 328.38572,47.280365 L 347.20977,47.107972"
+         id="path5807"
+         inkscape:connector-type="polyline" />
+      <rect
+         style="opacity:1;fill:#ddf9ed;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
+         id="rect5809"
+         width="23.206543"
+         height="18.405188"
+         x="348.20978"
+         y="63.720913" />
+      <rect
+         style="opacity:1;fill:#1336e6;fill-opacity:1;stroke:none;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
+         id="rect5811"
+         width="10.1194"
+         height="10.1194"
+         x="318.26633"
+         y="68.197968" />
+      <path
+         inkscape:connector-type="polyline"
+         id="path5813"
+         d="M 328.38572,73.211328 L 347.20977,73.038935"
+         style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         inkscape:connector-type="polyline"
+         id="path5833"
+         d="M 323.47927,24.326511 L 323.35974,42.267002"
+         style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:#2f29df;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         inkscape:connector-type="polyline"
+         id="path5835"
+         d="M 323.32603,52.386402 L 323.32603,68.197968"
+         style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:#2f29df;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         id="path6716"
+         d="M 429.08836,47.11641 L 394.37307,18.527349 L 394.37307,49.158485 L 359.65778,18.527349 L 359.65778,50.179523 L 359.65778,75.70547"
+         style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:#f3bf33;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;marker-start:url(#StopM);marker-end:url(#Arrow1Send);stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
+    </g>
+    <g
+       id="g2335"
+       transform="translate(0,-10)"
+       inkscape:export-filename="/home/thanson/code/uthash/doc/html/img/logo_tag.png"
+       inkscape:export-xdpi="90"
+       inkscape:export-ydpi="90">
+      <text
+         xml:space="preserve"
+         style="font-size:18.43119621px;font-style:normal;font-weight:normal;text-align:center;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Bitstream Vera Sans"
+         x="565.8512"
+         y="50.633156"
+         id="text2331"><tspan
+           sodipodi:role="line"
+           id="tspan2333"
+           x="565.85119"
+           y="50.633156">a hash table</tspan><tspan
+           sodipodi:role="line"
+           x="565.8512"
+           y="73.672151"
+           id="tspan2361">for C structures</tspan></text>
+    </g>
+  </g>
+</svg>

c/ext/uthash/doc/google315d692c9c632ed0.html

@@ -0,0 +1 @@
+google-site-verification: google315d692c9c632ed0.html

c/ext/uthash/doc/index.html

@@ -0,0 +1,122 @@
+<!DOCTYPE html
+     PUBLIC "-//W3C//DTD XTHML 1.0 Strict//EN"
+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <link rel="stylesheet" type="text/css" href="styles.css" />
+    <title>uthash: a hash table for C structures</title>
+  </head>
+  <body>
+
+  <div id="banner">
+  <img src="banner.png" alt="uthash: a hash table for C structures" />
+  </div> <!-- banner -->
+
+  <div id="topnav">
+  <a href="http://github.com/troydhanson/uthash">GitHub page</a> &gt;
+  uthash home <!-- http://troydhanson.github.com/uthash/ -->
+
+<a href="https://twitter.com/share" class="twitter-share-button" data-via="troydhanson">Tweet</a>
+<script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0];if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src="//platform.twitter.com/widgets.js";fjs.parentNode.insertBefore(js,fjs);}}(document,"script","twitter-wjs");</script>
+  </div>
+
+  <hr />
+  <div id="mid">
+
+      <div id="nav">
+
+        <h2>documentation</h2>
+        <div><a href="userguide.html">uthash</a></div>
+        <div><a href="utlist.html">utlist</a></div>
+        <div><a href="utarray.html">utarray</a></div>
+        <div><a href="utringbuffer.html">utringbuffer</a></div>
+        <div><a href="utstack.html">utstack</a></div>
+        <div><a href="utstring.html">utstring</a></div>
+
+        <h2>download</h2>
+        <h3>GNU/Linux, Windows</h3>
+        <div><a href=https://github.com/troydhanson/uthash/archive/master.zip>uthash-master.zip</a></div>
+        <div><a href=https://github.com/troydhanson/uthash>git clone</a></div>
+
+        <h2>license</h2>
+        <div><a href="license.html">BSD revised</a></div>
+
+
+        <h2>developer</h2>
+        <div><a href="http://troydhanson.github.io/">Troy D. Hanson</a></div>
+
+        <h2>maintainer</h2>
+        <div><a href="https://github.com/Quuxplusone">Arthur O'Dwyer</a></div>
+
+
+      </div>
+
+      <div id="main">
+        Any C structure can be stored in a hash table using uthash. Just add a
+        <em>UT_hash_handle</em> to the structure and choose one or more fields
+        in your structure to act as the key. Then use these macros to store,
+        retrieve or delete items from the hash table.
+
+<div class="listing">
+Example 1. Adding an item to a hash.
+<div class="code">
+<pre>
+#include "uthash.h"
+
+struct my_struct {
+    int id;            /* we'll use this field as the key */
+    char name[10];
+    UT_hash_handle hh; /* makes this structure hashable */
+};
+
+struct my_struct *users = NULL;
+
+void add_user(struct my_struct *s) {
+    HASH_ADD_INT(users, id, s);
+}
+
+</pre>
+</div> <!-- code -->
+</div> <!-- listing -->
+
+<div class="listing">
+Example 2. Looking up an item in a hash.
+<div class="code">
+<pre>
+struct my_struct *find_user(int user_id) {
+    struct my_struct *s;
+
+    HASH_FIND_INT(users, &amp;user_id, s);
+    return s;
+}
+
+</pre>
+</div> <!-- code -->
+</div> <!-- listing -->
+
+<div class="listing">
+Example 3. Deleting an item from a hash.
+<div class="code">
+
+<pre>
+void delete_user(struct my_struct *user) {
+    HASH_DEL(users, user);
+}
+
+</pre>
+</div> <!-- code -->
+</div> <!-- listing -->
+
+ For more information and examples, please see the <a href="userguide.html">User Guide.</a>
+
+</div> <!-- main -->
+</div> <!-- mid -->
+
+   <hr />
+  <div id="footer">
+  </div> <!-- footer -->
+
+  </body>
+
+</html>
+

c/ext/uthash/doc/license.html

@@ -0,0 +1,55 @@
+<!DOCTYPE html
+     PUBLIC "-//W3C//DTD XTHML 1.0 Strict//EN"
+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <link rel="stylesheet" type="text/css" href="styles.css" />
+    <title>uthash: a hash table for C structures</title>
+  </head>
+  <body>
+
+  <div id="banner">
+  <img src="banner.png" alt="uthash: a hash table for C structures" />
+  </div> <!-- banner -->
+
+  <div id="topnav">
+  <a href="http://troydhanson.github.com/uthash/">uthash home</a> &gt;
+  BSD license
+  </div>
+
+  <hr />
+  <div id="mid">
+      <div id="main">
+<pre>
+Copyright (c) 2005-2021, Troy D. Hanson  http://troydhanson.github.com/uthash/
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+</pre>
+</div> <!-- mid -->
+</div> <!-- main -->
+
+   <hr />
+  <div id="footer">
+  </div> <!-- footer -->
+
+  </body>
+
+</html>
+

c/ext/uthash/doc/styles.css

@@ -0,0 +1,141 @@
+#banner {
+    /* font-size: x-large; */
+    /* background: #ff00ff; */
+    /* height: 100px; */
+}
+
+#topnav {
+    /* background-image: url(img/grad_topnav.png); */
+    /* background-repeat: repeat-y; */
+    /* background-color: #af00af; */
+    /* height: 25px; */
+    margin-top: 5px;
+    margin-bottom: 10px;
+    padding: 3px;
+    font-size: 9pt;
+    font-family: sans-serif;
+    /* border-style: solid; */
+    /* border-width: 1px; */
+}
+
+#topnav a {
+    padding: 8px;
+}
+
+h1,p {  margin: 0; }  /* non-0 margin on firefox */
+
+#mid {
+    /* background-image: url(img/grad_blue.png); */
+    background-repeat: repeat-y;
+    /* background-color: #ffddaa; */
+    padding-top: 20px;
+    padding-top: 20px;
+    margin-bottom: 10px;
+}
+
+#mid img {
+     padding-left: 10px;
+     vertical-align: middle;
+}
+
+a img {
+   border: 0
+}
+
+.twitter-share-button {
+   float: right;
+}
+
+.twitter-follow-button {
+   padding: 5px;
+}
+
+#nav {
+    background-color: #fff8f1;
+    margin-left: 10px;
+    margin-top: 20px;
+    margin-right: 20px;
+    float: left;
+    padding: 10px;
+    border-style: solid;
+    border-width: 2px;
+    font-family: sans-serif;
+}
+
+
+#nav h2 {
+    font-weight: bold;
+    font-size: 10pt;
+}
+
+#nav h3 {
+    /* font-weight: bold; */
+    padding-left: 5px;
+    /* font-style: oblique;  */
+    font-family: sans-serif;
+    font-size: 7pt;
+}
+
+#nav div {
+    font-size: 9pt;
+    padding-left: 15px;
+}
+
+#main {
+    background: #ffffff;
+    margin-top: 20px;
+    margin-left: 170px;
+    padding-left: 20px;
+    height: 100%;
+}
+
+#main h1 {
+    font-family: sans-serif;
+}
+
+.listing {
+    margin: 20px;
+    font-family: sans-serif;
+    font-weight: bold;
+}
+
+.code {
+    padding: 10px;
+    margin: 10px;
+    font-size: 8pt;
+    font-weight: normal;
+    background: #f3f3f3;
+    width: 100%;
+    border-style: solid;
+    border-width: 1px;
+}
+
+#footer {
+    /* background: #00ffff; */
+    margin-top: 5px;
+    font-size: small;
+    font-family: sans-serif;
+}
+
+hr {
+    height: 0.04em;
+    background: black;
+    margin: 0 10% 0 0;
+}
+
+#footer {
+    width: 90%;
+}
+
+#footer img {
+    margin-right: 5px;
+    float: right;
+}
+
+#footer #support {
+    float: right;
+}
+
+body {
+    width: 80%;
+}

c/ext/uthash/doc/utarray.txt

@@ -0,0 +1,383 @@
+utarray: dynamic array macros for C
+===================================
+Troy D. Hanson <tdh@tkhanson.net>
+v2.3.0, February 2021
+
+Here's a link back to the https://github.com/troydhanson/uthash[GitHub project page].
+
+Introduction
+------------
+A set of general-purpose dynamic array macros for C structures are included with
+uthash in `utarray.h`.  To use these macros in your own C program, just
+copy `utarray.h` into your source directory and use it in your programs.
+
+  #include "utarray.h"
+
+The dynamic array supports basic operations such as push, pop, and erase on the
+array elements. These array elements can be any simple datatype or structure.
+The array <<operations,operations>> are based loosely on the C++ STL vector methods.
+
+Internally the dynamic array contains a contiguous memory region into which
+the elements are copied. This buffer is grown as needed using `realloc` to
+accommodate all the data that is pushed into it.
+
+Download
+~~~~~~~~
+To download the `utarray.h` header file,
+follow the links on https://github.com/troydhanson/uthash to clone uthash or get a zip file,
+then look in the src/ sub-directory.
+
+BSD licensed
+~~~~~~~~~~~~
+This software is made available under the
+link:license.html[revised BSD license].
+It is free and open source.
+
+Platforms
+~~~~~~~~~
+The 'utarray' macros have been tested on:
+
+ * Linux,
+ * Mac OS X,
+ * Windows, using Visual Studio 2008 and Visual Studio 2010
+
+Usage
+-----
+
+Declaration
+~~~~~~~~~~~
+
+The array itself has the data type `UT_array`, regardless of the type of
+elements to be stored in it. It is declared like,
+
+  UT_array *nums;
+
+New and free
+~~~~~~~~~~~~
+The next step is to create the array using `utarray_new`. Later when you're
+done with the array, `utarray_free` will free it and all its elements.
+
+Push, pop, etc
+~~~~~~~~~~~~~~
+The central features of the utarray involve putting elements into it, taking
+them out, and iterating over them. There are several <<operations,operations>>
+to pick from that deal with either single elements or ranges of elements at a
+time. In the examples below we will use only the push operation to insert
+elements.
+
+Elements
+--------
+
+Support for dynamic arrays of integers or strings is especially easy. These are
+best shown by example:
+
+Integers
+~~~~~~~~
+This example makes a utarray of integers, pushes 0-9 into it, then prints it.
+Lastly it frees it.
+
+.Integer elements
+-------------------------------------------------------------------------------
+#include <stdio.h>
+#include "utarray.h"
+
+int main() {
+  UT_array *nums;
+  int i, *p;
+
+  utarray_new(nums,&ut_int_icd);
+  for(i=0; i < 10; i++) utarray_push_back(nums,&i);
+
+  for(p=(int*)utarray_front(nums);
+      p!=NULL;
+      p=(int*)utarray_next(nums,p)) {
+    printf("%d\n",*p);
+  }
+
+  utarray_free(nums);
+
+  return 0;
+}
+-------------------------------------------------------------------------------
+
+The second argument to `utarray_push_back` is always a 'pointer' to the type
+(so a literal cannot be used). So for integers, it is an `int*`.
+
+Strings
+~~~~~~~
+In this example we make a utarray of strings, push two strings into it, print
+it and free it.
+
+.String elements
+-------------------------------------------------------------------------------
+#include <stdio.h>
+#include "utarray.h"
+
+int main() {
+  UT_array *strs;
+  char *s, **p;
+
+  utarray_new(strs,&ut_str_icd);
+
+  s = "hello"; utarray_push_back(strs, &s);
+  s = "world"; utarray_push_back(strs, &s);
+  p = NULL;
+  while ( (p=(char**)utarray_next(strs,p))) {
+    printf("%s\n",*p);
+  }
+
+  utarray_free(strs);
+
+  return 0;
+}
+-------------------------------------------------------------------------------
+
+In this example, since the element is a `char*`, we pass a pointer to it
+(`char**`) as the second argument to `utarray_push_back`. Note that "push" makes
+a copy of the source string and pushes that copy into the array.
+
+About UT_icd
+~~~~~~~~~~~~
+
+Arrays be made of any type of element, not just integers and strings.  The
+elements can be basic types or structures. Unless you're dealing with integers
+and strings (which use pre-defined `ut_int_icd` and `ut_str_icd`), you'll need
+to define a `UT_icd` helper structure. This structure contains everything that
+utarray needs to initialize, copy or destruct elements.
+
+  typedef struct {
+      size_t sz;
+      init_f *init;
+      ctor_f *copy;
+      dtor_f *dtor;
+  } UT_icd;
+
+The three function pointers `init`, `copy`, and `dtor` have these prototypes:
+
+  typedef void (ctor_f)(void *dst, const void *src);
+  typedef void (dtor_f)(void *elt);
+  typedef void (init_f)(void *elt);
+
+The `sz` is just the size of the element being stored in the array.
+
+The `init` function will be invoked whenever utarray needs to initialize an
+empty element. This only happens as a byproduct of `utarray_resize` or
+`utarray_extend_back`. If `init` is `NULL`, it defaults to zero filling the
+new element using memset.
+
+The `copy` function is used whenever an element is copied into the array.
+It is invoked during `utarray_push_back`, `utarray_insert`, `utarray_inserta`,
+or `utarray_concat`. If `copy` is `NULL`, it defaults to a bitwise copy using
+memcpy.
+
+The `dtor` function is used to clean up an element that is being removed from
+the array. It may be invoked due to `utarray_resize`, `utarray_pop_back`,
+`utarray_erase`, `utarray_clear`, `utarray_done` or `utarray_free`. If the
+elements need no cleanup upon destruction, `dtor` may be `NULL`.
+
+Scalar types
+~~~~~~~~~~~~
+
+The next example uses `UT_icd` with all its defaults to make a utarray of
+`long` elements. This example pushes two longs, prints them, and frees the
+array.
+
+.long elements
+-------------------------------------------------------------------------------
+#include <stdio.h>
+#include "utarray.h"
+
+UT_icd long_icd = {sizeof(long), NULL, NULL, NULL };
+
+int main() {
+  UT_array *nums;
+  long l, *p;
+  utarray_new(nums, &long_icd);
+
+  l=1; utarray_push_back(nums, &l);
+  l=2; utarray_push_back(nums, &l);
+
+  p=NULL;
+  while( (p=(long*)utarray_next(nums,p))) printf("%ld\n", *p);
+
+  utarray_free(nums);
+  return 0;
+}
+-------------------------------------------------------------------------------
+
+Structures
+~~~~~~~~~~
+
+Structures can be used as utarray elements. If the structure requires no
+special effort to initialize, copy or destruct, we can use `UT_icd` with all
+its defaults. This example shows a structure that consists of two integers. Here
+we push two values, print them and free the array.
+
+.Structure (simple)
+-------------------------------------------------------------------------------
+#include <stdio.h>
+#include "utarray.h"
+
+typedef struct {
+    int a;
+    int b;
+} intpair_t;
+
+UT_icd intpair_icd = {sizeof(intpair_t), NULL, NULL, NULL};
+
+int main() {
+
+  UT_array *pairs;
+  intpair_t ip, *p;
+  utarray_new(pairs,&intpair_icd);
+
+  ip.a=1;  ip.b=2;  utarray_push_back(pairs, &ip);
+  ip.a=10; ip.b=20; utarray_push_back(pairs, &ip);
+
+  for(p=(intpair_t*)utarray_front(pairs);
+      p!=NULL;
+      p=(intpair_t*)utarray_next(pairs,p)) {
+    printf("%d %d\n", p->a, p->b);
+  }
+
+  utarray_free(pairs);
+  return 0;
+}
+-------------------------------------------------------------------------------
+
+The real utility of `UT_icd` is apparent when the elements of the utarray are
+structures that require special work to initialize, copy or destruct.
+
+For example, when a structure contains pointers to related memory areas that
+need to be copied when the structure is copied (and freed when the structure is
+freed), we can use custom `init`, `copy`, and `dtor` members in the `UT_icd`.
+
+Here we take an example of a structure that contains an integer and a string.
+When this element is copied (such as when an element is pushed into the array),
+we want to "deep copy" the `s` pointer (so the original element and the new
+element point to their own copies of `s`). When an element is destructed, we
+want to "deep free" its copy of `s`. Lastly, this example is written to work
+even if `s` has the value `NULL`.
+
+.Structure (complex)
+-------------------------------------------------------------------------------
+#include <stdio.h>
+#include <stdlib.h>
+#include "utarray.h"
+
+typedef struct {
+    int a;
+    char *s;
+} intchar_t;
+
+void intchar_copy(void *_dst, const void *_src) {
+  intchar_t *dst = (intchar_t*)_dst, *src = (intchar_t*)_src;
+  dst->a = src->a;
+  dst->s = src->s ? strdup(src->s) : NULL;
+}
+
+void intchar_dtor(void *_elt) {
+  intchar_t *elt = (intchar_t*)_elt;
+  if (elt->s) free(elt->s);
+}
+
+UT_icd intchar_icd = {sizeof(intchar_t), NULL, intchar_copy, intchar_dtor};
+
+int main() {
+  UT_array *intchars;
+  intchar_t ic, *p;
+  utarray_new(intchars, &intchar_icd);
+
+  ic.a=1; ic.s="hello"; utarray_push_back(intchars, &ic);
+  ic.a=2; ic.s="world"; utarray_push_back(intchars, &ic);
+
+  p=NULL;
+  while( (p=(intchar_t*)utarray_next(intchars,p))) {
+    printf("%d %s\n", p->a, (p->s ? p->s : "null"));
+  }
+
+  utarray_free(intchars);
+  return 0;
+}
+
+-------------------------------------------------------------------------------
+
+[[operations]]
+Reference
+---------
+This table lists all the utarray operations. These are loosely based on the C++
+vector class.
+
+Operations
+~~~~~~~~~~
+
+[width="100%",cols="50<m,40<",grid="none",options="none"]
+|===============================================================================
+| utarray_new(UT_array *a, UT_icd *icd)| allocate a new array
+| utarray_free(UT_array *a)            | free an allocated array
+| utarray_init(UT_array *a,UT_icd *icd)| init an array (non-alloc)
+| utarray_done(UT_array *a)            | dispose of an array (non-allocd)
+| utarray_reserve(UT_array *a,int n)  | ensure space available for 'n' more elements
+| utarray_push_back(UT_array *a,void *p) | push element p onto a
+| utarray_pop_back(UT_array *a)        | pop last element from a
+| utarray_extend_back(UT_array *a)     | push empty element onto a
+| utarray_len(UT_array *a)             | get length of a
+| utarray_eltptr(UT_array *a,int j)    | get pointer of element from index
+| utarray_eltidx(UT_array *a,void *e)  | get index of element from pointer
+| utarray_insert(UT_array *a,void *p, int j) | insert element p to index j
+| utarray_inserta(UT_array *a,UT_array *w, int j) | insert array w into array a at index j
+| utarray_resize(UT_array *dst,int num)  | extend or shrink array to num elements
+| utarray_concat(UT_array *dst,UT_array *src) | copy src to end of dst array
+| utarray_erase(UT_array *a,int pos,int len) | remove len elements from a[pos]..a[pos+len-1]
+| utarray_clear(UT_array *a) | clear all elements from a, setting its length to zero
+| utarray_sort(UT_array *a,cmpfcn *cmp) | sort elements of a using comparison function
+| utarray_find(UT_array *a,void *v, cmpfcn *cmp) | find element v in utarray (must be sorted)
+| utarray_front(UT_array *a) | get first element of a
+| utarray_next(UT_array *a,void *e) | get element of a following e (front if e is NULL)
+| utarray_prev(UT_array *a,void *e) | get element of a before e (back if e is NULL)
+| utarray_back(UT_array *a) | get last element of a
+|===============================================================================
+
+Notes
+~~~~~
+
+1. `utarray_new` and `utarray_free` are used to allocate a new array and free it,
+   while `utarray_init` and `utarray_done` can be used if the UT_array is already
+   allocated and just needs to be initialized or have its internal resources
+   freed.
+
+2. `utarray_reserve` takes the "delta" of elements to reserve, not the total
+   desired capacity of the array. This differs from the C++ STL "reserve" notion.
+
+3. `utarray_sort` expects a comparison function having the usual `strcmp`-like
+   convention where it accepts two elements (a and b) and returns a negative
+   value if a precedes b, 0 if a and b sort equally, and positive if b precedes a.
+   This is an example of a comparison function:
+
+  int intsort(const void *a, const void *b) {
+      int _a = *(const int *)a;
+      int _b = *(const int *)b;
+      return (_a < _b) ? -1 : (_a > _b);
+  }
+
+4. `utarray_find` uses a binary search to locate an element having a certain value
+   according to the given comparison function. The utarray must be first sorted
+   using the same comparison function. An example of using `utarray_find` with
+   a utarray of strings is included in `tests/test61.c`.
+
+5. A 'pointer' to a particular element (obtained using `utarray_eltptr` or
+   `utarray_front`, `utarray_next`, `utarray_prev`, `utarray_back`) becomes invalid whenever
+   another element is inserted into the utarray. This is because the internal
+   memory management may need to `realloc` the element storage to a new address.
+   For this reason, it's usually better to refer to an element by its integer
+   'index' in code whose duration may include element insertion.
+
+6. To override the default out-of-memory handling behavior (which calls `exit(-1)`),
+   override the `utarray_oom()` macro before including `utarray.h`.
+   For example,
+
+  #define utarray_oom() do { longjmp(error_handling_location); } while (0)
+  ...
+  #include "utarray.h"
+
+// vim: set nowrap syntax=asciidoc:

c/ext/uthash/doc/uthash-mini.svg

@@ -0,0 +1,288 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://web.resource.org/cc/"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:xlink="http://www.w3.org/1999/xlink"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="118.44112"
+   height="22.655222"
+   id="svg2018"
+   sodipodi:version="0.32"
+   inkscape:version="0.44"
+   version="1.0"
+   sodipodi:docbase="/home/thanson/code/uthash/trunk/doc/html/img"
+   sodipodi:docname="uthash-mini.svg">
+  <defs
+     id="defs3">
+    <linearGradient
+       inkscape:collect="always"
+       id="linearGradient3964">
+      <stop
+         style="stop-color:#00eb00;stop-opacity:1;"
+         offset="0"
+         id="stop3966" />
+      <stop
+         style="stop-color:#00eb00;stop-opacity:0;"
+         offset="1"
+         id="stop3968" />
+    </linearGradient>
+    <radialGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient3964"
+       id="radialGradient3996"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(1,0,0,0.237347,0,36.5688)"
+       cx="176.99219"
+       cy="47.949429"
+       fx="176.99219"
+       fy="47.949429"
+       r="78.257812" />
+    <linearGradient
+       id="linearGradient12743">
+      <stop
+         style="stop-color:#99e1fa;stop-opacity:1;"
+         offset="0"
+         id="stop12745" />
+      <stop
+         id="stop12753"
+         offset="0"
+         style="stop-color:#99e1fa;stop-opacity:0.49803922;" />
+      <stop
+         style="stop-color:#99e1fa;stop-opacity:0;"
+         offset="1"
+         id="stop12747" />
+    </linearGradient>
+    <radialGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient12743"
+       id="radialGradient12751"
+       cx="165.91866"
+       cy="45.584854"
+       fx="165.91866"
+       fy="45.584854"
+       r="56.51194"
+       gradientTransform="matrix(0.268675,0,0,0.16215,17.28599,40.67469)"
+       gradientUnits="userSpaceOnUse" />
+    <marker
+       inkscape:stockid="Arrow1Send"
+       orient="auto"
+       refY="0"
+       refX="0"
+       id="Arrow1Send"
+       style="overflow:visible">
+      <path
+         id="path7749"
+         d="M 0,0 L 5,-5 L -12.5,0 L 5,5 L 0,0 z "
+         style="fill-rule:evenodd;stroke:black;stroke-width:1pt;marker-start:none"
+         transform="scale(-0.2,-0.2)" />
+    </marker>
+    <marker
+       inkscape:stockid="StopM"
+       orient="auto"
+       refY="0"
+       refX="0"
+       id="StopM"
+       style="overflow:visible">
+      <path
+         id="path7651"
+         d="M 0,5.65 L 0,-5.65"
+         style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:black;stroke-width:1pt"
+         transform="scale(0.4,0.4)" />
+    </marker>
+  </defs>
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="1.2"
+     inkscape:cx="160"
+     inkscape:cy="90"
+     inkscape:document-units="mm"
+     inkscape:current-layer="layer1"
+     inkscape:window-width="916"
+     inkscape:window-height="626"
+     inkscape:window-x="5"
+     inkscape:window-y="73" />
+  <metadata
+     id="metadata2022">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     transform="translate(-17.9166,-36.67108)">
+    <rect
+       style="opacity:1;fill:#393be9;fill-opacity:1;stroke:#f18a00;stroke-width:1.51941979;stroke-linecap:round;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
+       id="rect3981"
+       width="116.92171"
+       height="21.135801"
+       x="18.67631"
+       y="37.430794"
+       rx="7.8295798"
+       ry="5.3735089"
+       inkscape:export-filename="/home/thanson/code/uthash/doc/html/img/logo.png"
+       inkscape:export-xdpi="90"
+       inkscape:export-ydpi="90" />
+    <flowRoot
+       transform="matrix(0.449676,0,0,0.449676,-20.8252,25.84477)"
+       style="font-size:47.99999619px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#faf599;fill-opacity:1;stroke:#f3bf33;stroke-opacity:1;font-family:Bitstream Vera Sans"
+       id="flowRoot3988"
+       xml:space="preserve"
+       inkscape:export-filename="/home/thanson/code/uthash/doc/html/img/logo.png"
+       inkscape:export-xdpi="90"
+       inkscape:export-ydpi="90"><flowRegion
+         style="fill:url(#radialGradient3996);fill-opacity:1"
+         id="flowRegion3990"><rect
+           style="font-size:47.99999619px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#faf599;fill-opacity:1;stroke:#f3bf33;stroke-opacity:1;font-family:Bitstream Vera Sans"
+           y="18"
+           x="94.666664"
+           height="61.333332"
+           width="321.33334"
+           id="rect3992" /></flowRegion><flowPara
+         id="flowPara7831">ut     hash</flowPara></flowRoot>    <rect
+       style="opacity:1;fill:url(#radialGradient12751);fill-opacity:1;stroke:none;stroke-width:2.82532263;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
+       id="rect10995"
+       width="30.366741"
+       height="18.326834"
+       x="46.68087"
+       y="38.902855"
+       inkscape:export-filename="/home/thanson/code/uthash/doc/html/img/logo.png"
+       inkscape:export-xdpi="90"
+       inkscape:export-ydpi="90" />
+    <g
+       id="g7808"
+       transform="matrix(0.217052,0,0,0.217052,-20.55641,38.41883)"
+       inkscape:export-filename="/home/thanson/code/uthash/doc/html/img/logo.png"
+       inkscape:export-xdpi="90"
+       inkscape:export-ydpi="90">
+      <rect
+         y="37.730064"
+         x="382.39673"
+         height="18.405188"
+         width="23.206543"
+         id="rect4882"
+         style="opacity:1;fill:#9be5ea;fill-opacity:1;stroke:black;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
+      <rect
+         style="opacity:1;fill:#d48c21;fill-opacity:0.97777776;stroke:black;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
+         id="rect4886"
+         width="23.206543"
+         height="18.405188"
+         x="416.39673"
+         y="37.730064" />
+      <path
+         inkscape:connector-type="polyline"
+         id="path4890"
+         d="M 372.60327,46.932658 L 381.39673,46.932658"
+         style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:black;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         inkscape:connector-type="polyline"
+         id="path4892"
+         d="M 406.60327,46.932658 L 415.39673,46.932658"
+         style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:black;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <rect
+         y="9.7300644"
+         x="348.39673"
+         height="18.405188"
+         width="23.206543"
+         id="rect4896"
+         style="opacity:1;fill:#79c71a;fill-opacity:1;stroke:black;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
+      <rect
+         style="opacity:1;fill:#f5e1a2;fill-opacity:1;stroke:black;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
+         id="rect4898"
+         width="23.206543"
+         height="18.405188"
+         x="382.39673"
+         y="9.7300644" />
+      <path
+         style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:black;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+         d="M 372.60327,18.932658 L 381.39673,18.932658"
+         id="path4902"
+         inkscape:connector-type="polyline" />
+      <rect
+         y="14.207111"
+         x="318.45328"
+         height="10.1194"
+         width="10.1194"
+         id="rect4906"
+         style="opacity:1;fill:#1336e6;fill-opacity:1;stroke:none;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
+      <path
+         inkscape:connector-type="polyline"
+         id="path5789"
+         d="M 328.57268,19.220474 L 347.39673,19.048081"
+         style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:black;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:black;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+         d="M 328.57268,19.220474 L 347.39673,19.048081"
+         id="path5795"
+         inkscape:connector-type="polyline" />
+      <rect
+         y="37.789951"
+         x="348.20978"
+         height="18.405188"
+         width="23.206543"
+         id="rect5803"
+         style="opacity:1;fill:#e5e5e5;fill-opacity:1;stroke:black;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
+      <rect
+         y="42.267002"
+         x="318.26633"
+         height="10.1194"
+         width="10.1194"
+         id="rect5805"
+         style="opacity:1;fill:#1336e6;fill-opacity:1;stroke:none;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
+      <path
+         style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:black;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+         d="M 328.38572,47.280365 L 347.20977,47.107972"
+         id="path5807"
+         inkscape:connector-type="polyline" />
+      <rect
+         style="opacity:1;fill:#ddf9ed;fill-opacity:1;stroke:black;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
+         id="rect5809"
+         width="23.206543"
+         height="18.405188"
+         x="348.20978"
+         y="63.720913" />
+      <rect
+         style="opacity:1;fill:#1336e6;fill-opacity:1;stroke:none;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
+         id="rect5811"
+         width="10.1194"
+         height="10.1194"
+         x="318.26633"
+         y="68.197968" />
+      <path
+         inkscape:connector-type="polyline"
+         id="path5813"
+         d="M 328.38572,73.211328 L 347.20977,73.038935"
+         style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:black;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         inkscape:connector-type="polyline"
+         id="path5833"
+         d="M 323.47927,24.326511 L 323.35974,42.267002"
+         style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:#2f29df;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         inkscape:connector-type="polyline"
+         id="path5835"
+         d="M 323.32603,52.386402 L 323.32603,68.197968"
+         style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:#2f29df;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         id="path6716"
+         d="M 429.08836,47.11641 L 394.37307,18.527349 L 394.37307,49.158485 L 359.65778,18.527349 L 359.65778,50.179523 L 359.65778,75.70547"
+         style="fill:none;fill-opacity:0.75;fill-rule:evenodd;stroke:#f3bf33;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;marker-start:url(#StopM);marker-end:url(#Arrow1Send);stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
+    </g>
+  </g>
+</svg>

c/ext/uthash/doc/utlist.txt

@@ -0,0 +1,293 @@
+utlist: linked list macros for C structures
+===========================================
+Troy D. Hanson <tdh@tkhanson.net>
+v2.3.0, February 2021
+
+Here's a link back to the https://github.com/troydhanson/uthash[GitHub project page].
+
+Introduction
+------------
+A set of general-purpose 'linked list' macros for C structures are included with
+uthash in `utlist.h`.  To use these macros in your own C program, just
+copy `utlist.h` into your source directory and use it in your programs.
+
+  #include "utlist.h"
+
+These macros support the basic linked list operations: adding and deleting
+elements, sorting them and iterating over them.
+
+Download
+~~~~~~~~
+To download the `utlist.h` header file,
+follow the links on https://github.com/troydhanson/uthash to clone uthash or get a zip file,
+then look in the src/ sub-directory.
+
+BSD licensed
+~~~~~~~~~~~~
+This software is made available under the
+link:license.html[revised BSD license].
+It is free and open source.
+
+Platforms
+~~~~~~~~~
+The 'utlist' macros have been tested on:
+
+ * Linux,
+ * Mac OS X, and
+ * Windows, using Visual Studio 2008, Visual Studio 2010, or Cygwin/MinGW.
+
+Using utlist
+------------
+
+Types of lists
+~~~~~~~~~~~~~~
+Three types of linked lists are supported:
+
+- *singly-linked* lists,
+- *doubly-linked* lists, and
+- *circular, doubly-linked* lists
+
+Efficiency
+^^^^^^^^^^
+Prepending elements::
+ Constant-time on all list types.
+Appending::
+ 'O(n)' on singly-linked lists; constant-time on doubly-linked list.
+ (The utlist implementation of the doubly-linked list keeps a tail pointer in
+ `head->prev` so that append can be done in constant time).
+Deleting elements::
+ 'O(n)' on singly-linked lists; constant-time on doubly-linked list.
+Sorting::
+ 'O(n log(n))' for all list types.
+Insertion in order (for sorted lists)::
+ 'O(n)' for all list types.
+Iteration, counting and searching::
+ 'O(n)' for all list types.
+
+List elements
+~~~~~~~~~~~~~
+You can use any structure with these macros, as long as the structure
+contains a `next` pointer. If you want to make a doubly-linked list,
+the element also needs to have a `prev` pointer.
+
+  typedef struct element {
+      char *name;
+      struct element *prev; /* needed for a doubly-linked list only */
+      struct element *next; /* needed for singly- or doubly-linked lists */
+  } element;
+
+You can name your structure anything. In the example above it is called `element`.
+Within a particular list, all elements must be of the same type.
+
+Flexible prev/next naming
+^^^^^^^^^^^^^^^^^^^^^^^^^
+You can name your `prev` and `next` pointers something else. If you do, there is
+a <<flex_names,family of macros>> that work identically but take these names as
+extra arguments.
+
+List head
+~~~~~~~~~
+The list head is simply a pointer to your element structure. You can name it
+anything. *It must be initialized to `NULL`*.
+
+  element *head = NULL;
+
+List operations
+~~~~~~~~~~~~~~~
+The lists support inserting or deleting elements, sorting the elements and
+iterating over them.
+
+[width="100%",cols="10<m,10<m,10<m",grid="cols",options="header"]
+|===============================================================================
+|Singly-linked             | Doubly-linked              | Circular, doubly-linked
+|LL_PREPEND(head,add);     | DL_PREPEND(head,add);      | CDL_PREPEND(head,add);
+|LL_PREPEND_ELEM(head,ref,add); | DL_PREPEND_ELEM(head,ref,add); | CDL_PREPEND_ELEM(head,ref,add);
+|LL_APPEND_ELEM(head,ref,add); | DL_APPEND_ELEM(head,ref,add); | CDL_APPEND_ELEM(head,ref,add);
+|LL_REPLACE_ELEM(head,del,add); | DL_REPLACE_ELEM(head,del,add); | CDL_REPLACE_ELEM(head,del,add);
+|LL_APPEND(head,add);      | DL_APPEND(head,add);       | CDL_APPEND(head,add);
+|LL_INSERT_INORDER(head,add,cmp); | DL_INSERT_INORDER(head,add,cmp); | CDL_INSERT_INORDER(head,add,cmp);
+|LL_CONCAT(head1,head2);   | DL_CONCAT(head1,head2);    |
+|LL_DELETE(head,del);      | DL_DELETE(head,del);       | CDL_DELETE(head,del);
+|LL_SORT(head,cmp);        | DL_SORT(head,cmp);         | CDL_SORT(head,cmp);
+|LL_FOREACH(head,elt) {...}| DL_FOREACH(head,elt) {...} | CDL_FOREACH(head,elt) {...}
+|LL_FOREACH_SAFE(head,elt,tmp) {...}| DL_FOREACH_SAFE(head,elt,tmp) {...} | CDL_FOREACH_SAFE(head,elt,tmp1,tmp2) {...}
+|LL_SEARCH_SCALAR(head,elt,mbr,val);| DL_SEARCH_SCALAR(head,elt,mbr,val); | CDL_SEARCH_SCALAR(head,elt,mbr,val);
+|LL_SEARCH(head,elt,like,cmp);| DL_SEARCH(head,elt,like,cmp); | CDL_SEARCH(head,elt,like,cmp);
+|LL_LOWER_BOUND(head,elt,like,cmp); | DL_LOWER_BOUND(head,elt,like,cmp); | CDL_LOWER_BOUND(head,elt,like,cmp);
+|LL_COUNT(head,elt,count); | DL_COUNT(head,elt,count);  | CDL_COUNT(head,elt,count);
+|===============================================================================
+
+'Prepend' means to insert an element in front of the existing list head (if any),
+changing the list head to the new element. 'Append' means to add an element at the
+end of the list, so it becomes the new tail element. 'Concatenate' takes two
+properly constructed lists and appends the second list to the first.  (Visual
+Studio 2008 does not support `LL_CONCAT` and `DL_CONCAT`, but VS2010 is ok.)
+To prepend before an arbitrary element instead of the list head, use the
+`_PREPEND_ELEM` macro family.
+To append after an arbitrary element element instead of the list head, use the
+`_APPEND_ELEM` macro family.
+To 'replace' an arbitrary list element with another element use the `_REPLACE_ELEM`
+family of macros.
+
+The 'sort' operation never moves the elements in memory; rather it only adjusts
+the list order by altering the `prev` and `next` pointers in each element. Also
+the sort operation can change the list head to point to a new element.
+
+The 'foreach' operation is for easy iteration over the list from the head to the
+tail. A usage example is shown below. You can of course just use the `prev` and
+`next` pointers directly instead of using the 'foreach' macros.
+The 'foreach_safe' operation should be used if you plan to delete any of the list
+elements while iterating.
+
+The 'search' operation is a shortcut for iteration in search of a particular
+element. It is not any faster than manually iterating and testing each element.
+There are two forms: the "scalar" version searches for an element using a
+simple equality test on a given structure member, while the general version takes an
+element to which all others in the list will be compared using a `cmp` function.
+
+The 'lower_bound' operation finds the first element of the list which is no greater
+than the provided `like` element, according to the provided `cmp` function.
+The 'lower_bound' operation sets `elt` to a suitable value for passing to
+`LL_APPEND_ELEM`; i.e., `elt=NULL` if the proper insertion point is at the front of
+the list, and `elt=p` if the proper insertion point is between `p` and `p->next`.
+
+The 'count' operation iterates over the list and increments a supplied counter.
+
+The parameters shown in the table above are explained here:
+
+head::
+  The list head (a pointer to your list element structure).
+add::
+  A pointer to the list element structure you are adding to the list.
+del::
+  A pointer to the list element structure you are replacing or
+  deleting from the list.
+elt::
+  A pointer that will be assigned to each list element in succession (see
+  example) in the case of iteration macros; or, the output pointer from
+  the search macros.
+ref::
+  Reference element for prepend and append operations that will be
+  prepended before or appended after.
+  If `ref` is a pointer with value NULL, the new element will be appended to the
+  list for _PREPEND_ELEM() operations and prepended for _APPEND_ELEM() operations.
+  `ref` must be the name of a pointer variable and cannot be literally NULL,
+  use _PREPEND() and _APPEND() macro family instead.
+like::
+  An element pointer, having the same type as `elt`, for which the search macro
+  seeks a match (if found, the match is stored in `elt`). A match is determined
+  by the given `cmp` function.
+cmp::
+  pointer to comparison function which accepts two arguments-- these are
+  pointers to two element structures to be compared. The comparison function
+  must return an `int` that is negative, zero, or positive, which specifies
+  whether the first item should sort before, equal to, or after the second item,
+  respectively. (In other words, the same convention that is used by `strcmp`).
+  Note that under Visual Studio 2008 you may need to declare the two arguments
+  as `void *` and then cast them back to their actual types.
+tmp::
+  A pointer of the same type as `elt`. Used internally. Need not be initialized.
+mbr::
+  In the scalar search macro, the name of a member within the `elt` structure which
+  will be tested (using `==`) for equality with the value `val`.
+val::
+  In the scalar search macro, specifies the value of (of structure member
+  `field`) of the element being sought.
+count::
+  integer which will be set to the length of the list
+
+Example
+~~~~~~~
+This example program reads names from a text file (one name per line), and
+appends each name to a doubly-linked list. Then it sorts and prints them.
+
+.A doubly-linked list
+--------------------------------------------------------------------------------
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "utlist.h"
+
+#define BUFLEN 20
+
+typedef struct el {
+    char bname[BUFLEN];
+    struct el *next, *prev;
+} el;
+
+int namecmp(el *a, el *b) {
+    return strcmp(a->bname,b->bname);
+}
+
+el *head = NULL; /* important- initialize to NULL! */
+
+int main(int argc, char *argv[]) {
+    el *name, *elt, *tmp, etmp;
+
+    char linebuf[BUFLEN];
+    int count;
+    FILE *file;
+
+    if ( (file = fopen( "test11.dat", "r" )) == NULL ) {
+        perror("can't open: ");
+        exit(-1);
+    }
+
+    while (fgets(linebuf,BUFLEN,file) != NULL) {
+        if ( (name = (el *)malloc(sizeof *name)) == NULL) exit(-1);
+        strcpy(name->bname, linebuf);
+        DL_APPEND(head, name);
+    }
+    DL_SORT(head, namecmp);
+    DL_FOREACH(head,elt) printf("%s", elt->bname);
+    DL_COUNT(head, elt, count);
+    printf("%d number of elements in list\n", count);
+
+    memcpy(&etmp.bname, "WES\n", 5);
+    DL_SEARCH(head,elt,&etmp,namecmp);
+    if (elt) printf("found %s\n", elt->bname);
+
+    /* now delete each element, use the safe iterator */
+    DL_FOREACH_SAFE(head,elt,tmp) {
+      DL_DELETE(head,elt);
+      free(elt);
+    }
+
+    fclose(file);
+
+    return 0;
+}
+--------------------------------------------------------------------------------
+
+[[flex_names]]
+Other names for prev and next
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+If the `prev` and `next` fields are named something else, a separate group of
+macros must be used. These work the same as the regular macros, but take the
+field names as extra parameters.
+
+These "flexible field name" macros are shown below. They all end with `2`. Each
+operates the same as its counterpart without the `2`, but they take the name of
+the `prev` and `next` fields (as applicable) as trailing arguments.
+
+[width="100%",cols="10<m,10<m,10<m",grid="cols",options="header"]
+|===============================================================================
+|Singly-linked                             | Doubly-linked                               | Circular, doubly-linked
+|LL_PREPEND2(head,add,next);               | DL_PREPEND2(head,add,prev,next);            | CDL_PREPEND2(head,add,prev,next);
+|LL_PREPEND_ELEM2(head,ref,add,next);      | DL_PREPEND_ELEM2(head,ref,add,prev,next);   | CDL_PREPEND_ELEM2(head,ref,add,prev,next);
+|LL_APPEND_ELEM2(head,ref,add,next);       | DL_APPEND_ELEM2(head,ref,add,prev,next);    | CDL_APPEND_ELEM2(head,ref,add,prev,next);
+|LL_REPLACE_ELEM2(head,del,add,next);      | DL_REPLACE_ELEM2(head,del,add,prev,next);   | CDL_REPLACE_ELEM2(head,del,add,prev,next);
+|LL_APPEND2(head,add,next);                | DL_APPEND2(head,add,prev,next);             | CDL_APPEND2(head,add,prev,next);
+|LL_INSERT_INORDER2(head,add,cmp,next);    | DL_INSERT_INORDER2(head,add,cmp,prev,next); | CDL_INSERT_INORDER2(head,add,cmp,prev,next);
+|LL_CONCAT2(head1,head2,next);             | DL_CONCAT2(head1,head2,prev,next);          |
+|LL_DELETE2(head,del,next);                | DL_DELETE2(head,del,prev,next);             | CDL_DELETE2(head,del,prev,next);
+|LL_SORT2(head,cmp,next);                  | DL_SORT2(head,cmp,prev,next);               | CDL_SORT2(head,cmp,prev,next);
+|LL_FOREACH2(head,elt,next) {...}          | DL_FOREACH2(head,elt,next) {...}            | CDL_FOREACH2(head,elt,next) {...}
+|LL_FOREACH_SAFE2(head,elt,tmp,next) {...} | DL_FOREACH_SAFE2(head,elt,tmp,next) {...}   | CDL_FOREACH_SAFE2(head,elt,tmp1,tmp2,prev,next) {...}
+|LL_SEARCH_SCALAR2(head,elt,mbr,val,next); | DL_SEARCH_SCALAR2(head,elt,mbr,val,next);   | CDL_SEARCH_SCALAR2(head,elt,mbr,val,next);
+|LL_SEARCH2(head,elt,like,cmp,next);       | DL_SEARCH2(head,elt,like,cmp,next);         | CDL_SEARCH2(head,elt,like,cmp,next);
+|LL_LOWER_BOUND2(head,elt,like,cmp,next);  | DL_LOWER_BOUND2(head,elt,like,cmp,next);    | CDL_LOWER_BOUND2(head,elt,like,cmp,next);
+|LL_COUNT2(head,elt,count,next);           | DL_COUNT2(head,elt,count,next);             | CDL_COUNT2(head,elt,count,next);
+|===============================================================================
+
+// vim: set tw=80 wm=2 syntax=asciidoc:

c/ext/uthash/doc/utringbuffer.txt

@@ -0,0 +1,374 @@
+utringbuffer: dynamic ring-buffer macros for C
+==============================================
+Arthur O'Dwyer <arthur.j.odwyer@gmail.com>
+v2.3.0, February 2021
+
+Here's a link back to the https://github.com/troydhanson/uthash[GitHub project page].
+
+Introduction
+------------
+The functions in `utringbuffer.h` are based on the general-purpose array macros
+provided in `utarray.h`, so before reading this page you should read
+link:utarray.html[that page] first.
+
+To use these macros in your own C program, copy both `utarray.h` and `utringbuffer.h`
+into your source directory and use `utringbuffer.h` in your program.
+
+  #include "utringbuffer.h"
+
+The provided <<operations,operations>> are based loosely on the C++ STL vector methods.
+The ring-buffer data type supports construction (with a specified capacity),
+destruction, iteration, and push, but not pop; once the ring-buffer reaches full
+capacity, pushing a new element automatically pops and destroys the oldest element.
+The elements contained in the ring-buffer can be any simple datatype or structure.
+
+Internally the ring-buffer contains a pre-allocated memory region into which the
+elements are copied, starting at position 0. When the ring-buffer reaches full
+capacity, the next element to be pushed is pushed at position 0, overwriting the
+oldest element, and the internal index representing the "start" of the ring-buffer
+is incremented. A ring-buffer, once full, can never become un-full.
+
+
+Download
+~~~~~~~~
+To download the `utringbuffer.h` header file,
+follow the links on https://github.com/troydhanson/uthash to clone uthash or get a zip file,
+then look in the src/ sub-directory.
+
+BSD licensed
+~~~~~~~~~~~~
+This software is made available under the
+link:license.html[revised BSD license].
+It is free and open source.
+
+Platforms
+~~~~~~~~~
+The 'utringbuffer' macros have been tested on:
+
+ * Linux,
+ * Mac OS X,
+ * Windows, using Visual Studio 2008 and Visual Studio 2010
+
+Usage
+-----
+
+Declaration
+~~~~~~~~~~~
+
+The ring-buffer itself has the data type `UT_ringbuffer`, regardless of the type of
+elements to be stored in it. It is declared like,
+
+  UT_ringbuffer *history;
+
+New and free
+~~~~~~~~~~~~
+The next step is to create the ring-buffer using `utringbuffer_new`. Later when you're
+done with the ring-buffer, `utringbuffer_free` will free it and all its elements.
+
+Push, etc
+~~~~~~~~~
+The central features of the ring-buffer involve putting elements into it
+and iterating over them. There are several <<operations,operations>>
+that deal with either single elements or ranges of elements at a
+time. In the examples below we will use only the push operation to insert
+elements.
+
+Elements
+--------
+
+Support for dynamic arrays of integers or strings is especially easy. These are
+best shown by example:
+
+Integers
+~~~~~~~~
+This example makes a ring-buffer of integers, pushes 0-9 into it, then prints it
+two different ways. Lastly it frees it.
+
+.Integer elements
+-------------------------------------------------------------------------------
+#include <stdio.h>
+#include "utringbuffer.h"
+
+int main() {
+  UT_ringbuffer *history;
+  int i, *p;
+
+  utringbuffer_new(history, 7, &ut_int_icd);
+  for(i=0; i < 10; i++) utringbuffer_push_back(history, &i);
+
+  for (p = (int*)utringbuffer_front(history);
+       p != NULL;
+       p = (int*)utringbuffer_next(history, p)) {
+    printf("%d\n", *p);  /* prints "3 4 5 6 7 8 9" */
+  }
+
+  for (i=0; i < utringbuffer_len(history); i++) {
+    p = utringbuffer_eltptr(history, i);
+    printf("%d\n", *p);  /* prints "3 4 5 6 7 8 9" */
+  }
+
+  utringbuffer_free(history);
+
+  return 0;
+}
+-------------------------------------------------------------------------------
+
+The second argument to `utringbuffer_push_back` is always a 'pointer' to the type
+(so a literal cannot be used). So for integers, it is an `int*`.
+
+Strings
+~~~~~~~
+In this example we make a ring-buffer of strings, push two strings into it, print
+it and free it.
+
+.String elements
+-------------------------------------------------------------------------------
+#include <stdio.h>
+#include "utringbuffer.h"
+
+int main() {
+  UT_ringbuffer *strs;
+  char *s, **p;
+
+  utringbuffer_new(strs, 7, &ut_str_icd);
+
+  s = "hello"; utringbuffer_push_back(strs, &s);
+  s = "world"; utringbuffer_push_back(strs, &s);
+  p = NULL;
+  while ( (p=(char**)utringbuffer_next(strs,p))) {
+    printf("%s\n",*p);
+  }
+
+  utringbuffer_free(strs);
+
+  return 0;
+}
+-------------------------------------------------------------------------------
+
+In this example, since the element is a `char*`, we pass a pointer to it
+(`char**`) as the second argument to `utringbuffer_push_back`. Note that "push" makes
+a copy of the source string and pushes that copy into the array.
+
+About UT_icd
+~~~~~~~~~~~~
+
+Arrays can be made of any type of element, not just integers and strings. The
+elements can be basic types or structures. Unless you're dealing with integers
+and strings (which use pre-defined `ut_int_icd` and `ut_str_icd`), you'll need
+to define a `UT_icd` helper structure. This structure contains everything that
+utringbuffer (or utarray) needs to initialize, copy or destruct elements.
+
+  typedef struct {
+      size_t sz;
+      init_f *init;
+      ctor_f *copy;
+      dtor_f *dtor;
+  } UT_icd;
+
+The three function pointers `init`, `copy`, and `dtor` have these prototypes:
+
+  typedef void (ctor_f)(void *dst, const void *src);
+  typedef void (dtor_f)(void *elt);
+  typedef void (init_f)(void *elt);
+
+The `sz` is just the size of the element being stored in the array.
+
+The `init` function is used by utarray but is never used by utringbuffer;
+you may safely set it to any value you want.
+
+The `copy` function is used whenever an element is copied into the buffer.
+It is invoked during `utringbuffer_push_back`.
+If `copy` is `NULL`, it defaults to a bitwise copy using memcpy.
+
+The `dtor` function is used to clean up an element that is being removed from
+the buffer. It may be invoked due to `utringbuffer_push_back` (on the oldest
+element in the buffer), `utringbuffer_clear`, `utringbuffer_done`, or
+`utringbuffer_free`.
+If the elements need no cleanup upon destruction, `dtor` may be `NULL`.
+
+Scalar types
+~~~~~~~~~~~~
+
+The next example uses `UT_icd` with all its defaults to make a ring-buffer of
+`long` elements. This example pushes two longs into a buffer of capacity 1,
+prints the contents of the buffer (which is to say, the most recent value
+pushed), and then frees the buffer.
+
+.long elements
+-------------------------------------------------------------------------------
+#include <stdio.h>
+#include "utringbuffer.h"
+
+UT_icd long_icd = {sizeof(long), NULL, NULL, NULL };
+
+int main() {
+  UT_ringbuffer *nums;
+  long l, *p;
+  utringbuffer_new(nums, 1, &long_icd);
+
+  l=1; utringbuffer_push_back(nums, &l);
+  l=2; utringbuffer_push_back(nums, &l);
+
+  p=NULL;
+  while((p = (long*)utringbuffer_next(nums,p))) printf("%ld\n", *p);
+
+  utringbuffer_free(nums);
+  return 0;
+}
+-------------------------------------------------------------------------------
+
+Structures
+~~~~~~~~~~
+
+Structures can be used as utringbuffer elements. If the structure requires no
+special effort to initialize, copy or destruct, we can use `UT_icd` with all
+its defaults. This example shows a structure that consists of two integers. Here
+we push two values, print them and free the buffer.
+
+.Structure (simple)
+-------------------------------------------------------------------------------
+#include <stdio.h>
+#include "utringbuffer.h"
+
+typedef struct {
+    int a;
+    int b;
+} intpair_t;
+
+UT_icd intpair_icd = {sizeof(intpair_t), NULL, NULL, NULL};
+
+int main() {
+
+  UT_ringbuffer *pairs;
+  intpair_t ip, *p;
+  utringbuffer_new(pairs, 7, &intpair_icd);
+
+  ip.a=1;  ip.b=2;  utringbuffer_push_back(pairs, &ip);
+  ip.a=10; ip.b=20; utringbuffer_push_back(pairs, &ip);
+
+  for(p=(intpair_t*)utringbuffer_front(pairs);
+      p!=NULL;
+      p=(intpair_t*)utringbuffer_next(pairs,p)) {
+    printf("%d %d\n", p->a, p->b);
+  }
+
+  utringbuffer_free(pairs);
+  return 0;
+}
+-------------------------------------------------------------------------------
+
+The real utility of `UT_icd` is apparent when the elements stored in the
+ring-buffer are structures that require special work to initialize, copy or
+destruct.
+
+For example, when a structure contains pointers to related memory areas that
+need to be copied when the structure is copied (and freed when the structure is
+freed), we can use custom `init`, `copy`, and `dtor` members in the `UT_icd`.
+
+Here we take an example of a structure that contains an integer and a string.
+When this element is copied (such as when an element is pushed),
+we want to "deep copy" the `s` pointer (so the original element and the new
+element point to their own copies of `s`). When an element is destructed, we
+want to "deep free" its copy of `s`. Lastly, this example is written to work
+even if `s` has the value `NULL`.
+
+.Structure (complex)
+-------------------------------------------------------------------------------
+#include <stdio.h>
+#include <stdlib.h>
+#include "utringbuffer.h"
+
+typedef struct {
+    int a;
+    char *s;
+} intchar_t;
+
+void intchar_copy(void *_dst, const void *_src) {
+  intchar_t *dst = (intchar_t*)_dst, *src = (intchar_t*)_src;
+  dst->a = src->a;
+  dst->s = src->s ? strdup(src->s) : NULL;
+}
+
+void intchar_dtor(void *_elt) {
+  intchar_t *elt = (intchar_t*)_elt;
+  free(elt->s);
+}
+
+UT_icd intchar_icd = {sizeof(intchar_t), NULL, intchar_copy, intchar_dtor};
+
+int main() {
+  UT_ringbuffer *intchars;
+  intchar_t ic, *p;
+  utringbuffer_new(intchars, 2, &intchar_icd);
+
+  ic.a=1; ic.s="hello"; utringbuffer_push_back(intchars, &ic);
+  ic.a=2; ic.s="world"; utringbuffer_push_back(intchars, &ic);
+  ic.a=3; ic.s="peace"; utringbuffer_push_back(intchars, &ic);
+
+  p=NULL;
+  while( (p=(intchar_t*)utringbuffer_next(intchars,p))) {
+    printf("%d %s\n", p->a, (p->s ? p->s : "null"));
+    /* prints "2 world 3 peace" */
+  }
+
+  utringbuffer_free(intchars);
+  return 0;
+}
+
+-------------------------------------------------------------------------------
+
+[[operations]]
+Reference
+---------
+This table lists all the utringbuffer operations. These are loosely based on the C++
+vector class.
+
+Operations
+~~~~~~~~~~
+
+[width="100%",cols="50<m,40<",grid="none",options="none"]
+|===============================================================================
+| utringbuffer_new(UT_ringbuffer *a, int n, UT_icd *icd)  | allocate a new ringbuffer
+| utringbuffer_free(UT_ringbuffer *a)                     | free an allocated ringbuffer
+| utringbuffer_init(UT_ringbuffer *a, int n, UT_icd *icd) | init a ringbuffer (non-alloc)
+| utringbuffer_done(UT_ringbuffer *a)                     | dispose of a ringbuffer (non-alloc)
+| utringbuffer_clear(UT_ringbuffer *a)                    | clear all elements from a, making it empty
+| utringbuffer_push_back(UT_ringbuffer *a, element *p)    | push element p onto a
+| utringbuffer_len(UT_ringbuffer *a)                      | get length of a
+| utringbuffer_empty(UT_ringbuffer *a)                    | get whether a is empty
+| utringbuffer_full(UT_ringbuffer *a)                     | get whether a is full
+| utringbuffer_eltptr(UT_ringbuffer *a, int j)            | get pointer of element from index
+| utringbuffer_eltidx(UT_ringbuffer *a, element *e)       | get index of element from pointer
+| utringbuffer_front(UT_ringbuffer *a)                    | get oldest element of a
+| utringbuffer_next(UT_ringbuffer *a, element *e)         | get element of a following e (front if e is NULL)
+| utringbuffer_prev(UT_ringbuffer *a, element *e)         | get element of a before e (back if e is NULL)
+| utringbuffer_back(UT_ringbuffer *a)                     | get newest element of a
+|===============================================================================
+
+Notes
+~~~~~
+
+1. `utringbuffer_new` and `utringbuffer_free` are used to allocate a new ring-buffer
+   and to free it,
+   while `utringbuffer_init` and `utringbuffer_done` can be used if the UT_ringbuffer
+   is already allocated and just needs to be initialized or have its internal resources
+   freed.
+2. Both `utringbuffer_new` and `utringbuffer_init` take a second parameter `n` indicating
+   the capacity of the ring-buffer, that is, the size at which the ring-buffer is considered
+   "full" and begins to overwrite old elements with newly pushed ones.
+3. Once a ring-buffer has become full, it will never again become un-full except by
+   means of `utringbuffer_clear`. There is no way to "pop" a single old item from the
+   front of the ring-buffer. You can simulate this ability by maintaining a separate
+   integer count of the number of "logically popped elements", and starting your iteration
+   with `utringbuffer_eltptr(a, popped_count)` instead of with `utringbuffer_front(a)`.
+4. Pointers to elements (obtained using `utringbuffer_eltptr`, `utringbuffer_front`,
+   `utringbuffer_next`, etc.) are not generally invalidated by `utringbuffer_push_back`,
+   because utringbuffer does not perform reallocation; however, a pointer to the oldest
+   element may suddenly turn into a pointer to the 'newest' element if
+   `utringbuffer_push_back` is called while the buffer is full.
+5. The elements of a ring-buffer are stored in contiguous memory, but once the ring-buffer
+   has become full, it is no longer true that the elements are contiguously in order from
+   oldest to newest; i.e., `(element *)utringbuffer_front(a) + utringbuffer_len(a)-1` is
+   not generally equal to `(element *)utringbuffer_back(a)`.
+
+// vim: set nowrap syntax=asciidoc:

c/ext/uthash/doc/utstack.txt

@@ -0,0 +1,158 @@
+utstack: intrusive stack macros for C
+=====================================
+Arthur O'Dwyer <arthur.j.odwyer@gmail.com>
+v2.3.0, February 2021
+
+Here's a link back to the https://github.com/troydhanson/uthash[GitHub project page].
+
+Introduction
+------------
+A set of very simple stack macros for C structures are included with
+uthash in `utstack.h`.  To use these macros in your own C program, just
+copy `utstack.h` into your source directory and use it in your programs.
+
+  #include "utstack.h"
+
+These macros support the basic operations of a stack, implemented as
+an intrusive linked list. A stack supports the "push", "pop", and "count"
+operations, as well as the trivial operation of getting the top element
+of the stack.
+
+Download
+~~~~~~~~
+To download the `utstack.h` header file,
+follow the links on https://github.com/troydhanson/uthash to clone uthash or get a zip file,
+then look in the src/ sub-directory.
+
+BSD licensed
+~~~~~~~~~~~~
+This software is made available under the
+link:license.html[revised BSD license].
+It is free and open source.
+
+Platforms
+~~~~~~~~~
+The 'utstack' macros have been tested on:
+
+ * Linux,
+ * Mac OS X,
+ * Windows, using Visual Studio 2008 and Visual Studio 2010
+
+Usage
+-----
+
+Stack (list) head
+~~~~~~~~~~~~~~~~~
+The stack head is simply a pointer to your element structure. You can name it
+anything. *It must be initialized to `NULL`*. It doubles as a pointer to the
+top element of your stack.
+
+  element *stack = NULL;
+
+Stack operations
+~~~~~~~~~~~~~~~
+The only operations on a stack are O(1) pushing, O(1) popping, and
+O(n) counting the number of elements on the stack. None of the provided
+macros permit directly accessing stack elements other than the top element.
+
+To increase the readability of your code, you can use the macro
+`STACK_EMPTY(head)` as a more readable alternative to `head == NULL`,
+and `STACK_TOP(head)` as a more readable alternative to `head`.
+
+[width="100%",cols="50<m,40<",grid="none",options="none"]
+|===============================================================================
+|STACK_PUSH(stack,add);         | push `add` onto `stack`
+|STACK_POP(stack,elt);          | pop `stack` and save previous top as `elt`
+|STACK_COUNT(stack,tmp,count);  | store number of elements into `count`
+|STACK_TOP(stack)               | return `stack`
+|STACK_EMPTY(stack)             | return `stack == NULL`
+|===============================================================================
+
+The parameters shown in the table above are explained here:
+
+stack::
+  The stack head (a pointer to your element structure).
+add::
+  A pointer to the element structure you are adding to the stack.
+elt::
+  A pointer that will be assigned the address of the popped element. Need not be initialized.
+tmp::
+  A pointer of the same type as `elt`. Used internally. Need not be initialized.
+count::
+  An integer that will be assigned the size of the stack. Need not be initialized.
+
+
+Example
+~~~~~~~
+This example program reads names from a text file (one name per line), and
+pushes each name on the stack; then pops and prints them in reverse order.
+
+.A stack of names
+--------------------------------------------------------------------------------
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "utstack.h"
+
+#define BUFLEN 20
+
+typedef struct el {
+    char bname[BUFLEN];
+    struct el *next;
+} el;
+
+el *head = NULL; /* important- initialize to NULL! */
+
+int main(int argc, char *argv[]) {
+    el *elt, *tmp;
+
+    char linebuf[sizeof el->bname];
+    int count;
+    FILE *file = fopen("test11.dat", "r");
+    if (file == NULL) {
+        perror("can't open: ");
+        exit(-1);
+    }
+
+    while (fgets(linebuf, sizeof linebuf, file) != NULL) {
+        el *name = malloc(sizeof *name);
+        if (name == NULL) exit(-1);
+        strcpy(name->bname, linebuf);
+        STACK_PUSH(head, name);
+    }
+    fclose(file);
+
+    STACK_COUNT(head, elt, count);
+    printf("%d elements were read into the stack\n", count);
+
+    /* now pop, print, and delete each element */
+    while (!STACK_EMPTY(head)) {
+        printf("%s\n", STACK_TOP(head)->bname);
+        STACK_POP(head, elt);
+        free(elt);
+    }
+
+    return 0;
+}
+--------------------------------------------------------------------------------
+
+[[flex_names]]
+Other names for next
+~~~~~~~~~~~~~~~~~~~~
+If the element structure's `next` field is named something else, a separate group
+of macros must be used. These work the same as the regular macros, but take the
+field name as an extra parameter.
+
+These "flexible field name" macros are shown below. They all end with `2`. Each
+operates the same as its counterpart without the `2`, but they take the name of
+the `next` field as a trailing argument.
+
+[width="100%",cols="50<m,40<",grid="none",options="none"]
+|===============================================================================
+|STACK_PUSH2(stack,add,next);         | push `add` onto `stack`
+|STACK_POP2(stack,elt,next);          | pop `stack` and save previous top as `elt`
+|STACK_COUNT2(stack,tmp,count,next);  | store number of elements into `count`
+|===============================================================================
+
+
+// vim: set nowrap syntax=asciidoc:

c/ext/uthash/doc/utstring.txt

@@ -0,0 +1,239 @@
+utstring: dynamic string macros for C
+=====================================
+Troy D. Hanson <tdh@tkhanson.net>
+v2.3.0, February 2021
+
+Here's a link back to the https://github.com/troydhanson/uthash[GitHub project page].
+
+Introduction
+------------
+A set of basic dynamic string macros for C programs are included with
+uthash in `utstring.h`.  To use these in your own C program, just copy
+`utstring.h` into your source directory and use it in your programs.
+
+  #include "utstring.h"
+
+The dynamic string supports operations such as inserting data, concatenation,
+getting the length and content, substring search, and clear.  It's ok to put
+binary data into a utstring too. The string <<operations,operations>> are
+listed below.
+
+Some utstring operations are implemented as functions rather than macros.
+
+Download
+~~~~~~~~
+To download the `utstring.h` header file,
+follow the links on https://github.com/troydhanson/uthash to clone uthash or get a zip file,
+then look in the src/ sub-directory.
+
+BSD licensed
+~~~~~~~~~~~~
+This software is made available under the
+link:license.html[revised BSD license].
+It is free and open source.
+
+Platforms
+~~~~~~~~~
+The 'utstring' macros have been tested on:
+
+ * Linux,
+ * Windows, using Visual Studio 2008 and Visual Studio 2010
+
+Usage
+-----
+
+Declaration
+~~~~~~~~~~~
+
+The dynamic string itself has the data type `UT_string`.  It is declared like,
+
+  UT_string *str;
+
+New and free
+~~~~~~~~~~~~
+The next step is to create the string using `utstring_new`. Later when you're
+done with it, `utstring_free` will free it and all its content.
+
+Manipulation
+~~~~~~~~~~~~
+The `utstring_printf` or `utstring_bincpy` operations insert (copy) data into
+the string. To concatenate one utstring to another, use `utstring_concat`.  To
+clear the content of the string, use `utstring_clear`. The length of the string
+is available from `utstring_len`, and its content from `utstring_body`. This
+evaluates to a `char*`.  The buffer it points to is always null-terminated.
+So, it can be used directly with external functions that expect a string.
+This automatic null terminator is not counted in the length of the string.
+
+Samples
+~~~~~~~
+
+These examples show how to use utstring.
+
+.Sample 1
+-------------------------------------------------------------------------------
+#include <stdio.h>
+#include "utstring.h"
+
+int main() {
+    UT_string *s;
+
+    utstring_new(s);
+    utstring_printf(s, "hello world!" );
+    printf("%s\n", utstring_body(s));
+
+    utstring_free(s);
+    return 0;
+}
+-------------------------------------------------------------------------------
+
+The next example demonstrates that `utstring_printf` 'appends' to the string.
+It also shows concatenation.
+
+.Sample 2
+-------------------------------------------------------------------------------
+#include <stdio.h>
+#include "utstring.h"
+
+int main() {
+    UT_string *s, *t;
+
+    utstring_new(s);
+    utstring_new(t);
+
+    utstring_printf(s, "hello " );
+    utstring_printf(s, "world " );
+
+    utstring_printf(t, "hi " );
+    utstring_printf(t, "there " );
+
+    utstring_concat(s, t);
+    printf("length: %u\n", utstring_len(s));
+    printf("%s\n", utstring_body(s));
+
+    utstring_free(s);
+    utstring_free(t);
+    return 0;
+}
+-------------------------------------------------------------------------------
+
+The next example shows how binary data can be inserted into the string. It also
+clears the string and prints new data into it.
+
+.Sample 3
+-------------------------------------------------------------------------------
+#include <stdio.h>
+#include "utstring.h"
+
+int main() {
+    UT_string *s;
+    char binary[] = "\xff\xff";
+
+    utstring_new(s);
+    utstring_bincpy(s, binary, sizeof(binary));
+    printf("length is %u\n", utstring_len(s));
+
+    utstring_clear(s);
+    utstring_printf(s,"number %d", 10);
+    printf("%s\n", utstring_body(s));
+
+    utstring_free(s);
+    return 0;
+}
+-------------------------------------------------------------------------------
+
+[[operations]]
+Reference
+---------
+These are the utstring operations.
+
+Operations
+~~~~~~~~~~
+
+[width="100%",cols="50<m,40<",grid="none",options="none"]
+|===============================================================================
+| utstring_new(s) | allocate a new utstring
+| utstring_renew(s) | allocate a new utstring (if s is `NULL`) otherwise clears it
+| utstring_free(s) | free an allocated utstring
+| utstring_init(s)  | init a utstring (non-alloc)
+| utstring_done(s) | dispose of a utstring (non-alloc)
+| utstring_printf(s,fmt,...) | printf into a utstring (appends)
+| utstring_bincpy(s,bin,len) | insert binary data of length len (appends)
+| utstring_concat(dst,src) | concatenate src utstring to end of dst utstring
+| utstring_clear(s) | clear the content of s (setting its length to 0)
+| utstring_len(s) | obtain the length of s as an unsigned integer
+| utstring_body(s) | get `char*` to body of s (buffer is always null-terminated)
+| utstring_find(s,pos,str,len) | forward search from pos for a substring
+| utstring_findR(s,pos,str,len) | reverse search from pos for a substring
+|===============================================================================
+
+New/free vs. init/done
+~~~~~~~~~~~~~~~~~~~~~~
+Use `utstring_new` and `utstring_free` to allocate a new string or free it.  If
+the UT_string is statically allocated, use `utstring_init` and `utstring_done`
+to initialize or free its internal memory.
+
+Substring search
+~~~~~~~~~~~~~~~~
+Use `utstring_find` and `utstring_findR` to search for a substring in a utstring.
+It comes in forward and reverse varieties. The reverse search scans from the end of
+the string backward. These take a position to start searching from, measured from 0
+(the start of the utstring).  A negative position is counted from the end of
+the string, so, -1 is the last position.  Note that in the reverse search, the
+initial position anchors to the 'end' of the substring being searched for;
+e.g., the 't' in 'cat'. The return value always refers to the offset where the
+substring 'starts' in the utstring.  When no substring match is found, -1 is
+returned.
+
+For example if a utstring called `s` contains:
+
+  ABC ABCDAB ABCDABCDABDE
+
+Then these forward and reverse substring searches for `ABC` produce these results:
+
+  utstring_find(  s, -9, "ABC", 3 ) = 15
+  utstring_find(  s,  3, "ABC", 3 ) =  4
+  utstring_find(  s, 16, "ABC", 3 ) = -1
+  utstring_findR( s, -9, "ABC", 3 ) = 11
+  utstring_findR( s, 12, "ABC", 3 ) =  4
+  utstring_findR( s,  2, "ABC", 3 ) =  0
+
+"Multiple use" substring search
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+The preceding examples show "single use" versions of substring matching, where
+the internal Knuth-Morris-Pratt (KMP) table is internally built and then freed
+after the search. If your program needs to run many searches for a given
+substring, it is more efficient to save the KMP table and reuse it.
+
+To reuse the KMP table, build it manually and then pass it into the internal
+search functions. The functions involved are:
+
+ _utstring_BuildTable  (build the KMP table for a forward search)
+ _utstring_BuildTableR (build the KMP table for a reverse search)
+ _utstring_find        (forward search using a prebuilt KMP table)
+ _utstring_findR       (reverse search using a prebuilt KMP table)
+
+This is an example of building a forward KMP table for the substring "ABC", and
+then using it in a search:
+
+ long *KPM_TABLE, offset;
+ KPM_TABLE = (long *)malloc( sizeof(long) * (strlen("ABC")) + 1));
+ _utstring_BuildTable("ABC", 3, KPM_TABLE);
+ offset = _utstring_find(utstring_body(s), utstring_len(s), "ABC", 3, KPM_TABLE );
+ free(KPM_TABLE);
+
+Note that the internal `_utstring_find` has the length of the UT_string as its
+second argument, rather than the start position. You can emulate the position
+parameter by adding to the string start address and subtracting from its length.
+
+Notes
+~~~~~
+
+1. To override the default out-of-memory handling behavior (which calls `exit(-1)`),
+   override the `utstring_oom()` macro before including `utstring.h`.
+   For example,
+
+  #define utstring_oom() do { longjmp(error_handling_location); } while (0)
+  ...
+  #include "utstring.h"
+
+// vim: set nowrap syntax=asciidoc:

c/ext/uthash/include

@@ -0,0 +1 @@
+src

c/ext/uthash/package.json

@@ -0,0 +1,28 @@
+{
+  "description": "C macros for hash tables and more",
+
+  "keywords": [
+    "array",
+    "data",
+    "hash",
+    "list",
+    "macro",
+    "string",
+    "structure",
+    "uthash"
+  ],
+
+  "name": "uthash",
+  "repo": "troydhanson/uthash",
+
+  "src": [
+    "src/utarray.h",
+    "src/uthash.h",
+    "src/utlist.h",
+    "src/utringbuffer.h",
+    "src/utstack.h",
+    "src/utstring.h"
+  ],
+
+  "version": "2.3.0"
+}

c/ext/uthash/src/utarray.h

@@ -0,0 +1,248 @@
+/*
+Copyright (c) 2008-2021, Troy D. Hanson   http://troydhanson.github.com/uthash/
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/* a dynamic array implementation using macros
+ */
+#ifndef UTARRAY_H
+#define UTARRAY_H
+
+#define UTARRAY_VERSION 2.3.0
+
+#include <stddef.h>  /* size_t */
+#include <string.h>  /* memset, etc */
+#include <stdlib.h>  /* exit */
+
+#ifdef __GNUC__
+#define UTARRAY_UNUSED __attribute__((__unused__))
+#else
+#define UTARRAY_UNUSED
+#endif
+
+#ifdef oom
+#error "The name of macro 'oom' has been changed to 'utarray_oom'. Please update your code."
+#define utarray_oom() oom()
+#endif
+
+#ifndef utarray_oom
+#define utarray_oom() exit(-1)
+#endif
+
+typedef void (ctor_f)(void *dst, const void *src);
+typedef void (dtor_f)(void *elt);
+typedef void (init_f)(void *elt);
+typedef struct {
+    size_t sz;
+    init_f *init;
+    ctor_f *copy;
+    dtor_f *dtor;
+} UT_icd;
+
+typedef struct {
+    unsigned i,n;/* i: index of next available slot, n: num slots */
+    UT_icd icd;  /* initializer, copy and destructor functions */
+    char *d;     /* n slots of size icd->sz*/
+} UT_array;
+
+#define utarray_init(a,_icd) do {                                             \
+  memset(a,0,sizeof(UT_array));                                               \
+  (a)->icd = *(_icd);                                                         \
+} while(0)
+
+#define utarray_done(a) do {                                                  \
+  if ((a)->n) {                                                               \
+    if ((a)->icd.dtor) {                                                      \
+      unsigned _ut_i;                                                         \
+      for(_ut_i=0; _ut_i < (a)->i; _ut_i++) {                                 \
+        (a)->icd.dtor(utarray_eltptr(a,_ut_i));                               \
+      }                                                                       \
+    }                                                                         \
+    free((a)->d);                                                             \
+  }                                                                           \
+  (a)->n=0;                                                                   \
+} while(0)
+
+#define utarray_new(a,_icd) do {                                              \
+  (a) = (UT_array*)malloc(sizeof(UT_array));                                  \
+  if ((a) == NULL) {                                                          \
+    utarray_oom();                                                            \
+  }                                                                           \
+  utarray_init(a,_icd);                                                       \
+} while(0)
+
+#define utarray_free(a) do {                                                  \
+  utarray_done(a);                                                            \
+  free(a);                                                                    \
+} while(0)
+
+#define utarray_reserve(a,by) do {                                            \
+  if (((a)->i+(by)) > (a)->n) {                                               \
+    char *utarray_tmp;                                                        \
+    while (((a)->i+(by)) > (a)->n) { (a)->n = ((a)->n ? (2*(a)->n) : 8); }    \
+    utarray_tmp=(char*)realloc((a)->d, (a)->n*(a)->icd.sz);                   \
+    if (utarray_tmp == NULL) {                                                \
+      utarray_oom();                                                          \
+    }                                                                         \
+    (a)->d=utarray_tmp;                                                       \
+  }                                                                           \
+} while(0)
+
+#define utarray_push_back(a,p) do {                                           \
+  utarray_reserve(a,1);                                                       \
+  if ((a)->icd.copy) { (a)->icd.copy( _utarray_eltptr(a,(a)->i++), p); }      \
+  else { memcpy(_utarray_eltptr(a,(a)->i++), p, (a)->icd.sz); };              \
+} while(0)
+
+#define utarray_pop_back(a) do {                                              \
+  if ((a)->icd.dtor) { (a)->icd.dtor( _utarray_eltptr(a,--((a)->i))); }       \
+  else { (a)->i--; }                                                          \
+} while(0)
+
+#define utarray_extend_back(a) do {                                           \
+  utarray_reserve(a,1);                                                       \
+  if ((a)->icd.init) { (a)->icd.init(_utarray_eltptr(a,(a)->i)); }            \
+  else { memset(_utarray_eltptr(a,(a)->i),0,(a)->icd.sz); }                   \
+  (a)->i++;                                                                   \
+} while(0)
+
+#define utarray_len(a) ((a)->i)
+
+#define utarray_eltptr(a,j) (((j) < (a)->i) ? _utarray_eltptr(a,j) : NULL)
+#define _utarray_eltptr(a,j) ((void*)((a)->d + ((a)->icd.sz * (j))))
+
+#define utarray_insert(a,p,j) do {                                            \
+  if ((j) > (a)->i) utarray_resize(a,j);                                      \
+  utarray_reserve(a,1);                                                       \
+  if ((j) < (a)->i) {                                                         \
+    memmove( _utarray_eltptr(a,(j)+1), _utarray_eltptr(a,j),                  \
+             ((a)->i - (j))*((a)->icd.sz));                                   \
+  }                                                                           \
+  if ((a)->icd.copy) { (a)->icd.copy( _utarray_eltptr(a,j), p); }             \
+  else { memcpy(_utarray_eltptr(a,j), p, (a)->icd.sz); };                     \
+  (a)->i++;                                                                   \
+} while(0)
+
+#define utarray_inserta(a,w,j) do {                                           \
+  if (utarray_len(w) == 0) break;                                             \
+  if ((j) > (a)->i) utarray_resize(a,j);                                      \
+  utarray_reserve(a,utarray_len(w));                                          \
+  if ((j) < (a)->i) {                                                         \
+    memmove(_utarray_eltptr(a,(j)+utarray_len(w)),                            \
+            _utarray_eltptr(a,j),                                             \
+            ((a)->i - (j))*((a)->icd.sz));                                    \
+  }                                                                           \
+  if ((a)->icd.copy) {                                                        \
+    unsigned _ut_i;                                                           \
+    for(_ut_i=0;_ut_i<(w)->i;_ut_i++) {                                       \
+      (a)->icd.copy(_utarray_eltptr(a, (j) + _ut_i), _utarray_eltptr(w, _ut_i)); \
+    }                                                                         \
+  } else {                                                                    \
+    memcpy(_utarray_eltptr(a,j), _utarray_eltptr(w,0),                        \
+           utarray_len(w)*((a)->icd.sz));                                     \
+  }                                                                           \
+  (a)->i += utarray_len(w);                                                   \
+} while(0)
+
+#define utarray_resize(dst,num) do {                                          \
+  unsigned _ut_i;                                                             \
+  if ((dst)->i > (unsigned)(num)) {                                           \
+    if ((dst)->icd.dtor) {                                                    \
+      for (_ut_i = (num); _ut_i < (dst)->i; ++_ut_i) {                        \
+        (dst)->icd.dtor(_utarray_eltptr(dst, _ut_i));                         \
+      }                                                                       \
+    }                                                                         \
+  } else if ((dst)->i < (unsigned)(num)) {                                    \
+    utarray_reserve(dst, (num) - (dst)->i);                                   \
+    if ((dst)->icd.init) {                                                    \
+      for (_ut_i = (dst)->i; _ut_i < (unsigned)(num); ++_ut_i) {              \
+        (dst)->icd.init(_utarray_eltptr(dst, _ut_i));                         \
+      }                                                                       \
+    } else {                                                                  \
+      memset(_utarray_eltptr(dst, (dst)->i), 0, (dst)->icd.sz*((num) - (dst)->i)); \
+    }                                                                         \
+  }                                                                           \
+  (dst)->i = (num);                                                           \
+} while(0)
+
+#define utarray_concat(dst,src) do {                                          \
+  utarray_inserta(dst, src, utarray_len(dst));                                \
+} while(0)
+
+#define utarray_erase(a,pos,len) do {                                         \
+  if ((a)->icd.dtor) {                                                        \
+    unsigned _ut_i;                                                           \
+    for (_ut_i = 0; _ut_i < (len); _ut_i++) {                                 \
+      (a)->icd.dtor(utarray_eltptr(a, (pos) + _ut_i));                        \
+    }                                                                         \
+  }                                                                           \
+  if ((a)->i > ((pos) + (len))) {                                             \
+    memmove(_utarray_eltptr(a, pos), _utarray_eltptr(a, (pos) + (len)),       \
+            ((a)->i - ((pos) + (len))) * (a)->icd.sz);                        \
+  }                                                                           \
+  (a)->i -= (len);                                                            \
+} while(0)
+
+#define utarray_renew(a,u) do {                                               \
+  if (a) utarray_clear(a);                                                    \
+  else utarray_new(a, u);                                                     \
+} while(0)
+
+#define utarray_clear(a) do {                                                 \
+  if ((a)->i > 0) {                                                           \
+    if ((a)->icd.dtor) {                                                      \
+      unsigned _ut_i;                                                         \
+      for(_ut_i=0; _ut_i < (a)->i; _ut_i++) {                                 \
+        (a)->icd.dtor(_utarray_eltptr(a, _ut_i));                             \
+      }                                                                       \
+    }                                                                         \
+    (a)->i = 0;                                                               \
+  }                                                                           \
+} while(0)
+
+#define utarray_sort(a,cmp) do {                                              \
+  qsort((a)->d, (a)->i, (a)->icd.sz, cmp);                                    \
+} while(0)
+
+#define utarray_find(a,v,cmp) bsearch((v),(a)->d,(a)->i,(a)->icd.sz,cmp)
+
+#define utarray_front(a) (((a)->i) ? (_utarray_eltptr(a,0)) : NULL)
+#define utarray_next(a,e) (((e)==NULL) ? utarray_front(a) : (((a)->i != utarray_eltidx(a,e)+1) ? _utarray_eltptr(a,utarray_eltidx(a,e)+1) : NULL))
+#define utarray_prev(a,e) (((e)==NULL) ? utarray_back(a) : ((utarray_eltidx(a,e) != 0) ? _utarray_eltptr(a,utarray_eltidx(a,e)-1) : NULL))
+#define utarray_back(a) (((a)->i) ? (_utarray_eltptr(a,(a)->i-1)) : NULL)
+#define utarray_eltidx(a,e) (((char*)(e) - (a)->d) / (a)->icd.sz)
+
+/* last we pre-define a few icd for common utarrays of ints and strings */
+static void utarray_str_cpy(void *dst, const void *src) {
+  char *const *srcc = (char *const *)src;
+  char **dstc = (char**)dst;
+  *dstc = (*srcc == NULL) ? NULL : strdup(*srcc);
+}
+static void utarray_str_dtor(void *elt) {
+  char **eltc = (char**)elt;
+  if (*eltc != NULL) free(*eltc);
+}
+static const UT_icd ut_str_icd UTARRAY_UNUSED = {sizeof(char*),NULL,utarray_str_cpy,utarray_str_dtor};
+static const UT_icd ut_int_icd UTARRAY_UNUSED = {sizeof(int),NULL,NULL,NULL};
+static const UT_icd ut_ptr_icd UTARRAY_UNUSED = {sizeof(void*),NULL,NULL,NULL};
+
+
+#endif /* UTARRAY_H */

c/ext/uthash/src/utringbuffer.h

@@ -0,0 +1,108 @@
+/*
+Copyright (c) 2015-2021, Troy D. Hanson   http://troydhanson.github.com/uthash/
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/* a ring-buffer implementation using macros
+ */
+#ifndef UTRINGBUFFER_H
+#define UTRINGBUFFER_H
+
+#define UTRINGBUFFER_VERSION 2.3.0
+
+#include <stdlib.h>
+#include <string.h>
+#include "utarray.h"  // for "UT_icd"
+
+typedef struct {
+    unsigned i;       /* index of next available slot; wraps at n */
+    unsigned n;       /* capacity */
+    unsigned char f;  /* full */
+    UT_icd icd;       /* initializer, copy and destructor functions */
+    char *d;          /* n slots of size icd->sz */
+} UT_ringbuffer;
+
+#define utringbuffer_init(a, _n, _icd) do {                               \
+  memset(a, 0, sizeof(UT_ringbuffer));                                    \
+  (a)->icd = *(_icd);                                                     \
+  (a)->n = (_n);                                                          \
+  if ((a)->n) { (a)->d = (char*)malloc((a)->n * (_icd)->sz); }            \
+} while(0)
+
+#define utringbuffer_clear(a) do {                                        \
+  if ((a)->icd.dtor) {                                                    \
+    if ((a)->f) {                                                         \
+      unsigned _ut_i;                                                     \
+      for (_ut_i = 0; _ut_i < (a)->n; ++_ut_i) {                          \
+        (a)->icd.dtor(utringbuffer_eltptr(a, _ut_i));                     \
+      }                                                                   \
+    } else {                                                              \
+      unsigned _ut_i;                                                     \
+      for (_ut_i = 0; _ut_i < (a)->i; ++_ut_i) {                          \
+        (a)->icd.dtor(utringbuffer_eltptr(a, _ut_i));                     \
+      }                                                                   \
+    }                                                                     \
+  }                                                                       \
+  (a)->i = 0;                                                             \
+  (a)->f = 0;                                                             \
+} while(0)
+
+#define utringbuffer_done(a) do {                                         \
+  utringbuffer_clear(a);                                                  \
+  free((a)->d); (a)->d = NULL;                                            \
+  (a)->n = 0;                                                             \
+} while(0)
+
+#define utringbuffer_new(a,n,_icd) do {                                   \
+  a = (UT_ringbuffer*)malloc(sizeof(UT_ringbuffer));                      \
+  utringbuffer_init(a, n, _icd);                                          \
+} while(0)
+
+#define utringbuffer_free(a) do {                                         \
+  utringbuffer_done(a);                                                   \
+  free(a);                                                                \
+} while(0)
+
+#define utringbuffer_push_back(a,p) do {                                                \
+  if ((a)->icd.dtor && (a)->f) { (a)->icd.dtor(_utringbuffer_internalptr(a,(a)->i)); }  \
+  if ((a)->icd.copy) { (a)->icd.copy( _utringbuffer_internalptr(a,(a)->i), p); }        \
+  else { memcpy(_utringbuffer_internalptr(a,(a)->i), p, (a)->icd.sz); };                \
+  if (++(a)->i == (a)->n) { (a)->i = 0; (a)->f = 1; }                                   \
+} while(0)
+
+#define utringbuffer_len(a) ((a)->f ? (a)->n : (a)->i)
+#define utringbuffer_empty(a) ((a)->i == 0 && !(a)->f)
+#define utringbuffer_full(a) ((a)->f != 0)
+
+#define _utringbuffer_real_idx(a,j) ((a)->f ? ((j) + (a)->i) % (a)->n : (j))
+#define _utringbuffer_internalptr(a,j) ((void*)((a)->d + ((a)->icd.sz * (j))))
+#define utringbuffer_eltptr(a,j) ((0 <= (j) && (j) < utringbuffer_len(a)) ? _utringbuffer_internalptr(a,_utringbuffer_real_idx(a,j)) : NULL)
+
+#define _utringbuffer_fake_idx(a,j) ((a)->f ? ((j) + (a)->n - (a)->i) % (a)->n : (j))
+#define _utringbuffer_internalidx(a,e) (((char*)(e) >= (a)->d) ? (((char*)(e) - (a)->d)/(a)->icd.sz) : -1)
+#define utringbuffer_eltidx(a,e) _utringbuffer_fake_idx(a, _utringbuffer_internalidx(a,e))
+
+#define utringbuffer_front(a) utringbuffer_eltptr(a,0)
+#define utringbuffer_next(a,e) ((e)==NULL ? utringbuffer_front(a) : utringbuffer_eltptr(a, utringbuffer_eltidx(a,e)+1))
+#define utringbuffer_prev(a,e) ((e)==NULL ? utringbuffer_back(a) : utringbuffer_eltptr(a, utringbuffer_eltidx(a,e)-1))
+#define utringbuffer_back(a) (utringbuffer_empty(a) ? NULL : utringbuffer_eltptr(a, utringbuffer_len(a) - 1))
+
+#endif /* UTRINGBUFFER_H */

c/ext/uthash/src/utstack.h

@@ -0,0 +1,88 @@
+/*
+Copyright (c) 2018-2021, Troy D. Hanson   http://troydhanson.github.com/uthash/
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef UTSTACK_H
+#define UTSTACK_H
+
+#define UTSTACK_VERSION 2.3.0
+
+/*
+ * This file contains macros to manipulate a singly-linked list as a stack.
+ *
+ * To use utstack, your structure must have a "next" pointer.
+ *
+ * ----------------.EXAMPLE -------------------------
+ * struct item {
+ *      int id;
+ *      struct item *next;
+ * }
+ *
+ * struct item *stack = NULL:
+ *
+ * int main() {
+ *      int count;
+ *      struct item *tmp;
+ *      struct item *item = malloc(sizeof *item);
+ *      item->id = 42;
+ *      STACK_COUNT(stack, tmp, count); assert(count == 0);
+ *      STACK_PUSH(stack, item);
+ *      STACK_COUNT(stack, tmp, count); assert(count == 1);
+ *      STACK_POP(stack, item);
+ *      free(item);
+ *      STACK_COUNT(stack, tmp, count); assert(count == 0);
+ * }
+ * --------------------------------------------------
+ */
+
+#define STACK_TOP(head) (head)
+
+#define STACK_EMPTY(head) (!(head))
+
+#define STACK_PUSH(head,add)                                         \
+    STACK_PUSH2(head,add,next)
+
+#define STACK_PUSH2(head,add,next)                                   \
+do {                                                                 \
+  (add)->next = (head);                                              \
+  (head) = (add);                                                    \
+} while (0)
+
+#define STACK_POP(head,result)                                       \
+    STACK_POP2(head,result,next)
+
+#define STACK_POP2(head,result,next)                                 \
+do {                                                                 \
+  (result) = (head);                                                 \
+  (head) = (head)->next;                                             \
+} while (0)
+
+#define STACK_COUNT(head,el,counter)                                 \
+    STACK_COUNT2(head,el,counter,next)                               \
+
+#define STACK_COUNT2(head,el,counter,next)                           \
+do {                                                                 \
+  (counter) = 0;                                                     \
+  for ((el) = (head); el; (el) = (el)->next) { ++(counter); }        \
+} while (0)
+
+#endif /* UTSTACK_H */

c/ext/uthash/src/utstring.h

@@ -0,0 +1,407 @@
+/*
+Copyright (c) 2008-2021, Troy D. Hanson   http://troydhanson.github.com/uthash/
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/* a dynamic string implementation using macros
+ */
+#ifndef UTSTRING_H
+#define UTSTRING_H
+
+#define UTSTRING_VERSION 2.3.0
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+#ifdef __GNUC__
+#define UTSTRING_UNUSED __attribute__((__unused__))
+#else
+#define UTSTRING_UNUSED
+#endif
+
+#ifdef oom
+#error "The name of macro 'oom' has been changed to 'utstring_oom'. Please update your code."
+#define utstring_oom() oom()
+#endif
+
+#ifndef utstring_oom
+#define utstring_oom() exit(-1)
+#endif
+
+typedef struct {
+    char *d;  /* pointer to allocated buffer */
+    size_t n; /* allocated capacity */
+    size_t i; /* index of first unused byte */
+} UT_string;
+
+#define utstring_reserve(s,amt)                            \
+do {                                                       \
+  if (((s)->n - (s)->i) < (size_t)(amt)) {                 \
+    char *utstring_tmp = (char*)realloc(                   \
+      (s)->d, (s)->n + (amt));                             \
+    if (!utstring_tmp) {                                   \
+      utstring_oom();                                      \
+    }                                                      \
+    (s)->d = utstring_tmp;                                 \
+    (s)->n += (amt);                                       \
+  }                                                        \
+} while(0)
+
+#define utstring_init(s)                                   \
+do {                                                       \
+  (s)->n = 0; (s)->i = 0; (s)->d = NULL;                   \
+  utstring_reserve(s,100);                                 \
+  (s)->d[0] = '\0';                                        \
+} while(0)
+
+#define utstring_done(s)                                   \
+do {                                                       \
+  if ((s)->d != NULL) free((s)->d);                        \
+  (s)->n = 0;                                              \
+} while(0)
+
+#define utstring_free(s)                                   \
+do {                                                       \
+  utstring_done(s);                                        \
+  free(s);                                                 \
+} while(0)
+
+#define utstring_new(s)                                    \
+do {                                                       \
+  (s) = (UT_string*)malloc(sizeof(UT_string));             \
+  if (!(s)) {                                              \
+    utstring_oom();                                        \
+  }                                                        \
+  utstring_init(s);                                        \
+} while(0)
+
+#define utstring_renew(s)                                  \
+do {                                                       \
+   if (s) {                                                \
+     utstring_clear(s);                                    \
+   } else {                                                \
+     utstring_new(s);                                      \
+   }                                                       \
+} while(0)
+
+#define utstring_clear(s)                                  \
+do {                                                       \
+  (s)->i = 0;                                              \
+  (s)->d[0] = '\0';                                        \
+} while(0)
+
+#define utstring_bincpy(s,b,l)                             \
+do {                                                       \
+  utstring_reserve((s),(l)+1);                             \
+  if (l) memcpy(&(s)->d[(s)->i], b, l);                    \
+  (s)->i += (l);                                           \
+  (s)->d[(s)->i]='\0';                                     \
+} while(0)
+
+#define utstring_concat(dst,src)                                 \
+do {                                                             \
+  utstring_reserve((dst),((src)->i)+1);                          \
+  if ((src)->i) memcpy(&(dst)->d[(dst)->i], (src)->d, (src)->i); \
+  (dst)->i += (src)->i;                                          \
+  (dst)->d[(dst)->i]='\0';                                       \
+} while(0)
+
+#define utstring_len(s) ((s)->i)
+
+#define utstring_body(s) ((s)->d)
+
+UTSTRING_UNUSED static void utstring_printf_va(UT_string *s, const char *fmt, va_list ap) {
+   int n;
+   va_list cp;
+   for (;;) {
+#ifdef _WIN32
+      cp = ap;
+#else
+      va_copy(cp, ap);
+#endif
+      n = vsnprintf (&s->d[s->i], s->n-s->i, fmt, cp);
+      va_end(cp);
+
+      if ((n > -1) && ((size_t) n < (s->n-s->i))) {
+        s->i += n;
+        return;
+      }
+
+      /* Else try again with more space. */
+      if (n > -1) utstring_reserve(s,n+1); /* exact */
+      else utstring_reserve(s,(s->n)*2);   /* 2x */
+   }
+}
+#ifdef __GNUC__
+/* support printf format checking (2=the format string, 3=start of varargs) */
+static void utstring_printf(UT_string *s, const char *fmt, ...)
+  __attribute__ (( format( printf, 2, 3) ));
+#endif
+UTSTRING_UNUSED static void utstring_printf(UT_string *s, const char *fmt, ...) {
+   va_list ap;
+   va_start(ap,fmt);
+   utstring_printf_va(s,fmt,ap);
+   va_end(ap);
+}
+
+/*******************************************************************************
+ * begin substring search functions                                            *
+ ******************************************************************************/
+/* Build KMP table from left to right. */
+UTSTRING_UNUSED static void _utstring_BuildTable(
+    const char *P_Needle,
+    size_t P_NeedleLen,
+    long *P_KMP_Table)
+{
+    long i, j;
+
+    i = 0;
+    j = i - 1;
+    P_KMP_Table[i] = j;
+    while (i < (long) P_NeedleLen)
+    {
+        while ( (j > -1) && (P_Needle[i] != P_Needle[j]) )
+        {
+           j = P_KMP_Table[j];
+        }
+        i++;
+        j++;
+        if (i < (long) P_NeedleLen)
+        {
+            if (P_Needle[i] == P_Needle[j])
+            {
+                P_KMP_Table[i] = P_KMP_Table[j];
+            }
+            else
+            {
+                P_KMP_Table[i] = j;
+            }
+        }
+        else
+        {
+            P_KMP_Table[i] = j;
+        }
+    }
+
+    return;
+}
+
+
+/* Build KMP table from right to left. */
+UTSTRING_UNUSED static void _utstring_BuildTableR(
+    const char *P_Needle,
+    size_t P_NeedleLen,
+    long *P_KMP_Table)
+{
+    long i, j;
+
+    i = P_NeedleLen - 1;
+    j = i + 1;
+    P_KMP_Table[i + 1] = j;
+    while (i >= 0)
+    {
+        while ( (j < (long) P_NeedleLen) && (P_Needle[i] != P_Needle[j]) )
+        {
+           j = P_KMP_Table[j + 1];
+        }
+        i--;
+        j--;
+        if (i >= 0)
+        {
+            if (P_Needle[i] == P_Needle[j])
+            {
+                P_KMP_Table[i + 1] = P_KMP_Table[j + 1];
+            }
+            else
+            {
+                P_KMP_Table[i + 1] = j;
+            }
+        }
+        else
+        {
+            P_KMP_Table[i + 1] = j;
+        }
+    }
+
+    return;
+}
+
+
+/* Search data from left to right. ( Multiple search mode. ) */
+UTSTRING_UNUSED static long _utstring_find(
+    const char *P_Haystack,
+    size_t P_HaystackLen,
+    const char *P_Needle,
+    size_t P_NeedleLen,
+    long *P_KMP_Table)
+{
+    long i, j;
+    long V_FindPosition = -1;
+
+    /* Search from left to right. */
+    i = j = 0;
+    while ( (j < (int)P_HaystackLen) && (((P_HaystackLen - j) + i) >= P_NeedleLen) )
+    {
+        while ( (i > -1) && (P_Needle[i] != P_Haystack[j]) )
+        {
+            i = P_KMP_Table[i];
+        }
+        i++;
+        j++;
+        if (i >= (int)P_NeedleLen)
+        {
+            /* Found. */
+            V_FindPosition = j - i;
+            break;
+        }
+    }
+
+    return V_FindPosition;
+}
+
+
+/* Search data from right to left. ( Multiple search mode. ) */
+UTSTRING_UNUSED static long _utstring_findR(
+    const char *P_Haystack,
+    size_t P_HaystackLen,
+    const char *P_Needle,
+    size_t P_NeedleLen,
+    long *P_KMP_Table)
+{
+    long i, j;
+    long V_FindPosition = -1;
+
+    /* Search from right to left. */
+    j = (P_HaystackLen - 1);
+    i = (P_NeedleLen - 1);
+    while ( (j >= 0) && (j >= i) )
+    {
+        while ( (i < (int)P_NeedleLen) && (P_Needle[i] != P_Haystack[j]) )
+        {
+            i = P_KMP_Table[i + 1];
+        }
+        i--;
+        j--;
+        if (i < 0)
+        {
+            /* Found. */
+            V_FindPosition = j + 1;
+            break;
+        }
+    }
+
+    return V_FindPosition;
+}
+
+
+/* Search data from left to right. ( One time search mode. ) */
+UTSTRING_UNUSED static long utstring_find(
+    UT_string *s,
+    long P_StartPosition,   /* Start from 0. -1 means last position. */
+    const char *P_Needle,
+    size_t P_NeedleLen)
+{
+    long V_StartPosition;
+    long V_HaystackLen;
+    long *V_KMP_Table;
+    long V_FindPosition = -1;
+
+    if (P_StartPosition < 0)
+    {
+        V_StartPosition = s->i + P_StartPosition;
+    }
+    else
+    {
+        V_StartPosition = P_StartPosition;
+    }
+    V_HaystackLen = s->i - V_StartPosition;
+    if ( (V_HaystackLen >= (long) P_NeedleLen) && (P_NeedleLen > 0) )
+    {
+        V_KMP_Table = (long *)malloc(sizeof(long) * (P_NeedleLen + 1));
+        if (V_KMP_Table != NULL)
+        {
+            _utstring_BuildTable(P_Needle, P_NeedleLen, V_KMP_Table);
+
+            V_FindPosition = _utstring_find(s->d + V_StartPosition,
+                                            V_HaystackLen,
+                                            P_Needle,
+                                            P_NeedleLen,
+                                            V_KMP_Table);
+            if (V_FindPosition >= 0)
+            {
+                V_FindPosition += V_StartPosition;
+            }
+
+            free(V_KMP_Table);
+        }
+    }
+
+    return V_FindPosition;
+}
+
+
+/* Search data from right to left. ( One time search mode. ) */
+UTSTRING_UNUSED static long utstring_findR(
+    UT_string *s,
+    long P_StartPosition,   /* Start from 0. -1 means last position. */
+    const char *P_Needle,
+    size_t P_NeedleLen)
+{
+    long V_StartPosition;
+    long V_HaystackLen;
+    long *V_KMP_Table;
+    long V_FindPosition = -1;
+
+    if (P_StartPosition < 0)
+    {
+        V_StartPosition = s->i + P_StartPosition;
+    }
+    else
+    {
+        V_StartPosition = P_StartPosition;
+    }
+    V_HaystackLen = V_StartPosition + 1;
+    if ( (V_HaystackLen >= (long) P_NeedleLen) && (P_NeedleLen > 0) )
+    {
+        V_KMP_Table = (long *)malloc(sizeof(long) * (P_NeedleLen + 1));
+        if (V_KMP_Table != NULL)
+        {
+            _utstring_BuildTableR(P_Needle, P_NeedleLen, V_KMP_Table);
+
+            V_FindPosition = _utstring_findR(s->d,
+                                             V_HaystackLen,
+                                             P_Needle,
+                                             P_NeedleLen,
+                                             V_KMP_Table);
+
+            free(V_KMP_Table);
+        }
+    }
+
+    return V_FindPosition;
+}
+/*******************************************************************************
+ * end substring search functions                                              *
+ ******************************************************************************/
+
+#endif /* UTSTRING_H */

c/ext/uthash/tests/Makefile

@@ -0,0 +1,120 @@
+#CC=clang
+HASHDIR = ../src
+UTILS = emit_keys
+PROGS = test1 test2 test3 test4 test5 test6 test7 test8 test9   \
+        test10 test11 test12 test13 test14 test15 test16 test17 \
+        test18 test19 test20 test21 test22 test23 test24 test25 \
+        test26 test27 test28 test29 test30 test31 test32 test33 \
+        test34 test35 test36 test37 test38 test39 test40 test41 \
+        test42 test43 test44 test45 test46 test47 test48 test49 \
+        test50 test51 test52 test53 test54 test55 test56 test57 \
+        test58 test59 test60 test61 test62 test63 test64 test65 \
+        test66 test67 test68 test69 test70 test71 test72 test73 \
+        test74 test75 test76 test77 test78 test79 test80 test81 \
+        test82 test83 test84 test85 test86 test87 test88 test89 \
+        test90 test91 test92 test93 test94 test95 test96
+CFLAGS += -I$(HASHDIR)
+#CFLAGS += -DHASH_BLOOM=16
+#CFLAGS += -O2
+CFLAGS += -g
+#CFLAGS += -Wstrict-aliasing=2
+CFLAGS += -Wall
+#CFLAGS += -Wextra
+#CFLAGS += -std=c89
+CFLAGS += ${EXTRA_CFLAGS}
+
+ifeq ($(HASH_DEBUG),1)
+CFLAGS += -DHASH_DEBUG=1
+endif
+
+ifeq ($(HASH_PEDANTIC),1)
+CFLAGS += -pedantic
+endif
+
+TEST_TARGET=run_tests
+TESTS=./do_tests
+
+# detect Cygwin
+ifneq ($(strip $(shell $(CC) -v 2>&1 |grep "cygwin")),)
+  TESTS=./do_tests.cygwin
+endif
+
+# detect MinGW
+ifneq ($(strip $(shell $(CC) -v 2>&1 |grep "mingw")),)
+  TEST_TARGET=run_tests_mingw
+  TESTS=./do_tests.mingw
+endif
+
+#detect Linux (platform specific utilities)
+ifneq ($(strip $(shell $(CC) -v 2>&1 |grep "linux")),)
+  PLAT_UTILS = hashscan sleep_test
+endif
+
+#detect FreeBSD (platform specific utilities)
+ifeq ($(strip $(shell uname -s)), FreeBSD)
+  ifeq ($(shell if [ `sysctl -n kern.osreldate` -ge 0801000 ]; then echo "ok"; fi), ok)
+    PLAT_UTILS = hashscan sleep_test
+  endif
+endif
+
+all: $(PROGS) $(UTILS) $(PLAT_UTILS) keystat $(TEST_TARGET)
+
+tests_only: $(PROGS) $(TEST_TARGET)
+
+GITIGN = .gitignore
+MKGITIGN = [ -f "$(GITIGN)" ] || echo "$(GITIGN)" > $(GITIGN); grep -q '^\$@$$' $(GITIGN) || echo "$@" >> $(GITIGN)
+
+debug:
+	$(MAKE) all HASH_DEBUG=1
+
+pedantic:
+	$(MAKE) all HASH_PEDANTIC=1
+
+cplusplus:
+	CC="$(CXX) -x c++" $(MAKE) all
+
+thorough:
+	$(MAKE) clean && $(MAKE) all EXTRA_CFLAGS='-pedantic'
+	$(MAKE) clean && $(MAKE) all EXTRA_CFLAGS='-pedantic -DHASH_BLOOM=16'
+	$(MAKE) clean && $(MAKE) tests_only EXTRA_CFLAGS='-pedantic -DHASH_BLOOM=16 -DHASH_DEBUG -DNO_DECLTYPE'
+	$(MAKE) clean && CC="$(CXX) -x c++" $(MAKE) all EXTRA_CFLAGS='-pedantic'
+	$(MAKE) clean && CC="$(CXX) -x c++" $(MAKE) all EXTRA_CFLAGS='-pedantic -DHASH_BLOOM=16'
+	$(MAKE) clean && CC="$(CXX) -x c++" $(MAKE) tests_only EXTRA_CFLAGS='-pedantic -DHASH_BLOOM=16 -DHASH_DEBUG -DNO_DECLTYPE'
+
+example: example.c $(HASHDIR)/uthash.h
+	$(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) -o $@ $(@).c
+
+$(PROGS) $(UTILS) : $(HASHDIR)/uthash.h
+	$(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) -o $@ $(@).c
+	@$(MKGITIGN)
+
+hashscan : $(HASHDIR)/uthash.h
+	$(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) -o $@ $(@).c
+	@$(MKGITIGN)
+
+sleep_test : $(HASHDIR)/uthash.h
+	$(CC) $(CPPFLAGS) $(CFLAGS) -DHASH_BLOOM=16 $(LDFLAGS) -o $@ $(@).c
+	@$(MKGITIGN)
+
+keystat : $(HASHDIR)/uthash.h
+	$(CC) $(CPPFLAGS) $(CFLAGS) -DHASH_FUNCTION=HASH_BER $(LDFLAGS) -o keystat.BER keystat.c
+	$(CC) $(CPPFLAGS) $(CFLAGS) -DHASH_FUNCTION=HASH_FNV $(LDFLAGS) -o keystat.FNV keystat.c
+	$(CC) $(CPPFLAGS) $(CFLAGS) -DHASH_FUNCTION=HASH_JEN $(LDFLAGS) -o keystat.JEN keystat.c
+	$(CC) $(CPPFLAGS) $(CFLAGS) -DHASH_FUNCTION=HASH_OAT $(LDFLAGS) -o keystat.OAT keystat.c
+	$(CC) $(CPPFLAGS) $(CFLAGS) -DHASH_FUNCTION=HASH_SAX $(LDFLAGS) -o keystat.SAX keystat.c
+	$(CC) $(CPPFLAGS) $(CFLAGS) -DHASH_FUNCTION=HASH_SFH $(LDFLAGS) -o keystat.SFH keystat.c
+
+run_tests: $(PROGS)
+	perl $(TESTS)
+
+run_tests_mingw: $(PROGS)
+	/bin/bash do_tests.mingw
+
+astyle:
+	astyle -n --style=kr --indent-switches --add-brackets *.c
+
+.PHONY: clean astyle
+
+clean:
+	rm -f $(UTILS) $(PLAT_UTILS) $(PROGS) test*.out keystat.??? example hashscan sleep_test *.exe $(GITIGN)
+	rm -rf *.dSYM

c/ext/uthash/tests/README

@@ -0,0 +1,132 @@
+Automated tests for uthash
+==============================================================================
+Run "make" in this directory to build the tests and run them.
+
+test1:  make 10-item hash, iterate and print each one
+test2:  make 10-item hash, lookup items with even keys, print
+test3:  make 10-item hash, delete items with even keys, print others
+test4:  10 structs have dual hash handles, separate keys
+test5:  10 structs have dual hash handles, lookup evens by alt key
+test6:  test alt malloc macros (and alt key-comparison macro)
+test7:  test alt malloc macros with 1000 structs so bucket expansion occurs
+test8:  test num_items counter in UT_hash_handle
+test9:  test "find" after bucket expansion
+test10: dual-hash handle test, bucket expansion on one and not the other
+test11: read dat file of names into hash, sort them and print
+test12: create hash with string keys, add 10 items, lookup each item
+test13: make 10-item hash, delete items with even keys, reverse print others
+test14: read dat file of names into hash, read file again and lookup each one
+test15: build string-keyed hash of 3 items, lookup one item (c.f. test40.c)
+test16: hash on aggregate key, iterate, lookup, using generalized macros
+test17: sort, add more items, sort again
+test18: test pathological HASH_DEL(a,a) scenario (single head,deletee variable)
+test19: sort two hash tables with shared elements using HASH_SRT
+test20: test a 5-byte "binary" key
+test21: test a structure key (userguide)
+test22: test multi-field key using flexible array member (userguide utf32)
+test23: test whether delete in iteration works
+test24: make 10-item hash and confirm item count (HASH_COUNT)
+test25: CDL / DL / LL tests
+test26: test the linked list sort macros in utlist.h
+test27: LL_APPEND, SORT
+test28: CDL / DL / LL tests
+test29: DL_APPEND, SORT
+test30: CDL_PREPEND, SORT
+test31: CDL_PREPEND, SORT
+test32: DL_PREPEND
+test33: LL_PREPEND
+test34: CDL_PREPEND
+test35: CDL_PREPEND
+test36: HASH_SELECT
+test37: HASH_CLEAR
+test38: find-or-add test on integer keys in short loop
+test39: HASH_ADD_KEYPTR then HASH_FIND using array element as key pointer
+test40: HASH_ADD_KEYPTR on string keys; pointer equivalent to test15.c
+test41: test LL_FOREACH_SAFE,DL_FOREACH_SAFE,CDL_FOREACH_SAFE
+test42: test LL_SEARCH, LL_SEARCH_SCALAR, and DL and CDL counterparts
+test43: test utarray with intpair objects
+test44: test utarray with int objects
+test45: test utarray with int objects
+test46: test utarray with char* objects
+test47: test utstring
+test48: test utarray of int
+test49: test utarray of str
+test50: test utarray of long
+test51: test utarray of intpair
+test52: test utarray of intchar
+test53: test utstring
+test54: test utstring
+test55: test utstring
+test56: test uthash, utlist and utstring together for #define conflicts etc
+test57: test uthash HASH_ADD_PTR and HASH_FIND_PTR
+test58: test HASH_ITER macro
+test59: sample of multi-level hash
+test60: sample of multi-level hash that also does HASH_DEL and free
+test61: test utarray_find
+test62: test macros used in safe unaligned reads on non-Intel type platforms
+test63: LL_CONCAT test
+test64: DL_CONCAT test
+test65: LRU cache example courtesy of jehiah.cz with modifications
+test66: test example where output variable to HASH_FIND needs extra parens
+test67: test utarray_prev
+test68: test DL_REPLACE_ELEM (Zoltán Lajos Kis)
+test69: test DL_PREPEND_ELEM (Zoltán Lajos Kis)
+test70: test LL_REPLACE_ELEM (Zoltán Lajos Kis)
+test71: test LL_PREPEND_ELEM (Zoltán Lajos Kis)
+test72: test CDL_REPLACE_ELEM (Zoltán Lajos Kis)
+test73: test CDL_PREPEND_ELEM (Zoltán Lajos Kis)
+test74: test utstring with utstring_find (Joe Wei)
+test75: test utstring with utstring_findR (Joe Wei)
+test76: test utstring with _utstring_find (Joe Wei)
+test77: test utstring with _utstring_findR (Joe Wei)
+test78: test utlist "2" family with flexible Prev/Next naming eg. DL_DELETE2
+test79: test HASH_REPLACE
+test80: test utarray_insert past end of array
+test81: test utarray_insert past end of array
+test82: test utarray_inserta past end of array
+test83: test HASH_REPLACE_STR with char[] key
+test84: test HASH_REPLACE_STR with char* key
+test85: test HASH_OVERHEAD on null and non null hash
+test86: test *_APPEND_ELEM / *_PREPEND_ELEM (Thilo Schulz)
+test87: test HASH_ADD_INORDER() macro (Thilo Schulz)
+test88: test alt key-comparison and strlen macros
+test89: test code from the tinydtls project
+test90: regression-test HASH_ADD_KEYPTR_INORDER (IronBug)
+test91: test LL_INSERT_INORDER etc.
+test92: HASH_NONFATAL_OOM
+test93: alt_fatal
+test94: utlist with fields named other than 'next' and 'prev'
+test95: utstack
+test96: HASH_FUNCTION + HASH_KEYCMP
+
+Other Make targets
+================================================================================
+pedantic:  makes the tests with extra CFLAGS for pedantic compiling
+cplusplus: compiles all the C tests using the C++ compiler to test compatibility
+debug:     makes the tests with debugging symbols and no optimization
+example:   builds the 'example' program from the user guide
+================================================================================
+
+Testing a specific hash function
+--------------------------------
+Set EXTRA_CFLAGS with this Makefile to use a specific hash function:
+   EXTRA_CFLAGS=-DHASH_FUNCTION=HASH_BER make
+
+Other files
+================================================================================
+keystats:  key statistics analyzer. See the uthash User Guide.
+emit_keys: reads a data file of unique strings, emits as keys w/HASH_EMIT_KEYS=1
+all_funcs: a script which executes the test suite with every hash function
+win32tests:builds and runs the test suite under Microsoft Visual Studio
+
+LINUX/FREEBSD
+-------------
+hashscan:  tool to examine a running process and get info on its hash tables
+test_sleep:used as a subject for inspection by hashscan
+
+Manual performance testing
+================================================================================
+  # test performance characteristics on keys that are English dictionary words
+  emit_keys /usr/share/dict/words > words.keys
+  ./keystats words.keys
+

c/ext/uthash/tests/all_funcs

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+function proceed {
+  read -p "proceed ? [n] " response
+  if [ "$response" != "y" ]; then exit -1; fi
+}
+
+make clean tests_only EXTRA_CFLAGS='-DHASH_FUNCTION=HASH_BER'; proceed
+make clean tests_only EXTRA_CFLAGS='-DHASH_FUNCTION=HASH_FNV'; proceed
+make clean tests_only EXTRA_CFLAGS='-DHASH_FUNCTION=HASH_JEN'; proceed
+make clean tests_only EXTRA_CFLAGS='-DHASH_FUNCTION=HASH_OAT'; proceed
+make clean tests_only EXTRA_CFLAGS='-DHASH_FUNCTION=HASH_SAX'; proceed
+make clean tests_only EXTRA_CFLAGS='-DHASH_FUNCTION=HASH_SFH'; proceed

c/ext/uthash/tests/bloom_perf.c

@@ -0,0 +1,82 @@
+#include <stdlib.h>   /* malloc */
+#include <sys/time.h> /* gettimeofday */
+#include <errno.h>    /* perror */
+#include <stdio.h>    /* printf */
+#include "uthash.h"
+
+#define BUFLEN 20
+#if 0
+#undef uthash_expand_fyi
+#define uthash_expand_fyi(tbl) printf("expanding to %d buckets\n", tbl->num_buckets)
+#endif
+
+typedef struct name_rec {
+    char boy_name[BUFLEN];
+    UT_hash_handle hh;
+} name_rec;
+
+int main(int argc,char *argv[])
+{
+    name_rec *name, *names=NULL;
+    char linebuf[BUFLEN];
+    FILE *file;
+    int i=0,j,nloops=3,loopnum=0,miss;
+    struct timeval tv1,tv2;
+    long elapsed_usec;
+    if (argc > 1) {
+        nloops = atoi(argv[1]);
+    }
+
+    if ( (file = fopen( "test14.dat", "r" )) == NULL ) {
+        perror("can't open: ");
+        exit(-1);
+    }
+
+    while (fgets(linebuf,BUFLEN,file) != NULL) {
+        i++;
+        if ( (name = (name_rec*)malloc(sizeof(name_rec))) == NULL) {
+            exit(-1);
+        }
+        strcpy(name->boy_name, linebuf);
+        HASH_ADD_STR(names,boy_name,name);
+    }
+
+again:
+    if (fseek(file,0,SEEK_SET) == -1) {
+        fprintf(stderr,"fseek failed: %s\n", strerror(errno));
+    }
+    j=0;
+
+    if (gettimeofday(&tv1,NULL) == -1) {
+        perror("gettimeofday: ");
+    }
+    while (fgets(linebuf,BUFLEN,file) != NULL) {
+        /* if we do 10 loops, the first has a 0% miss rate,
+         * the second has a 10% miss rate, etc */
+        miss = ((rand()*1.0/RAND_MAX) < (loopnum*1.0/nloops)) ? 1 : 0;
+        /* generate a miss if we want one */
+        if (miss) {
+            linebuf[0]++;
+            if (linebuf[1] != '\0') {
+                linebuf[1]++;
+            }
+        }
+        HASH_FIND_STR(names,linebuf,name);
+        if (name) {
+            j++;
+        }
+    }
+    if (gettimeofday(&tv2,NULL) == -1) {
+        perror("gettimeofday: ");
+    }
+    elapsed_usec = ((tv2.tv_sec - tv1.tv_sec) * 1000000) + (tv2.tv_usec - tv1.tv_usec);
+    printf("lookup on %d of %d (%.2f%%) names succeeded (%.2f usec)\n", j, i,
+           j*100.0/i, (double)(elapsed_usec));
+    if (++loopnum < nloops) {
+        goto again;
+    }
+    fclose(file);
+
+    return 0;
+}
+

c/ext/uthash/tests/bloom_perf.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+BITS="16"
+
+cc -I../src  -O3 -Wall   -m64    bloom_perf.c   -o bloom_perf.none
+for bits in $BITS
+do
+cc -I../src  -DHASH_BLOOM=$bits -O3 -Wall   -m64    bloom_perf.c   -o bloom_perf.$bits
+done
+
+for bits in none $BITS
+do
+echo
+echo "using $bits-bit filter:"
+./bloom_perf.$bits 10
+done
+

c/ext/uthash/tests/do_tests

@@ -0,0 +1,21 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+
+my @tests;
+for (glob "test*[0-9]") {
+    push @tests, $_ if -e "$_.ans";
+}
+
+my $num_failed=0;
+
+for my $test (@tests) {
+    `./$test > $test.out`;
+    `diff $test.out $test.ans`;
+    print "$test failed\n" if $?;
+    $num_failed++ if $?;
+}
+
+print scalar @tests . " tests conducted, $num_failed failed.\n";
+exit $num_failed;

c/ext/uthash/tests/do_tests.cygwin

@@ -0,0 +1,22 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+
+my @tests;
+for (glob "test*[0-9].exe") {
+    push @tests, "$_" if -e substr($_, 0, - 4).".ans";
+}
+
+my $num_failed=0;
+
+for my $test (@tests) {
+    `./$test > $test.out`;
+    my $ansfile = substr($test, 0, - 4).".ans";
+    `diff $test.out $ansfile`;
+    print "$test failed\n" if $?;
+    $num_failed++ if $?;
+}
+
+print scalar @tests . " tests conducted, $num_failed failed.\n";
+exit $num_failed;

c/ext/uthash/tests/do_tests.mingw

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+echo "MinGW test script starting"
+
+for f in test*.exe
+do
+  t=`echo $f | sed s/.exe//`
+  "./$f" > "$t.out"
+  diff -qb "$t.out" "$t.ans"
+  if [ $? -eq 1 ]
+  then
+    echo "$f failed"
+  else
+    true # can't have empty else
+    #echo "$f passed"
+  fi
+done
+
+echo 
+echo "All tests complete"

c/ext/uthash/tests/do_tests_win32.cmd

@@ -0,0 +1,16 @@
+:: this compiles and runs the test suite under Visual Studio 2008
+::@echo off
+call "C:\Program Files\Microsoft Visual Studio 9.0\VC\bin\vcvars32.bat" > vc.out
+::call "C:\Program Files\Microsoft Visual Studio 10.0\VC\bin\vcvars32.bat" > vc.out
+set "COMPILE=cl.exe /I ..\src /EHsc /nologo"
+echo compiling...
+%COMPILE% tdiff.cpp > compile.out
+::for %%f in (test*.c) do %COMPILE% /Tp %%f >> compile.out
+for %%f in (test*.c) do %COMPILE% /Tc %%f >> compile.out
+echo running tests...
+for %%f in (test*.exe) do %%f > %%~nf.out
+echo scanning for failures...
+for %%f in (test*.out) do tdiff %%f %%~nf.ans
+echo tests completed
+::for %%f in (test*.out test*.obj test*.exe vc.out compile.out tdiff.obj tdiff.exe) do del %%f
+pause

c/ext/uthash/tests/emit_keys.c

@@ -0,0 +1,48 @@
+#include <stdlib.h>   /* malloc */
+#include <errno.h>    /* perror */
+#include <stdio.h>    /* printf */
+#include <unistd.h>   /* write */
+
+/* this define must precede uthash.h */
+#define HASH_EMIT_KEYS 1
+#include "uthash.h"
+
+#define BUFLEN 30
+
+typedef struct name_rec {
+    char boy_name[BUFLEN];
+    UT_hash_handle hh;
+} name_rec;
+
+int main(int argc,char *argv[])
+{
+    name_rec *name, *names=NULL;
+    char linebuf[BUFLEN];
+    FILE *file;
+    int i=0;
+
+    if (argc != 2) {
+        fprintf(stderr,"usage: %s file\n", argv[0]);
+        exit(-1);
+    }
+
+    if ( (file = fopen( argv[1], "r" )) == NULL ) {
+        perror("can't open: ");
+        exit(-1);
+    }
+
+    while (fgets(linebuf,BUFLEN,file) != NULL) {
+        name = (name_rec*)malloc(sizeof(name_rec));
+        if (name == NULL) {
+            exit(-1);
+        }
+        strcpy(name->boy_name, linebuf);
+        HASH_ADD_STR(names,boy_name,name);
+        i++;
+    }
+
+    fprintf(stderr,"%d keys emitted.\n", i);
+    fclose(file);
+    return 0;
+}
+

c/ext/uthash/tests/example.c

@@ -0,0 +1,149 @@
+#include <stdio.h>   /* gets */
+#include <stdlib.h>  /* atoi, malloc */
+#include <string.h>  /* strcpy */
+#include "uthash.h"
+
+struct my_struct {
+    int id;                    /* key */
+    char name[10];
+    UT_hash_handle hh;         /* makes this structure hashable */
+};
+
+struct my_struct *users = NULL;
+
+void add_user(int user_id, char *name)
+{
+    struct my_struct *s;
+
+    HASH_FIND_INT(users, &user_id, s);  /* id already in the hash? */
+    if (s == NULL) {
+        s = (struct my_struct*)malloc(sizeof(struct my_struct));
+        s->id = user_id;
+        HASH_ADD_INT(users, id, s);  /* id: name of key field */
+    }
+    strcpy(s->name, name);
+}
+
+struct my_struct *find_user(int user_id)
+{
+    struct my_struct *s;
+
+    HASH_FIND_INT(users, &user_id, s);  /* s: output pointer */
+    return s;
+}
+
+void delete_user(struct my_struct *user)
+{
+    HASH_DEL(users, user);  /* user: pointer to deletee */
+    free(user);
+}
+
+void delete_all()
+{
+    struct my_struct *current_user, *tmp;
+
+    HASH_ITER(hh, users, current_user, tmp) {
+        HASH_DEL(users, current_user);  /* delete it (users advances to next) */
+        free(current_user);             /* free it */
+    }
+}
+
+void print_users()
+{
+    struct my_struct *s;
+
+    for (s = users; s != NULL; s = (struct my_struct*)(s->hh.next)) {
+        printf("user id %d: name %s\n", s->id, s->name);
+    }
+}
+
+int name_sort(struct my_struct *a, struct my_struct *b)
+{
+    return strcmp(a->name, b->name);
+}
+
+int id_sort(struct my_struct *a, struct my_struct *b)
+{
+    return (a->id - b->id);
+}
+
+void sort_by_name()
+{
+    HASH_SORT(users, name_sort);
+}
+
+void sort_by_id()
+{
+    HASH_SORT(users, id_sort);
+}
+
+int main()
+{
+    char in[10];
+    int id = 1, running = 1;
+    struct my_struct *s;
+    unsigned num_users;
+
+    while (running) {
+        printf(" 1. add user\n");
+        printf(" 2. add/rename user by id\n");
+        printf(" 3. find user\n");
+        printf(" 4. delete user\n");
+        printf(" 5. delete all users\n");
+        printf(" 6. sort items by name\n");
+        printf(" 7. sort items by id\n");
+        printf(" 8. print users\n");
+        printf(" 9. count users\n");
+        printf("10. quit\n");
+        gets(in);
+        switch(atoi(in)) {
+            case 1:
+                printf("name?\n");
+                add_user(id++, gets(in));
+                break;
+            case 2:
+                printf("id?\n");
+                gets(in);
+                id = atoi(in);
+                printf("name?\n");
+                add_user(id, gets(in));
+                break;
+            case 3:
+                printf("id?\n");
+                s = find_user(atoi(gets(in)));
+                printf("user: %s\n", s ? s->name : "unknown");
+                break;
+            case 4:
+                printf("id?\n");
+                s = find_user(atoi(gets(in)));
+                if (s) {
+                    delete_user(s);
+                } else {
+                    printf("id unknown\n");
+                }
+                break;
+            case 5:
+                delete_all();
+                break;
+            case 6:
+                sort_by_name();
+                break;
+            case 7:
+                sort_by_id();
+                break;
+            case 8:
+                print_users();
+                break;
+            case 9:
+                num_users = HASH_COUNT(users);
+                printf("there are %u users\n", num_users);
+                break;
+            case 10:
+                running = 0;
+                break;
+        }
+    }
+
+    delete_all();  /* free any structures */
+    return 0;
+}

c/ext/uthash/tests/hashscan.c

@@ -0,0 +1,678 @@
+/*
+Copyright (c) 2005-2021, Troy D. Hanson    http://troydhanson.github.com/uthash/
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <sys/types.h>  /* on OSX, must come before ptrace.h */
+#include <sys/ptrace.h>
+#include <unistd.h>
+#include <sys/wait.h>
+#include <assert.h>
+
+#ifdef __FreeBSD__
+#include <sys/param.h>  /* MAXPATHLEN */
+#include <vm/vm.h>      /* VM_PROT_* flags */
+#endif
+
+#if defined(PT_ATTACH) && !defined(PTRACE_ATTACH)
+#define PTRACE_ATTACH PT_ATTACH
+#define PTRACE_DETACH PT_DETACH
+#endif
+
+/* need this defined so offsetof can give us bloom offsets in UT_hash_table */
+#define HASH_BLOOM 16
+#include "uthash.h"
+
+#ifdef __FreeBSD__
+typedef struct {
+    void *start;
+    void *end;
+} vma_t;
+#else
+typedef struct {
+    off_t start;
+    off_t end;
+    char perms[4];   /* rwxp */
+    char device[5];  /* fd:01 or 00:00 */
+} vma_t;
+#endif
+
+const uint32_t sig = HASH_SIGNATURE;
+int verbose=0;
+int getkeys=0;
+
+#define vv(...)  do {if (verbose>0) printf(__VA_ARGS__);} while(0)
+#define vvv(...) do {if (verbose>1) printf(__VA_ARGS__);} while(0)
+
+/* these id's are arbitrary, only meaningful within this file */
+#define JEN 1
+#define BER 2
+#define SFH 3
+#define SAX 4
+#define FNV 5
+#define OAT 6
+#define NUM_HASH_FUNCS 7 /* includes id 0, the non-function */
+const char *hash_fcns[] = {"???","JEN","BER","SFH","SAX","FNV","OAT"};
+
+/* given a peer key/len/hashv, reverse engineer its hash function */
+static int infer_hash_function(char *key, size_t keylen, uint32_t hashv)
+{
+    uint32_t ohashv;
+    /* BER SAX FNV OAT JEN SFH */
+    HASH_JEN(key,keylen,ohashv);
+    if (ohashv == hashv) {
+        return JEN;
+    }
+    HASH_BER(key,keylen,ohashv);
+    if (ohashv == hashv) {
+        return BER;
+    }
+    HASH_SFH(key,keylen,ohashv);
+    if (ohashv == hashv) {
+        return SFH;
+    }
+    HASH_SAX(key,keylen,ohashv);
+    if (ohashv == hashv) {
+        return SAX;
+    }
+    HASH_FNV(key,keylen,ohashv);
+    if (ohashv == hashv) {
+        return FNV;
+    }
+    HASH_OAT(key,keylen,ohashv);
+    if (ohashv == hashv) {
+        return OAT;
+    }
+    return 0;
+}
+
+/* read peer's memory from addr for len bytes, store into our dst */
+#ifdef __FreeBSD__
+static int read_mem(void *dst, pid_t pid, void *start, size_t len)
+{
+    struct ptrace_io_desc io_desc;
+    int ret;
+
+    io_desc.piod_op = PIOD_READ_D;
+    io_desc.piod_offs = start;
+    io_desc.piod_addr = dst;
+    io_desc.piod_len = len;
+
+    ret = ptrace(PT_IO, pid, (void *) &io_desc, 0);
+
+    if (ret) {
+        vv("read_mem: ptrace failed: %s\n", strerror(errno));
+        return -1;
+    } else if (io_desc.piod_len != len) {
+        vv("read_mem: short read!\n");
+        return -1;
+    }
+
+    return 0;
+}
+#else
+static int read_mem(void *dst, int fd, off_t start, size_t len)
+{
+    int rc;
+    size_t bytes_read=0;
+    if (lseek(fd, start, SEEK_SET) == (off_t)-1) {
+        fprintf(stderr, "lseek failed: %s\n", strerror(errno));
+        return -1;
+    }
+    while ( len && ((rc=read(fd, (char*)dst+bytes_read, len)) > 0)) {
+        len -= rc;
+        bytes_read += rc;
+    }
+    if (rc==-1) {
+        vv("read_mem failed (%s)\n",strerror(errno));
+    }
+    if ((len != 0 && rc >= 0)) {
+        vv("INTERNAL ERROR\n");
+    }
+    return (rc == -1) ? -1 : 0;
+}
+#endif
+
+/* later compensate for possible presence of bloom filter */
+static char *tbl_from_sig_addr(char *sig)
+{
+    return (sig - offsetof(UT_hash_table,signature));
+}
+
+#define HS_BIT_TEST(v,i) (v[i/8] & (1U << (i%8)))
+static void found(int fd, char* peer_sig, pid_t pid)
+{
+    UT_hash_table *tbl=NULL;
+    UT_hash_bucket *bkts=NULL;
+    UT_hash_handle hh;
+    size_t i, bloom_len, bloom_bitlen,  bloom_on_bits=0,bloom_off_bits=0;
+    char *peer_tbl, *peer_bloom_sig, *peer_bloom_nbits, *peer_bloombv_ptr,
+         *peer_bloombv, *peer_bkts, *peer_hh, *key=NULL;
+    const char *peer_key;
+    const char *hash_fcn = NULL;
+    unsigned char *bloombv=NULL;
+    static int fileno=0;
+    char keyfile[50];
+    unsigned char bloom_nbits=0;
+    int keyfd=-1, mode=S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH,
+        hash_fcn_hits[NUM_HASH_FUNCS], hash_fcn_winner;
+    unsigned max_chain=0;
+    uint32_t bloomsig;
+    int has_bloom_filter_fields = 0;
+
+    for(i=0; i < NUM_HASH_FUNCS; i++) {
+        hash_fcn_hits[i]=0;
+    }
+
+    if (getkeys) {
+        snprintf(keyfile, sizeof(keyfile), "/tmp/%u-%u.key", (unsigned)pid,fileno++);
+        if ( (keyfd = open(keyfile, O_WRONLY|O_CREAT|O_TRUNC, mode)) == -1) {
+            fprintf(stderr, "can't open %s: %s\n", keyfile, strerror(errno));
+            exit(-1);
+        }
+    }
+
+    vv("found signature at peer %p\n", (void*)peer_sig);
+    peer_tbl = tbl_from_sig_addr(peer_sig);
+    vvv("reading table at peer %p\n", (void*)peer_tbl);
+
+    if ( (tbl = (UT_hash_table*)malloc(sizeof(UT_hash_table))) == NULL) {
+        fprintf(stderr, "out of memory\n");
+        exit(-1);
+    }
+#ifdef __FreeBSD__
+    if (read_mem(tbl, pid, (void *)peer_tbl, sizeof(UT_hash_table)) != 0) {
+#else
+    if (read_mem(tbl, fd, (off_t)peer_tbl, sizeof(UT_hash_table)) != 0) {
+#endif
+        fprintf(stderr, "failed to read peer memory\n");
+        goto done;
+    }
+
+    /* got the table. how about the buckets */
+    peer_bkts = (char*)tbl->buckets;
+    vvv("reading %u buckets at peer %p\n", tbl->num_buckets, (void*)peer_bkts);
+    bkts = (UT_hash_bucket*)malloc(sizeof(UT_hash_bucket)*tbl->num_buckets);
+    if (bkts == NULL) {
+        fprintf(stderr, "out of memory\n");
+        goto done;
+    }
+#ifdef __FreeBSD__
+    if (read_mem(bkts, pid, (void *)peer_bkts, sizeof(UT_hash_bucket)*tbl->num_buckets) != 0) {
+#else
+    if (read_mem(bkts, fd, (off_t)peer_bkts, sizeof(UT_hash_bucket)*tbl->num_buckets) != 0) {
+#endif
+        fprintf(stderr, "failed to read peer memory\n");
+        goto done;
+    }
+
+    vvv("scanning %u peer buckets\n", tbl->num_buckets);
+    for(i=0; i < tbl->num_buckets; i++) {
+        vvv("bucket %u has %u items\n",  (unsigned)i, (unsigned)(bkts[i].count));
+        if (bkts[i].count > max_chain) {
+            max_chain = bkts[i].count;
+        }
+        if (bkts[i].expand_mult) {
+            vvv("  bucket %u has expand_mult %u\n",  (unsigned)i, (unsigned)(bkts[i].expand_mult));
+        }
+
+        vvv("scanning bucket %u chain:\n",  (unsigned)i);
+        peer_hh = (char*)bkts[i].hh_head;
+        while(peer_hh) {
+#ifdef __FreeBSD__
+            if (read_mem(&hh, pid, (void *)peer_hh, sizeof(hh)) != 0) {
+#else
+            if (read_mem(&hh, fd, (off_t)peer_hh, sizeof(hh)) != 0) {
+#endif
+                fprintf(stderr, "failed to read peer memory\n");
+                goto done;
+            }
+            if ((char*)hh.tbl != peer_tbl) {
+                goto done;
+            }
+            peer_hh = (char*)hh.hh_next;
+            peer_key = (const char*)(hh.key);
+            /* malloc space to read the key, and read it */
+            if ( (key = (char*)malloc(sizeof(hh.keylen))) == NULL) {
+                fprintf(stderr, "out of memory\n");
+                exit(-1);
+            }
+#ifdef __FreeBSD__
+            if (read_mem(key, pid, (void*)peer_key, hh.keylen) != 0) {
+#else
+            if (read_mem(key, fd, (off_t)peer_key, hh.keylen) != 0) {
+#endif
+                fprintf(stderr, "failed to read peer memory\n");
+                goto done;
+            }
+            hash_fcn_hits[infer_hash_function(key,hh.keylen,hh.hashv)]++;
+            /* write the key if requested */
+            if (getkeys) {
+                write(keyfd, &hh.keylen, sizeof(unsigned));
+                write(keyfd, key, hh.keylen);
+            }
+            free(key);
+            key=NULL;
+        }
+    }
+
+    /* does it have a bloom filter?  */
+    peer_bloom_sig =   peer_tbl + offsetof(UT_hash_table, bloom_sig);
+    peer_bloombv_ptr = peer_tbl + offsetof(UT_hash_table, bloom_bv);
+    peer_bloom_nbits = peer_tbl + offsetof(UT_hash_table, bloom_nbits);
+    vvv("looking for bloom signature at peer %p\n", (void*)peer_bloom_sig);
+#ifdef __FreeBSD__
+    if ((read_mem(&bloomsig, pid, (void *)peer_bloom_sig, sizeof(uint32_t)) == 0)  &&
+            (bloomsig == HASH_BLOOM_SIGNATURE)) {
+#else
+    if ((read_mem(&bloomsig, fd, (off_t)peer_bloom_sig, sizeof(uint32_t)) == 0)  &&
+            (bloomsig == HASH_BLOOM_SIGNATURE)) {
+#endif
+        vvv("bloom signature (%x) found\n",bloomsig);
+        /* bloom found. get at bv, nbits */
+#ifdef __FreeBSD__
+        if (read_mem(&bloom_nbits, pid, (void *)peer_bloom_nbits, sizeof(char)) == 0) {
+#else
+        if (read_mem(&bloom_nbits, fd, (off_t)peer_bloom_nbits, sizeof(char)) == 0) {
+#endif
+            /* scan bloom filter, calculate saturation */
+            bloom_bitlen = (1ULL << bloom_nbits);
+            bloom_len = (bloom_bitlen / 8) + ((bloom_bitlen % 8) ? 1 : 0);
+            vvv("bloom bitlen is %u, bloom_bytelen is %u\n", (unsigned)bloom_bitlen, (unsigned)bloom_len);
+            if ( (bloombv = (unsigned char*)malloc(bloom_len)) == NULL) {
+                fprintf(stderr, "out of memory\n");
+                exit(-1);
+            }
+            /* read the address of the bitvector in the peer, then read the bv itself */
+#ifdef __FreeBSD__
+            if ((read_mem(&peer_bloombv, pid, (void *)peer_bloombv_ptr, sizeof(void*)) == 0) &&
+                    (read_mem(bloombv, pid, (void *)peer_bloombv, bloom_len) == 0)) {
+#else
+            if ((read_mem(&peer_bloombv, fd, (off_t)peer_bloombv_ptr, sizeof(void*)) == 0) &&
+                    (read_mem(bloombv, fd, (off_t)peer_bloombv, bloom_len) == 0)) {
+#endif
+                /* calculate saturation */
+                vvv("read peer bloom bitvector from %p (%u bytes)\n", (void*)peer_bloombv, (unsigned)bloom_len);
+                for(i=0; i < bloom_bitlen; i++) {
+                    if (HS_BIT_TEST(bloombv,(unsigned)i)) {
+                        /* vvv("bit %u set\n",(unsigned)i); */
+                        bloom_on_bits++;
+                    } else {
+                        bloom_off_bits++;
+                    }
+                }
+                has_bloom_filter_fields = 1;
+                vvv("there were %u on_bits among %u total bits\n", (unsigned)bloom_on_bits, (unsigned)bloom_bitlen);
+            }
+        }
+    }
+
+    /* choose apparent hash function */
+    hash_fcn_winner=0;
+    for(i=0; i<NUM_HASH_FUNCS; i++) {
+        if (hash_fcn_hits[i] > hash_fcn_hits[hash_fcn_winner]) {
+            hash_fcn_winner=i;
+        }
+    }
+    hash_fcn = hash_fcns[hash_fcn_winner];
+
+    /*
+    Address            ideal    items  buckets mc fl bloom   sat fcn keys saved to
+    ------------------ ----- -------- -------- -- -- ----- ----- --- -------------
+    0x10aa4090           98% 10000000 32000000 10 ok             BER /tmp/9110-0.key
+    0x10abcdef          100% 10000000 32000000  9 NX    27   12% BER /tmp/9110-1.key
+    */
+    printf("Address            ideal    items  buckets mc fl bloom   sat fcn keys saved to\n");
+    printf("------------------ ----- -------- -------- -- -- ----- ----- --- -------------\n");
+    if (has_bloom_filter_fields) {
+        printf("%-18p %4.0f%% %8u %8u %2u %2s %5u %4.0f%c %3s %s\n",
+               (void*)peer_tbl,
+               (tbl->num_items - tbl->nonideal_items) * 100.0 / tbl->num_items,
+               tbl->num_items,
+               tbl->num_buckets,
+               max_chain,
+               tbl->noexpand ? "NX" : "ok",
+               bloom_nbits,
+               bloom_on_bits * 100.0 / bloom_bitlen, '%',
+               hash_fcn,
+               (getkeys ? keyfile : ""));
+    } else {
+        printf("%-18p %4.0f%% %8u %8u %2u %2s %5s %4s%c %3s %s\n",
+               (void*)peer_tbl,
+               (tbl->num_items - tbl->nonideal_items) * 100.0 / tbl->num_items,
+               tbl->num_items,
+               tbl->num_buckets,
+               max_chain,
+               tbl->noexpand ? "NX" : "ok",
+               "",
+               "", ' ',
+               hash_fcn,
+               (getkeys ? keyfile : ""));
+    }
+
+#if 0
+    printf("read peer tbl:\n");
+    printf("num_buckets: %u\n", tbl->num_buckets);
+    printf("num_items: %u\n", tbl->num_items);
+    printf("nonideal_items: %u (%.2f%%)\n", tbl->nonideal_items,
+           tbl->nonideal_items*100.0/tbl->num_items);
+    printf("expand: %s\n", tbl->noexpand ? "inhibited": "normal");
+    if (getkeys) {
+        printf("keys written to %s\n", keyfile);
+    }
+#endif
+
+done:
+    if (bkts) {
+        free(bkts);
+    }
+    if (tbl) {
+        free(tbl);
+    }
+    if (key) {
+        free(key);
+    }
+    if (keyfd != -1) {
+        close(keyfd);
+    }
+    if (bloombv) {
+        free(bloombv);
+    }
+}
+
+
+#ifdef __FreeBSD__
+static void sigscan(pid_t pid, void *start, void *end, uint32_t sig)
+{
+    struct ptrace_io_desc io_desc;
+    int page_size = getpagesize();
+    char *buf;
+    char *pos;
+
+    /* make sure page_size is a multiple of the signature size, code below assumes this */
+    assert(page_size % sizeof(sig) == 0);
+
+    buf = malloc(page_size);
+
+    if (buf == NULL) {
+        fprintf(stderr, "malloc failed in sigscan()\n");
+        return;
+    }
+
+    io_desc.piod_op = PIOD_READ_D;
+    io_desc.piod_offs = start;
+    io_desc.piod_addr = buf;
+    io_desc.piod_len = page_size;
+
+    /* read in one page after another and search sig */
+    while(!ptrace(PT_IO, pid, (void *) &io_desc, 0)) {
+        if (io_desc.piod_len != page_size) {
+            fprintf(stderr, "PT_IO returned less than page size in sigscan()\n");
+            return;
+        }
+
+        /* iterate over the the page using the signature size and look for the sig */
+        for (pos = buf; pos < (buf + page_size); pos += sizeof(sig)) {
+            if (*(uint32_t *) pos == sig) {
+                found(pid, (char *) io_desc.piod_offs + (pos - buf), pid);
+            }
+        }
+
+        /*
+         * 'end' is inclusive (the address of the last valid byte), so if the current offset
+         * plus a page is beyond 'end', we're already done. since all vm map entries consist
+         * of entire pages and 'end' is inclusive, current offset plus one page should point
+         * exactly one byte beyond 'end'. this is assert()ed below to be on the safe side.
+         */
+        if (io_desc.piod_offs + page_size > end) {
+            assert(io_desc.piod_offs + page_size == (end + 1));
+            break;
+        }
+
+        /* advance to the next page */
+        io_desc.piod_offs += page_size;
+    }
+}
+#else
+static void sigscan(int fd, off_t start, off_t end, uint32_t sig, pid_t pid)
+{
+    int rlen;
+    uint32_t u;
+    off_t at=0;
+
+    if (lseek(fd, start, SEEK_SET) == (off_t)-1) {
+        fprintf(stderr, "lseek failed: %s\n", strerror(errno));
+        return;
+    }
+
+    while ( (rlen = read(fd,&u,sizeof(u))) == sizeof(u)) {
+        if (!memcmp(&u,&sig,sizeof(u))) {
+            found(fd, (char*)(start+at),pid);
+        }
+        at += sizeof(u);
+        if ((off_t)(at + sizeof(u)) > end-start) {
+            break;
+        }
+    }
+
+    if (rlen == -1) {
+        //fprintf(stderr,"read failed: %s\n", strerror(errno));
+        //exit(-1);
+    }
+}
+#endif
+
+
+#ifdef __FreeBSD__
+static int scan(pid_t pid)
+{
+    vma_t *vmas=NULL, vma;
+    unsigned i, num_vmas = 0;
+    int ret;
+    struct ptrace_vm_entry vm_entry;
+    char path[MAXPATHLEN];
+
+    vv("attaching to peer\n");
+    if (ptrace(PT_ATTACH,pid,NULL,0) == -1) {
+        fprintf(stderr,"failed to attach to %u: %s\n", (unsigned)pid, strerror(errno));
+        exit(EXIT_FAILURE);
+    }
+    vv("waiting for peer to suspend temporarily\n");
+    if (waitpid(pid,NULL,0) != pid) {
+        fprintf(stderr,"failed to wait for pid %u: %s\n",(unsigned)pid, strerror(errno));
+        goto die;
+    }
+
+    /* read memory map using ptrace */
+    vv("listing peer virtual memory areas\n");
+    vm_entry.pve_entry = 0;
+    vm_entry.pve_path = path; /* not used but required to make vm_entry.pve_pathlen work */
+    while(1) {
+        /* set pve_pathlen every turn, it gets overwritten by ptrace */
+        vm_entry.pve_pathlen = MAXPATHLEN;
+        errno = 0;
+
+        ret = ptrace(PT_VM_ENTRY, pid, (void *) &vm_entry, 0);
+
+        if (ret) {
+            if (errno == ENOENT) {
+                /* we've reached the last entry */
+                break;
+            }
+            fprintf(stderr, "fetching vm map entry failed: %s (%i)\n", strerror(errno), errno);
+            goto die;
+        }
+
+        vvv("vmmap entry: start: %p, end: %p", (void *) vm_entry.pve_start, (void *) vm_entry.pve_end);
+
+        /* skip unreadable or vnode-backed entries */
+        if (!(vm_entry.pve_prot & VM_PROT_READ) || vm_entry.pve_pathlen > 0) {
+            vvv(" -> skipped (not readable or vnode-backed)\n");
+            vm_entry.pve_path[0] = 0;
+            continue;
+        }
+
+        /* useful entry, add to list */
+        vvv(" -> will be scanned\n");
+        vma.start = (void *)vm_entry.pve_start;
+        vma.end = (void *)vm_entry.pve_end;
+        vmas = (vma_t *) realloc(vmas, (num_vmas + 1) * sizeof(vma_t));
+        if (vmas == NULL) {
+            exit(-1);
+        }
+        vmas[num_vmas++] = vma;
+    }
+
+    vv("peer has %u virtual memory areas\n", num_vmas);
+
+    /* look for the hash signature */
+    vv("scanning peer memory for hash table signatures\n");
+    for(i=0; i<num_vmas; i++) {
+        vma = vmas[i];
+        sigscan(pid, vma.start, vma.end, sig);
+    }
+
+die:
+    vv("detaching and resuming peer\n");
+    if (ptrace(PT_DETACH, pid, NULL, 0) == -1) {
+        fprintf(stderr,"failed to detach from %u: %s\n", (unsigned)pid, strerror(errno));
+    }
+    return 0;
+}
+# else
+static int scan(pid_t pid)
+{
+    FILE *mapf;
+    char mapfile[30], memfile[30], line[100];
+    vma_t *vmas=NULL, vma;
+    unsigned i, num_vmas = 0;
+    int memfd;
+    void *pstart, *pend, *unused;
+
+    /* attach to the target process and wait for it to suspend */
+    vv("attaching to peer\n");
+    if (ptrace(PTRACE_ATTACH, pid, NULL, 0) == -1) {
+        fprintf(stderr,"failed to attach to %u: %s\n", (unsigned)pid, strerror(errno));
+        exit(-1);
+    }
+    vv("waiting for peer to suspend temporarily\n");
+    if (waitpid(pid,NULL,0) != pid) {
+        fprintf(stderr,"failed to wait for pid %u: %s\n",(unsigned)pid, strerror(errno));
+        goto die;
+    }
+
+    /* get ready to open its memory map. this gives us its valid memory areas */
+    snprintf(mapfile,sizeof(mapfile),"/proc/%u/maps",(unsigned)pid);
+    snprintf(memfile,sizeof(memfile),"/proc/%u/mem", (unsigned)pid);
+    vv("opening peer memory map [%s]\n", mapfile);
+    if ( (mapf = fopen(mapfile,"r")) == NULL) {
+        fprintf(stderr,"failed to open %s: %s\n", mapfile, strerror(errno));
+        goto die;
+    }
+    vv("listing peer virtual memory areas\n");
+    while(fgets(line,sizeof(line),mapf)) {
+        if (sscanf(line, "%p-%p %4c %p %5c", &pstart, &pend, vma.perms,
+                   &unused, vma.device) == 5) {
+            vma.start = (off_t)pstart;
+            vma.end = (off_t)pend;
+            if (vma.perms[0] != 'r') {
+                continue;    /* only readable vma's */
+            }
+            if (memcmp(vma.device,"fd",2)==0) {
+                continue;    /* skip mapped files */
+            }
+            vmas = (vma_t*)realloc(vmas, (num_vmas+1) * sizeof(vma_t));
+            if (vmas == NULL) {
+                exit(-1);
+            }
+            vmas[num_vmas++] = vma;
+        }
+    }
+    vv("peer has %u virtual memory areas\n",num_vmas);
+    fclose(mapf);
+
+    /* ok, open up its memory and start looking around in there */
+    vv("opening peer memory\n");
+    if ( (memfd=open(memfile,O_RDONLY)) == -1) {
+        fprintf(stderr,"failed to open %s: %s\n", memfile, strerror(errno));
+        goto die;
+    }
+    /* look for the hash signature */
+    vv("scanning peer memory for hash table signatures\n");
+    for(i=0; i<num_vmas; i++) {
+        vma = vmas[i];
+        pstart = (void*)vma.start;
+        pend = (void*)vma.end;
+        /*fprintf(stderr,"scanning %p-%p %.4s %.5s\n", pstart, pend,
+                  vma.perms, vma.device);*/
+        sigscan(memfd, vma.start, vma.end, sig, pid);
+    }
+
+    /* done. close memory and detach. this resumes the target process */
+    close(memfd);
+
+die:
+    vv("detaching and resuming peer\n");
+    if (ptrace(PTRACE_DETACH, pid, NULL, 0) == -1) {
+        fprintf(stderr,"failed to detach from %u: %s\n", (unsigned)pid, strerror(errno));
+    }
+    return 0;
+}
+#endif
+
+
+static int usage(const char *prog)
+{
+    fprintf(stderr,"usage: %s [-v] [-k] <pid>\n", prog);
+    return -1;
+}
+
+int main(int argc, char *argv[])
+{
+    int opt;
+
+    while ( (opt = getopt(argc, argv, "kv")) != -1) {
+        switch (opt) {
+            case 'v':
+                verbose++;
+                break;
+            case 'k':
+                getkeys++;
+                break;
+            default:
+                return usage(argv[0]);
+        }
+    }
+
+    if (optind < argc) {
+        pid_t pid = atoi(argv[optind++]);
+        return scan(pid);
+    } else {
+        return usage(argv[0]);
+    }
+}

c/ext/uthash/tests/keystats

@@ -0,0 +1,42 @@
+#!/usr/bin/perl
+
+use strict;
+
+use FindBin;
+
+sub usage {
+  print "usage: keystats [-v] keyfile\n";
+  print "usage: keystats [-p <pct> [-v]] keyfile\n";
+  exit -1;
+}
+
+usage if ((@ARGV == 0) or ($ARGV[0] eq '-h'));
+
+my @exes = glob "'$FindBin::Bin/keystat.???'";
+
+my %stats;
+for my $exe (@exes) {
+    $exe =~ s/\ /\\ /g;
+    $stats{$exe} = `$exe @ARGV`;
+    delete $stats{$exe} if ($? != 0); # omit hash functions that fail to produce stats (nx)
+}
+
+print( "fcn  ideal%     #items   #buckets  dup%  fl   add_usec  find_usec  del-all usec\n");
+printf("---  ------ ---------- ---------- -----  -- ---------- ----------  ------------\n");
+for my $exe (sort statsort keys %stats) {
+    my ($ideal,$items,$bkts,$dups,$ok,$add,$find,$del) = split /,/, $stats{$exe};
+
+    # convert 0-1 values to percentages
+    $dups = $items ? (100.0 * $dups / $items) : 0.0;
+    $ideal = 100.0 * $ideal;
+
+    printf("%3s  %5.1f%% %10d %10d %4.0f%%  %2s %10d %10d  %12d\n", substr($exe,-3,3),
+        $ideal,$items,$bkts,$dups,$ok,$add,$find,$del);
+}
+
+# sort on hash_q (desc) then by find_usec (asc)
+sub statsort {
+    my @a_stats = split /,/, $stats{$a};
+    my @b_stats = split /,/, $stats{$b};
+    return ($b_stats[0] <=> $a_stats[0]) || ($a_stats[-1] <=> $b_stats[-1]);
+}

c/ext/uthash/tests/lru_cache/Makefile

@@ -0,0 +1,21 @@
+CC=gcc
+
+CFLAGS+=-W -Werror -Wall -Wextra -std=c99 \
+	-D_FORTIFY_SOURCE=2 -fstack-protector -g \
+	-Wformat=2 -pedantic -pedantic-errors \
+	-D_GNU_SOURCE=1 -D_BSD_SOURCE=1 \
+	-I../../src
+
+LDFLAGS+=-pthread
+
+cache: main.o cache.o
+	$(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) main.o cache.o -o cache
+
+main.o: main.c
+	$(CC) $(CPPFLAGS) $(CFLAGS) -c main.c -o main.o
+
+cache.o: cache.c
+	$(CC) $(CPPFLAGS) $(CFLAGS) -c cache.c -o cache.o
+
+clean:
+	rm -f cache *.o

c/ext/uthash/tests/lru_cache/cache.c

@@ -0,0 +1,221 @@
+/*
+ * =====================================================================================
+ *
+ *       Filename:  cache.c
+ *
+ *    Description:  A simple cache
+ *
+ *        Version:  1.0
+ *        Created:  04/11/2013 02:31:02 PM
+ *       Revision:  none
+ *       Compiler:  gcc
+ *
+ *         Author:  Oliver Lorenz (ol), olli@olorenz.org
+ *        Company:  https://olorenz.org
+ *        License:  This is licensed under the same terms as uthash itself
+ *
+ * =====================================================================================
+ */
+
+#include <errno.h>
+#include <pthread.h>
+#include <stdlib.h>
+#include "cache.h"
+#include "uthash.h"
+
+/**
+ * A cache entry
+ */
+struct foo_cache_entry {
+	char *key; /**<The key */
+	void *data; /**<Payload */
+	UT_hash_handle hh; /**<Hash Handle for uthash */
+};
+#define KEY_MAX_LENGTH		32
+
+/**
+ * A cache object
+ */
+struct foo_cache {
+	size_t max_entries; /**<Amount of entries this cache object can hold */
+	pthread_rwlock_t cache_lock; /**<A lock for concurrent access */
+	struct foo_cache_entry *entries; /**<Head pointer for uthash */
+	void (*free_cb) (void *element);/**<Callback function to free cache entries */
+};
+
+/** Creates a new cache object
+
+    @param dst
+    Where the newly allocated cache object will be stored in
+
+    @param capacity
+    The maximum number of elements this cache object can hold
+
+    @return EINVAL if dst is NULL, ENOMEM if malloc fails, 0 otherwise
+*/
+int foo_cache_create(struct foo_cache **dst, const size_t capacity,
+		     void (*free_cb) (void *element))
+{
+	struct foo_cache *new = NULL;
+	int rv;
+
+	if (!dst)
+		return EINVAL;
+
+	if ((new = malloc(sizeof(*new))) == NULL)
+		return ENOMEM;
+
+	if ((rv = pthread_rwlock_init(&(new->cache_lock), NULL)) != 0)
+		goto err_out;
+
+	new->max_entries = capacity;
+	new->entries = NULL;
+	new->free_cb = free_cb;
+	*dst = new;
+	return 0;
+
+err_out:
+	if (new)
+		free(new);
+	return rv;
+}
+
+/** Frees an allocated cache object
+
+    @param cache
+    The cache object to free
+
+    @param keep_data
+    Whether to free contained data or just delete references to it
+
+    @return EINVAL if cache is NULL, 0 otherwise
+*/
+int foo_cache_delete(struct foo_cache *cache, int keep_data)
+{
+	struct foo_cache_entry *entry, *tmp;
+	int rv;
+
+	if (!cache)
+		return EINVAL;
+
+	rv = pthread_rwlock_wrlock(&(cache->cache_lock));
+	if (rv)
+		return rv;
+
+	if (keep_data) {
+		HASH_CLEAR(hh, cache->entries);
+	} else {
+		HASH_ITER(hh, cache->entries, entry, tmp) {
+			HASH_DEL(cache->entries, entry);
+			if (cache->free_cb)
+				cache->free_cb(entry->data);
+			free(entry);
+		}
+	}
+	(void)pthread_rwlock_unlock(&(cache->cache_lock));
+	(void)pthread_rwlock_destroy(&(cache->cache_lock));
+	free(cache);
+	cache = NULL;
+	return 0;
+}
+
+/** Checks if a given key is in the cache
+
+    @param cache
+    The cache object
+
+    @param key
+    The key to look-up
+
+    @param result
+    Where to store the result if key is found.
+
+    A warning: Even though result is just a pointer,
+    you have to call this function with a **ptr,
+    otherwise this will blow up in your face.
+
+    @return EINVAL if cache is NULL, 0 otherwise
+*/
+int foo_cache_lookup(struct foo_cache *cache, char *key, void *result)
+{
+	int rv;
+	struct foo_cache_entry *tmp = NULL;
+	char **dirty_hack = result;
+
+	if (!cache || !key || !result)
+		return EINVAL;
+
+	rv = pthread_rwlock_wrlock(&(cache->cache_lock));
+	if (rv)
+		return rv;
+
+	HASH_FIND_STR(cache->entries, key, tmp);
+	if (tmp) {
+		size_t key_len = strnlen(tmp->key, KEY_MAX_LENGTH);
+		HASH_DELETE(hh, cache->entries, tmp);
+		HASH_ADD_KEYPTR(hh, cache->entries, tmp->key, key_len, tmp);
+		*dirty_hack = tmp->data;
+	} else {
+		*dirty_hack = result = NULL;
+	}
+	rv = pthread_rwlock_unlock(&(cache->cache_lock));
+	return rv;
+}
+
+/** Inserts a given <key, value> pair into the cache
+
+    @param cache
+    The cache object
+
+    @param key
+    The key that identifies <value>
+
+    @param data
+    Data associated with <key>
+
+    @return EINVAL if cache is NULL, ENOMEM if malloc fails, 0 otherwise
+*/
+int foo_cache_insert(struct foo_cache *cache, char *key, void *data)
+{
+	struct foo_cache_entry *entry = NULL;
+	struct foo_cache_entry *tmp_entry = NULL;
+	size_t key_len = 0;
+	int rv;
+
+	if (!cache || !data)
+		return EINVAL;
+
+	if ((entry = malloc(sizeof(*entry))) == NULL)
+		return ENOMEM;
+
+	if ((rv = pthread_rwlock_wrlock(&(cache->cache_lock))) != 0)
+		goto err_out;
+
+	entry->key = key;
+	entry->data = data;
+	key_len = strnlen(entry->key, KEY_MAX_LENGTH);
+	HASH_ADD_KEYPTR(hh, cache->entries, entry->key, key_len, entry);
+
+	if (HASH_COUNT(cache->entries) >= cache->max_entries) {
+		HASH_ITER(hh, cache->entries, entry, tmp_entry) {
+			HASH_DELETE(hh, cache->entries, entry);
+			if (cache->free_cb)
+				cache->free_cb(entry->data);
+			else
+				free(entry->data);
+			/* free(key->key) if data has been copied */
+			free(entry);
+			break;
+		}
+	}
+
+	rv = pthread_rwlock_unlock(&(cache->cache_lock));
+	return rv;
+
+err_out:
+	if (entry)
+		free(entry);
+	(void)pthread_rwlock_unlock(&(cache->cache_lock));
+	return rv;
+
+}

c/ext/uthash/tests/lru_cache/cache.h

@@ -0,0 +1,31 @@
+/*
+ * =====================================================================================
+ *
+ *       Filename:  cache.h
+ *
+ *    Description:  A simple cache
+ *
+ *        Version:  1.0
+ *        Created:  04/11/2013 02:30:46 PM
+ *       Revision:  none
+ *       Compiler:  gcc
+ *
+ *         Author:  Oliver Lorenz (ol), olli@olorenz.org
+ *        Company:  https://olorenz.org
+ *        License:  This is licensed under the same terms as uthash itself
+ *
+ * =====================================================================================
+ */
+
+#ifndef _CACHE_
+#define _CACHE_
+
+struct foo_cache;
+
+extern int foo_cache_create(struct foo_cache **dst, const size_t capacity,
+			    void (*free_cb) (void *element));
+extern int foo_cache_delete(struct foo_cache *cache, int keep_data);
+extern int foo_cache_lookup(struct foo_cache *cache, char *key, void *result);
+extern int foo_cache_insert(struct foo_cache *cache, char *key, void *data);
+
+#endif

c/ext/uthash/tests/lru_cache/main.c

@@ -0,0 +1,191 @@
+#include <errno.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "cache.h"
+
+#define MAX_RANDOM_ENTRIES	32
+
+struct key_record {
+	char *key;
+	char *value;
+};
+
+int generate_random_entry(struct key_record **entry);
+int generate_random_string(char **dst, const size_t len);
+void free_random_entry(void *entry);
+
+void *producer(void *arg)
+{
+	struct foo_cache *cache = arg;
+	int i;
+
+	for (i = 0; i < MAX_RANDOM_ENTRIES; i++) {
+		struct key_record *entry = NULL;
+		if (generate_random_entry(&entry)) {
+			fprintf(stderr, "generate_random_entry() failed\n");
+			continue;
+		}
+#if defined(DEBUG)
+		printf("Random Entry:\n");
+		printf("  key: %s\n", entry->key);
+		printf("   Key: %s\n", entry->value);
+#else
+		printf("inserted %s (%d)\n", entry->key,
+		       (int)strlen(entry->key));
+#endif
+		if (foo_cache_insert(cache, entry->key, entry)) {
+			fprintf(stderr, "foo_cache_insert() failed\n");
+			continue;
+		}
+	}
+
+	pthread_exit(NULL);
+}
+
+void *consumer(void *arg)
+{
+	struct foo_cache *cache = arg;
+	struct key_record *result = NULL;
+	char *buffer = malloc(64);
+	char key[33];
+	int stop = 0;
+
+	if (!buffer)
+		goto out;
+
+	/* give producer time to populate the cache */
+	sleep(2);
+	printf("\n\n");
+
+	do {
+		memset(key, 0, 64);
+		result = NULL;
+
+		printf("Enter key for lookup: ");
+		fgets(buffer, sizeof(key), stdin);
+		sscanf(buffer, "%s\n", key);
+		/* read '\n' from stdin */
+		getchar();
+
+		if (strncmp(key, "exit", 4) == 0) {
+			stop = 1;
+			continue;
+		}
+
+		printf("Got key %s (%d)\n", key, (int)strlen(key));
+
+		if (foo_cache_lookup(cache, key, &result)) {
+			fprintf(stderr, "Could not retrieve key %s\n", key);
+			continue;
+		}
+
+		if (!result) {
+			printf("MISS\n");
+			continue;
+		}
+
+		printf("HIT\n");
+		printf("key: %s\n", result->key);
+		printf("key : %s\n", result->value);
+	} while (!stop);
+
+out:
+	if (buffer)
+		free(buffer);
+	pthread_exit(NULL);
+}
+
+int main()
+{
+	int rv;
+	struct foo_cache *cache = NULL;
+	pthread_t workers[2];
+
+	rv = foo_cache_create(&cache, MAX_RANDOM_ENTRIES / 2,
+			      free_random_entry);
+	if (rv) {
+		fprintf(stderr, "Could not create cache\n");
+		exit(1);
+	}
+
+	(void)pthread_create(&workers[0], NULL, producer, (void *)cache);
+	(void)pthread_create(&workers[1], NULL, consumer, (void *)cache);
+
+	pthread_join(workers[0], NULL);
+	pthread_join(workers[1], NULL);
+
+	(void)foo_cache_delete(cache, 0);
+	return 0;
+}
+
+int generate_random_entry(struct key_record **entry)
+{
+	struct key_record *new = NULL;
+	char *key = NULL;
+	char *value = NULL;
+	int rv;
+
+	if (!entry)
+		return EINVAL;
+
+	rv = generate_random_string(&key, 33);
+	if (rv)
+		return rv;
+
+	rv = generate_random_string(&value, 129);
+	if (rv)
+		return rv;
+
+	if ((new = malloc(sizeof(*new))) == NULL) {
+		free(key);
+		free(value);
+		return ENOMEM;
+	}
+
+	new->key = key;
+	new->value = value;
+
+	*entry = new;
+	return 0;
+}
+
+int generate_random_string(char **dst, const size_t len)
+{
+	static const char alphanum[] =
+	    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+	size_t i;
+	char *s;
+
+	if (!dst || len == 0)
+		return EINVAL;
+
+	if ((s = malloc(len)) == NULL)
+		return ENOMEM;
+
+	for (i = 0; i < len - 1; i++) {
+		s[i] = alphanum[rand() % (sizeof(alphanum) - 1)];
+	}
+
+	s[len - 1] = '\0';
+	*dst = s;
+	return 0;
+}
+
+void free_random_entry(void *entry)
+{
+#if defined(DEBUG)
+	fprintf(stderr, "In %s: entry @ %p\n", __func__, entry);
+#endif
+	struct key_record *record = entry;
+	if (!record)
+		return;
+	if (record->key)
+		free(record->key);
+	if (record->value)
+		free(record->value);
+	free(record);
+	record = NULL;
+}

c/ext/uthash/tests/simkeys.pl

@@ -0,0 +1,28 @@
+#!/usr/bin/perl
+
+# This program generates a simkey10.dat (100, 1000, etc) each
+# containing 100 random keys of length 10 (100, 1000, etc).
+# These files can then be fed into keystats to observe that
+# the time to add or find the keys is directly proportional to
+# keylength n [in other words, O(n)].
+#
+# The conclusion is that really long keys (e.g. 100k) are not
+# efficient.                                       TDH 23Jan07
+
+use strict;
+use warnings;
+
+
+#for my $len (10,100,1000,10000,100000,1000000) {
+for my $len (100) {
+   open OUTFILE, ">simkeys$len.dat" or die "can't open: $!\n";
+   # we'll do 100 keys of $len
+   print "keylen $len\n";
+   for my $i (0..99) {
+       my $key = pack "I", $len;
+       $key .= pack "C", (int(rand(256))) for (1..$len);
+       print OUTFILE $key;
+   }
+   close OUTFILE;
+}
+

c/ext/uthash/tests/sleep_test.c

@@ -0,0 +1,32 @@
+#include "uthash.h"
+#include <stdlib.h>   /* malloc */
+#include <stdio.h>    /* printf */
+#include <unistd.h>   /* getpid */
+
+typedef struct example_user_t {
+    int id;
+    int cookie;
+    UT_hash_handle hh;
+} example_user_t;
+
+int main()
+{
+    int i;
+    example_user_t *user, *users=NULL;
+
+    /* create elements */
+    for(i=0; i<10000; i++) {
+        if ( (user = (example_user_t*)malloc(sizeof(example_user_t))) == NULL) {
+            exit(-1);
+        }
+        user->id = i;
+        user->cookie = i*i;
+        HASH_ADD_INT(users,id,user);
+    }
+
+    printf("pid: %u\n", (unsigned)getpid());
+    /* printf("sig: %p\n", &users->hh.tbl->signature); */
+    /* printf("bbv: %p\n", &users->hh.tbl->bloom_bv); */
+    sleep(60*10);
+    return 0;
+}

c/ext/uthash/tests/tdiff.cpp

@@ -0,0 +1,34 @@
+// Windows does not have unix diff so this is a simple replacement
+#include <iostream>
+#include <fstream>
+using namespace std;
+int main(int argc, char *argv[] ) {
+  int rc=-1;
+  if (argc != 3) {
+      cout << "usage: " << argv[0] << " file1 file2\n";
+      return -1;
+  }
+  char *file1 = argv[1];
+  char *file2 = argv[2];
+  ifstream is1(file1, ios::in);
+  ifstream is2(file2, ios::in);
+  if (is1.fail()) {cerr << "failed to open " << file1 << "\n"; goto done;}
+  if (is2.fail()) {cerr << "failed to open " << file2 << "\n"; goto done;}
+  char d1[256], d2[256];
+  do {
+    is1.read(d1,sizeof(d1));
+    is2.read(d2,sizeof(d2));
+    if ((is1.gcount() != is2.gcount()) || memcmp(d1,d2,is1.gcount())) {
+        cout << file1 << " and " << file2 << " differ\n";
+        goto done;
+    }
+  } while (!is1.eof() && !is2.eof());
+
+  rc=0;
+
+ done:
+  is1.close();
+  is2.close();
+  return rc;
+}
+

c/ext/uthash/tests/test1.ans

@@ -0,0 +1,10 @@
+user 0, cookie 0
+user 1, cookie 1
+user 2, cookie 4
+user 3, cookie 9
+user 4, cookie 16
+user 5, cookie 25
+user 6, cookie 36
+user 7, cookie 49
+user 8, cookie 64
+user 9, cookie 81

c/ext/uthash/tests/test1.c

@@ -0,0 +1,31 @@
+#include "uthash.h"
+#include <stdlib.h>   /* malloc */
+#include <stdio.h>    /* printf */
+
+typedef struct example_user_t {
+    int id;
+    int cookie;
+    UT_hash_handle hh;
+} example_user_t;
+
+int main()
+{
+    int i;
+    example_user_t *user, *users=NULL;
+
+    /* create elements */
+    for(i=0; i<10; i++) {
+        user = (example_user_t*)malloc(sizeof(example_user_t));
+        if (user == NULL) {
+            exit(-1);
+        }
+        user->id = i;
+        user->cookie = i*i;
+        HASH_ADD_INT(users,id,user);
+    }
+
+    for(user=users; user != NULL; user=(example_user_t*)(user->hh.next)) {
+        printf("user %d, cookie %d\n", user->id, user->cookie);
+    }
+    return 0;
+}

c/ext/uthash/tests/test10.ans

@@ -0,0 +1,4 @@
+9 found in hh
+9 found in alth
+10 not found in hh
+10 found in alth

c/ext/uthash/tests/test10.c

@@ -0,0 +1,54 @@
+#include "uthash.h"
+#include <stdlib.h>   /* malloc */
+#include <stdio.h>    /* printf */
+
+typedef struct example_user_t {
+    int id;
+    int cookie;
+    UT_hash_handle hh;
+    UT_hash_handle alth;
+} example_user_t;
+
+int main()
+{
+    int i;
+    example_user_t *user, *tmp, *users=NULL, *altusers=NULL;
+
+    /* create elements */
+    for(i=0; i<1000; i++) {
+        user = (example_user_t*)malloc(sizeof(example_user_t));
+        if (user == NULL) {
+            exit(-1);
+        }
+        user->id = i;
+        user->cookie = i*i;
+        if (i<10) {
+            HASH_ADD_INT(users,id,user);
+        }
+        HASH_ADD(alth,altusers,id,sizeof(int),user);
+    }
+
+    /*
+    printf("hh items: %d, alth items: %d\n",
+            users->hh.tbl->num_items, users->alth.tbl->num_items);
+    printf("hh buckets: %d, alth buckets: %d\n",
+            users->hh.tbl->num_buckets, users->alth.tbl->num_buckets);
+    */
+
+    i=9;
+    HASH_FIND_INT(users,&i,tmp);
+    printf("%d %s in hh\n", i, (tmp != NULL) ? "found" : "not found");
+    HASH_FIND(alth,altusers,&i,sizeof(int),tmp);
+    printf("%d %s in alth\n", i, (tmp != NULL) ? "found" : "not found");
+
+    i=10;
+    HASH_FIND_INT(users,&i,tmp);
+    printf("%d %s in hh\n", i, (tmp != NULL) ? "found" : "not found");
+    HASH_FIND(alth,altusers,&i,sizeof(int),tmp);
+    printf("%d %s in alth\n", i, (tmp != NULL) ? "found" : "not found");
+
+    HASH_CLEAR(hh, users);
+    HASH_CLEAR(alth, altusers);
+
+    return 0;
+}

c/ext/uthash/tests/test11.ans

@@ -0,0 +1,51 @@
+ADRIAN
+ARNOLDO
+CARROLL
+CARY
+CHONG
+CLIFTON
+CODY
+COLTON
+CORNELL
+DAMON
+DANNIE
+DARIO
+DONN
+DOUG
+DOUGLAS
+FREDERICK
+FRITZ
+GERALD
+GUS
+HARVEY
+IRVING
+ISAIAH
+JARVIS
+JOHN
+KENTON
+LAURENCE
+LESTER
+LINCOLN
+LOWELL
+NELSON
+NEVILLE
+NIGEL
+NORMAND
+ODIS
+OMAR
+ORLANDO
+RAYMUNDO
+REX
+ROLANDO
+RON
+SHANE
+TONEY
+TRINIDAD
+WALTER
+WARNER
+WARREN
+WES
+WILLARD
+WILLIAM
+WINFRED
+XAVIER

c/ext/uthash/tests/test11.c

@@ -0,0 +1,57 @@
+#include "uthash.h"
+#include <stdlib.h>   /* malloc */
+#include <errno.h>    /* perror */
+#include <stdio.h>    /* printf */
+
+#define BUFLEN 20
+
+#if 0
+/* Print a message if the hash's no-expand flag is set. */
+#undef uthash_noexpand_fyi
+#undef uthash_expand_fyi
+#define uthash_noexpand_fyi(tbl) printf("noexpand set\n");
+#define uthash_expand_fyi(tbl) printf("hash expanded\n");
+#endif
+
+typedef struct name_rec {
+    char boy_name[BUFLEN];
+    UT_hash_handle hh;
+} name_rec;
+
+static int namecmp(void *_a, void *_b)
+{
+    name_rec *a = (name_rec*)_a;
+    name_rec *b = (name_rec*)_b;
+    return strcmp(a->boy_name,b->boy_name);
+}
+
+int main()
+{
+    name_rec *name, *names=NULL;
+    char linebuf[BUFLEN];
+    FILE *file;
+
+    file = fopen( "test11.dat", "r" );
+    if (file == NULL) {
+        perror("can't open: ");
+        exit(-1);
+    }
+
+    while (fgets(linebuf,BUFLEN,file) != NULL) {
+        name = (name_rec*)malloc(sizeof(name_rec));
+        if (name == NULL) {
+            exit(-1);
+        }
+        strcpy(name->boy_name, linebuf);
+        HASH_ADD_STR(names,boy_name,name);
+    }
+
+    fclose(file);
+    HASH_SORT(names,namecmp);
+    for(name=names; name!=NULL; name=(name_rec*)(name->hh.next)) {
+        printf("%s",name->boy_name);
+    }
+
+    return 0;
+}
+

c/ext/uthash/tests/test11.dat

@@ -0,0 +1,51 @@
+JOHN
+WILLIAM
+WALTER
+DOUGLAS
+GERALD
+FREDERICK
+WARREN
+SHANE
+LESTER
+RON
+HARVEY
+ADRIAN
+CODY
+NELSON
+CLIFTON
+WILLARD
+DOUG
+ORLANDO
+REX
+OMAR
+DAMON
+LOWELL
+IRVING
+CARROLL
+LAURENCE
+ROLANDO
+CARY
+XAVIER
+ISAIAH
+GUS
+JARVIS
+WINFRED
+RAYMUNDO
+LINCOLN
+CORNELL
+NIGEL
+NORMAND
+FRITZ
+DONN
+TRINIDAD
+ODIS
+DANNIE
+DARIO
+KENTON
+CHONG
+NEVILLE
+TONEY
+WARNER
+WES
+COLTON
+ARNOLDO

c/ext/uthash/tests/test12.ans

@@ -0,0 +1,20 @@
+added bob (id 0)
+added jack (id 1)
+added gary (id 2)
+added ty (id 3)
+added bo (id 4)
+added phil (id 5)
+added art (id 6)
+added gil (id 7)
+added buck (id 8)
+added ted (id 9)
+found bob (id 0)
+found jack (id 1)
+found gary (id 2)
+found ty (id 3)
+found bo (id 4)
+found phil (id 5)
+found art (id 6)
+found gil (id 7)
+found buck (id 8)
+found ted (id 9)

c/ext/uthash/tests/test12.c

@@ -0,0 +1,40 @@
+#include "uthash.h"
+#include <stdio.h>
+#include <stdlib.h>  /* malloc */
+
+typedef struct person_t {
+    char first_name[10];
+    int id;
+    UT_hash_handle hh;
+} person_t;
+
+int main()
+{
+    person_t *people=NULL, *person;
+    const char **name;
+    const char * names[] = { "bob", "jack", "gary", "ty", "bo", "phil", "art",
+                             "gil", "buck", "ted", NULL
+                           };
+    int id=0;
+
+    for(name=names; *name != NULL; name++) {
+        person = (person_t*)malloc(sizeof(person_t));
+        if (person == NULL) {
+            exit(-1);
+        }
+        strcpy(person->first_name, *name);
+        person->id = id++;
+        HASH_ADD_STR(people,first_name,person);
+        printf("added %s (id %d)\n", person->first_name, person->id);
+    }
+
+    for(name=names; *name != NULL; name++) {
+        HASH_FIND_STR(people,*name,person);
+        if (person != NULL) {
+            printf("found %s (id %d)\n", person->first_name, person->id);
+        } else {
+            printf("failed to find %s\n", *name);
+        }
+    }
+    return 0;
+}

c/ext/uthash/tests/test13.ans

@@ -0,0 +1,5 @@
+id 9, following prev...
+id 7, following prev...
+id 5, following prev...
+id 3, following prev...
+id 1, following prev...

c/ext/uthash/tests/test13.c

@@ -0,0 +1,50 @@
+#include "uthash.h"
+#include <stdlib.h>   /* malloc */
+#include <stdio.h>    /* printf */
+
+typedef struct example_user_t {
+    int id;
+    int cookie;
+    UT_hash_handle hh;
+} example_user_t;
+
+int main()
+{
+    int i;
+    example_user_t *user, *tmp, *users=NULL;
+
+    /* create elements */
+    for(i=0; i<10; i++) {
+        user = (example_user_t*)malloc(sizeof(example_user_t));
+        if (user == NULL) {
+            exit(-1);
+        }
+        user->id = i;
+        user->cookie = i*i;
+        HASH_ADD_INT(users,id,user);
+    }
+
+    /* delete each even ID */
+    for(i=0; i<10; i+=2) {
+        HASH_FIND_INT(users,&i,tmp);
+        if (tmp != NULL) {
+            HASH_DEL(users,tmp);
+            free(tmp);
+        } else {
+            printf("user id %d not found\n", i);
+        }
+    }
+
+    i=9;
+    HASH_FIND_INT(users,&i,tmp);
+    if (tmp != NULL) {
+        while (tmp != NULL) {
+            printf("id %d, following prev...\n", tmp->id);
+            tmp = (example_user_t*)tmp->hh.prev;
+        }
+    } else {
+        printf("user id %d not found\n", i);
+    }
+
+    return 0;
+}

c/ext/uthash/tests/test14.ans

@@ -0,0 +1 @@
+lookup on 1219 of 1219 names succeeded

c/ext/uthash/tests/test14.c

@@ -0,0 +1,54 @@
+#include "uthash.h"
+#include <stdlib.h>   /* malloc */
+#include <errno.h>    /* perror */
+#include <stdio.h>    /* printf */
+
+#define BUFLEN 20
+#if 0
+#undef uthash_expand_fyi
+#define uthash_expand_fyi(tbl) printf("expanding to %d buckets\n", tbl->num_buckets)
+#endif
+
+typedef struct name_rec {
+    char boy_name[BUFLEN];
+    UT_hash_handle hh;
+} name_rec;
+
+int main()
+{
+    name_rec *name, *names=NULL;
+    char linebuf[BUFLEN];
+    FILE *file;
+    int i=0,j=0;
+
+    file = fopen( "test14.dat", "r" );
+    if (file == NULL ) {
+        perror("can't open: ");
+        exit(-1);
+    }
+
+    while (fgets(linebuf,BUFLEN,file) != NULL) {
+        i++;
+        name = (name_rec*)malloc(sizeof(name_rec));
+        if (name == NULL) {
+            exit(-1);
+        }
+        strcpy(name->boy_name, linebuf);
+        HASH_ADD_STR(names,boy_name,name);
+    }
+
+    fseek(file,0L,SEEK_SET);
+
+    while (fgets(linebuf,BUFLEN,file) != NULL) {
+        HASH_FIND_STR(names,linebuf,name);
+        if (!name) {
+            printf("failed to find: %s", linebuf);
+        } else {
+            j++;
+        }
+    }
+    fclose(file);
+    printf("lookup on %d of %d names succeeded\n", j, i);
+    return 0;
+}
+

c/ext/uthash/tests/test15.ans

@@ -0,0 +1 @@
+betty's id is 2

c/ext/uthash/tests/test15.c

@@ -0,0 +1,40 @@
+#include <string.h>  /* strcpy */
+#include <stdlib.h>  /* malloc */
+#include <stdio.h>   /* printf */
+#include "uthash.h"
+
+struct my_struct {
+    char name[10];             /* key */
+    int id;
+    UT_hash_handle hh;         /* makes this structure hashable */
+};
+
+
+int main()
+{
+    const char **n, *names[] = { "joe", "bob", "betty", NULL };
+    struct my_struct *s, *tmp, *users = NULL;
+    int i=0;
+
+    for (n = names; *n != NULL; n++) {
+        s = (struct my_struct*)malloc(sizeof(struct my_struct));
+        if (s == NULL) {
+            exit(-1);
+        }
+        strcpy(s->name, *n);
+        s->id = i++;
+        HASH_ADD_STR( users, name, s );
+    }
+
+    HASH_FIND_STR( users, "betty", s);
+    if (s != NULL) {
+        printf("betty's id is %d\n", s->id);
+    }
+
+    /* free the hash table contents */
+    HASH_ITER(hh, users, s, tmp) {
+        HASH_DEL(users, s);
+        free(s);
+    }
+    return 0;
+}

c/ext/uthash/tests/test16.ans

@@ -0,0 +1 @@
+found: user 5, unix time 157680000

c/ext/uthash/tests/test16.c

@@ -0,0 +1,53 @@
+#include <stdlib.h>    /* malloc       */
+#include <stddef.h>    /* offsetof     */
+#include <stdio.h>     /* printf       */
+#include <string.h>    /* memset       */
+#include "uthash.h"
+
+struct inner {
+    int a;
+    int b;
+};
+
+struct my_event {
+    struct inner is;           /* key is aggregate of this field */
+    char event_code;           /* and this field.                */
+    int user_id;
+    UT_hash_handle hh;         /* makes this structure hashable */
+};
+
+
+int main()
+{
+    struct my_event *e, ev, *events = NULL;
+    unsigned keylen;
+    int i;
+
+    keylen =   offsetof(struct my_event, event_code) + sizeof(char)
+               - offsetof(struct my_event, is);
+
+    for(i = 0; i < 10; i++) {
+        e = (struct my_event*)malloc(sizeof(struct my_event));
+        if (e == NULL) {
+            exit(-1);
+        }
+        memset(e,0,sizeof(struct my_event));
+        e->is.a = i * (60*60*24*365);          /* i years (sec)*/
+        e->is.b = 0;
+        e->event_code = 'a'+(i%2);              /* meaningless */
+        e->user_id = i;
+
+        HASH_ADD( hh, events, is, keylen, e);
+    }
+
+    /* look for one specific event */
+    memset(&ev,0,sizeof(struct my_event));
+    ev.is.a = 5 * (60*60*24*365);
+    ev.is.b = 0;
+    ev.event_code = 'b';
+    HASH_FIND( hh, events, &ev.is, keylen , e);
+    if (e != NULL) {
+        printf("found: user %d, unix time %d\n", e->user_id, e->is.a);
+    }
+    return 0;
+}

c/ext/uthash/tests/test17.ans

@@ -0,0 +1,134 @@
+user 9, cookie 81
+user 8, cookie 64
+user 7, cookie 49
+user 6, cookie 36
+user 5, cookie 25
+user 4, cookie 16
+user 3, cookie 9
+user 2, cookie 4
+user 1, cookie 1
+user 0, cookie 0
+sorting
+called for a:9, b:8
+called for a:7, b:6
+called for a:5, b:4
+called for a:3, b:2
+called for a:1, b:0
+called for a:8, b:6
+called for a:8, b:7
+called for a:4, b:2
+called for a:4, b:3
+called for a:6, b:2
+called for a:6, b:3
+called for a:6, b:4
+called for a:6, b:5
+called for a:2, b:0
+called for a:2, b:1
+user 0, cookie 0
+user 1, cookie 1
+user 2, cookie 4
+user 3, cookie 9
+user 4, cookie 16
+user 5, cookie 25
+user 6, cookie 36
+user 7, cookie 49
+user 8, cookie 64
+user 9, cookie 81
+adding 10-20
+user 0, cookie 0
+user 1, cookie 1
+user 2, cookie 4
+user 3, cookie 9
+user 4, cookie 16
+user 5, cookie 25
+user 6, cookie 36
+user 7, cookie 49
+user 8, cookie 64
+user 9, cookie 81
+user 20, cookie 400
+user 19, cookie 361
+user 18, cookie 324
+user 17, cookie 289
+user 16, cookie 256
+user 15, cookie 225
+user 14, cookie 196
+user 13, cookie 169
+user 12, cookie 144
+user 11, cookie 121
+user 10, cookie 100
+sorting
+called for a:0, b:1
+called for a:2, b:3
+called for a:4, b:5
+called for a:6, b:7
+called for a:8, b:9
+called for a:20, b:19
+called for a:18, b:17
+called for a:16, b:15
+called for a:14, b:13
+called for a:12, b:11
+called for a:0, b:2
+called for a:1, b:2
+called for a:4, b:6
+called for a:5, b:6
+called for a:8, b:19
+called for a:9, b:19
+called for a:17, b:15
+called for a:17, b:16
+called for a:13, b:11
+called for a:13, b:12
+called for a:0, b:4
+called for a:1, b:4
+called for a:2, b:4
+called for a:3, b:4
+called for a:8, b:15
+called for a:9, b:15
+called for a:19, b:15
+called for a:19, b:16
+called for a:19, b:17
+called for a:19, b:18
+called for a:11, b:10
+called for a:0, b:8
+called for a:1, b:8
+called for a:2, b:8
+called for a:3, b:8
+called for a:4, b:8
+called for a:5, b:8
+called for a:6, b:8
+called for a:7, b:8
+called for a:0, b:10
+called for a:1, b:10
+called for a:2, b:10
+called for a:3, b:10
+called for a:4, b:10
+called for a:5, b:10
+called for a:6, b:10
+called for a:7, b:10
+called for a:8, b:10
+called for a:9, b:10
+called for a:15, b:10
+called for a:15, b:11
+called for a:15, b:12
+called for a:15, b:13
+called for a:15, b:14
+user 0, cookie 0
+user 1, cookie 1
+user 2, cookie 4
+user 3, cookie 9
+user 4, cookie 16
+user 5, cookie 25
+user 6, cookie 36
+user 7, cookie 49
+user 8, cookie 64
+user 9, cookie 81
+user 10, cookie 100
+user 11, cookie 121
+user 12, cookie 144
+user 13, cookie 169
+user 14, cookie 196
+user 15, cookie 225
+user 16, cookie 256
+user 17, cookie 289
+user 18, cookie 324
+user 19, cookie 361
+user 20, cookie 400

c/ext/uthash/tests/test17.c

@@ -0,0 +1,63 @@
+#include "uthash.h"
+#include <stdlib.h>   /* malloc */
+#include <stdio.h>    /* printf */
+
+typedef struct example_user_t {
+    int id;
+    int cookie;
+    UT_hash_handle hh;
+} example_user_t;
+
+static int rev(void *_a, void *_b)
+{
+    example_user_t *a = (example_user_t*)_a;
+    example_user_t *b = (example_user_t*)_b;
+    printf("called for a:%d, b:%d\n",a->id, b->id);
+    return (a->id - b->id);
+}
+
+int main()
+{
+    int i;
+    example_user_t *user, *users=NULL;
+
+    /* create elements */
+    for(i=9; i>=0; i--) {
+        user = (example_user_t*)malloc(sizeof(example_user_t));
+        if (user == NULL) {
+            exit(-1);
+        }
+        user->id = i;
+        user->cookie = i*i;
+        HASH_ADD_INT(users,id,user);
+    }
+
+    for(user=users; user != NULL; user=(example_user_t*)user->hh.next) {
+        printf("user %d, cookie %d\n", user->id, user->cookie);
+    }
+    printf("sorting\n");
+    HASH_SORT(users,rev);
+    for(user=users; user != NULL; user=(example_user_t*)user->hh.next) {
+        printf("user %d, cookie %d\n", user->id, user->cookie);
+    }
+
+    printf("adding 10-20\n");
+    for(i=20; i>=10; i--) {
+        user = (example_user_t*)malloc(sizeof(example_user_t));
+        if (user == NULL) {
+            exit(-1);
+        }
+        user->id = i;
+        user->cookie = i*i;
+        HASH_ADD_INT(users,id,user);
+    }
+    for(user=users; user != NULL; user=(example_user_t*)user->hh.next) {
+        printf("user %d, cookie %d\n", user->id, user->cookie);
+    }
+    printf("sorting\n");
+    HASH_SORT(users,rev);
+    for(user=users; user != NULL; user=(example_user_t*)user->hh.next) {
+        printf("user %d, cookie %d\n", user->id, user->cookie);
+    }
+    return 0;
+}

c/ext/uthash/tests/test18.ans

@@ -0,0 +1,20 @@
+user 0, cookie 0
+user 1, cookie 1
+user 2, cookie 4
+user 3, cookie 9
+user 4, cookie 16
+user 5, cookie 25
+user 6, cookie 36
+user 7, cookie 49
+user 8, cookie 64
+user 9, cookie 81
+deleting id 0
+deleting id 1
+deleting id 2
+deleting id 3
+deleting id 4
+deleting id 5
+deleting id 6
+deleting id 7
+deleting id 8
+deleting id 9

c/ext/uthash/tests/test18.c

@@ -0,0 +1,37 @@
+#include "uthash.h"
+#include <stdlib.h>   /* malloc */
+#include <stdio.h>    /* printf */
+
+typedef struct example_user_t {
+    int id;
+    int cookie;
+    UT_hash_handle hh;
+} example_user_t;
+
+int main()
+{
+    int i;
+    example_user_t *user, *users=NULL;
+
+    /* create elements */
+    for(i=0; i<10; i++) {
+        user = (example_user_t*)malloc(sizeof(example_user_t));
+        if (user == NULL) {
+            exit(-1);
+        }
+        user->id = i;
+        user->cookie = i*i;
+        HASH_ADD_INT(users,id,user);
+    }
+
+    for(user=users; user != NULL; user=(example_user_t*)user->hh.next) {
+        printf("user %d, cookie %d\n", user->id, user->cookie);
+    }
+
+    /* delete them all, pathologically */
+    while(users != NULL) {
+        printf("deleting id %i\n", users->id);
+        HASH_DEL(users,users); /* single head/deletee var! */
+    }
+    return 0;
+}

c/ext/uthash/tests/test19.c

@@ -0,0 +1,66 @@
+#include "uthash.h"
+#include <stdlib.h>   /* malloc */
+#include <stdio.h>    /* printf */
+
+typedef struct example_user_t {
+    int id;
+    int cookie;
+    UT_hash_handle hh;
+    UT_hash_handle alth;
+} example_user_t;
+
+static int ascending_sort(void *_a, void *_b)
+{
+    example_user_t *a = (example_user_t*)_a;
+    example_user_t *b = (example_user_t*)_b;
+    if (a->id == b->id) {
+        return 0;
+    }
+    return (a->id < b->id) ? -1 : 1;
+}
+
+static int descending_sort(void *_a, void *_b)
+{
+    example_user_t *a = (example_user_t*)_a;
+    example_user_t *b = (example_user_t*)_b;
+    if (a->id == b->id) {
+        return 0;
+    }
+    return (a->id < b->id) ? 1 : -1;
+}
+
+int main()
+{
+    int i;
+    example_user_t *user, *users=NULL, *altusers=NULL;
+
+    /* create elements */
+    for(i=0; i<1000; i++) {
+        user = (example_user_t*)malloc(sizeof(example_user_t));
+        if (user == NULL) {
+            exit(-1);
+        }
+        user->id = i;
+        user->cookie = i*i;
+        if (i<10) {
+            HASH_ADD_INT(users,id,user);
+        }
+        HASH_ADD(alth,altusers,id,sizeof(int),user);
+    }
+
+    printf("sorting users ascending\n");
+    HASH_SRT(hh,users,ascending_sort);
+    for(user=users; user!=NULL; user=(example_user_t*)user->hh.next) {
+        printf("user %d\n", user->id);
+    }
+
+    printf("sorting altusers descending\n");
+    HASH_SRT(alth,altusers,descending_sort);
+    for(user=altusers; user!=NULL; user=(example_user_t*)user->alth.next) {
+        printf("altuser %d\n", user->id);
+    }
+
+    /* HASH_FSCK(hh,users); */
+    /* HASH_FSCK(alth,altusers); */
+    return 0;
+}

c/ext/uthash/tests/test2.ans

@@ -0,0 +1,5 @@
+user id 0 found, cookie 0
+user id 2 found, cookie 4
+user id 4 found, cookie 16
+user id 6 found, cookie 36
+user id 8 found, cookie 64

c/ext/uthash/tests/test2.c

@@ -0,0 +1,38 @@
+#include "uthash.h"
+#include <time.h>
+#include <stdlib.h>   /* malloc */
+#include <stdio.h>    /* printf */
+
+typedef struct example_user_t {
+    int id;
+    int cookie;
+    UT_hash_handle hh;
+} example_user_t;
+
+int main()
+{
+    int i;
+    example_user_t *user, *tmp, *users=NULL;
+
+    /* create elements */
+    for(i=0; i<10; i++) {
+        user = (example_user_t*)malloc(sizeof(example_user_t));
+        if (user == NULL) {
+            exit(-1);
+        }
+        user->id = i;
+        user->cookie = i*i;
+        HASH_ADD_INT(users,id,user);
+    }
+
+    /* find each even ID */
+    for(i=0; i<10; i+=2) {
+        HASH_FIND_INT(users,&i,tmp);
+        if (tmp != NULL) {
+            printf("user id %d found, cookie %d\n", tmp->id, tmp->cookie);
+        } else {
+            printf("user id %d not found\n", i);
+        }
+    }
+    return 0;
+}

c/ext/uthash/tests/test20.ans

@@ -0,0 +1 @@
+found

c/ext/uthash/tests/test20.c

@@ -0,0 +1,34 @@
+#include <string.h>  /* memcpy */
+#include <stdlib.h>  /* malloc */
+#include <stdio.h>   /* printf */
+#include "uthash.h"
+
+struct my_struct {
+    char bkey[5];              /* "binary" key */
+    int data;
+    UT_hash_handle hh;
+};
+
+int main()
+{
+    struct my_struct *s, *t, *bins = NULL;
+    char binary[5] = {'\3','\1','\4','\1','\6'};
+
+    /* allocate our structure. initialize to some values */
+    s = (struct my_struct*)calloc(1UL,sizeof(struct my_struct));
+    if (s == NULL) {
+        exit(-1);
+    }
+    memcpy(s->bkey, binary, sizeof(binary));
+
+    /* add to hash table using general macro */
+    HASH_ADD( hh, bins, bkey, sizeof(binary), s);
+
+    /* look up the structure we just added */
+    HASH_FIND( hh, bins, binary, sizeof(binary), t );
+
+    if (t != NULL) {
+        printf("found\n");
+    }
+    return 0;
+}

c/ext/uthash/tests/test21.ans

@@ -0,0 +1 @@
+found a 1

c/ext/uthash/tests/test21.c

@@ -0,0 +1,44 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include "uthash.h"
+
+typedef struct {
+    char a;
+    int b;
+} record_key_t;
+
+typedef struct {
+    record_key_t key;
+    /* ... other data ... */
+    UT_hash_handle hh;
+} record_t;
+
+int main()
+{
+    record_t l, *p, *r, *tmp, *records = NULL;
+
+    r = (record_t*)malloc( sizeof(record_t) );
+    if (r == NULL) {
+        exit(-1);
+    }
+    memset(r, 0, sizeof(record_t));
+    r->key.a = 'a';
+    r->key.b = 1;
+    HASH_ADD(hh, records, key, sizeof(record_key_t), r);
+
+    memset(&l, 0, sizeof(record_t));
+    l.key.a = 'a';
+    l.key.b = 1;
+    HASH_FIND(hh, records, &l.key, sizeof(record_key_t), p);
+
+    if (p != NULL) {
+        printf("found %c %d\n", p->key.a, p->key.b);
+    }
+
+    HASH_ITER(hh, records, p, tmp) {
+        HASH_DEL(records, p);
+        free(p);
+    }
+    return 0;
+}
+

c/ext/uthash/tests/test22.ans

@@ -0,0 +1 @@
+found 

c/ext/uthash/tests/test22.c

@@ -0,0 +1,68 @@
+#include <stdlib.h>    /* malloc       */
+#include <stddef.h>    /* offsetof     */
+#include <stdio.h>     /* printf       */
+#include <string.h>    /* memset       */
+#include "uthash.h"
+
+#define UTF32 '\x1'
+
+typedef struct {
+    UT_hash_handle hh;
+    size_t len;
+    char encoding;      /* these two fields */
+    int text[];         /* comprise the key */
+} msg_t;
+
+typedef struct {
+    char encoding;
+    int text[];
+} lookup_key_t;
+
+int main()
+{
+    unsigned keylen;
+    msg_t *msg, *tmp, *msgs = NULL;
+    lookup_key_t *lookup_key;
+
+    int beijing[] = {0x5317, 0x4eac};   /* UTF-32LE for 北京 */
+
+    /* allocate and initialize our structure */
+    msg = (msg_t*)malloc( sizeof(msg_t) + sizeof(beijing) );
+    if (msg == NULL) {
+        exit(-1);
+    }
+    memset(msg, 0, sizeof(msg_t)+sizeof(beijing)); /* zero fill */
+    msg->len = sizeof(beijing);
+    msg->encoding = UTF32;
+    memcpy(msg->text, beijing, sizeof(beijing));
+
+    /* calculate the key length including padding, using formula */
+    keylen =   offsetof(msg_t, text)       /* offset of last key field */
+               + sizeof(beijing)             /* size of last key field */
+               - offsetof(msg_t, encoding);  /* offset of first key field */
+
+    /* add our structure to the hash table */
+    HASH_ADD( hh, msgs, encoding, keylen, msg);
+
+    /* look it up to prove that it worked :-) */
+    msg=NULL;
+
+    lookup_key = (lookup_key_t*)malloc(sizeof(*lookup_key) + sizeof(beijing));
+    if (lookup_key == NULL) {
+        exit(-1);
+    }
+    memset(lookup_key, 0, sizeof(*lookup_key) + sizeof(beijing));
+    lookup_key->encoding = UTF32;
+    memcpy(lookup_key->text, beijing, sizeof(beijing));
+    HASH_FIND( hh, msgs, &lookup_key->encoding, keylen, msg );
+    if (msg != NULL) {
+        printf("found \n");
+    }
+    free(lookup_key);
+
+    HASH_ITER(hh, msgs, msg, tmp) {
+        HASH_DEL(msgs, msg);
+        free(msg);
+    }
+    return 0;
+}

c/ext/uthash/tests/test23.ans

@@ -0,0 +1,6 @@
+found 12345
+found 6789
+found 98765
+deleting 12345
+deleting 6789
+deleting 98765

c/ext/uthash/tests/test23.c

@@ -0,0 +1,69 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "uthash.h"
+
+typedef struct {
+    int key;
+    int data;
+    UT_hash_handle hh;
+} item;
+
+int main()
+{
+    item *i, *j, *items=NULL;
+    int k;
+
+    /* first item */
+    k = 12345;
+    i = (item*)malloc(sizeof(item));
+    if (i == NULL) {
+        exit(-1);
+    }
+    i->key = k;
+    i->data = 0;
+    HASH_ADD_INT(items,key,i);
+
+    /* second item */
+    k = 6789;
+    i = (item*)malloc(sizeof(item));
+    if (i == NULL) {
+        exit(-1);
+    }
+    i->key = k;
+    i->data = 0;
+    HASH_ADD_INT(items,key,i);
+
+    /* third item */
+    k = 98765;
+    i = (item*)malloc(sizeof(item));
+    if (i == NULL) {
+        exit(-1);
+    }
+    i->key = k;
+    i->data = 0;
+    HASH_ADD_INT(items,key,i);
+
+    /* look them all up */
+    k = 12345;
+    HASH_FIND_INT(items, &k, j);
+    if (j != NULL) {
+        printf("found %d\n",k);
+    }
+    k = 6789;
+    HASH_FIND_INT(items, &k, j);
+    if (j != NULL) {
+        printf("found %d\n",k);
+    }
+    k = 98765;
+    HASH_FIND_INT(items, &k, j);
+    if (j != NULL) {
+        printf("found %d\n",k);
+    }
+
+    /* delete them not the way we prefer but it works */
+    for(j=items; j != NULL; j=(item*)j->hh.next) {
+        printf("deleting %d\n", j->key);
+        HASH_DEL(items,j);
+    }
+    return 0;
+}

c/ext/uthash/tests/test24.ans

@@ -0,0 +1 @@
+hash contains 10 items

c/ext/uthash/tests/test24.c

@@ -0,0 +1,29 @@
+#include "uthash.h"
+#include <stdlib.h>   /* malloc */
+#include <stdio.h>    /* printf */
+
+typedef struct example_user_t {
+    int id;
+    int cookie;
+    UT_hash_handle hh;
+} example_user_t;
+
+int main()
+{
+    int i;
+    example_user_t *user, *users=NULL;
+
+    /* create elements */
+    for(i=0; i<10; i++) {
+        user = (example_user_t*)malloc(sizeof(example_user_t));
+        if (user == NULL) {
+            exit(-1);
+        }
+        user->id = i;
+        user->cookie = i*i;
+        HASH_ADD_INT(users,id,user);
+    }
+
+    printf("hash contains %u items\n", HASH_COUNT(users));
+    return 0;
+}

c/ext/uthash/tests/test25.ans

@@ -0,0 +1,31 @@
+CDL macros
+c b a 
+count = 3
+advancing head pointer
+b a c 
+b a c b a c b a c b 
+b c a b c a b c a b 
+deleting b
+a c 
+deleting (a)
+c 
+deleting (c)
+
+DL macros
+a b c 
+count = 3
+deleting tail c
+a b 
+deleting head a
+b 
+deleting head b
+
+LL macros
+a b c 
+count = 3
+deleting tail c
+a b 
+deleting head a
+b 
+deleting head b
+

c/ext/uthash/tests/test25.c

@@ -0,0 +1,138 @@
+#include <stdio.h>
+#include "utlist.h"
+
+typedef struct el {
+    int id;
+    struct el *next, *prev;
+} el;
+
+int main()
+{
+    int i;
+    int count;
+    el els[10], *e;
+    el *head = NULL;
+    for(i=0; i<10; i++) {
+        els[i].id=(int)'a'+i;
+    }
+
+    /* test CDL macros */
+    printf("CDL macros\n");
+    CDL_PREPEND(head,&els[0]);
+    CDL_PREPEND(head,&els[1]);
+    CDL_PREPEND(head,&els[2]);
+    CDL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+    CDL_COUNT(head,e, count);
+    printf("count = %d\n", count);
+
+    /* point head to head->next */
+    printf("advancing head pointer\n");
+    head = head->next;
+    CDL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    /* follow circular loop a few times */
+    for(i=0,e=head; e && i<10; i++,e=e->next) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    /* follow circular loop backwards a few times */
+    for(i=0,e=head; e && i<10; i++,e=e->prev) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    printf("deleting b\n");
+    CDL_DELETE(head,&els[1]);
+    CDL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+    printf("deleting (a)\n");
+    CDL_DELETE(head,&els[0]);
+    CDL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+    printf("deleting (c)\n");
+    CDL_DELETE(head,&els[2]);
+    CDL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    /* test DL macros */
+    printf("DL macros\n");
+    DL_APPEND(head,&els[0]);
+    DL_APPEND(head,&els[1]);
+    DL_APPEND(head,&els[2]);
+    DL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+    DL_COUNT(head,e, count);
+    printf("count = %d\n", count);
+
+    printf("deleting tail c\n");
+    DL_DELETE(head,&els[2]);
+    DL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    printf("deleting head a\n");
+    DL_DELETE(head,&els[0]);
+    DL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    printf("deleting head b\n");
+    DL_DELETE(head,&els[1]);
+    DL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    /* test LL macros */
+    printf("LL macros\n");
+    LL_APPEND(head,&els[0]);
+    LL_APPEND(head,&els[1]);
+    LL_APPEND(head,&els[2]);
+    LL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    LL_COUNT(head,e,count);
+    printf("count = %d\n", count);
+
+    printf("deleting tail c\n");
+    LL_DELETE(head,&els[2]);
+    LL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    printf("deleting head a\n");
+    LL_DELETE(head,&els[0]);
+    LL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    printf("deleting head b\n");
+    LL_DELETE(head,&els[1]);
+    LL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    return 0;
+}

c/ext/uthash/tests/test26.ans

@@ -0,0 +1,53 @@
+ADRIAN
+ARNOLDO
+CARROLL
+CARY
+CHONG
+CLIFTON
+CODY
+COLTON
+CORNELL
+DAMON
+DANNIE
+DARIO
+DONN
+DOUG
+DOUGLAS
+FREDERICK
+FRITZ
+GERALD
+GUS
+HARVEY
+IRVING
+ISAIAH
+JARVIS
+JOHN
+KENTON
+LAURENCE
+LESTER
+LINCOLN
+LOWELL
+NELSON
+NEVILLE
+NIGEL
+NORMAND
+ODIS
+OMAR
+ORLANDO
+RAYMUNDO
+REX
+ROLANDO
+RON
+SHANE
+TONEY
+TRINIDAD
+WALTER
+WARNER
+WARREN
+WES
+WILLARD
+WILLIAM
+WINFRED
+XAVIER
+found WES
+

c/ext/uthash/tests/test26.c

@@ -0,0 +1,61 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "utlist.h"
+
+#define BUFLEN 20
+
+typedef struct el {
+    char bname[BUFLEN];
+    struct el *next, *prev;
+} el;
+
+static int namecmp(void *_a, void *_b)
+{
+    el *a = (el*)_a;
+    el *b = (el*)_b;
+    return strcmp(a->bname,b->bname);
+}
+
+int main()
+{
+    el *name, *elt, *tmp, etmp;
+    el *head = NULL; /* important- initialize to NULL! */
+
+    char linebuf[BUFLEN];
+    FILE *file;
+
+    file = fopen( "test11.dat", "r" );
+    if (file == NULL) {
+        perror("can't open: ");
+        exit(-1);
+    }
+
+    while (fgets(linebuf,BUFLEN,file) != NULL) {
+        name = (el*)malloc(sizeof(el));
+        if (name == NULL) {
+            exit(-1);
+        }
+        strcpy(name->bname, linebuf);
+        DL_APPEND(head, name);
+    }
+    DL_SORT(head, namecmp);
+    DL_FOREACH(head,elt) {
+        printf("%s", elt->bname);
+    }
+
+    memcpy(etmp.bname, "WES\n", 5UL);
+    DL_SEARCH(head,elt,&etmp,namecmp);
+    if (elt != NULL) {
+        printf("found %s\n", elt->bname);
+    }
+
+    /* now delete each element, use the safe iterator */
+    DL_FOREACH_SAFE(head,elt,tmp) {
+        DL_DELETE(head,elt);
+    }
+
+    fclose(file);
+
+    return 0;
+}

c/ext/uthash/tests/test27.ans

@@ -0,0 +1,28 @@
+CDL macros
+c b a 
+advancing head pointer
+b a c 
+b a c b a c b a c b 
+b c a b c a b c a b 
+deleting b
+a c 
+deleting head (a)
+c 
+deleting new head (c)
+
+DL macros
+c b a 
+deleting c
+b a 
+deleting a
+b 
+deleting b
+
+LL macros
+c b a 
+deleting c
+b a 
+deleting a
+b 
+deleting b
+

c/ext/uthash/tests/test27.c

@@ -0,0 +1,130 @@
+#include <stdio.h>
+#include "utlist.h"
+
+typedef struct el {
+    int id;
+    struct el *next, *prev;
+} el;
+
+int main()
+{
+    int i;
+    el els[10], *e;
+    el *head = NULL;
+    for(i=0; i<10; i++) {
+        els[i].id=(int)'a'+i;
+    }
+
+    /* test CDL macros */
+    printf("CDL macros\n");
+    CDL_PREPEND(head,&els[0]);
+    CDL_PREPEND(head,&els[1]);
+    CDL_PREPEND(head,&els[2]);
+    CDL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    /* point head to head->next */
+    printf("advancing head pointer\n");
+    head = head->next;
+    CDL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    /* follow circular loop a few times */
+    for(i=0,e=head; e && i<10; i++,e=e->next) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    /* follow circular loop backwards a few times */
+    for(i=0,e=head; e && i<10; i++,e=e->prev) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    printf("deleting b\n");
+    CDL_DELETE(head,&els[1]);
+    CDL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+    printf("deleting head (a)\n");
+    CDL_DELETE(head,&els[0]);
+    CDL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+    printf("deleting new head (c)\n");
+    CDL_DELETE(head,&els[2]);
+    CDL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    /* test DL macros */
+    printf("DL macros\n");
+    DL_PREPEND(head,&els[0]);
+    DL_PREPEND(head,&els[1]);
+    DL_PREPEND(head,&els[2]);
+    DL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    printf("deleting c\n");
+    DL_DELETE(head,&els[2]);
+    DL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    printf("deleting a\n");
+    DL_DELETE(head,&els[0]);
+    DL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    printf("deleting b\n");
+    DL_DELETE(head,&els[1]);
+    DL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    /* test LL macros */
+    printf("LL macros\n");
+    LL_PREPEND(head,&els[0]);
+    LL_PREPEND(head,&els[1]);
+    LL_PREPEND(head,&els[2]);
+    LL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    printf("deleting c\n");
+    LL_DELETE(head,&els[2]);
+    LL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    printf("deleting a\n");
+    LL_DELETE(head,&els[0]);
+    LL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    printf("deleting b\n");
+    LL_DELETE(head,&els[1]);
+    LL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    return 0;
+}

c/ext/uthash/tests/test28.ans

@@ -0,0 +1,34 @@
+CDL macros
+d c b a 
+advancing head pointer
+c b a d 
+c b a d c b a d c b 
+c d a b c d a b c d 
+deleting b
+c a d 
+deleting (a)
+c d 
+deleting (c)
+d 
+deleting (d)
+
+DL macros
+c b a d 
+deleting c
+b a d 
+deleting a
+b d 
+deleting b
+d 
+deleting d
+
+LL macros
+c b a d 
+deleting c
+b a d 
+deleting a
+b d 
+deleting b
+d 
+deleting d
+

c/ext/uthash/tests/test28.c

@@ -0,0 +1,153 @@
+#include <stdio.h>
+#include "utlist.h"
+
+typedef struct el {
+    int id;
+    struct el *next, *prev;
+} el;
+
+int main()
+{
+    int i;
+    el els[10], *e;
+    el *head = NULL;
+    for(i=0; i<10; i++) {
+        els[i].id=(int)'a'+i;
+    }
+
+    /* test CDL macros */
+    printf("CDL macros\n");
+    CDL_PREPEND(head,&els[0]);
+    CDL_PREPEND(head,&els[1]);
+    CDL_PREPEND(head,&els[2]);
+    CDL_PREPEND(head,&els[3]);
+    CDL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    /* point head to head->next */
+    printf("advancing head pointer\n");
+    head = head->next;
+    CDL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    /* follow circular loop a few times */
+    for(i=0,e=head; e && i<10; i++,e=e->next) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    /* follow circular loop backwards a few times */
+    for(i=0,e=head; e && i<10; i++,e=e->prev) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    printf("deleting b\n");
+    CDL_DELETE(head,&els[1]);
+    CDL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+    printf("deleting (a)\n");
+    CDL_DELETE(head,&els[0]);
+    CDL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+    printf("deleting (c)\n");
+    CDL_DELETE(head,&els[2]);
+    CDL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+    printf("deleting (d)\n");
+    CDL_DELETE(head,&els[3]);
+    CDL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    /* test DL macros */
+    printf("DL macros\n");
+    DL_PREPEND(head,&els[0]);
+    DL_PREPEND(head,&els[1]);
+    DL_PREPEND(head,&els[2]);
+    DL_APPEND(head,&els[3]);
+    DL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    printf("deleting c\n");
+    DL_DELETE(head,&els[2]);
+    DL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    printf("deleting a\n");
+    DL_DELETE(head,&els[0]);
+    DL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    printf("deleting b\n");
+    DL_DELETE(head,&els[1]);
+    DL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    printf("deleting d\n");
+    DL_DELETE(head,&els[3]);
+    DL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    /* test LL macros */
+    printf("LL macros\n");
+    LL_PREPEND(head,&els[0]);
+    LL_PREPEND(head,&els[1]);
+    LL_PREPEND(head,&els[2]);
+    LL_APPEND(head,&els[3]);
+    LL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    printf("deleting c\n");
+    LL_DELETE(head,&els[2]);
+    LL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    printf("deleting a\n");
+    LL_DELETE(head,&els[0]);
+    LL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    printf("deleting b\n");
+    LL_DELETE(head,&els[1]);
+    LL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    printf("deleting d\n");
+    LL_DELETE(head,&els[3]);
+    LL_FOREACH(head,e) {
+        printf("%c ", e->id);
+    }
+    printf("\n");
+
+    return 0;
+}

c/ext/uthash/tests/test29.ans

@@ -0,0 +1,103 @@
+ADRIAN
+ARNOLDO
+CARROLL
+CARY
+CHONG
+CLIFTON
+CODY
+COLTON
+CORNELL
+DAMON
+DANNIE
+DARIO
+DONN
+DOUG
+DOUGLAS
+FREDERICK
+FRITZ
+GERALD
+GUS
+HARVEY
+IRVING
+ISAIAH
+JARVIS
+JOHN
+KENTON
+LAURENCE
+LESTER
+LINCOLN
+LOWELL
+NELSON
+NEVILLE
+NIGEL
+NORMAND
+ODIS
+OMAR
+ORLANDO
+RAYMUNDO
+REX
+ROLANDO
+RON
+SHANE
+TONEY
+TRINIDAD
+WALTER
+WARNER
+WARREN
+WES
+WILLARD
+WILLIAM
+WINFRED
+XAVIER
+deleting head ADRIAN
+head->prev: XAVIER
+ARNOLDO
+CARROLL
+CARY
+CHONG
+CLIFTON
+CODY
+COLTON
+CORNELL
+DAMON
+DANNIE
+DARIO
+DONN
+DOUG
+DOUGLAS
+FREDERICK
+FRITZ
+GERALD
+GUS
+HARVEY
+IRVING
+ISAIAH
+JARVIS
+JOHN
+KENTON
+LAURENCE
+LESTER
+LINCOLN
+LOWELL
+NELSON
+NEVILLE
+NIGEL
+NORMAND
+ODIS
+OMAR
+ORLANDO
+RAYMUNDO
+REX
+ROLANDO
+RON
+SHANE
+TONEY
+TRINIDAD
+WALTER
+WARNER
+WARREN
+WES
+WILLARD
+WILLIAM
+WINFRED
+XAVIER

c/ext/uthash/tests/test29.c

@@ -0,0 +1,57 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "utlist.h"
+
+#define BUFLEN 20
+
+typedef struct el {
+    char bname[BUFLEN];
+    struct el *next, *prev;
+} el;
+
+static int namecmp(void *_a, void *_b)
+{
+    el *a = (el*)_a;
+    el *b = (el*)_b;
+    return strcmp(a->bname,b->bname);
+}
+
+int main()
+{
+    el *name, *tmp;
+    el *head = NULL;
+
+    char linebuf[BUFLEN];
+    FILE *file;
+
+    file = fopen( "test11.dat", "r" );
+    if (file == NULL) {
+        perror("can't open: ");
+        exit(-1);
+    }
+
+    while (fgets(linebuf,BUFLEN,file) != NULL) {
+        name = (el*)malloc(sizeof(el));
+        if (name == NULL) {
+            exit(-1);
+        }
+        strcpy(name->bname, linebuf);
+        DL_APPEND(head, name);
+    }
+    DL_SORT(head, namecmp);
+    DL_FOREACH(head,tmp) {
+        printf("%s", tmp->bname);
+    }
+
+    /* now delete the list head */
+    printf("deleting head %shead->prev: %s", head->bname, head->prev->bname);
+    DL_DELETE(head,head);
+    DL_FOREACH(head,tmp) {
+        printf("%s", tmp->bname);
+    }
+
+    fclose(file);
+
+    return 0;
+}

c/ext/uthash/tests/test3.ans

@@ -0,0 +1,5 @@
+user 1, cookie 1
+user 3, cookie 9
+user 5, cookie 25
+user 7, cookie 49
+user 9, cookie 81

c/ext/uthash/tests/test3.c

@@ -0,0 +1,43 @@
+#include "uthash.h"
+#include <stdlib.h>   /* malloc */
+#include <stdio.h>    /* printf */
+
+typedef struct example_user_t {
+    int id;
+    int cookie;
+    UT_hash_handle hh;
+} example_user_t;
+
+int main()
+{
+    int i;
+    example_user_t *user, *tmp, *users=NULL;
+
+    /* create elements */
+    for(i=0; i<10; i++) {
+        user = (example_user_t*)malloc(sizeof(example_user_t));
+        if (user == NULL) {
+            exit(-1);
+        }
+        user->id = i;
+        user->cookie = i*i;
+        HASH_ADD_INT(users,id,user);
+    }
+
+    /* delete each even ID */
+    for(i=0; i<10; i+=2) {
+        HASH_FIND_INT(users,&i,tmp);
+        if (tmp != NULL) {
+            HASH_DEL(users,tmp);
+            free(tmp);
+        } else {
+            printf("user id %d not found\n", i);
+        }
+    }
+
+    /* show the hash */
+    for(user=users; user != NULL; user=(example_user_t*)(user->hh.next)) {
+        printf("user %d, cookie %d\n", user->id, user->cookie);
+    }
+    return 0;
+}