d

c/ext/uthash/.gitignore

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

c/ext/uthash/.travis.yml

@@ -1,14 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,8 +0,0 @@
-
-[![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

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

c/ext/uthash/doc/ChangeLog.txt

@@ -1,282 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,451 +0,0 @@
-<?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

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

c/ext/uthash/doc/index.html

@@ -1,122 +0,0 @@
-<!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

@@ -1,55 +0,0 @@
-<!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

@@ -1,141 +0,0 @@
-#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

@@ -1,383 +0,0 @@
-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

@@ -1,288 +0,0 @@
-<?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

@@ -1,293 +0,0 @@
-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

@@ -1,374 +0,0 @@
-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

@@ -1,158 +0,0 @@
-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

@@ -1,239 +0,0 @@
-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

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

c/ext/uthash/package.json

@@ -1,28 +0,0 @@
-{
-  "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

@@ -1,248 +0,0 @@
-/*
-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

@@ -1,108 +0,0 @@
-/*
-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

@@ -1,88 +0,0 @@
-/*
-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

@@ -1,407 +0,0 @@
-/*
-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

@@ -1,120 +0,0 @@
-#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

@@ -1,132 +0,0 @@
-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

@@ -1,13 +0,0 @@
-#!/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

@@ -1,82 +0,0 @@
-#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

@@ -1,17 +0,0 @@
-#!/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

@@ -1,21 +0,0 @@
-#!/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

@@ -1,22 +0,0 @@
-#!/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

@@ -1,20 +0,0 @@
-#!/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

@@ -1,16 +0,0 @@
-:: 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

@@ -1,48 +0,0 @@
-#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

@@ -1,149 +0,0 @@
-#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

@@ -1,678 +0,0 @@
-/*
-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

@@ -1,42 +0,0 @@
-#!/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

@@ -1,21 +0,0 @@
-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

@@ -1,221 +0,0 @@
-/*
- * =====================================================================================
- *
- *       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

@@ -1,31 +0,0 @@
-/*
- * =====================================================================================
- *
- *       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

@@ -1,191 +0,0 @@
-#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

@@ -1,28 +0,0 @@
-#!/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

@@ -1,32 +0,0 @@
-#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

@@ -1,34 +0,0 @@
-// 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

@@ -1,10 +0,0 @@
-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

@@ -1,31 +0,0 @@
-#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

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

c/ext/uthash/tests/test10.c

@@ -1,54 +0,0 @@
-#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

@@ -1,51 +0,0 @@
-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

@@ -1,57 +0,0 @@
-#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

@@ -1,51 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,40 +0,0 @@
-#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

@@ -1,5 +0,0 @@
-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

@@ -1,50 +0,0 @@
-#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

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

c/ext/uthash/tests/test14.c

@@ -1,54 +0,0 @@
-#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

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

c/ext/uthash/tests/test15.c

@@ -1,40 +0,0 @@
-#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

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

c/ext/uthash/tests/test16.c

@@ -1,53 +0,0 @@
-#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

@@ -1,134 +0,0 @@
-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

@@ -1,63 +0,0 @@
-#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

@@ -1,20 +0,0 @@
-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

@@ -1,37 +0,0 @@
-#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

@@ -1,66 +0,0 @@
-#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

@@ -1,5 +0,0 @@
-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

@@ -1,38 +0,0 @@
-#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

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

c/ext/uthash/tests/test20.c

@@ -1,34 +0,0 @@
-#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

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

c/ext/uthash/tests/test21.c

@@ -1,44 +0,0 @@
-#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

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

c/ext/uthash/tests/test22.c

@@ -1,68 +0,0 @@
-#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

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

c/ext/uthash/tests/test23.c

@@ -1,69 +0,0 @@
-#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

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

c/ext/uthash/tests/test24.c

@@ -1,29 +0,0 @@
-#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

@@ -1,31 +0,0 @@
-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

@@ -1,138 +0,0 @@
-#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

@@ -1,53 +0,0 @@
-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

@@ -1,61 +0,0 @@
-#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

@@ -1,28 +0,0 @@
-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

@@ -1,130 +0,0 @@
-#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

@@ -1,34 +0,0 @@
-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

@@ -1,153 +0,0 @@
-#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

@@ -1,103 +0,0 @@
-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

@@ -1,57 +0,0 @@
-#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

@@ -1,5 +0,0 @@
-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

@@ -1,43 +0,0 @@
-#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;
-}

c/ext/uthash/tests/test30.ans

@@ -1,51 +0,0 @@
-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